JS常⽤数组⽅法封装（包含splice）
数组基本操作⽅法
以下⽅法均改变原数组，需要操作数组的 length 属性
Push
返回值：新数组的长度
思路：数组的长度等于 arguments[i]
Push=function(){
for(let i =0; i < arguments.length; i++){
this[this.length]= arguments[i];
}
return this.length;
};
Pop
返回值：删除的项（如果空数组，返回 undefined）
思路：让数组长度 -1
Pop=function(){
return this.length==0?undefined:(this[this.length -1],this.length--);
};
Shift
返回值：删除的项
思路：让数组前⼀个值 this[i] 等于后⼀个值 this[i + 1] ，之后把数组长度 -1
Shift=function(){
if(this.length ==0){
return;
}
let del =this[0];
for(let i =0; i <this.length; i++){
this[i]=this[i +1];
}
this.length--;
return del;
};
Unshift
返回值：新数组的长度
思路：让数组后⼀个值 this[i] 等于前 n（n=arguments.length）个值 this[i - arguments.length] ，之后把前 n 个值填为 arguments[i]
Unshift=function(){
this.length += arguments.length;
for(let i =this.length -1; i >=0; i--){
if(i >= arguments.length){
this[i]=this[i - arguments.length];
}else{
this[i]= arguments[i];
}
}
return this.length;
};
ES6 ⽅法实现能简单⼀些。其实就是拼接数组，之后把拼接的数组⼀项⼀项赋值给原数组
Unshift=function(...arg){
var newArr =[...arg,...this];
for(let i =0; i < newArr.length; i++){
this[i]= newArr[i];
}
return this.length;
};
数组操作⽅法
以下⽅法除splice（改变原数组）均不改变原数组
splice（特殊）
因为 push 实现⽐较简单，这⾥⽤到了 push ⽅法，能简写⼀两⾏
返回值：删除的项（数组）
思路：按参数数量分别进⾏判定
参数⼩于等于1个，从 start 开始添加到新数组，并把添加那项删除（数组长度也减少）
参数⼤于1个，先进⾏删除（跟上⼀步相同）再把数组分成三份，左边+中间被替换的项+右边，合并数组注意：
1. 第⼀个参数为负数：如果转换为正数，⼤于数组长度，直接转换为0；⼩于等于数组长度，需加上数组长度
2. 第⼆个参数：如果⼩于0，直接转换为0
3. 第三个参数起：要添加的项
Splice=function(start, del){
let arr =[];
if(start <0){
start =-start >this.length ?0:this.length + start;
}
if(arguments.length <=1){
for(let i = start; i <this.length; i++){
arr.push(this[i]);
}
this.length = start;
}else{
del = del <0?0: del;
// 删除数组这⼀步
for(let i =0; i < del; i++){
arr.push(this[start + i]);
this[start + i]=this[start + i + del];
}
this.length -= del;
let lArr =[];
for(let i =0; i < start; i++){
lArr.push(this[i]);
}
for(let i =0; i < arguments.length -2; i++){
lArr.push(arguments[i +2]);
}
for(let i = start; i <this.length; i++){
lArr.push(this[i]);
}
for(let i =0; i < lArr.length; i++){
this[i]= lArr[i];
}
}
return arr;
};
删除数组那⼀步，我第⼀时间想到的是冒泡（把删除项⼀次⼀次冒到最后⼀位），最后出来的代码是下⾯这样（⾮常⿇烦）
let that = del;
for(let i = that; i >0; i++){
if(that <=0){
break;
}
for(let j = start; j <this.length -1; j++){
[this[j],this[j +1]]=[this[j +1],this[j]];
}
arr.push(this[this.length -1]);
js arguments
this.length--;
that--;
}
⼤可不必这样，把删除项的下⼀位（不删除）往前挪⼀个⼀个覆盖要删除的项即可
for(let i =0; i < del; i++){
arr.push(this[start + i]);
this[start + i]=this[start + i + del];
}
this.length -= del;
concat
返回值：拼接后的新数组
思路：如果参数是数组需遍历后⼀个⼀个添加到新数组
Concat=function(){
let arr =[];
for(let i =0; i <this.length; i++){
arr[i]=this[i];
}
for(let i =0; i < arguments.length; i++){
const el = arguments[i];
if(Array.isArray(el)){
for(let i =0; i < el.length; i++){
arr[arr.length]= el[i];
}
}else{
arr[arr.length]= el;
}
}
return arr;
};
slice
返回值：复制后的新数组
思路：如果传参是负数索引，需对其长度进⾏判定。如果⼤于数组长度，将其改为0；⼩于数组长度，将其改为arr.length+(负数索引)
Slice=function(start =0, end =this.length){
var arr =[];
if(start <0){
start =-start >this.length ?0:this.length + start;
}
if(end <0){
end =-end >this.length ?0:this.length + end;
}
for(let i = start; i < end; i++){
arr.push(this[i]);
}
return arr;
};
flat
返回值：扁平后的新数组
思路：递归（下⾯实现没有加上可以指定递归深度的参数，类似arr.flat(Infinity)）
Flat=function(){
let arr =[];
fn(this);
function fn(ary){
for(let i =0; i < ary.length; i++){
const item = ary[i];
if(Array.isArray(item)){
fn(item);
}else{
arr.push(item);
}
}
}
return arr;
};
Flat=function(){
String().split(",").map((item)=>Number(item));
};
数组重排⽅法
reverse
返回值：倒序后的数组
思路：第n个数和倒数第n个数两两对换
Reverse=function(){
for(let i =0, j =this.length -1; j > i; i++, j--){
var temp =this[i];
this[i]=this[j];
this[j]= temp;
}
return this;
};
sort
返回值：排序后的数组
思路：不传参的时候，两两⽐较 String(xxx) 的值；传参的时候判断 callBack(a-b) 是否⼤于 0 即可
Sort=function(callBack){
if(this.length <=1){
return this;
}
if(typeof callBack ==="function"){
for(let i =0; i <this.length -1; i++){
for(let j =0; j <this.length -1- i; j++){
if(callBack(this[j],this[j +1])>0){
[this[j],this[j +1]]=[this[j +1],this[j]];
}
}
}
}else if(typeof callBack ==="undefined"){
for(let i =0; i <this.length -1; i++){
for(let j =0; j <this.length -1- i; j++){
if(String(this[j])>String(this[j +1])){
[this[j],this[j +1]]=[this[j +1],this[j]];
}
}
}
}else{
return"参数异常";
}
return this;
};
数组位置⽅法
以下⽅法均不改变原数组
indexOf
返回值：索引/-1
思路：遍历数组，第⼆个参数是从哪个索引开始。如果不传参，从头查到尾部

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。