数组语法
push
- 语法: `数组名.push(数据)`
- 作用: 向数组末尾添加数据
- 返回值: 追加数据后, 数组最新的长度
- push不但可以添加一个元素，还可以添加多个元素
var arr = [1, 2, 3]
数组名.push(数据)
var len = arr.push(100)
console.log(arr)
console.log('返回值: ', len)
用法 var arr=["a","b","c","d","e","f"];
// 给数组的尾部插入数组的长度(length)
arr.push(arr.push());
console.log(arr); // ['a', 'b', 'c', 'd', 'e', 'f', 6]
/**
* 手动模拟 push
* 作用: 向数组末尾 新增一条数据
*/
function push(push_arr, data) {
/**
*
* 在 函数传参的过程中, 如果实参的值是一个引用数据类型
* 然后在函数内部 对这个形参 做了一些修改
* 那么会影响到 函数外边的 原数据
*
* 在当前案例中
* 在 函数传参的过程中, 传递了一个 引用数据类型 arr 和一个基本数据类型 100
* 然后在函数内部 对形参 push_arr 做了一些修改
* 然后此时的修改会影响 函数外部的原数据 也就是 会影响到 数组 arr
*
*
*/
push_arr[push_arr.length] = data
return push_arr.length
}
push(arr, true) //增加 true
push(arr, 100)
push(arr, 'QF001')
console.log(arr) // 一次性打印
- pop
- 语法: `数组名.pop()`
- 作用:它没有参数，删除数组的最后一项元素，并且将这个被删除的元素返回
- 返回值: 被删除的数据
- unshift
- 语法: `数组名.unshift(数据)`
- 作用: 向数组的头部添加一个或者多个元素，并且返回一个新数组的长度
- 返回值: 添加数据后, 数组最新的长度
var arr=["a","b","c","d","e","f"];
// 把尾部的元素插在数组的头部
arr.unshift(arr.pop());
console.log(arr) // ['f', 'a', 'b', 'c', 'd', 'e']
- shift
- 语法: `数组名.shift()`
- 作用: 删除数组下标0数据
- 返回值: 被删除的数据
at
// push unshift 改变原数组，并且返回一个新长度，返回值的类型是数值型
// pop shift 改变原数组，并且返回一个元素，数组中删除的原数组类型
// at 获取数组中对应下标的元素 允许使用负数,负数从后向前获取
// 不改变数组，返回一个元素，数组中对应下标的元素类型
var arr=["a","b","c","d","e"];
console.log(arr.at(0))
console.log(arr.at(1))
从后向前获取
console.log(arr.at(-1)) //最后的下标元素“e"
- reverse
- 语法: `数组名.reverse()`
- 作用: 反转数组
- 返回值: 反转后的数组
- sort
* 语法1: 数组名.sort()
* 作用: 将数组内的数据, 转换为 字符串, 然后一位一位的对比
*
* 语法2: 数组名.sort(function (a, b) { return a - b })
* 作用: 会按照数字的 从小到大
*
* 语法3: 数组名.sort(function (a, b) { return b - a })
* 作用: 和 语法2相反, 从大到小
*
* 返回值: 返回一个排序好的数组
*
* 注意: sort 使用后能够修改原数组
- 不传参数: 会将数据转换为字符串后, 一位一位的对比
- 回调函数内进行 a - b, 那么会按照数字大小升序排序
- 回调函数内进行 b - a, 那么会按照数字大小降序排序
- 作用: 根据参数对数组数据实现排序
- 返回值: 排序后的数组
- splice
- 语法: `数组名.splice(开始索引, 多少个);
数组名.splice(开始索引, 多少个, 插入数据1, 插入数据2, ...)`
//改变原数组，并且返回一个由被删除元素组成的新数组
// 插入、删除、替换
// 1、可以删除指定位置的一个或者多个元素
// 2、可以用在指定位置添加一个或者多个元素
// 3、用来替换数组中某个位置开始到某个位置结束的元素为其他元素
// var arr = [1, 2, 3, 4, 5]
下标 0 1 2 3 4
语法1
arr.splice(0, 3) // 从 [0] 开始, 剪切 3 个
console.log(arr)
var res = arr.splice(0, 3)
console.log('剪切到的内容: ', res)
console.log('剪切后的数组: ', arr)
// 语法2
arr.splice(0, 3, '新加入的数据1', true, undefined, { name: '张三' }, [1, 2, 3])
console.log('剪切后的数组: ', arr)
var arr=["a","b","c","d","e","f"];
插入
var arr1=arr.splice(2,0,"0");//在b和c之间插入一个0
console.log(arr,arr1);
arr 原数组 ['a', 'b', '0', 'c', 'd', 'e', 'f']
arr1 重组的数组 []
var arr1=arr.splice(4,0,"1","2","3");//在e前面插入1,2,3
console.log(arr,arr1);// ['a', 'b', 'c', 'd', '1', '2', '3', 'e', 'f'][]
插入在数组的头部 unshift
var arr1=arr.splice(0,0,"0","1","2");
console.log(arr1,arr);
插入在数组的尾部 push
var arr1=arr.splice(arr.length,0,"0","1","2");
console.log(arr)
var arr=["a","b","c","d","e","f"];
// 替换
var arr1=arr.splice(2,2,"1","2");//将数组中cd替换为12
console.log(arr1,arr);
arr1 : ['c', 'd']
arr : ['a', 'b', '1', '2', 'e', 'f']
var arr1=arr.splice(-1,1,"1","2","3");
console.log(arr1,arr);
arr1 : ['f']
arr : ['a', 'b', 'c', 'd', 'e', '1', '2', '3']
var arr1=arr.splice(); // 什么也没删除返回一个空数组
console.log(arr1); // []
// 将数组里的所有元素转移到另一个数组中 也就是给原数组清空
var arr1=arr.splice(0);
console.log(arr1,arr);
//将数组的最中间的元素删除，并且获取到这个被删除的元素
var item=arr.splice(~~(arr.length/2),1)[0]
console.log(item);
splice 数组去重
var arr=[1,2,4,2,4,1,2,5,2,5,1,1,2,4];
// 改变原数组
// 第一次外层循环取到一个1，内层循环从这个1后面的元素开始循环到尾部
for(var i=0;i<arr.length;i++){
for(var j=i+1;j<arr.length;){
// console.log(j);
// // arr[i] 外层的这个元素 1 第一次外层为1时，
循环内层删除了下标是5 10 11的这三个1
// // arr[i] 外层这个元素 2 第二次外层为2时，循环内层，删除所有2
// // ...
if(arr[i]===arr[j]){
// 当 删除下标5上的1时，下标六就会变成下标5接着运行 j不会改变
// 直到 内循环运行结束，或超出判断范围
arr.splice(j,1);
}else{
// 这是刹车器，当j的值超出范围停止运行
j++
};
}
}
console.log(arr);
slice
* 语法: 数组.slice(开始下标, 结束下标)
* 参数的特点:
* 1. 包前不包后
* 2. 开始与结束都省略, 相当于复制整个数组，省略结束下标, 那么会从开始下标复制到数组的末尾
* 3. 参数可以支持 负数, 相当于 数组.length + 负数
* 4 . 不改变原数组，返回新数组
* 作用: 复制出指定范围的内容
* 返回值: 复制到的内容
*
var arr=[1,2,3,"a",5,6];
// 如果没有结束表示到数组的尾部
var arr1=arr.slice(0);
console.log(arr1);// [1, 2, 3, 'a', 5, 6]
// 允许负数，负数从后向前数
var arr1=arr.slice(-1);
console.log(arr1);//获取最后一个数组 [6]
// var item=arr.slice(-1)[0];//获取最后一个元素组成的数组，
并且从这个数组中获取第0项
当没有起始下标和结束下标时，表示从数组的第0项到结束
数组浅复制
var arr1=arr.slice();
console.log(arr1);
concat
* 语法: 数组.concat(数据1, 数据2, 数据3, 数据4.......)
* 作用: 将传入的数据, 合并到指定的数组中, 然后返回出来, 注意: 不会改变原数组!!!
* 返回值: 合并后的数组
*
// 数组浅复制
var arr=[1,2,3];
var arr1=arr.concat();
arr[0]=100;
console.log(arr1);// [1, 2, 3]
console.log(arr) // [100, 2, 3]
with
// with(要替换元素的下标，要替换为的元素)
// 将数组中指定下标位置的元素，替换为给定元素 只能替换一个元素
// 不改变原数组，返回替换后的新数组
var arr=[1,2,3,4,5,6];
var arr1=arr.with(2,"a");
console.log(arr1,arr);
arr1:[1, 2, 'a', 4, 5, 6]
arr : [1, 2, 3, 4, 5, 6]
var arr = [1, 2, 3, 4, 5, 6];
// 将数组中的元素5替换为元素0
var arr1 = arr.with(arr.indexOf(5), 0);
console.log(arr1); //
copyWithin
// copyWithin 复制当前数组中某个位置开始到某个位置结束的
所有元素到当前数组指定为止开始一直到结束的元素,不改变原数组长度
// 改变原数组，并且返回原数组
var arr=[1,2,3,4,5,6];
// arr.copyWithin(要复制到的起始位置,从什么位置开始复制数据, 到什么位置之前结束的复制内容)
arr.copyWithin(4,0,4);
console.log(arr); // [1, 2, 3, 4, 1, 2]
var arr=[1,2,3,4,5,6];
var arr1=arr.copyWithin(2,0,2);
console.log(arr) //[1, 2, 1, 2, 5, 6]
// 当省略结束下标的参数时，默认到当前数组的尾部
，也就是结束下标是当前数组的长度
var arr=[1,2,3,4,5,6];
arr.copyWithin(4,0);
console.log(arr); //[1, 2, 3, 4, 1, 2]
arr.copyWithin(0,4)
console.log(arr);//[5, 6, 3, 4, 5, 6]
// 当使用复制时，也是允许使用负数的,负数也是从后向前数
var arr=[1,2,3,4,5,6];
arr.copyWithin(0,2,-1);//负1代表最后1个下标元素
console.log(arr);//[3, 4, 5, 4, 5, 6]
var arr=["a","b","c","d","e","f"];
// 从左往右计算
arr.copyWithin(0,-2).copyWithin(2,-2);
console.log(arr); //['e', 'f', 'e', 'f', 'e', 'f']
fill
// fill 填充 从什么位置开始到什么位置之前结束填充给定第一个参数值，
不改变数组的原长度(length)
// 改变原数组 返回改变后的原数组
var arr=[1,2,3];
arr.fill(值,从什么位置开始,到什么位置之前结束)
从什么位置开始 默认不写就是0开始
到什么位置之前结束 默认不写就是到数组尾部结束
arr.fill(1,0,3);// [1, 1, 1]
arr.fill(1,0);// [1, 1, 1] 如果到数组的尾部位置，最后结束下标可以不写
arr.fill(1);// [1, 1, 1]如果从0开始，开始位置可以不写
arr.fill(0,1); // [1, 0, 0]
console.log(arr);
构建一个长度为六的数组用 数字1 填充
var arr=Array(6).fill(1);
console.log(arr);// [1, 1, 1, 1, 1, 1]
var arr = Array(10).fill({ a: 1 });
// 放入的这个10个对象都是同一个对象，引用地址完全相同
console.log(arr); // 数组都是1
// arr[0].a = 10;
console.log(arr) //数组都是10
join
* 语法: 数组.join('连接符') 连接符如果不传递默认按照','符号连接
* 作用: 根据传入的连接符 将数组内的所有元素, 拼接成一个完整的字符串
* 返回值: 拼接好的字符串
var arr=[1,2,3,4,5]
var str=arr.join();
console.log(str); // 字符串用"," 号链接 1,2,3,4,5
// 使用""可以将数组中的元素紧密连接在一起
var str=arr.join("");
console.log(str); // 12345
toString() 没有参数，等同于使用join不填写参数
var str=arr.toString();
console.log(str); // 字符串用"," 号链接 1,2,3,4,5
include
// include 判断这个元素在数组中是否存在，如果存在返回true，
如果不存在返回false
// 不适用判断元素为引用类型的
// 不改变原数组，返回布尔值
var arr=[1,2,3,4];
console.log(arr.includes(3));//true
var arr=[ {a:1}, {a:2}, {a:3} ]
// 每次写一个{}就是一个新对象，就是一个新的引用地址
console.log(arr.includes({a:1})) // false 无法检测只会是false
var arr=[,,,];
// 空元素判断为undefined
console.log(arr.includes(undefined));// true
indexOf
* 语法: 数组.indexOf(要查询的数据, 从哪里开始查询(下标)) 第二个参数不写默认为 0
* 作用: 按照 从左到右(按照下标的从小到大) 的顺序
检查数组中是否包含指定数据 不适用判断元素为引用类型的
* 返回值:
* 查询到: 返回从左到右数据第一次出现的下标
* 没有查询到: 返回 -1
*
lastIndexOf
* 语法: 数组.lastIndexOf(要查询的数据, 从哪里开始查询(下标))
不传递第二个参数, 默认从 最后一个元素的下标 开始 查到下标0结束 不适用判断元素为引用类型的
* 作用: 按照 从右到左(按照下标的从大到小) 的顺序 检查数组中是否包含指定数据 ,
* 返回值:
* 查询到: 返回从右到左数据第一次出现的下标
* 没有查询到: 返回 -1
*/
/**
* 数组塌陷
*/
var arr = [1, 2, 3, 4, 5]
// 0 1 2 3 4
for (var i = 0; i < arr.length; i++) {
arr.splice(i, 1)
i--
}
console.log(arr) // []
/**
* 第 1 轮循环 i === 0 arr === [1, 2, 3, 4, 5]
* arr.splice(i, 1) 其实相当于 把数组 [0] 的内容删掉 [2, 3, 4, 5]
* i-- i === -1
* 第 1 轮循环结束
* 这样才能让i从零开始
*
* 第 2 轮循环 i === 0 arr === [2, 3, 4, 5]
* arr.splice(i, 1) 其实相当于 把数组 [0] 的内容删掉 [3, 4, 5]
* i-- i === -1
* 第 2 轮循环结束
*
* ........
*/
