创建数组
- Array是 JavaScript 的原生对象，也是一个构造函数，可以用它生成新的数组。
let arr=new Array(2)- Array（2）中的2是创建数组，这个数组里面有两个元素，两个元素都是empty
- Array是js的原生对象，也是构造函数，构造函数本质就是一个函数
- 那么我们也可以这样写(省去new关键字)：
var arr = Array(2); - 运行结果是一样的，但new与不new还是有差别的（prototype……）在这里不做过多的介绍了。建议用这种方式创建数组的时候加上new关键字
- 那么我们也可以这样写(省去new关键字)：
- Array()构造函数，不同的参数会导致行为不一致。
//无参数时，返回一个空数组
new Array(0)
//单个正整数参数，表示返回的新数组的长度
new Array() // []
new Array(1) // [ empty ]--------------这里的空位已经再javascript数组Array中的第四点介绍过了，不在这里赘述了
new Array(2) // [ empty x 2 ]
//非正整数的数值作为参数，会报错
new Array(5.2) //Uncaught RangeError: Invalid array length
new Array(-5) //Uncaught RangeError: Invalid array length
//单个非数值（比如字符串、布尔值、对象、数值……）作为参数，则该参数是返回的新数组的成员
new Array('abc') // ['abc']
new Array([1]) // [Array[1]]
//多参数时，所有参数都是返回的新数组的成员
new Array(1, 2) // [1, 2]
new Array('a', 'b', 'c') // ['a', 'b', 'c']
console.log(new Array([1]))
可以看到参数类型、个数不同都会产生不一样的行为。建议直接使用数组字面量（隐式创建---var arr = [1,2];）是更好的做法
静态方法
- Array.isArray()方法返回一个布尔值，表示参数是否为数组。typeof运算符运算Array类型的返回的是object
var arr = [83, 13, 32];
console.log(typeof arr) // "object"
console.log(Array.isArray(arr) )// true
数组方法
- valueOf()，toString()
- valueOf()方法是Object的原型方法，每个对象都具有该方法，但是各对象返回的值有一定的区别。当需要返回对象的原始值而非字符串的时候才调用它。
var arr = [1123, 2,1,3]
console.log(arr.valueOf())//[1123, 2, 1, 3] - toString方法也是对象的通用方法，数组的toString方法返回数组的字符串形式。
console.log(arr.toString())//1123,2,1,3
- push()，pop()
- push()方法用于在数组的末端添加一个或多个元素，并返回添加新元素后的数组长度。
- 会改变原数组。
var arr = [1123, 2,1,3]
arr.push(10) - 接收多个参数
var arrLength=arr.push(true, {})
console.log(arrLength)//7
console.log(arr)// [1123, 2, 1, 3, 10, true, {…}] - push()没有参数，数组长度不变，数组不改变
var arr = new Array(3)
console.log(arr.length)//3
console.log(arr.push())//3
- 会改变原数组。
- pop()方法用于删除数组的最后一个元素，并返回该元素。
- 会改变原数组
arr.pop()
console.log(arr)//[1123, 2, 1, 3, 10, true]
- 会改变原数组
- 删除空数组里面的元素，返回undefined
var arr=[]
console.log(arr.pop())//undefined - 删除empty（空位），返回undefined
var arr = new Array(3)
console.log(arr.length)//3
console.log(arr.shift())//undefined
console.log(arr.length)//2
- shift()，unshift()
- shift()方法用于删除数组的第一个元素，并返回该元素。
- 会改变原数组。
var arr = [11,22,33,44,55]
console.log(arr.shift())//11---返回删除的元素
console.log(arr)//[22, 33, 44, 55] - 删除空数组里面的元素，返回undefined
var arr=[]
console.log(arr.shift())
- 会改变原数组。
- shift()方法用于删除数组的第一个元素，并返回该元素。
- unshift()方法用于在数组的第一个位置添加元素，并返回添加新元素后的数组长度
- 该方法会改变原数组。
var arr = [11,22,33,44,55];
console.log(arr.unshift('小明'))//6
console.log(arr)//["小明", 11, 22, 33, 44, 55] - 接收多个参数
console.log(arr.unshift('小明','小张','小王'))//8
console.log(arr)//["小明", "小张", "小王", 11, 22, 33, 44, 55]
- 该方法会改变原数组。
- join() 方法连接数组：以指定参数作为分隔符，返回连接后的数组字符串。如果不没有参数，默认逗号分隔。
var arr = [11,22,33,44,55]
console.log(arr.join(' '))//11 22 33 44 55
console.log(arr.join('#'))//11#22#33#44#55
console.log(arr)//[11, 22, 33, 44, 55]//------------------------------原数组不改变- 数组中空位，undefined，null，拼接字符串是什么样子的。
console.log([,undefined,null].join())//,,
console.log([1,,undefined,null].join())//1,,,
- 数组中空位，undefined，null，拼接字符串是什么样子的。
- concat()用于连接两个数组。它将新数组的成员，添加到原数组成员的后部，然后返回一个新数组，原数组不变。
var arr=[1,2]
console.log(arr.concat(3))//[1, 2, 3]
console.log(arr.concat(false))//[1, 2, false]
console.log(arr.concat({}))//[1, 2, {…}]
console.log(arr.concat(undefined))//[1, 2, undefined]
console.log(arr.concat(null))//[1, 2, null]
console.log(arr.concat([100,200]))//[1, 2, 100, 200]
-
数组中的元素有对象类型，concat方法返回当前数组的一个浅拷贝（拷贝对象的引用）。
var obj1={name:'xiaoming'}
var obj2={gender:0}
var arr1 = [obj1]
var arr2 = [obj2,0,1]
var concatArr=arr1.concat(obj2,arr2)
obj2.gender=1
obj1.name='小明'
console.log(concatArr,'concatArr')
image.png
- reverse()用于反转数组中的元素，返回改变后的数组。
+ 该方法将改变原数组。
var arr = [1,2,3,4]
console.log(arr.reverse())//[4, 3, 2, 1]
console.log(arr)//[4, 3, 2, 1] - slice()
- 方法用于获取数组中的一部分元素。返回一个新数组，原数组不变。
arr.slice(start, end)--表示从start开始，end结束。省略第二个参数的时候，则是从start开始到数组最后一个元素
var arr = [1,2,3,4]
console.log(arr.slice(1))//[2, 3, 4]-----------------返回从索引为1到末尾
console.log(arr.slice(0,2))//[1, 2]
console.log(arr.slice(1,2))//[2]
+ 没有参数，相当于拷贝原数组，拷贝的时引用
var obj={a:'小米'}
var arr = [obj,2,3,4]
var arr2=arr.slice()
obj.a='华为'
console.log(arr2[0].a)//华为
+ 参数是负数----从后往前数的位置
var arr = [1,2,3,4]
console.log(arr.slice(-4,-1))//[1, 2, 3]
console.log(arr.slice(-4,3))//[1, 2, 3]
console.log(arr.slice(0,3))//[1, 2, 3]
console.log(arr.slice(0,-1))//[1, 2, 3]
console.log(arr.slice(-1,0))// []
console.log(arr.slice(-3,-1))// []
- splice()
- splice()方法用于删除原数组的一部分成员，并可以在删除的位置添加新的数组成员，返回值是删除元素的数组。
- 该方法会改变原数组
- arr.splice(start, count, ele, ...);
- splice的第一个参数是删除的起始位置（从0开始），第二个参数是删除的元素个数。后面其余蚕食表示添加的元素。
var arr = [1,2,3,4,5,6]
console.log(arr.splice(2,3))//[3, 4, 5]
console.log(arr)//[1, 2, 6] - splice添加元素
var arr = [1,2,3,4,5,6]
console.log(arr.splice(2,3,'a','b','c'))//[3, 4, 5]-----在索引为2的位置插入a,b,c三个元素
console.log(arr)//[1, 2, "a", "b", "c", 6]
var arr = [1,2,3,4,5,6]
console.log(arr.splice(2,0,'a','b','c'))//[]
console.log(arr)//[1, 2, "a", "b", "c", 3, 4, 5, 6] - 第一个参数是负数，表示从倒数位置开始删除数组种的元素。
var arr = [1,2,3,4,5,6]
console.log(arr.splice(-2,0,'a','b','c'))//[]
console.log(arr)//[1, 2, 3, 4, "a", "b", "c", 5, 6] - 只有一个参数，将数组拆分成两个数组。或者理解成将原数组指定位置后面的元素删除
var arr = [1,2,3,4,5,6]
console.log(arr.splice(2))//[3, 4, 5, 6]
console.log(arr)// [1, 2]
9.sort()
- sort方法对数组成员进行排序，默认是按照字典顺序排序。返回排序后的数组
- 该方法会改变原数组
var arr=[33,4,5,6,2,1]
var arr2=['a','c','h','g','a']
var arr3=[5,3,2,7,8]
console.log(arr.sort())//[1, 2, 33, 4, 5, 6]
console.log(arr2.sort())//["a", "a", "c", "g", "h"]
console.log(arr3.sort())//[2, 3, 5, 7, 8]
注:sort()方法不是按照大小排序，而是按照字典顺序。数值会被先转成字符串，然后再按照字符编码的顺序进行排序。sort自定义方式排序，可传一个函数作为参数
如果想让sort方法按照自定义方式排序，可以传入一个函数作为参数
var arr=[33,4,5,6,2,1]
arr.sort(function (a, b) {
return a - b;
})
console.log(arr)//[1, 2, 4, 5, 6, 33]
- map()
- map方法将数组的所有成员依次传入参数函数，然后把每一次的执行结果组成一个新数组返回。原数组不变
var arr=[33,4,5,6,2,1]
var arr4=arr.map(item=>item+1)
console.log(arr4)//[34, 5, 6, 7, 3, 2]- map方法接受回调函数作为参数，该函数可接收三个参数，第一个参数：当前元素，第二个参数：当前元素的索引位置，第三个函数当前数组。map()的 callback 函数需要有返回值，返回值组成新数组作为map()方法的返回值。如果回调函数没有返回值，返回undefined。
arr.map(function(item, index, arr) {
//item:当前元素
//index:当前元素的索引位置
//arr:当前数组
})
- map方法接受回调函数作为参数，该函数可接收三个参数，第一个参数：当前元素，第二个参数：当前元素的索引位置，第三个函数当前数组。map()的 callback 函数需要有返回值，返回值组成新数组作为map()方法的返回值。如果回调函数没有返回值，返回undefined。
- map 接收第二个参数，将回调函数内部this指向，指向第二个参数。
var arr =[2,3,4,5]
var arr1=[0,1,2]
var arr2=arr1.map(function(item){//这个回调函数不要用箭头函数
return this[item]
},arr)
console.log(arr2)// [2, 3, 4] - 如果数组有空位，则跳过空位，但不会跳过undefined和null
- forEach()
- forEach方法与map方法相似。forEach方法不返回值，只用来操作数据。
**12. filter()
- 过滤数组元素，满足条件的元素会组成一个新数组并返回
var arr =[2,3,4,5,6,7,8]
var arr2=arr.filter(item=>{
return item>5
})
console.log(arr2)//[6, 7, 8] - filter方法的参数函数可以接受三个参数：当前元素，当前位置和当前数组。
- filter 接收第二个参数，将回调函数内部this指向，指向第二个参数。
- some()返回一个布尔值，判断数组中的元素是否符合条件。
- 接收一个回调函数作为参数。这个回调函数可以有三个参数，当前成员、当前位置和整个数组
- 返回值是布尔值。
- some方法是只要一个元素符合条件，停止遍历，整个some方法的返回值就是true。否则返回false
var arr = [2,3,23,54]
let isBoolean=arr.some((item,index,bbL)=>{
return item>4
})
console.log(isBoolean)//true
[].some(isEven) --- false - 接受第二个参数，改变回调函数中this
14.every（）和some()类似。只是every（）是所有元素都满足条件的情况下返回true，否则返回false
var arr = [2,3,23,54]
let isBoolean=arr.every((item,index,bbL)=>{
console.log(item,index,bbL)
return item>4
})
console.log(isBoolean)//false
上面代码中其实执行元素2返回的false就不执行了。因为第一就不符合条件。 - 接受第二个参数，改变回调函数中this
[].every(isEven)-------------- true
- reduce()，reduceRight()
- reduce是从左到右处理
- reduceRight则是从右到左
var arr = [2,3,7,5]
var bar = arr.reduce(function (a, b) {
console.log(a, b);
return a + b;
})
console.log(bar,'bar')
var arr = [2,3,7,5]
var bar = arr.reduceRight(function (a, b) {
console.log(a, b);
return a + b;
})
console.log(bar,'bar') - reduce和reduceRight中的回调函数可以接收四个参数。
1.累积变量（必传）
2.当前变量（必传）
3.当前索引
4.原数组
- indexOf()，lastIndexOf()
- indexOf()方法返回给定元素在数组中第一次出现的位置，如果没有出现则返回-1。
var arr = ['a', 'b', 'c'];
arr.indexOf('b') // 1
arr.indexOf('y') // -1
- indexOf()接受第二个参数，表示搜索的开始位置
arr.indexOf('a', 1) // -1
-lastIndexOf方法返回给定元素在数组中最后一次出现的位置，如果没有出现则返回-1。 - 注意
[NaN].indexOf(NaN) // -1
[NaN].lastIndexOf(NaN) // -1
