var Arr1 = new Array();//创建一个空数组
var Arr2 = new Array(6);//规定了数组长度为6,然后再根据索引向里面添加值
Arr2[0] = 1;
var Arr3 = new Array('a','b','c');//直接实例化创建一个包含三个字符串的数组
var Arr1 = [];//创建一个空数组
var Arr2 = [6];//创建一个包含6项的数组
var Arr3 = ['a','b','c'];//创建一个包含三个字符串的数组
方法 | 作用 | 是否改变原数组 |
---|---|---|
1.push | 在数组的末尾增加一个或多个元素,并返回数组的新长度 | 是 |
2.pop | 删除数组的最后一个元素,并返回这个元素 | 是 |
3.unshift | 在数组的开头增加一个或多个元素,并返回数组的新长度 | 是 |
4.shift | 删除数组的第一个元素,并返回这个元素 | 是 |
5.sort | 对数组元素进行排序,并返回当前数组 | 是 |
6.reverse | 颠倒数组中元素的顺序 | 是 |
7.splice | 添加或删除数组中的元素 | 是 |
8.copyWithin | 从数组的指定位置拷贝元素到数组的另一个指定位置中 | 是 |
9.concat | 用于连接两个或多个数组 | 否 |
10.entries | 返回一个数组的迭代对象,该对象包含数组的键值对 (key/value) | 否 |
11.every | 检测数组所有元素是否都符合指定条(通过函数提供) | 否 |
12.fill | 将一个固定值替换数组的元素 | 是 |
13.filter | 创建一个新的数组,新数组中的元素是通过检查指定数组中符合条件的所有元素 | 否 |
14.find | 返回通过测试(函数内判断)的数组的第一个元素的值 | 否 |
15.findIndex | 返回传入一个测试条件(函数)符合条件的数组第一个元素位置 | 否 |
16.forEach | 用于调用数组的每个元素,并将元素传递给回调函数 | 否 |
17.from | 通过拥有 length 属性的对象或可迭代的对象来返回一个数组 | 否 |
18.includes | 判断一个数组是否包含一个指定的值,如果是返回 true,否则false | 否 |
19.indexOf | 返回数组中某个指定的元素位置,没有的话返回-1 | 否 |
20.isArray | 判断一个对象是否为数组,是返回true否则返回false | 否 |
21.join | 把数组中的所有元素转换一个字符串。元素是通过指定的分隔符进行分隔的 | 否 |
22.keys | 从数组创建一个包含数组键的可迭代对象。如果对象是数组返回 true,否则返回 false | 否 |
23.lastIndexOf | 返回一个指定的元素在数组中最后出现的位置,从该字符串的后面向前查找 | 否 |
24.map | 返回一个新数组,数组中的元素为原始数组元素调用函数处理后的值 | 否 |
25.reduce | 接收一个函数作为累加器,数组中的每个值(从左到右)开始缩减,最终计算为一个值 | 否 |
26.reduceRight | 功能和 reduce() 功能是一样的,不同的是 reduceRight() 从数组的末尾向前将数组中的数组项做累加 | 否 |
27.slice | 可从已有的数组中返回选定的元素 | 否 |
28.some | 用于检测数组中的元素是否满足指定条件(函数提供) | 否 |
29.toString | 把数组转换为字符串,并返回结果 | 否 |
30.valueOf | 返回 Array 对象的原始值 | 否 |
语法:array.push(item1, item2, …, itemX)
var array = ['1','2'];
array.push('3','4');
console.log(array);//['1','2','3','4'] 改变了数组
语法:array.pop()
var array = ['1','2'];
array.pop();
console.log(array); //['1'] 改变了原数组
语法:array.unshift(item1, item2, …, itemX)
var array = ['1','2'];
array.unshift('0','6');
console.log(array); //['0','6','1','2'] 改变了原数组
语法:array.shift()
var array = ['1','2'];
array.shift();
console.log(array); //['2'] 改变了原数组
语法:array.sort(sortfunction)
参数:sortfunction 可选。规定排序顺序。必须是函数。
//1.第一种情况不传参数默认为升序
var array = ['2','1','4'];
array.sort();
console.log(array);//['1','2','4'] 改变了原数组
//2.数字排序(数字和升序)
var array = ['2','1','4'];
array.sort(function(a,b){
return a - b
});
console.log(array);//['1','2','4']
//3.数字排序(数字和降序)
var array = ['2','1','4'];
array.sort(function(a,b){
return b - a
});
console.log(array);//['4','2','1']
语法:array.reverse()
var array = ['2','1','4'];
array.reverse()
console.log(array);//['4','1','2'] 改变了原数组
语法:array.splice(index,howmany,item1,…,itemX)
参数:index必需。规定从何处添加/删除元素。该参数是开始插入和(或)删除的数组元素的下标,必须是数字。(如果有第三个参数就是添加元素,如果没有就是删除元素)
howmany:可选。规定应该删除多少元素。必须是数字,但可以是 “0”。如果未规定此参数,则删除从 index 开始到原数组结尾的所有元素。
item1, …, itemX:可选。要添加到数组的新元素
//1.只有一个参数的时候
var array = ['2','1','4','5'];
array.splice(2);//删除从左到右两项
console.log(array);// ['2','1'] 改变了原数组 返回的是删除的元素
//2.只有两个参数的时候
var array = ['2','1','4','5'];
array.splice(0,3);//如果第一个参数是0则删除不会包括第二个参数的索引
console.log(array);// ['5'] 改变了原数组
array.splice(1,2);//如果第二个参数不是0则删除会包括第二个参数的索引['2','5'] 显然它删掉了索引为2的元素‘4’
//3.当有>=3个参数的时候
//当第二个参数为0的时候,第一个参数就是起始位置,从索引1开始添加第三个参数到array数组
var array = ['1','2','3','4'];
array.splice(1,0,'xiaoming');
console.log(array);//['1', 'xiaoming', '2', '3', '4']
//当第二个参数不为0的时候,从第一个参数索引1起始位置开始删除一个元素并把第三个参数加上
var array = ['1','2','3','4'];
array.splice(1,1,'xiaoming');
console.log(array);//['1', 'xiaoming', '3', '4']
var array = ['1','2','3','4'];
array.splice(1,2,'xiaoming');
console.log(array);//['1', 'xiaoming','4']
语法:array.copyWithin(target, start, end)
参数:target 必需。复制到指定目标索引位置。
start 可选。元素复制的起始位置。
end 可选。停止复制的索引位置 (默认为 array.length)。如果为负值,表示倒数。
//一个参数的时候
var array = ['1','2','3','4'];
array.copyWithin(2);
console.log(array);//['1','2','1','2'];
//二个参数的时候
var array = ['1','2','3','4'];
array.copyWithin(2,1);
console.log(array);//['1','2','2','3'];
//三个参数的时候
var array = ['1','2','3','4','5'];
array.copyWithin(2,1,3);//从索引2开始,复制的元素索引从1开始,复制到索引为3(包括3)停止
console.log(array);//['1','2','2','3','5'];
语法:array1.concat(array2,array3,…,arrayX)
注意⚠️:不会改变原数组
var array1 = ['1','2'];
var array2 = ['3','4'];
var array3 = ['5','6'];
var arrayBox = array1.concat(array2,array3)
console.log(arrayBox) //['1', '2', '3', '4', '5', '6'];
语法:array.entries()
var array = ['xiaoming','lisi','zhangsan'];
var x = array.entries();
console.log(x.next().value); //[0, 'xiaoming'];
console.log(x.next().value); //[1, 'lisi'];
console.log(x.next().value); //[2, 'zhangsan'];
语法:array.every(function(currentValue,index,arr), thisValue)
参数:function(currentValue,index,arr){}
currentValue:必须。当前元素的值
index:可选。当前元素的索引值
arr可选。当前元素属于的数组对象
every() 方法使用指定函数检测数组中的所有元素:
如果数组中检测到有一个元素不满足,则整个表达式返回 false ,且剩余的元素不会再进行检测。
如果所有元素都满足条件,则返回 true。
var array = ['1','2','3','4','5','6'];
var ArrBox = array.every(function(currentValue,index,arr){
return currentValue > 5
})
console.log(ArrBox);//false
语法:array.fill(value, start, end)
参数:value 必需。填充的值。
start 可选。开始填充位置。
end 可选。停止填充位置 (默认为 array.length)
//只有一个参数的时候
var array = ['1','2','3','4'];
array.fill('6');
console.log(array);//['6', '6', '6', '6'] 所有的都会被替换掉
//不止一个参数的时候
var array = ['1','2','3','4'];
array.fill('6',1,3);
console.log(array);//['1', '6', '6', '4'] 索引1到索引3 不包括索引3都会被替换掉
语法:array.filter(function(currentValue,index,arr), thisValue) 同11
var array = ['1','2','3','4'];
var ArrBox = array.filter(function(currentValue){
return currentValue > 2
})
console.log(ArrBox);// ['3', '4']
语法:array.find(function(currentValue, index, arr),thisValue) 同11
var array = ['6','9','18','20'];
var ArrBox = array.find(function(currentValue){
return currentValue >= 18
})
console.log(ArrBox);//18 第三个元素满足条件,返回第三个元素就不接着往下面走啦
语法:array.findIndex(function(currentValue, index, arr), thisValue) 同11
var array = ['1','2','3'];
var ArrBox = array.findIndex(function(currentValue){
return currentValue > 2
})
console.log(ArrBox);//2 这个2就是索引2 它满足条件,如果array中都没有大于2的这时就会返回-1
语法:array.forEach(function(currentValue, index, arr), thisValue) 同11
var array = ['1','2','3','4'];
array.forEach(function(currentValue, index, arr){
console.log(currentValue, index, arr);
})
//1 0 (4) ['1', '2', '3', '4']
//2 1 (4) ['1', '2', '3', '4']
//3 2 (4) ['1', '2', '3', '4']
//4 3 (4) ['1', '2', '3', '4']
语法:Array.from(object, mapFunction, thisValue)
参数:object:必需,要转换为数组的对象。
mapFunction:可选,数组中每个元素要调用的函数。
thisValue 可选,映射函数(mapFunction)中的 this 对象。
//只有一个参数的情况
var array = Array.from('xiaoming');
console.log(array);//(8) ['x', 'i', 'a', 'o', 'm', 'i', 'n', 'g']
//不止一个参数的情况
var array = Array.from([1,2,3],function(x){
return x * 10
})
console.log(array);//[10, 20, 30]
//从类数组对象(arguments)生成数组
function f() {
console.log(arguments);
console.log(Array.from(arguments)); // [ 1, 2, 3 ]
}
f(1, 2, 3);
语法:arr.includes(searchElement, fromIndex)
参数:searchElement 必须。需要查找的元素值。
fromIndex 可选。从该索引处开始查找 searchElement。如果为负值,则按升序从 array.length + fromIndex 的索引开始搜索。默认为 0。
//传一个参数的时候
var array = ['1','2','3','4'];
var ArrBox = array.includes('2');
console.log(array);//true
//传两个参数的时候
var array = ['1','2','3','4'];
var ArrBox = array.includes('2',2);
console.log(array);//false 虽然这时array数组里面有2但是它是从索引为2开始查找的,所以返回false
语法:array.indexOf(item,start)
参数:item 必须。查找的元素。
start 可选的整数参数。规定在数组中开始检索的位置。它的合法取值是 0 到 stringObject.length - 1。如省略该参数,则将从字符串的首字符开始检索。
//一个参数的时候
var array = ['1','2','3','4'];
var ArrBox = array.indexOf('1');
console.log(ArrBox);//0 返回的就是‘1’的索引位置
//二个参数的时候
var array = ['1','2','3','4'];
var ArrBox = array.indexOf('1',1);
console.log(ArrBox);//false 这是第二个参数的是为1,从索引1开始查找找不到‘1’,所以返回-1
语法:Array.isArray(obj)
参数:obj:必须。要判断的对象。
var array1 = ['1','2','3'];
var array2 = {name:'xiaoming',age:18};
console.log(Array.isArray(array1));//true
console.log(Array.isArray(array2));//false
语法:array.join(separator)
参数:separator 可选。指定要使用的分隔符。如果省略该参数,则使用逗号作为分隔符。
var array = ['1','2','3','4'];
var ArrBox = array.join('--');
console.log(ArrBox);//1--2--3--4
语法:array.keys()
iterable:一个具有可枚举属性并且可以迭代的对象。
for…of 语句创建一个循环来迭代可迭代的对象
var array = ['a','b','c','d'];
var ArrBox = array.keys();
console.log(ArrBox);//Array Iterator {}
for(key of ArrBox){
console.log(key);//0 1 2 3
};
语法:array.lastIndexOf(item,start)
参数:item 必需。规定需检索的字符串值。
start 可选的整数参数。规定在字符串中开始检索的位置。它的合法取值是 0 到 stringObject.length - 1。如省略该参数,则将从字符串的最后一个字符处开始检索。
//当只有一个参数的时候
var array = ['1','2','3','2'];
var ArrBox = array.lastIndexOf('2');
console.log(ArrBox);//3 从后往前开始检索
//当有两个参数的时候
var array = ['1','2','3','2'];
var ArrBox = array.lastIndexOf('2',array.length - 2);
console.log(ArrBox);//1 从后往前开始检索,开始检索的位置是从倒数第二个开始
语法:array.map(function(currentValue,index,arr), thisValue) 同11
var array = ['1','2','3','4'];
var ArrBox = array.map(function(currentValue){
return currentValue * 10
});
console.log(ArrBox);//[10, 20, 30, 40]
语法:array.reduce(function(total, currentValue, currentIndex, arr), initialValue)
参数:function(total,currentValue, index,arr) 必需。用于执行每个数组元素的函数。
参数 描述
total 必需。初始值, 或者计算结束后的返回值。
currentValue 必需。当前元素
currentIndex 可选。当前元素的索引
arr 可选。当前元素所属的数组对象。
initialValue 可选。传递给函数的初始值
var array = [1,2,3,4];
var ArrBox = array.reduce(function(total,currentValue){
console.log(total,currentValue);
// 0 1
// 1 2
// 3 3
// 6 4
return total + currentValue
},0);
console.log(ArrBox);// 10
语法:同上
var array = [1,2,3,4];
var ArrBox = array.reduceRight(function(total,currentValue){
console.log(total,currentValue);
// 4 3
// 1 2
// -1 1
// -2
return total - currentValue
});
console.log(ArrBox);//-2
语法:array.slice(start, end)
参数:
start 可选。规定从何处开始选取。如果是负数,那么它规定从数组尾部开始算起的位置。如果该参数为负数,则表示从原数组中的倒数第几个元素开始提取,slice(-2) 表示提取原数组中的倒数第二个元素到最后一个元素(包含最后一个元素)。
end 可选。规定从何处结束选取。该参数是数组片断结束处的数组下标。如果没有指定该参数,那么切分的数组包含从 start 到数组结束的所有元素。如果该参数为负数, 则它表示在原数组中的倒数第几个元素结束抽取。 slice(-2,-1) 表示抽取了原数组中的倒数第二个元素到最后一个元素(不包含最后一个元素,也就是只有倒数第二个元素)。
var array = [1,2,3,4];
console.log(array.slice(1));//[2, 3, 4] 从索引1截取到最后
console.log(array.slice(-2));//[3, 4] 从原数组中的倒数第几个元素开始提取
console.log(array.slice(1,2));//[2] 选取索引1到索引2的元素(不包含索引2)
console.log(array.slice(-2,-1));//[2] 选取倒数第二个到倒数第一个(不包含倒数第一个)
如果有一个元素满足就会返回ture,剩下的不会在进行检测。没有满足的返回false
语法:array.some(function(currentValue,index,arr),thisValue) 同11
var array = [1,2,3,4];
var ArrBox = array.some(function(currentValue){
return currentValue > 2
});
console.log(ArrBox);//true
语法:array.toString()
var array = ['1','2','3','4'];
var ArrBox = array.toString();
console.log(ArrBox);//1,2,3,4
语法:array.valueOf()
Array:返回数组对象本身。
Boolean: 返回布尔值
Date:存储的时间是从 1970 年 1 月 1 日午夜开始计的毫秒数 UTC。
Function: 返回函数本身。
Number: 返回数字值。
Object:返回对象本身。这是默认情况。
String:返回字符串值。
Math 和 Error 对象没有 valueOf 方法。
//返回数组本身
var array = ['xiaoming','1','2'];
console.log(array.valueOf() == array);//true
//返回布尔值
var boolean = true
console.log(boolean.valueOf() == boolean);//true
// new一个Boolean对象
var newBool = new Boolean(true); // Boolean {true}
newBool.valueOf() // true
// valueOf()返回的是true,两者的值相等
console.log(newBool.valueOf() == newBool); // true
// 但是不全等,两者类型不相等,前者是boolean类型,后者是object类型
console.log(newBool.valueOf() === newBool); // false
//返回时间戳
var date = new Date(2021, 11, 2, 13, 04, 59, 230);
console.log(date.valueOf());//1638421499230 返回时间戳
//返回函数本身
var function = function foo(){};
console.log(function.valueOf() == function);//true
//返回数字值
var number = 5;
console.log(number.valueOf() == number );//true
//返回对象本身
var object = {name: "张三", age: 18};
console.log(object.valueOf() == object);//true
//返回字符串本身
var string = 'xiaoming';
console.log(string.valueOf() == string);//true
let arr = [1,2,3,4,1,2];
let set1 = new Set(arr);
console.log(set1);//Set(3) {1, 2, 3} 此时时类数组,不是真正的数组
let newArr1 = Array.from(set1); //第一种方法可以使用Array.from()将类数组转换成真正的数组
console.log(newArr1);//[1, 2, 3, 4]
let newArr2 = [...set1];//第二种方法直接结构赋值,也可以得到一个真正的数组
console.log(newArr2);//[1, 2, 3, 4]
var arr = [1,2,3,4,1,2];
for(var i = 0;i<arr.length;i++){
for(var j = i+1;j<arr.length;j++){
console.log(arr[i],arr[j]);
if(arr[i] == arr[j]) {
//如果数据相同则通过splice删除一条相同的数据
arr.splice(i,1);
//i是第一层遍历的下标,因为上一步删除了一条数据,所以下标也需要减一,否则实际下标,要比数组中的数据更多
i--;
//j 也同样需要和i一样减一,保持遍历依旧同步判断
j--;
}
}
}
console.log(arr);// [3, 4, 1, 2]
let arr = [4,5,6,2,3,2,4,5];
let newArr = []
for(var i=0;i<arr.length;i++) { //循环arr数组
if(newArr.indexOf(arr[i]) == -1) {
newArr.push(arr[i]);
}
}
console.log(newArr);//[4, 5, 6, 2, 3]
let arr = [4,5,6,2,3,2,4,5];
let newArr = []
for(var i=0;i<arr.length;i++) {
if(!newArr.includes(arr[i])){
newArr.push(arr[i])
}
}
console.log(newArr);//[4, 5, 6, 2, 3]
let arr = [4,5,6,2,3,2,4,5];
let newArr = arr.filter(function(item,index){
console.log(arr.indexOf(item,0),index);
//arr.indexOf(item,0)循环返回元素所在的位置,有两个相同的元素只会返回第一个元素的索引
//0 0
//1 1
//2 2
//3 3
//4 4
//3 5
//0 6
//1 7
return arr.indexOf(item,0) === index
})
console.log(newArr);/[4, 5, 6, 2, 3]