数组经常使用要领
建立数组
var fruits = ['Apple', 'Banana'];
console.log(fruits.length);经由过程索引接见数组元素
var first = fruits[0]; // Apple遍历数组
for(var i = fruits.length-1;i >=0 ; i--){
console.log(fruits[i]);
}
for(var i = 0;i < fruits.length; i++){
console.log(fruits[i]);
}
fruits.forEach(function (item, index, array) {
console.log(item, index);
});增加元素到数组的末端
var newLength = fruits.push('Orange'); // ["Apple", "Banana", "Orange"]删除数组末端的元素
var last = fruits.pop(); // remove Orange (from the end)
// ["Apple", "Banana"];删除数组最前面（头部）的元素
var first = fruits.shift(); // remove Apple from the front
// ["Banana"];增加元素到数组的头部
var newLength = fruits.unshift('Strawberry') // add to the front
// ["Strawberry", "Banana"];找出某个元素在数组中的索引
indexOf 该要领用来检索某项数组涌现的位置,涌现屡次的话只纪录第一次涌现的位置
var index = fruits.indexOf('Banana'); // 1经由过程索引删除某个元素
var removedItem = fruits.splice(pos, 1); // this is how to remove an item
// ["Strawberry", "Mango"]从一个索引位置删除多个元素
会转变原数组
var vegetables = ['Cabbage', 'Turnip', 'Radish', 'Carrot'];
var pos = 1, n = 2;
var removedItems = vegetables.splice(pos, n);
console.log(vegetables); // ["Cabbage", "Carrot"]
console.log(removedItems); // ["Turnip", "Radish"]复制一个数组
从某个已有的数组返回选定的元素。可理解为数组截取，可接受两个参数，只填一个参数示意从该位置起截取至末了，填两个参数示意要截取的头和尾的位置
var shallowCopy = fruits.slice();console.log(fruits['2'] == fruits['02']); // true
fruits[5] = 'mango';
console.log(Object.keys(fruits)); // ['0', '1', '2', '5']
console.log(fruits.length); // 6
JavaScript 诠释器经由过程挪用 toString 隐式转换成字符串
Array.length 属性会依据数组的内置要领调解转变
数组要领
Array.from() 从类数组对象或许可迭代对象中建立一个新的数组实例。
Array.isArray() 用来推断某个变量是不是是一个数组对象。
Array.of() 依据一组参数来建立新的数组实例，支撑恣意的参数数目和范例。
实例要领
一切数组实例都邑从 Array.prototype 继续属性和要领。修正 Array 的原型会影响到一切的数组实例。
concat()
衔接两个或更多的数组，并返回效果
var arr = [ 1, 2, 3 ];
var arr2= arr.concat("4", "5", "6"); //["1", "2", "3", "4", "5", "6"];join()
把数组的一切元素放入一个字符串并经由过程指定的分开符举行分开
arr.join("+"); //"1+2+3";reverse()
反转数组中元素的递次。
arr.reverse();
console.log(arr); // [3, 2, 1];sort()
数组排序 根据字符串的体式格局来排序。
toString()
把数组转换为字符串，并返回效果
filter()
建立一个新的数组，新数组中的元素是经由过程搜检指定数组中相符前提的一切元素。
//过滤掉即是 2 的数组元素：
function isBigEnough(element, index, array) {
return (element == 2);
}
arr.filter(isBigEnough) //2map()
返回一个新数组，数组中的元素为原始数组元素挪用函数处置惩罚后的值
//数组元素平方：
function two(x) {
return x*x;
}
console.log(arr.map(two))some()
用于检测数组中的元素是不是满足指定前提,假如有一个元素满足前提，则表达式返回true, 盈余的元素不会再实行检测,假如没有满足前提的元素，则返回false。
function whoBig(element, index, array) {
return (element >= 100);
}
arr.some(whoBig) //falseevery()
用于检测数组一切元素是不是都相符指定前提,假如数组中检测到有一个元素不满足，则全部表达式返回false，且盈余的元素不会再举行检测。
function whoBig(element, index, array) {
return (element >= 4);
}
arr.every(whoBig) //falsefind()
返回传入一个测试前提,相符前提的数组第一个元素,当数组中的元素在测试前提时返回true时, find() 返回相符前提的元素，以后的值不会再挪用实行函数。假如没有相符前提的元素返回 undefined
const pets = [
{ type: 'Dog', name: 'Max'},
{ type: 'Cat', name: 'Karl'},
{ type: 'Dog', name: 'Tommy'},
];
var pet = pets.find(pet => pet.type ==='Dog' && pet.name === 'Tommy');
console.log(pet); // { type: 'Dog', name: 'Tommy' }reduce()
吸收一个函数作为累加器，数组中的每一个值（从左到右）最先缩减，终究盘算为一个值
var arr = [1,2,3];
var sum = arr.reduce(function(prev, cur, index, arr) {
console.log(prev, cur, index);
return prev + cur;
})
console.log(arr, sum); 数组去重
function unique(arr) {
var result = [];
for (var i = arr.length - 1; i >= 0; i--) {
if(result.indexOf(arr[i])==-1){
result.push(arr[i]);
}
}
return result;
}
var arr = [1,2,3,4,5,2,2,2,'test','king','test'];
console.log(unique(arr));
function unique1(arr){
var obj = {},result = [];
for (var i = arr.length - 1; i >= 0; i--) {
if(!obj[arr[i]]){
obj[arr[i]] = true;
result.push(arr[i]);
}
}
return result;
}
console.log(unique1(arr));
function unique2(arr){
arr.sort();
var result =[];
for (var i = arr.length - 1; i >= 0; i--) {
if(arr[i]!=result[result.length-1]){
result.push(arr[i]);
}
}
return result;
}
console.log(unique2(arr));
function unique3(a) {
return Array.from(new Set(a));
}
谢谢
