数组

创建数组

• 用逗号隔开

var array = new Array()
var array =[1,2,3,true,'yym']

arr.length

• 数组长度

var students = [
  {id:1,score:80},
  {id:2,score:70},
  {id:3,score:90}
]
students.length  //3
students = []
students.length  //0

获取数组元素

var students = [
  {id:1,score:80},
  {id:2,score:70},
  {id:3,score:90}
]
students[0]  //{id: 1, score: 80}
students[1].score = 60  //60  修改

arr.indexOf(searchElement)

• 寻找元素,获得索引位置

var tel = [110,114,120]
tel.indexOf(110)  //0 索引位置
tel.indexOf(119)  //-1 没有返回-1

arr.forEach(callback)遍历

• .forEach(element, index, array)
  • 遍历数组，参数为一个回调函数，回调函数有三个参数：

当前元素
当前元素索引值
整个数组
var students = [
    {id:1,score:80},
    {id:2,score:50},
    {id:3,score:70}
];
var editScore = function(item,index,array){
    item.score += 5;
};
students.forEach(editScore);


var scores = [60,70,80,90]
var newScores = []
var editScores = function(item,index,array){
  newScores.push(item+5)
}
scores.forEach(editScores)
console.log(newScores)

---

arr.reverse()

• 将数组逆序，与之前不同的是它会修改原数组

var students = [
    {id:1,score:80},
    {id:2,score:50},
    {id:3,score:70}
];
students.reverse()

[{id: 3, score: 70}
{id: 2, score: 50}
{id: 1, score: 80}]

arr.sort([comparaFunction])

• 传入一个回调函数
• 改变原有数组

var students = [
    {id:1,score:80},
    {id:2,score:50},
    {id:3,score:70}
];
var byScore = function(a,b){
  return b.score - a.score
}
students.sort(byScore)
// {id: 1, score: 80}
// {id: 3, score: 70}
// {id: 2, score: 50}

arr.push(element1,element2...)

• 返回的是数组长度
• 往后添加数组

var students = [
    {id:1,score:80},
    {id:2,score:50},
    {id:3,score:70}
];
students.push({id:4,score:90})  //4

var a = new Array(1,2,3);
a.push(4);
console.log(a);//[1, 2, 3, 4]

arr.unshift(element1,element2...)

• 往数组前添加

var a=new Array(1,2,3);
a.unshift(4);
console.log(a);//[4, 1, 2, 3]

arr.shift()

• 获取第一个数组并删掉

var students = [
    {id:1,score:80},
    {id:2,score:50},
    {id:3,score:70}
];

students.shift()  //{id: 1, score: 80}

var a=new Array(1,2,3);
a.shift();  //1
console.log(a); //[2, 3]

arr.pop

• 获取最后一个,并删掉

var students = [
    {id:1,score:80},
    {id:2,score:50},
    {id:3,score:70}
];
students.pop()  //{id: 3, score: 70}

var a = new Array(1,2,3);
a.pop();  //3
console.log(a); //[1, 2]

arr.splice(index,howmany[,elements])

• index 你要从哪里删(开始索引)
• howmany 删掉多少(删除元素的位移)
• 加入多少元素(插入的新元素，当然也可以写多个)
• splice方法返回一个由删除元素组成的新数组，没有删除则返回空数组
• 插入往前面插

替换

删除

添加

arr.reverse() arr.sort() arr.push() arr.unshift() arr.shift() arr.pop() arr.splice() 都改变了数组

---

arr.slice(begin[,end])

• 从哪个索引位置开始,到哪里结束
• 开始包含,结束不包含
• 数组未改变

var num = [1,2,3,4,5,6]
num.slice(1,4)  // [2, 3, 4]
num // [1, 2, 3, 4, 5, 6]

arr.concat(value1,value2,...)

• concat方法用于拼接数组
• a.concat(b)返回一个a和b共同组成的新数组，同样不会修改任何一个原始数组，也不会递归连接数组内部数组

var a = [1,2,3,4,5];
var b = [6,7,8,9];
console.log(a.concat(b));//[1, 2, 3, 4, 5, 6, 7, 8, 9]
console.log(a); //[1, 2, 3, 4, 5]
console.log(b); //[6, 7, 8, 9]

arr.join(separator)

• 分隔符

var a = [1,2,3,4,5];
console.log(a.join(',')); //1,2,3,4,5
console.log(a.join('-')); //1-2-3-4-5

arr.map(callback)

• 遍历数组，回调函数返回值组成一个新数组返回，新数组索引结构和原数组一致，原数组不变

var scores = [60,70,80,90]
var addScore = function(item,index,array){
  return item+5
}
scores.map(addScore)

arr.reduce(callback,[initialValue])

• 后面一个参数是初始值

var students = [
    {id:1,score:80},
    {id:2,score:50},
    {id:3,score:70}
];
var sum = function(previousResult,item,index,array){
    return previousResult+item.score;
};
students.reduce(sum,0);  // 200

---

增加的一些数组知识

Array.isArray(obj)

• 这是Array对象的一个静态函数，用来判断一个对象是不是数组

var a = [];
var b = new Date();
console.log(Array.isArray(a)); //true
console.log(Array.isArray(b)); //false

arr.lastIndexOf(element)

• lastIndexOf反向搜索。

var a = [1,2,3,3,2,1];
console.log(a.indexOf(2)); //1
console.log(a.lastIndexOf(2)); //4

.every(function(element, index, array)) / .some(function(element, index, array))

• 两个函数类似于离散数学中的逻辑判定，回调函数返回一个布尔值
  • every是所有函数的每个回调函数都返回true的时候才会返回true，当遇到false的时候终止执行，返回false
  • some函数是“存在”有一个回调函数返回true的时候终止执行并返回true，否则返回false

var a=new Array(1,2,3,4,5,6);

console.log(a.every(function(e, i, arr){
return e < 5;
}));  //false

console.log(a.some(function(e,i,arr){
  return e > 4;
}));  //true

.filter(function(element))(类似于过滤)

• 返回数组的一个子集，回调函数用于逻辑判断是否返回，返回true则把当前元素加入到返回数组中，false则不加
• 新数组只包含返回true的值，索引缺失的不包括，原数组保持不变

var a = new Array(1,2,3,4,5,6);

console.log(a.filter(function(e){
  return e % 2 == 0;
})); // [2, 4, 6]

console.log(a); //[1, 2, 3, 4, 5, 6]