数组方法汇总

数组相关方法汇总

数组的四个基本方法如下：（数组元素的添加和删除）

方法	描述	备注
push()	向数组的最后面插入一个或多个元素，返回结果为该数组新的长度	会改变原数组
pop()	删除数组中的最后一个元素，返回结果为被删除的元素	会改变原数组
unshift()	在数组最前面插入一个或多个元素，返回结果为该数组新的长度	会改变原数组
shift()	删除数组中的第一个元素，返回结果为被删除的元素	会改变原数组

数组的常见方法如下：

方法	描述	备注
slice()	从数组中提取指定的一个或多个元素，返回结果为新的数组	不会改变原数组
splice()	从数组中删除指定的一个或多个元素，返回结果为新的数组	会改变原数组
concat()	连接两个或多个数组，返回结果为新的数组	不会改变原数组
join()	将数组转换为字符串，返回结果为转换后的字符串	不会改变原数组
reverse()	反转数组，返回结果为反转后的数组	会改变原数组
sort()	对数组的元素,默认按照Unicode编码，从小到大进行排序	会改变原数组

遍历数组的方法如下：

方法	描述	备注
for循环	for循环进行数组提取
forEach()	和 for循环类似，但需要兼容IE8以上	forEach() 没有返回值。也就是说，它的返回值是 undefined
map()	对原数组中的每一项进行加工，将组成新的数组	不会改变原数组
filter()	对数组中的每一项运行回调函数，该函数返回结果是true的项，将组成新的数组，返回结果为新的数组。可以起到过滤的作用	不会改变原数组
every()	如果有一项返回false，则停止遍历，此方法返回 false	一假即假。要求每一项都返回true，最终的结果才返回true
some()	只要有一项返回true，则停止遍历，此方法返回true	一真即真。要求每一项都返回false，最终的结果才返回false
reduce	为数组中的每一个元素，依次执行回调函数

数组的其他方法如下：

方法	描述	备注
indexOf(value)	从前往后索引，获取 value 在数组中的第一个下标
lastIndexOf(value)	从后往前索引，获取 value 在数组中的最后一个下标
find(function())	找出第一个满足「指定条件返回true」的元素。
findIndex(function())	找出第一个满足「指定条件返回true」的元素的index
Array.from(arrayLike)	将伪数组转化为真数组
Array.of(value1, value2, value3)	将一系列值转换成数组。

---

数组的四个基本方法（数组元素的添加和删除）

以此为例：

var arr = ['孙悟空','猪八戒','沙和尚'];

push()

该方法可以向数组的末尾添加一个或多个元素，并返回数组的长度，可以将要添加的元素作为方法的参数传递。

var a = arr.push('唐僧','蜘蛛精','白骨精');
console.log(arr);  // ['孙悟空','猪八戒','沙和尚','唐僧','蜘蛛精','白骨精']
console.log(a);   //6

pop()

该方法可以删除数组的最后一个元素，并将被删除的元素作为返回值返回

var b = arr.pop(); 
console.log(arr); // ['孙悟空','猪八戒','沙和尚','唐僧','蜘蛛精']
console.log(b);		// 白骨精

unshift()

该方法可以向数组开头添加一个或多个元素，并返回新的数组长度，与push一样，可以将要添加的元素作为方法的参数传递。

向前面插入元素后，其他的元素索引会依次调整

var c = arr.unshift("复活的白骨精");
console.log(arr); // ['复活的白骨精','孙悟空','猪八戒','沙和尚','唐僧','蜘蛛精']
console.log(c);	//6

shift()

该方法可以删除数组的第一个元素，并将被删除的元素作为返回值返回

var d = arr.shift();
console.log(arr);  //['孙悟空','猪八戒','沙和尚','唐僧','蜘蛛精']
console.log(d);		// 复活的白骨精

前两个基本方法，就是在数组末尾添加或删除元素、后两个基本方法，就是在数组前头添加或删除元素。

小练习：在一类示例中，找到符合条件的实例，再它们保存在一组数组中。

//构造一个函数对象
function Person(name,age){
            this.name=name;
            this.age=age;
}

//修改Person原型的toString返回值
Person.prototype.toString = function(){
             return "Person[name="+this.name+",age="+this.age+"]";
}

//构造函数的类确定好了，接下来创建实例
        var per = new Person('孙悟空',18);
        var per2 = new Person('猪八戒',28);
        var per3 = new Person('沙悟净',14);
        var per4 = new Person('蜘蛛精',16);
        var per5 = new Person('玉兔精',26);

//将这些实例放入到一个数组中
        var perArr = [per,per2,per3,per4,per5];

//创建一个函数，可以将perArr中满18岁的Person实例提取出来,然后封装到一个新的数组中再返回。

//创建提取函数，xarr是形参，需提取的数组在使用方法时，将地址填写在形参中
function getAdult(xarr){
        //创建新数组接收对应元素
		var newArr =[]

        //遍历数组
        for(var i = 0 ; i<xarr.length ; i++){
           if(xarr[i].age >= 18){
                 newArr.push(xarr[i]);
             }   
        }

        //返回新数组
        return newArr;
}

        console.log( getAdult(perArr) );

---

数组的常见方法

slice()

slice()：从数组中提取指定的一个或者多个元素，返回结果为新的数组（不会改变原来的数组）。

• 截取开始位置的索引，包含开始的元素；截取结束位置的索引，不包含结束的元素。

var arr =['唐僧','孙悟空','猪八戒','沙和尚'];
var xarr = arr.slice(0,2);     // xarr=['唐僧','孙悟空'] 不包括结束索引的内容，只有0.1两个索引的元素。

• 如果参数只有一个，则是以这个参数作为索引开头，往后截取

var xarr = arr.slice(1); // xarr=['孙悟空','猪八戒','沙和尚'] 从索引1开始，后面全截取

var xarr = arr.slice(-2); // xarr=['猪八戒','沙和尚'] 从倒数第二个索引开始，后面全截取，相当于截取数组后两个。

• 如果第一个参数大于第二个参数，则只会返回一个空的数组

var arr =['唐僧','孙悟空','猪八戒','沙和尚'];
var xarr = arr.slice(2,1);     // xarr=[]  

补充：

很多前端开发人员会用 slice()将伪数组，转化为真数组。写法如下：

array = Array.prototye.slice.call(arrayLike);
或者
array = [].slice.call(arrayLike);
//相当于将一个空数组用slice，这样会返回一个新的数组出来，但因为call改变了this指向，会将arrayLike伪数组的内容提取出来，存储到array中。

ES6 看不下去这种蹩脚的转化方法，于是出了一个新的 API：（专门用来将伪数组转化成真数组）

array = Array.from(arrayLike)

splice()

splice()：可以删除数组中的指定元素,并添加新元素，将指定元素从原数组中删除，并将删除元素被封装到新数组作为返回值返回 。

使用splice()会影响原数组

参数：

• 表示开始位置的索引。
• 表示删除的数量。（可以把第二参数设置为0，不删除元素，然后第一个参数指定位置进行元素插入）
• 在前两位参数后，可以传递新的元素，这些元素将自动插入到开始位置的索引前。

var arr =['唐僧','孙悟空','猪八戒','沙和尚'];
//从索引0开始，删除两位元素,并将删除元素提取出来封装到新数组
var xxarr = arr.splice(0,2,"法海");

console.log(xxarr);  //  ['唐僧','孙悟空']
console.log(arr);	// ['法海','猪八戒','沙和尚']

练习：数组中元素去重

for(var i = 0;i < arr.length ; i++){
		for(var j = i+1 ; j < arr.length; j++){
			if(arr[i] == arr[j]){
				arr.splice(j,1);
			}
            // 这里的j--就是为了重复检查，因为数值相同在删除后，后面的数值会补位
                //若部位的也为相同数值，则已经判定过后无法进行再次检查，会有遗漏
			j--;  
           
		}
}

concat()

concat()：连接两个或多个数组，并将新的数组返回。（不会改变原数组）

参数中可以传多个数组/元素

var arr =['唐僧','孙悟空','猪八戒','沙和尚'];
var arr2 = ['白骨精','蜘蛛精','玉兔精'];
var arr3 = ['银角','金角'];

var xarr = arr.concat(arr2,arr3,'玉皇大帝');
console.log(xarr);  // ['唐僧','孙悟空','猪八戒','沙和尚','白骨精','蜘蛛精','玉兔精','银角','金角','玉皇大帝']

join()

join()：将数组转换为字符串，将转换后的字符串返回（不会改变原数组）。

在join()中可以指定一个字符串作为参数，这个而字符串将会成为数组中元素的连接符。

如果没有参数，默认使用，隔开元素。

var arr3 = ['银角','金角'];
var str = arr3.join('-');
console.log(str); // 金角-银角
 //若是join()中没有指定参数，则默认用，作为连接符
var str2 = arr.join();
cosole.log(str2); // 金角,银角

**reverse() **【数组镜像反转】

reverse()：该方法来反转数组（镜像反转），该方法会直接修改原数组。

• 这种方法有效的替代了用数组遍历进行反转的过程，代码简洁方便。

var arr =['唐僧','孙悟空','猪八戒','沙和尚'];
var result = arr.reverse();
console.log(arr); 	// ['沙和尚','猪八戒','孙悟空','唐僧']
console.log(result); 	// ['沙和尚','猪八戒','孙悟空','唐僧']

sort() 【冒泡】

sort()：该方法可以用来对数组的元素进行排序，该方法会直接修改原数组，默认按照Unicode的编码进行排序（所以可以看成对元素进行从小到大的排序）。

• sort()在无参数时，则默认按Unicode编码进行从小到大的排序。

var arr4 =["a","e","b","c","d"];
arr4.sort();
console.log(arr4); // ["a","b","c","d","e"]

而对纯数字而言，按照Unicode编码进行排序，可能会导致错误的结果

var sarr = [5, 2, 11, 3, 4, 1];
sarr.sort();
console.log('sarr');  //[1,11,2,3,4,5]

所以需要用某种方法，让数字的排序也能按照十进制上从小打大的方式进行排序。

• sort()带参数，可以指定排序的规则。
  • 这种方法有效地代替了用数组遍历进行冒泡的判断过程，代码简洁方便

在sort()的参数中添加一个回调函数，回调函数中需要定义两个形参，浏览器将会分别使用数组中的元素作为实参去调用回调函数。（这个过程中，回调函数具体用了哪两个元素不确定，但是可以肯定的是，第一个参数在数组中的位置在第二个参数前面。）

浏览器将会根据回调函数的返回值决定元素的顺序：

• 如果返回一个大于0的值，则元素会交换位置
• 如果返回一个小于等于0的值，则元素位置不变

var sarr = [5, 2, 11, 3, 4, 1];
sarr.sort(function(a,b){
    //升序排列
    return a-b; // 第一个参数a在数组中的位置肯定在b前面，所以a-b如果是前者大的话，则结果肯定大于0，进行位置交换。
    //降序排列 
    //return b-a;
});

---

数组的遍历

遍历数组即：获取并操作数组中的每一个元素。在我们的实战开发中，使用得非常频繁。

遍历数组的方法包括：every()、filter()、forEach()、map()、some()

PS：这几个方法不会修改原数组。

语法格式：

数组/boolean/无 = 数组.every/filter/forEach/map/some(
    function(item, index, arr){
        程序和返回值；
    })

for循环

没啥好说，for的每次循环，i都对等于数组索引，直接打印即可，看例：

var arr =['唐僧','孙悟空','猪八戒','沙和尚'];
//创建for循环
for(i=0;i<arr.length;i++){
    //每循环一次，打印当前索引的数组元素
    console.log(arr[i]);
}

forEach()

forEach() 这种遍历方法只支持IE8以上的浏览器。IE8及以下的浏览器均不支持该方法。所以如果需要兼容IE8，则不要使用forEach，改为使用for循环来遍历即可。

forEach()方法会对数组的每个数组元素进行执行，回调函数的三个参数对应的是数组元素、数组元素的索引、数组元素所在的数组对象，对每个数组元素的这三个数据进行操作。

forEach()方法需要一个函数作为参数（回调函数：作为方法的参数，这种函数会在方法被调用时，由系统自动调用。）。

对数组中每一项执行回调函数，函数每次执行时，浏览器会将遍历到的元素，以实参的形式传递进回调函数中，我们可以定义形参，来读取这些内容。

数组中有几个元素，函数就会执行几次。

浏览器会在回调函数中传递三个参数：

• 当前正在遍历的元素
• 当前正在遍历的元素索引
• 正在遍历的数组

var arr =['孙悟空','猪八戒','沙和尚'];
arr.forEach( function(value,index,obj){
    console.log(value);
    console.log(index);
    console.log(obj);
}
);

//得出来的结果为：
"孙悟空" 0 ['孙悟空','猪八戒','沙和尚']；'猪八戒' 1 ['孙悟空','猪八戒','沙和尚']；'沙和尚' 2 ['孙悟空','猪八戒','沙和尚']；

//所以我们可以单纯的获取相对索引的数组元素
arr.forEach( function(value,index,obj){
    console.log(value);
}
);
//孙悟空 猪八戒 沙和尚

map() 【蛮重要的】

map()方法会对数组的每个数组元素进行执行，回调函数的两个参数对应的是数组元素、数组元素的索引，可对每个数组元素进行操作，map()会将被操作后的数值封装到新数组中。

对数组中每一项执行回调函数，返回该函数的结果，组成的新数组（返回的是加工之后的新数组）。

• 可以在拷贝过程中，对新数组内的元素进行加工

var arr1 = [1, 3, 6, 2, 5, 6];

var arr2 = arr1.map(function (item, index) {
    return item + 10;  //让arr1中的每个元素加10
})
console.log(arr2); [11,13,16,12,15,16]
//原本返回item不进行操作的话，返回出来的item将会组成新数组，相当于拷贝了原数组的数据。

实用举例 [重要案例，实际开发中常用]

将A数组中某个属性的值，存储到B数组中。代码举例（ES6写法）：

    const arr = [
        { name: '孙悟空', age: '18' },
        { name: '猪八戒', age: '16' },
    ];

    // 将数组 arr 中的 name 属性，存储到 数组 arr1 中
    const arr1 = arr.map(item => item.name); //遍历数组元素时，只要形参对象item的name属性，将每个形参对象的name属性提取出来，封装到新数组中。

    // 将数组 arr 中的 name、age这两个属性，改一下“键”的名字，存储到 arr2中
    const arr2 = arr.map(item => ({   //遍历数组元素时，将形参对象的name赋值给新对象的myName属性（age同理），再将新的对象封装到新的数组中。
        myName: item.name,
        myAge: item.age,
    })); // 将数组 arr1 中的 name 属性，存储到 数组 arr2 中

    console.log(arr);  // [{name:"孙悟空",age: '18'},{name:'猪八戒', age:'16'}]
    console.log(arr1);	// ['孙悟空','猪八戒']
    console.log(arr2);	//[{myName:"孙悟空",myAge: '18'},{myName:'猪八戒', myAge:'16'}]

filter() 【也蛮挺重要的】

filter()方法会对数组的每个数组元素进行执行，回调函数的两个参数对应的是数组元素、数组元素的索引，可对每个数组元素进行关系判断，filter()会将判断为true的数组元素封装到一个新的数组中。

对数组中的每一项运行回调函数，该函数返回结果是true的项，将组成新的数组（返回值就是这个新的数组）。

var arr1 = [1, 3, 6, 2, 5, 6];

var arr2 = arr1.filter(function(item, index) {
	return item > 4; //将arr1中大于4的元素返回，组成新的数组
});
console.log(arr2);  //[6,5,6]

上方代码的ES6写法：

const arr1 = [1, 3, 6, 2, 5, 6];

const arr2 = arr1.filter(item=> item > 4); //将arr1中大于4的元素返回，组成新的数组

console.log(arr2);

实用举例

获取数组A中指定类型的对象，放到数组B中。代码举例如下：

const arr = [ 
    {name:'唐僧',age:24},
	{name:'孙悟空',age:18},
    {name:'猪八戒',age:16},
    {name:'沙悟净',age:14},
    {name:'女儿国国王',age:22},
    {name:'如来佛祖',age:9999}
];

const arr1 = arr.filter(item => item.age > 18);
console.log(arr1); //[{name:'唐僧',age:24},{name:'女儿国国王',age:22},{name:'如来佛祖',age:9999}]

every()

对数组中每一项运行回调函数，如果都返回true，every就返回true；如果有一项返回false，则停止遍历，此方法返回false。

   var arr1 = ["千古", "宿敌", "南山忆", "素颜"];
    var bool1 = arr1.every(function (value, index, array) {
        if (value.length > 2) {
            return false;
        }
        return true;
    });
    console.log(bool1);  //输出结果：false。只要有一个元素的长度是超过两个字符的，就返回false

    var arr2 = ["千古", "宿敌", "南山", "素颜"];
    var bool2 = arr2.every(function (value, index, array) {
        if (value.length > 2) {
            return false;
        }
        return true;
    });
    console.log(bool2);  //输出结果：true。因为每个元素的长度都是两个字符。

如上例，只要有一首歌的歌名条件不同于其他元素，就会立刻返回false，意义在于清楚数组内的元素是否拥有相同的目标条件。

some()方法

对数组中每一项运行回调函数，只要有一项返回true，则停止遍历，此方法返回true。

和every()方法相似，不同的是，只要数组中有元素符合条件，some()方法立刻返回true，无法知道数组内有多少符合条件的元素。

reduce()方法【应该很重要吧】

如果能熟练使用 reduce 的用法，将能替代很多其他的数组方法。

该方法会为数组中的每一个元素，依次执行回调函数。

arr.reduce(
    function(previousValue, currentValue, currentIndex, array) {
    }, initialValue)

• 回调函数内的参数：

  • previousValue：上一次调用回调函数时的返回值，或者初始值
  • currentValue：当前数组元素
  • currentIndex：当前数组元素的索引
  • array：调用reduce()方法的数组

• reduce第二个参数

  • initialValue：可选的初始值（作为第一次调用回调函数时传给 previousValue 的值）

实例：

计算数组中所有元素项的总和。代码实现：

var arr = [2, 0, 1, 9, 6];
sumValue = arr.reduce(function(total, item) { //  计算 arr 数组中，所有元素项的综合
    return total + item;
}, 0);

console.log('sumValue:' + sumValue); // 打印结果：18

数组的其他方法

indexOf() 和 lastIndexOf()

语法：

用来储存索引的变量 = 数组.indexOf(value);

用来储存索引的变量 = 数组.lastIndexOf(value);

解释：

• indexOf(valye)：从第一个索引往后找，获取value在数组中第一个出现的位置索引
• lastindexOf(value)：从最后一个索引往前找，获取value在数组中最后一个位置的索引。

作用：

利用这个方法，我们可以判断某个值是否在指定的数组中。如果没找到则返回-1。

**举例：

var arr = ["a","b","c","d","e","d","c"];

//从前往后，找第一个"c"在哪个位置
console.log(arr.indexOf("c"));	//2
//从后往前，找第一个"d"在哪个位置
console.log(arr.lastIndexOf("d"));	//5

结合实例：判断某个值是否在数组中

var arr = [18,22,33,40];
var str = [
{name:"孙悟空", age: 18},
{name:"如来佛祖", age: 9999}
];

var arr1 = str.filter(item => 
	arr.indexOf(item.age) !== -1
)
console.log(arr1);  //[{name:"孙悟空", age: 18}]

• 这里内部还可以用一个回调函数，但是需要retuen返回结果

var arr1 = str.filter(item => {
    return arr.indexOf(item.age) !== -1
})
console.log(arr1);  //[{name:"孙悟空", age: 18}]

• 思路扩展，如果要完成这个过程，可以用ES6中字符串的一个方法 includes()

var arr1 = str.filter(item => {
	return arr.includes(item.age) ;
})

find()

语法：

    find(function(item, index, arr){return true})

作用：找出第一个满足的元素「指定条件返回true」。

• 一旦找到符合条件的第一个元素，将不再继续往下遍历。

举例：

let arr = [2, 3, 2, 5, 7, 6];

let result = arr.find(function (item, index) {
    return item > 4; //遍历数组arr，一旦发现有第一个元素大于4，就把这个元素返回
});

console.log(result);  //打印结果：5

findIndex()

语法：

    findIndex(function(item, index, arr){return true})

作用：找出第一个满足的元素的index「指定条件返回true」。

举例：

let arr = [2, 3, 2, 5, 7, 6];

let result = arr.findIndex(function (item, index) {
return item > 4; //遍历数组arr，一旦发现有第一个元素大于4，就把这个元素的index返回
});

console.log(result); //打印结果：3

判断是否为一个数组 Array.isArray()

Array.from() 【ES6】将伪数组转换成真数组

语法：

array = Array.from(arrayLike)

作用：将伪数组或可遍历对象转换为真数组。

举例：

<body>
<button>按钮1</button>
<button>按钮2</button>
<button>按钮3</button>

<script>
    let btnArray = document.getElementsByTagName('button');
    console.log(btnArray);
    console.log(btnArray[0]);

</script>

</body>

上面的布局中，有三个button标签，我们通过getElementsByTagName获取到的btnArray实际上是伪数组，并不是真实的数组。

既然btnArray是伪数组，它就不能使用数组的一般方法，否则会报错

所以这时要采用Array.from方法将btnArray这个伪数组转换为真数组。

    Array.from(btnArray);

然后就可以使用数组的一般方法了。

伪数组与真数组的区别：

伪数组的原型链中没有 Array.prototype，而真数组的原型链中有 Array.prototype。因此伪数组没有 pop、join等属性。

Array.of() 将一系列数据转换成数组

将一系列值转换成数组，并返回。

let arr = Array.of(1, 'abc', true);
console.log(arr);

isArray(）判断是否为数组

存储布尔值的变量 = Array.isArray(被检测的值) ;

以前，会通过 A instanceof B来判断 A 是否属于 B 类型。但是在数组里，因为有isArray()方法， instanceof 方法已经用的不多了。

toString() 将数组转换成字符串

把数组转换成字符串，每一项用,分割。

之前在字符串的相关方法中，学习了字符串其中一个split()方法，可以将字符串转换成数组，split()内的参数指定分隔符

    字符串 = 数组.toString();

valueOf()：返回数组本身

    数组本身 = 数组.valueOf();

这个方法的意义不大。因为我们指直接写数组对象的名字，就已经是数组本身了。

数组练习

splice()练习：数组去重

代码实现：

//创建一个数组
var arr = [1, 2, 3, 2, 2, 1, 3, 4, 2, 5];

//去除数组中重复的数字
//获取数组中的每一个元素
for (var i = 0; i < arr.length; i++) {
    //console.log(arr[i]);
    /*获取当前元素后的所有元素*/
    for (var j = i + 1; j < arr.length; j++) {
        //console.log("---->"+arr[j]);
        //判断两个元素的值是否相等
        if (arr[i] == arr[j]) {
            //如果相等则证明出现了重复的元素，则删除j对应的元素
            arr.splice(j, 1);
            //当删除了当前j所在的元素以后，后边的元素会自动补位
            //此时将不会在比较这个元素，我需要再比较一次j所在位置的元素
            //使j自减
            j--;
        }
    }
}

console.log(arr);

清空数组

清空数组，有以下几种方式：

var array = [1,2,3,4,5,6];

array.splice(0);      //方式1：删除数组中所有项目
array.length = 0;     //方式2：length属性可以赋值，在其它语言中length是只读
array = [];           //方式3：推荐

练习1 将数组内容转为字符串

问题：将一个字符串数组输出为|分割的形式，比如“千古|宿敌|素颜”。使用两种方式实现。

方式1：（不推荐）

var arr = ["千古","宿敌","素颜"];
var str = arr[0];
var separator = "|";
for(var i = 1;i< arr.length;i++) {
    str += separator+arr[i];    //从第1个数组元素开始，每个元素前面加上符号"|"
}

console.log(str);

方式2：（推荐。通过array数组自带的api来实现）

    var arr = ["千古","宿敌","素颜"];

    console.log(arr.join("|"));

想数组转换成字符串，也可以用toString()方法，但无法指定字符串之间的连接符，只有,

练习2 数组镜像反转

题目：将一个字符串数组的元素的顺序进行反转，使用两种种方式实现。提示：第i个和第length-i-1个进行交换。

答案：

方式1：

function reverse(array) {
    var newArr = [];
    for (var i = array.length - 1; i >= 0; i--) {
        newArr[newArr.length] = array[i];
    }
    return newArr;
}

方式2：（算法里比较常见的方式）

function reverse(array){
    //其实这里也可以用array.length-1-i作为循环的遍历数，每将一个数和对应的数对调，遍历数-1，这也是相对镜像对调的情况。
    for(var i=0;i<array.length/2;i++){
        var temp = array[i];
        array[i] = array[array.length-1-i];
        array[array.length-1-i] = temp;
    }
    return array;
}

方式3：（数组自带的reverse方法）

现在我们学习了数组自带的api，我们就可以直接使用reverse()方法。

arr.reverse();

练习3 去除不符合要求的数组元素

问题：针对工资的数组[1500,1200,2000,2100,1800]，把工资超过2000的删除。

答案：

var arr1 = [1500, 1200, 2000, 2100, 1800];

var arr2 = arr1.filter(function (ele, index, array) {
    if (ele < 2000) {
        return true;
    }
    return false;
})
console.log(arr1);
console.log(arr2);

练习4

问题：找到数组["c","a","z","a","x","a"]中每一个元素出现的次数。

分析：这道题建议用json数据来做，因为我们想知道a出现了几次，c出现了几次，x出现了几次。恰好k:v .. k:v这种键值对的形式就比数组方便很多了。

键值对的形式：用key代表数组中的元素，用value代表元素出现的次数。

整个过程可以参考字符串相关方法的最后一个练习

练习5：数组去重

在练习1中是直接遍历数组自身，然后进行数组元素对比，若有相同则splice()进行删除。

而练习5则是封装了一个函数，内外循环的作用下，每个实参数组的元素会对比新数组的每一个元素，若无相同，则将实参数组元素，利用arr[length]为新数组添加进该元素。若相同，则返回false，取反插旗元素bool。

这里运用的还是一个很常用的知识概念，就是插旗元素，因为js中的判断都是靠true和false进行判断，在这个例子中，先进行插旗，为bool赋值true，若无其他状况，判断语句则会按照要求进行操作，若有其他状况，判断语句则因为bool的原因，不会执行判断语句中的内容。

问题：编写一个方法去掉一个数组中的重复元素。

分析：创建一个新数组，循环遍历，只要新数组中有老数组的值，就不用再添加了。

答案：

//    编写一个方法 去掉一个数组的重复元素
var arr = [1,2,3,4,5,2,3,4];
console.log(arr);
var aaa = fn(arr);
console.log(aaa);
//思路：创建一个新数组，循环遍历，只要新数组中有老数组的值，就不用再添加了。
function fn(array){
    var newArr = [];
    for(var i=0;i<array.length;i++){
        //开闭原则
        var bool = true;
        //每次都要判断新数组中是否有旧数组中的值。
        for(var j=0;j<newArr.length;j++){
            if(array[i] === newArr[j]){
                bool = false;
            }
        }
        if(bool){
            newArr[newArr.length] = array[i];
        }
    }
    return newArr;
}