新人学习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谢谢你的观看~
网友评论