1.实例化
- 字面量
使用中括号作为边界，元素与元素之间通过逗号分隔。
var arr = ["terry","larry","tom",1,true,{age:120},function(){}]
- 构造函数
var arr = new Array(); //var arr = []
var arr = new Array(3); //创建一个数组长度为3的数组
var arr = new Array(true); //创建一个数组，数组中有一个元素等价于[true];
var arr = new Array(3,4); //等价于[3,4]
2.数组访问
中括号访问，索引，索引从0开始表示第一个元素 arr[0]; 数组的长度为length,在js中不存在数组越界异常。
3.数组遍历
- 三种基础遍历： while，do-while，for
- for - in
- 各种api
4.API（引用程序编程接口）库
- 静态方法（构造函数方法）
Array.isArray(arr);
判定参数arr是不是数组
var arr = [1,2,3,4,4];
var result = Array.isArray(arr);
console.log(result)
Array.of();
es6中的方法，将参数放到数组中返回。
var arr = Array.of(3,4);
console.log(arr);
- 非静态方式（构造函数原型中的方法，实例方法）
1）循环类
Array.prototype.forEach(handler)
作用:遍历指定数组
参数:回调函数，可以接受3个参数（item,index,arr）
forEach 方法每次遍历出来一个元素之后都执行这个回调函数。
返回值：undefined
var arr = [
{
name : "terry",
age: 12
},{
name : "Merry",
age: 13
},{
name : "lerry",
age: 14
}
];
arr.forEach(function(item,index,arr){
console.log(item,index,arr)
});
Array.prototype.exery(handler)
作用：遍历指定数组，判定是否每个元素都满足指定条件
参数：回调函数，可以接受3个参数（item,index,arr）,该回调函数会返回一个boolean值，当所有回调函数返回true，最终结果为true，当一个回调函数返回了false，该函数终止，every方法的结果为false。
返回值：boolean
//判断年龄大小
var arr = [{
id : 1,
age: 19,
gender : "male"
},{
id : 2,
age: 27,
gender : "male"
},{
id : 3,
age: 37,
gender : "male"
}]
var a=arr.every(function(item){
return item.age>18;
});
console.log(a);
//判断数字大于10
var arr = [1,2,4,6,65];
var a = arr.every(function(item){
return item>10 ;
});
console.log(a);
Array.prototype.some(handler)
作用：遍历数组，判断是否有元素都满足指定条件
参数：回调函数，可以接受3个参数（item，index，arr），该回调函数会返回一个boolean值，当有回调函数返回true，该函数中止，最终every方法的结果为true, 当所回调函数返回了false,every方法的结果为false
返回值：boolean
注：some跟every的区别在于，some中有一个满足条件就返回true而every必须全部满足才返回true
var arr = [1,2,4,6,65];
var a = arr.some(function(item){
return item>10 ;
});
console.log(a);//true
Array.prototype.map(handler)
作用：从指定元素中映射出某些值，组成新的数组返回
参数：回调函数，可以接受3个参数（item，index，arr），该回调函数会返回一个数组，数组元素为每个回调函数返回的值。
返回值：Array
var arr = [{
name : "terry",
age : 12
},{
name : "merry",
age : 13
},{
name : "lerry",
age : 14
}]
var a = arr.map(function(item){
return item.age;
});
console.log(a); //结果[ 12, 13, 14 ]
console.log(arr);
//结果[
{ name: 'terry', age: 12 },
{ name: 'merry', age: 13 },
{ name: 'lerry', age: 14 }
]
//小写转大写
var arr = ["Hello","body","Cup","dEll"];
var a = arr.map(function(item){
return item.toUpperCase();//小写转大写
//retuen item .toLowerCase(); 大写转小写
});
console.log(a);//[ 'HELLO', 'BODY', 'CUP', 'DELL' ]
Array.prototype.filter(handler)
作用：从指定中过滤出满足条件的元素，组成新的数组返回
参数：回调函数，可以接受3个参数（item，index，arr），该回调函数会返回一个数组，数组元素为回调函数返回值为true的那个元素。
返回值：Array
var arr = [1,23,423,12,4,5,2];
var a = arr.filter(function(item){
return item>10;
});
console.log(a); //[23,423,12]
console.log(arr);//[1,23,423,12,4,5,2]
var arr = [{
name: "北京",
temp:36.1,
time:"2020-08-20"
},{
name: "北京",
temp:36.4,
time:"2020-08-21"
},{
name: "北京",
temp:35.3,
time:"2020-08-22"
}]
var a = arr.map(function(item){
return item.temp;
});
console.log(a);//[ 36.1, 36.4, 35.3 ]
2）栈方法
后进先出结构
Array.prototype.push(v) 【原值改变】
作用：入栈，为指定数组添加元素，该元素添加到数组的末尾
参数：可以多个任意类型的数组
返回值：数组的长度
var arr = [1,2,3,4];
arr.push(5,6);
console.log(arr);//[1,2,3,4,5,6]
Array.prototype.pop(v) 【原值改变】
作用：出栈，将数组末尾的值删除并且返回
返回值：出栈的元素
var arr = [1,2,3];
var a = arr.pop();
console.log(a); //3
console.log(arr); // [1,2]
3）队列方法
先进先出
Array.prototype.shift() 【原值改变】
作用：出队列，将数组开头的值删除并且返回
返回值：出队列的元素
var arr = [1,2,3];
var a = arr.shift();
console.log(a); //1
console.log(arr); //[2,3]
Array.prototype.unshift(v) 【原值改变】
作用:在数组的开头插入一个值
参数：值
返回值：数组长度
var arr = [1,2,3];
var a = arr.unshift(3);
console.log(a); //4
console.log(arr); //[3,1,2,3]
4）排序方法
Array.prototype.reverse() 【原值改变】反转序列
作用：将数组中的元素反转
返回值：反转之后的数组
var arr = [1,2,3];
var a = arr.reverse();
console.log(a); //[3,2,1]
console.log(arr); //[3,2,1]
Array.prototype.sort() 【原值改变】
作用：排序，如果没参数，将会按照字符串【如果是其他数据类型，先转换为字符串】的顺序进行排序；如果参数由比较器函数，则按照比较强函数规则进行排序
参数：无 或 比较器函数
比较器函数接受两个参数，a，b 当a>b 返回-1 正序
当比较器函数返回值大于0，a排在b的后面
返回值：排序后的数组
var arr = [1,7,2,3,53];
var a = arr.sort();
console.log(a); //[1,2,3,53,7] 通过ASCLI码排首个数
console.log(arr);//[1,2,3,53,7]
var arr = [1,7,2,3,53];
arr.sort(function(a,b){
if(a>b) return 1;
else return -1;
});
console.log(arr); //[1,2,3,7,53]
var arr = [{
name: "百事可乐",
price:3,
grade:90
},{
name: "可口可乐",
price:2.5,
grade:85
},{
name: "非常可乐",
price:1.5,
grade:60
}];
arr.sort(
function(item){
return function(a,b){
if(a[item] > b[item]) return 1;
else return -1;
}
}("price")
);
console.log(arr);
5）数组分割函数
Array.prototype.slice(begin,end)【原值不改变】
作用：从指定数组中获得子数组，不改变原值
参数：begin开始位置，end结束位置，不包含结束位置，end可以省略，截取到数组末尾
返回值：截取的数组
var arr = [1,2,4,5];
var a = arr.slice(1,2);
console.log(arr); //[1,2,3,4],
console.log(a);, //[2]
var arr = [1,2,4,5];
var a = arr.slice(1,3);
console.log(arr); //[1,2,3,4]
console.log(a); //[2,3]
Array.prototype.splic(begin,len,a,b,c…) 【原值改变】
作用：删除替换插入
参数:begin开始位置、len删除的元素个数、abc插入的元素
返回值：删除元素组成的数组
var arr = [1,2,3,4];
var a = arr.splice(0,0,5,6);
console.log(a); //[]
console.log(arr);//[5,6,1,2,3,4]
var arr = [1,2,3,4];
var a = arr.splice(1,1,5,6);
console.log(a); //[2]
console.log(arr); //[1,5,6,3,4]
6)数组元素查找
Array.prototype.indexOf(item)
作用：从数组前往后查找item所在的索引，找到之后不再检索
参数：要查找的元素值
返回值：索引/-1
var arr = [1,2,4,5]
var a = arr.indexOf(4);
console.log(a); //2
Array.prototype.lastIndexOf(item)
作用：从数组后往前查找item所在的索引，找到之后不再检索
参数：要查找的元素值
返回值：索引/-1
var arr = [1,2,4,5]
var a = arr.lastIndexOf(2);
console.log(a); //1
7)数组合并
Array.prototype.concat() 【原值不改变】
作用：合并数组
参数：数组
返回值：合并后的数组
var arr = [1,2,3];
var a = arr.concat([1,2,3]);
console.log(arr); //[1,2,3]
console.log(a); //[1,2,3,1,2,3]
8）数组的序列化
Array.prototype.join(s) 【原值没改变】
将数组转换为字符串，通过s分割开数组中每个元素。
JSON.stringify() // es标准
querystring.stringify() // nodejs，浏览器（第三方）
var arr = ["a",1,3,"j"];
var a = arr.join("*");
console.log(arr); //[ 'a', 1, 3, 'j' ]
console.log(a); //a*1*3*j
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
