新人学习JS的日记。

欢迎各位朋友纠错！

以下内容都在谷歌浏览器进行测试可用
一些方法是ES6的,要用babel转码才能用(不过最新版本谷歌浏览器已经支持90%的ES6语法了,基本都可以使用).

>>语法

创建数组
let arr = new Array();  // [] 一个空数组
arr = new Array(10); // [undefined × 10]  当参数只有一个且是number,会生成对应个数的空单元.
arr = Array(10) // 同上,可以不带new操作符.
注意:虽然大多浏览器显示是undefined,但是其实是错误的,因为其单元项是空的,而不是存储的了10个undefined. 
arr = new Array(1,2,'s') //  [1, 2, "s"] 多个参数,将由参数构成数组.
arr = [1,2]; //[1,2]  字面量直接生成数组

>>结构

let arr = ['a','b','c'] // arr的结构大概如下
{
    0: 'a',
    1: 'b',
    2: 'c',
    length:3 // 不可枚举的
};
JS的数组像是一个对象, 所以你也可以给数组定义方法,属性(不推荐,容易出问题).
获取数组项: arr[0] (其实就是获取对象的属性), 但是 arr.0 就不可以了,因为JS中数字开头的属性不能通过.访问
length属性,如果你直接给length赋值(整数),数组大小会直接变为你赋值的大小. 多余的删除,数量不够补上空单元.
不要使用delete 删除数组项. delete删除后,length属性不会改变(数组大小不变).
任何和数组结构相似的(比如说字符串)都可以用call,apply借用数组方法.

>>静态方法

>> Array.isArray(val) -- 检测是否为数组
1: val: 要检测的值.
2: 如果为数组返回true, 反则返回false.
3: 例: Array.isArray(Array.prototype) // true 其实数组的原型也是个数组
   Array.isArray([]) // true

>> Array.from(obj[ ,mapFn [, mapFnThis ] ]) -- 通过类数组或可遍历对象,创建一个新数组.
1: obj:类数组对象,可遍历对象. 
   mapFn:可选参数,写入函数后,生成的数组的每一项都会调用该函数,每一项的值变为调用函数的返回值. 函数自动传入 值,索引 2个参数.
   mapFnThis: 可选参数,执行mapFn是的this值.
2: 类数组项对象:拥有length属性,若干索引属性的对象(例如arguments,字符串等).
   可遍历对象:Map对象,Set对象等.
3: 返回一个数组.
4: 例: Array.from('test',function(val,i){
    if( val === 't' ){
        return i
    } else {
        return 'X'
    }
}) // 返回 [0, "X", "X", 3]

>> Array.of(arg1,arg2,arg3,...) -- 由参数构成数组.
1: arg1: 任意值. 参数个数:任意数量.
2: 与new Arrat() 区别,在参数为单且为整数,也只是创建一个val项的数组. 例: 
   Array.of(7);    // [7] 
   new Array(7);   // [undefined × 7] 其实为7个空单元,每个单元项没有值,而不是每个单元项值都为undefined. 谷歌浏览器显示有问题.

>> 实例方法 (这些方法都定义在数组原型中)

>>会改变数组本身的方法.

let arr = [] // 空数组

>> arr.push(val1, ... , valn) -- 将参数添加到数组末尾. 返回数组新大小.
1: val:可以是任何值.  参数数量不限制. 将其添加到数组末尾.
2: 返回数组的length属性.
3: 虽然字符串对象是类数组对象,但是并不能用此方法,因为字符串是不可改变的.
4: 例: [0].push(1,2,3) // 返回4 , 数组变为[0,1,2,3]

>> arr.pop() -- 删除数组末尾项.返回其值.
1: 删除数组最后一个元素.
2: 返回被删元素的值. 如果对空数组使用,返回undefined.

>> arr.unshift(val1, ...,valn) -- 将参数添加到数组开头. 返回数组新大小.
1: val:可以是任何值.  参数数量不限制. 将其添加到数组开头.
2: 返回数组的length属性.
3: 例如: [0].unshift.(1,2,3) // 返回4,数组变为[1,2,3,0]

>> arr.shift() -- 删除数组首项,返回其值.
1: 删除数组的第一个元素.
2: 返回被删元素的值. 如果对空数组使用,返回undefined.

>> arr.splice(start, deleteCount, item1,...,itemnd) -- 删除/添加元素,来更改数组,返回被删除元素.
1: start:开始删除元素的索引位置. deleteCount:删除的个数. item:从start位置开始添加的项目
2: 若只写start参数, 从start到末尾的元素全部删除.
   写start,deleteCount参数,从start开始计算,删除deleteCount个元素.
   参数都写,item项添加到start位置,其余项依次向后添加,原有项向后移动.
3: 返回一个数组,包含所有被删除的元素.没有删除返回空数组.
4: 例: [0,1,2,3].splice(1, 0, 'a', 'b') // 返回[].  数组: [0, "a", "b", 1, 2, 3]

>> arr.sort( compareFn ) -- 数组排序
1: compareFn: 按照某种顺序排列的函数,可省略.
2: 不写compareFn参数,默认将以字符串Unicode码点排序(数组项在排序时会转为字符串,在进行排序) 
   例:[1,[2],3,10].sort()  排序后:  [1, 10, [2], 3]
3: compareFn函数会对数组中的每一项(除最后一项)进行调用,传入参数 (当前项的值,下一项的值). 
   compareFn(a, b) //a是当前项,b是下一项
   函数返回值 等于0: a,b的位置不改变.
   函数返回值 小于0: a会排列到b的前面. 
   函数返回值 大于0: b会排列到a的前面.
4: 返回排序后的数组.
5: 例: [1,2,10,3].sort( function(a,b){
    return a-b
}) // 返回 [1,2,3,10]

>> arr.reverse() -- 数组反转
1: 将数组反转.
2: 返回反转后的数组.
2: 例: [1,2,3].reverse() // [3, 2, 1]

>> arr.fill(val, start, end) -- 将数组项全部填充为指定值
1: val: 要填充的值. start:起始点索引,默认为0. end:终止点索引,默认为arr.length. 
   start若为负数: 则计算为 arr.length+start
   end若为负数: 则计算为 arr.length+end
   NaN计算为0
2: 例: [1,2,3].fill(0) // [0, 0, 0]
   [1,2,3].fill(0, 1) // [1, 0, 0] 
   [1,2,3].fill(0, 1, 1) // [1, 2, 3]
   [1,2,3].fill(0, 1, 2) // [1, 0, 3]    

>> arr.copyWithin(target, start, end) -- 复制数组的一部分,从指定位置去覆盖原数组, 不改变数组大小.
1: target: 指定位置,从此处开始原数组项将被 复制的数组覆盖.
   start: 从此处开始复制数组. 默认为0
   end: 到此处结束复制(此索引位的值,不会计入). 默认为arr.length
   如果参数是负数,则计算为 参数+arr.length
2: 返回操作完的数组.
3: 例:[0,1,2,3,4,5].copyWithin(2) // [0, 1, 0, 1, 2, 3]
   [0,1,2,3,4,5].copyWithin(0, 3) // [3, 4, 5, 3, 4, 5]
   [0,1,2,3,4,5].copyWithin(0, 3, 5) // [3, 4, 2, 3, 4, 5]

>>不改变数组本身的方法.

>> arr.indexOf(val, start) -- 查找指定值
1: val: 要查找的值. start: 开始查找的位置,默认为0. start为负数计算为: start + arr.length
2: 值是否相等的判断规则与 === 相同. 从左向右进行查找.
3: 返回<首个>被找到的值的索引,没有找到则返回-1
4: 例: [2,5,6].indexOf(2) // 0
   [2,5,6].indexOf(2, 1) // -1   

>> arr.lastIndexOf(val, start) -- 查找指定值,逆向查找.
1: 规则同上,区别: 从右向左查找.
2: 例: [2,5,6].indexOf(2) // 0
   [2,5,6].indexOf(2, 1) // 0  

arr.includes(val, start) -- 查找指定值是否存在
1: val: 要查找的值. start: 开始查找的位置,默认为0. 
2: 该方法会正确处理 NaN �
   [0,NaN].includes(NaN)  // true
   [0,NaN].indexOf(NaN) // -1 

>> arr.slice(start, end) -- 浅拷贝一部分数组
1: start: 此索引位置,开始拷贝,默认为0.  end: 此索引位置,结束拷贝,该索引位不会被拷贝,默认为arr.length.
2: 浅拷贝:若数组项为引用类型,则拷贝引用,两个对象引用都引用了同一个对象.如果被引用的对象发生改变,则新的和原来的数组中的这个元素也会发生改变.
3: 返回拷贝的新数组
4: 例: [0,1,2,3].slice() // [0,1,2,3]
   [0,1,2,3].slice(1) // [1,2,3]
   [0,1,2,3].slice(1,2) // [1]
   
>> arr.concat(val1, ..., valn) -- 数组合并
1: val: 要与arr合并的值,可以说任意值. 参数数量无限制.
2: 此方法是将,元素都浅拷贝到新数组中,然后返回.
   浅拷贝:若数组项为引用类型,则拷贝引用,两个对象引用都引用了同一个对象.如果被引用的对象发生改变,则新的和原来的数组中的这个元素也会发生改变.
3: 返回合并后的一个新数组.
4: 例: [1,2].concat(3) // [1,2,3]
   [1,2].concat([3,4]) // [1,2,3,4]
 
>> arr.join(val) -- 将数组项连接为字符串
1: val:数组项之间连接的值,默认为","
2: 将数组项都转换为字符串,在进行连接. 若数组项是undefined,null 会将其转换为''空字符串在进行连接.
3: 返回字符串
2: 例: [1,2,3,4].join() // "1,2,3,4"
   [1,2,3,4].join('') //"1234"  空字符串
   [1,2,3,4].join('-') // "1-2-3-4"
   [1,2,3,null].join('-') // "1-2-3-"

>> arr.toString() -- 返回数组的字符串形式
1: 和调用arr.join() 差不多.
2: 例:[1,2,3,4].toString() //"1,2,3,4"  

>>遍历方法

>> arr.forEach(fn, fnThis) -- 每个数组项执行一次函数.
1: fn:对每个数组项执行的函数,有3个参数. fnThis:fn函数的this值 
   fn(val, index, array)  //val:当前处理的数组项. index: 当前数组项的索引. array:原数组.
2: 不会对空单元调用函数(没有任何值的数组项). 
3: forEach遍历的范围在调用函数前就已经确定,函数中数组项的值是调用函数时去访问的值.
   在函数中增大数组大小,增加的项不会被遍历.
   删除(shfit,pop,splice)数组项,有效, 被删除的值,不会被遍历到.
   改变数组本身的方法都有效,但是将原数组重新赋值,不会影响forEach所遍历的数组.
4: 返回undefined 
5: 例:
   let arr = [1,2,3]
   arr.forEach(function(a,b,c){
      console.log(a,b,c) 
      c.unshift(1)
      c = arr = null
   })
   // 1  0  [1, 2, 3]
   // 1  1  [1, 1, 2, 3]
   // 1  2  [1, 1, 1, 2, 3]
   
>> arr.map(fn, fnThis) --  一个新数组,数组项都为函数的返回值.
1: fn:对每个数组项执行的函数,有3个参数. fnThis:fn函数的this值 
   fn(val, index, array)  //val:当前处理的数组项. index: 当前数组项的索引. array:原数组.
2: map遍历的范围在调用函数前就已经确定,函数中数组项的值是调用函数时去访问的值.
   在函数中增大数组大小,增加的项不会被遍历.
   删除(shfit,pop,splice)数组项,有效, 被删除的值,不会被遍历到.
   改变数组本身的方法都有效,但是将原数组重新赋值,不会影响map所遍历的数组.
3: 返回值:该方法对数组每个数组项调用一次fn函数,将返回值组合为数组,作为返回值.
2: 例: let arr = [1,2,3]
   let newArr =  arr.map(function(a,b,c){
      console.log(a,b,c) 
      c.unshift(1)
      c = arr = null
      return 'test'
   })
   console.log(newArr)
   // 1  0  [1, 2, 3]
   // 1  1  [1, 1, 2, 3]
   // 1  2  [1, 1, 1, 2, 3]
   // ["test", "test", "test"]

>> arr.reduce(fn,initialValue) -- 累加数组项.
1: fn:对每个数组项执行的函数,有4个参数. initialValue:上一次函数调用返回值,尚未有函数调用时,默认为0
   fn( lastVal, nowVal, nowIndex, array )
   // lastVal:上一次函数调用的返回值. nowVal:当前数组项. nowIndex:当前数组项索引. array:调用reduce数组. 
   fn第一次调用时,lastVal为数组第一项或则是提供的initialValue.
   如果提供了initialValue, nowIndex从0开始,否则从1开始.
2: reduce遍历的范围在调用函数前就已经确定,函数中数组项的值是调用函数时去访问的值.
   在函数中增大数组大小,增加的项不会被遍历.
   删除(shfit,pop,splice)数组项,有效, 被删除的值,不会被遍历到.
   改变数组本身的方法都有效,但是将原数组重新赋值,不会影响reduce所遍历的数组.
3: 若数组为空,会报错. 
    如果数组仅有一个元素(无论位置如何)并且没有提供initialValue, 或者有提供initialValue但是数组为空,那么此唯一值将被返回并且callback不会被执行.
4: 返回最终累加值
5: [0,1,2,3,4].reduce(function(lastVal,nowVal){
      return lastVal+nowVal;
   }); // 返回10

>> arr.reduceRight(fn, initialValue) -- 反向累加数组项
1: 规则同上,只是从右向左累加.

>> arr.find(fn, fnThis) -- 查找通过函数检测的第一个数组项,返回其值
1: fn:对每个数组项执行的函数,有3个参数. fnThis:fn函数的this值.
   fn( nowValue, index, array ) 
   // nowValue:当前数组项. index:当前索引. array:调用此函数的数组.
2: find遍历的范围在调用函数前就已经确定,函数中数组项的值是调用函数时去访问的值.
   在函数中增大数组大小,增加的项不会被遍历.
   删除(shfit,pop,splice)数组项,有效, 被删除的值,不会被遍历到.
   改变数组本身的方法都有效,但是将原数组重新赋值,不会影响find所遍历的数组.
3: 当函数返回true(或则可以转换为true的值)时,会立刻停止遍历,返回当前所遍历的数组项.  
   遍历完,没有函数返回true,则返回undefined.
4: 例: [1,2,'test'].find(function(now){
       if(now === 'test'){
           return true
       }
   }) // 返回  "test"

>> arr.findIndex(fn, fnThis) -- 查找通过函数检测的第一个数组项,返回其索引值.
1: 规则同上.
   区别:返回索引值. 若没满足函数的数组项,返回-1;

>> arr.filter(fn, fnThis) -- 将通过函数检测的数组项,组成新数组返回.
1: fn:对每个数组项执行的函数,有3个参数. fnThis:fn函数的this值.
   fn( nowValue, index, array ) 
   // nowValue:当前数组项. index:当前索引. array:调用此函数的数组.
2: filter遍历的范围在调用函数前就已经确定,函数中数组项的值是调用函数时去访问的值.
   在函数中增大数组大小,增加的项不会被遍历.
   删除(shfit,pop,splice)数组项,有效, 被删除的值,不会被遍历到.
   改变数组本身的方法都有效,但是将原数组重新赋值,不会影响filter所遍历的数组.
3: 返回一个新数组. 新数组项为:调用函数会返回true的数组项. 
4: 例:[1,2,'test'].filter(function(now){
       return typeof now === 'number';
   }) // [1, 2]

>> arr.some(fn, fnThis) -- 是否有数组项通过函数检测.
1: fn:对每个数组项执行的函数,有3个参数. fnThis:fn函数的this值.
   fn( nowValue, index, array ) 
   // nowValue:当前数组项. index:当前索引. array:调用此函数的数组.
2: some遍历的范围在调用函数前就已经确定,函数中数组项的值是调用函数时去访问的值.
   在函数中增大数组大小,增加的项不会被遍历.
   删除(shfit,pop,splice)数组项,有效, 被删除的值,不会被遍历到.
   改变数组本身的方法都有效,但是将原数组重新赋值,不会影响some所遍历的数组.
3: 例:[1,2,'test'].some(function(now){
       return typeof now === 'string';
   }) // true

>> arr.every(fn, fnThis) -- 所有数组项是否都通过了指定数组的检测
1: fn:对每个数组项执行的函数,有3个参数. fnThis:fn函数的this值.
   fn( nowValue, index, array ) 
   // nowValue:当前数组项. index:当前索引. array:调用此函数的数组.
2: every遍历的范围在调用函数前就已经确定,函数中数组项的值是调用函数时去访问的值.
   在函数中增大数组大小,增加的项不会被遍历.
   删除(shfit,pop,splice)数组项,有效, 被删除的值,不会被遍历到.
   改变数组本身的方法都有效,但是将原数组重新赋值,不会影响every所遍历的数组.
3: 例:[1,2,'test'].every(function(now){
       return typeof now === 'number';
   }) // false

以上是我所知的的东西，有任何错误，请在评论指出！
O(∩_∩)O谢谢你的观看~