数组api
- 创建数组 new Array() 构造方法
arr = [] 数组自变量 相当于new Array 所有方法都是 Array.prototype
js里的数组基于对象，当访问没有的属性时返回undefined 不报错
var arr = [,] // [empty] length 1
var arr = [, , ] // [empty*2] // length 3
var arr = [ 1, ,1 ] // [1, empty ,1] // length 3
var arr = new Array(1,2,3,4,5) // [1,2,3,4,5]
var arr = new Array(10)
// [empty*10] 当newArray只有一个参数，参数为length
var arr = new Array(10.3) // 报错 数组长度不能为小数
Array() // []
- Array.of() 方法创建一个具有可变数量参数的新数组实例，而不考虑参数的数量或类型。
Array.of(7) 创建一个具有单个元素 7 的数组，而 Array(7) 创建一个长度为7的空数组
Array.of(7); // [7]
Array.of(1, 2, 3); // [1, 2, 3]
Array(7); // [ , , , , , , ]
Array(1, 2, 3); // [1, 2, 3]
- 将数组转换为字符串
String(arr) 返回一个与数组视觉上一样的字符串
var arr = [1, 2, 3, 4]
var str = String(arr)
str // "1, 2, 3, 4"
- 将数组拼成字符串
arr. join(“分隔符”) 如果分隔符""则无缝拼接，如果括号里不写，则等同于 String()
var arr = [1, 2, 3, 4]
console.log(arr.join("")); // 1234
console.log(arr.join()); // "1,2,3,4"
console.log(arr.join("~")); //1~2~3~4
- 数组连接
arr.concat() 将两个数组合并成一个数组，concat的参数中包含数组，则打散数组，以单个元素拼接
// 字符串拼数组
var arr1 = [1, 2, 3], arr2 = [4, 5, 6]
console.log(arr1.concat(1, 2)); //[1, 2, 3, 1, 2]
// 数组拼数组
var arr1 = [1, 2, 3], arr2 = [4, 5, 6]
console.log(arr1.concat(arr2)); //[1, 2, 3, 4, 5, 6]
- 数组截取
arr.slice(start,end+1) 含头不含尾
获得arr中starti位置开始，到endi位置的所有元素组成的新数组
省略第二个参数：表示从starti一直取到结尾
可支持负数参数：-n表示倒数第n个元素，相当于length-n
var arr = [1, 2, 3, 4]
arr.slice(0)//[1, 2, 3, 4]
arr.slice(0, 2)//[1, 2]
arr.slice(-3)//[2, 3, 4]
arr.slice(-3, -1)//[2, 3]
arr.slice(0, 2)//[1, 2]
arr//[1, 2, 3, 4]
- 删除，插入，替换数组元素 直接修改原数组
arr.splice(start,n) 删除从start开始的n个元素 返回被删除的元素组成的临时新数组
arr.splice(start,0,1,2,3) 从start开始删除0个元素，添加1,2,3
arr.splice(start,3,1,2,3) 从start开始删除n个，添加1，2，3
// 删除
var arr = [1, 2, 3, 4]
arr.splice(0)//[1, 2, 3, 4]
var arr = [1, 2, 3, 4]
arr.splice(-1)//[4]
var arr = [1, 2, 3, 4]
arr.splice(0, 3)//[1, 2, 3]
arr // [4]
// 添加
var arr = [1, 2, 3, 4]
arr.splice(2, 0, 22, 33)
arr//[1, 2, 22, 33, 3, 4] 在 2 的位置上删除0个 添22,33
// 替换
var arr = [1, 2, 3, 4]
arr.splice(2, 2, 5, 6)
arr//[1, 2, 5, 6]
- 数组排序 改变原数组
arr.sort() 默认升序
sort()括号里是一个接口，可以通过回调函数按照想要的方式排序
要求： 必须写两个形参 ； 排序根据返回值
当为负数升序 前面的数在前，正数降序 后面的数在前， 0不动
arr=[1,5,3,2]
arr.sort()//[1, 2, 3, 5]
arr=[1,5,32,2]
arr.sort()//[1, 2, 32, 5]
arr//[1, 2, 32, 5] 这里有个bug 因为排序是按照Unicode码来排序 3在5之前
var arr = [1, 4, 3, 10, 42]
arr.sort(function (a, b){
if(a > b){ // 可以直接写成 return a-b 升序
return 1; // return b-a 降序
}else {
return -1;
}
})
// [1, 3, 4, 10, 42] 降序只需要把判断改掉
// 对象也可以排序
var a = {
age: 21
}
var b = {
age: 51
}
var c = {
age: 17
}
var d = {
age: 24
}
var arr = [a, b, c, d]
arr.sort(function (a, b) {
return a.age - b.age
})
(4) [{…}, {…}, {…}, {…}]
/*
0:{age: 17}
1:{age: 21}
2:{age: 24}
3:{age: 51}
*/
// 根据字节长度排序
String.prototype.bytes = function retBytes() {
var num = this.length
for (var i = 0; i < this.length; i++) {
if (this.charCodeAt(i) > 255) {
num++
}
}
return num
}
var arr = ["dfafd", "sfdfffdsss", "cd", "sdfdfss"]
arr.sort(function (a, b) {
return a.bytes() - b.bytes()
})
console.log(arr); //["cd", "dfafd", "sdfdfss", "sfdfffdsss"]
- 数组反转 修改原数组
arr.reverse() 将数组里的数值反转，并修改原数组
自己封装思路 就是将原数组逆向循环，然后push新数组里，最后重新赋值给原数组
var arr = [1, 2, 3]
arr.reverse()
arr // [3,2,1]
// 原理
var arr = [1, 2, 3]
var index=[]
for (let i = arr.length; i ; i--) {
index.push(i)
}
console.log(index); // [3,2,1]
- 结尾出入栈
结尾入栈 arr.push() 返回新数组的length
结尾出栈arr.pop()
// 入栈
var arr=[1,2,3,4]
arr2=arr.push(1)//5
//返回新数组的长度
arr//[1, 2, 3, 4, 1]
// push 原理
Array.prototype.push = function (target) {
this[this.length] = target;
this.length++
}
// 出栈
var arr=[1,2,3,4]
arr.pop()//4
//返回弹出的元素
arr//[1,2,3]
- 开头出入栈 修改原数组
入栈 arr.unshift()
出栈arr.shift() 返回取出的元素
// 入栈
var arr=[1,2,3,4]
arr.unshift(22)//5
arr//[22, 1, 2, 3, 4]
// 原理 新建一个数组，然后再拼接
// 出栈
var arr=[1,2,3,4]
arr.shift()//1
arr//[2, 3, 4]
- 直接修改原数组
1.arr.splice();
2.arr.reverse();
3.arr.sort();
4.arr.push(值);arr.pop();
5.arr.unshift(值);arr.shift();
- 不修改原数组：
1.String(arr);
2.arr.join(“自定义分隔符”);
3.arr1.concat(值1,值2,arr2,…);
4.arr.slice(starti,endi+1);
- Array.from() 方法从一个类似数组或可迭代对象中创建一个新的数组实例。
console.log(Array.from('foo'));
// expected output: Array ["f", "o", "o"]
console.log(Array.from([1, 2, 3], x => x + x));
// expected output: Array [2, 4, 6]
- Array.isArray() 用于确定传递的值是否是一个 Array。
Array.isArray([1, 2, 3]);
// true
Array.isArray({foo: 123});
// false
Array.isArray("foobar");
// false
Array.isArray(undefined);
// false
- arr.copyWithin(target[, start[, end]]) 方法浅复制数组的一部分到同一数组中的另一个位置，并返回它，而不修改其大小
target:必需。复制到指定目标索引位置。
start: 可选。元素复制的起始位置。
end:可选。停止复制的索引位置 (默认为 array.length)。如果为负值，表示倒数
var array1 = [1, 2, 3, 4, 5];
// place at position 0 the element between position 3 and 4
console.log(array1.copyWithin(0, 3, 4));
// expected output: Array [4, 2, 3, 4, 5]
// place at position 1 the elements after position 3
console.log(array1.copyWithin(1, 3));
// expected output: Array [4, 4, 5, 4, 5]
- arr.entries() //没卵用的方法
entries构造出一个对象，有next方法构造出一个对象
var array1 = ['a', 'b', 'c'];
var iterator1 = array1.entries();
console.log(iterator1.next().value);
// expected output: Array [0, "a"]
console.log(iterator1.next().value);
// expected output: Array [1, "b"]
{
value:[0:index,1:'value'],
done:false
}
//结束时value:undefine, done: true
- arr.every(callback[, thisArg]) // 用来测试此数组的元素是否满足某个条件
callback
用来测试每个元素的函数。
thisArg
执行 callback 时使用的 this 值。
function isBelowThreshold(currentValue) {
return currentValue < 40;
}
var array1 = [1, 30, 39, 29, 10, 13];
console.log(array1.every(isBelowThreshold));
// expected output: true
- arr.fill(value[, start[, end]]) 用来填充/替换数组，把一些固定值放进数组的某个位置
value:用来填充的值 若只有一个值则替换所有数组
start: 开始位置 可不写
end: 结束位置 可不写 不写则到数组结束
var array1 = [1, 2, 3, 4];
// fill with 0 from position 2 until position 4
console.log(array1.fill(0, 1, 3));
// expected output: [1, 0, 0, 4]
// fill with 5 from position 1
console.log(array1.fill(5, 1));
// expected output: [1, 5, 5, 5]
console.log(array1.fill(6));
// expected output: [6, 6, 6, 6]
- var new_array = arr.filter(callback(element[, index[, array]])[, thisArg]) 过滤满足条件的值
callback
用来测试数组的每个元素的函数。调用时使用参数 (element, index, array)。
返回true表示保留该元素（通过测试），false则不保留。它接受三个参数：
element
当前在数组中处理的元素。
array可选
调用了filter的数组。
thisArg可选
可选。执行 callback 时的用于 this 的值。
var words = ['spray', 'limit', 'elite', 'exuberant', 'destruction', 'present'];
const result = words.filter(word => word.length > 6);
console.log(result);
// expected output: Array ["exuberant", "destruction", "present"]
- arr.find(callback[, thisArg])返回数组中满足提供的测试函数的第一个元素的值。否则返回 undefined。
callback
在数组每一项上执行的函数，接收 3 个参数：
element
当前遍历到的元素。
index
当前遍历到的索引。
array
数组本身。
thisArg 可选
可选，指定 callback 的 this 参数。
function findCherries(fruit) {
return fruit.name === 'cherries';
}
console.log(inventory.find(findCherries)); // { name: 'cherries', quantity: 5 }
类数组
相当于一个以数字为索引的对象
属性为索引
有length属性
最好有push方法
var obj = {
'0': 'a',
'1': 'b',
'2': 'c',
"length": 3,
"push": Array.prototype.push, // push方法为人为添加
"splice": Array.prototype.splice // 加了splice方法后，打印出来就和数组一样
}
// alibaba 面试题：
var obj = {
'2': 'a',
'3': 'b',
"length": 2,
"push": Array.prototype.push
}
obj.push("c")
obj.push("d")
console.log(obj); // {'2':"c",'3':"d",'length':4}
typeof (arguments) // Object
// 类数组也是对象 即使是数组返回也是Object