js基础--数组05

数组的方法

push

• 作用：向数组
• 参数：添加具体的值，可以是一项也可以是多项
• 返回值：新数组的长度
• 是否改变原数组：改变

    var ary=[2,3];
    console.log(ary.push(1,5));//新数组的长度 4
    console.log(ary);//新数组 [2,3,1,5]

unshift

• 作用：在数组开头添加项，可以是一个或多个
• 参数，具体的值
• 返回值：新数组的长度
• 是否改变原数组：改变

    var ary=[2,3];
    console.log(ary.unshift(0,1));//4
    console.log(ary);//[0,1,2,3]

pop

• 作用：删除数组末尾的一个项
• 参数：无
• 返回值：删除的最后一项
• 是否改变原数组：改变原数组长度

    var ary=[2,3];
    console.log(ary.pop());//删除的项 3
    console.log(ary);//新数组 [2]

shift

• 作用：删除数组第一个项
• 参数：无
• 返回值：删除的第一个项
• 是否改变原数组：改变

    var ary=[2,3];
    console.log(ary.shift());//2
    console.log(ary);//[3]

splice(i,n,m)

• 作用：从i开始删除后面的n个项，并且在i后加入m项
• 参数i，n，m m可以为多个
• 当n为0时，就是新增
• 返回值：数组，里面包含的是删除的n项
• 是否改变原数组：改变
• 两个值时为在i后删除n个项
• 如果只写一个值0就是全部删除

    var ary=[1,2,3];
    console.log(ary.splice(1,2,9));//[2,3]
    console.log(ary);//[1,9]
        //两个值时为删除
    var ary=[1,2,3];
    console.log(ary.splice(1,2));//[2,3]
    console.log(ary);//[1]
    //增加
    var ary=[1,2,3];
    console.log(ary.splice(0,0,5));//[]
    console.log(ary);//[5,1,2,3]
        //删除最后一项
    var ary=[1,2,3];
    console.log(ary.splice(ary.length-1,1));//[3]

删除数组最后一项的方法

    var ary=[1,2,3];
    console.log(ary.pop());//3
    console.log(ary.length--);//3
    console.log(ary.splice(ary.length-1,1));//[3]

在数组最后增加项的方法

    //在数组最后添加的方法
    var ary = [1, 2, 3];
    console.log(ary.push(4)); //4
    console.log(ary[ary.length]=4); //4
    console.log(ary.splice(ary.length,0,4)); //[]
    console.log(ary.splice(ary.length,1,4)); //[]
    console.log(ary);

slice(n,m)

• 作用：复制索引n到索引m的项，但不包含索引m
• 返回值：复制的新数组
• 不改变原数组
• 如果参数为0或者空就会复制整个数组,如果为其他的单个值就是从那个索引开始全部复制
• 注意：克隆的新数组和原来的数组并不相等，因为是不同的堆内存地址；

   var ary = [1, 2, 3, 4, 5, 6];
    console.log(ary.slice(0)); //复制整个数组[1, 2, 3,4,5,6]
    console.log(ary.slice()); //复制整个数组[1, 2, 3,4,5,6]
    console.log(ary.slice(2, 5));//[3, 4, 5]

concat

• 作用：拼接数组
• 返回值：拼接好的数组
• 参数：可以为数组也可以为项
• 不改变原数组

    var ary = [1, 2, 3];
    var ary2=[9,10];
    console.log(ary.concat(ary2,5,6));//[1,2,3,9,10,5,6]
    console.log(ary);//[1,2,3]

toString

• 作用：变为字符串
• 不改变原数组
• 返回值：变为字符串的数组
• 参数：无

    var ary = [1, 2, 3];
    console.log(ary.toString());//"1,2,3"
    console.log(ary);//[1,2,3]

join

• 作用：把数组连接符转为想要的
• 参数："连接符"
• 返回值：字符串包裹的改变连接符后的数组
• 不改变原数组

    var ary = [1, 2, 3];
    console.log(ary.join('+'));//"1+2+3"
    console.log(ary.join('a'));//"1a2a3"
    console.log(ary);//[1,2,3]

reverse

• 作用：倒序排列数组
• 参数：无
• 返回值：倒序排列的数组
• 改变原数组，为倒序的数组

    var ary = [1, 2, 3];
    console.log(ary.reverse());//[3,2,1]
    console.log(ary);//[3,2,1]

sort

• 作用 ：排序
• 参数：
  • 没有参数时只能排10以内的,且根据第一个值来排序，然后在根据第二个排序 +如果10~19可以正常拍
  • 可以传参数为函数function(a,b){return a-b;}
    • 当return a-b时为升序
    • return b-a为降序
• 返回值：排序后的数组
• 改变原数组

    var ary = [8, 5, 11, 22, 3, 1, 2];
    console.log(ary.sort()); //[1,11,2,22,3,5,8]  没参数时，只能识别10以内的参数排序
    console.log(ary); //[1,11,2,22,3,5,8]
    
    var ary = [8, 5, 11, 3, 1, 2];
    console.log(ary.sort(function(a,b){return a-b;})); //[1,2,3,5,8,11]   可以传一个函数   return a-b为升序
    console.log(ary); //[1,2,3,5,8,11]
    console.log(ary.sort(function(a,b){return b-a;})); //[11,8,5,3,2,1]   return b-a为降序
    console.log(ary); //[11,8,5,3,2,1]

indexOf

• 作用：检测当前值在数组中第一次出现的索引
• 参数：
  • 一个值时，时当前值在数组中第一次出现的索引
  • 两个值时，第一个值时第一次出现的索引，第二个是从哪个索引开始查找
• 返回值：当前值第一次出现的索引值
• 是否改变原数组：不改变
• 注意：当值不存在时返回值为-1

    var ary=[1,2,1,3];
    console.log(ary.indexOf(1));//0当前项第一次出现的索引
    console.log(ary.indexOf(1,1));//2两个值的话，第一个数代表出现的第一次位置  第二个数代表的时从索引几开始检索
    console.log(ary.indexOf(8));//当前项不存在的话为-1

lastIndexOf

• 作用：检测当前值在数组中最后一次出现的索引
• 参数：
  • 一个值时，时当前值在数组中第一次出现的索引
  • 两个值时，第一个值时第一次出现的索引，第二个是到哪个索引结束,包含第二个索引值
• 返回值：当前值第一次出现的索引值
• 是否改变原数组：不改变
• 注意：当值不存在时返回值为-1

    var ary=[1,2,1,3];
    console.log(ary.lastIndexOf(1));//2 当前项最后一次出现的索引
    console.log(ary.lastIndexOf(1,1));//0
    console.log(ary.lastIndexOf(1,2));//2
    console.log(ary.lastIndexOf(8));//当前项不存在的话为-1

includes

• 作用：检测值是否在数组中
• 返回值：在就是true 不在就是false
• 参数：检测的值
• 是否改变原数组：不改变

    var ary=[1,2,3];
    console.log(ary.includes(1));//true
    console.log(ary.includes(8));//fasle

forEach

• 作用：遍历数组里的每一项
• 返回值：undefined
• 参数：函数function(item,index){};
• 是否改变原数组：不改变

    var ary=[1,2,3,4];
    console.log(ary.forEach(function(item,index){console.log(item,index); return item,index;}))//1 0  2 1  3 2  4 3  undefined

map

• 作用:映射数组
• 参数：函数function(item,index){return item;};
• 是否改变原数组：不改变
• 返回值：映射的新数组

    var ary=[1,2,3,4];
    console.log(ary.map(function(item,index){return item;}));//[1,2,3,4]

filter

• 依次便历，参数为回调函数，返回一个新数组，数组里是过滤好的数组

var res=[100, 200, 300].filter((item, index) => {
    return item > 200
})

some

• 依次便历，参数为回调函数,找到符合规则的那一项，就返回true,然后就停止查询了，如果全部都没找到，就返回false

[100, 200, 300,400].some((item, index) => {
    return item > 200
})

every

• 依次便历，参数为回调函数,只要数组中有一个不满足，就停止查找，返回false，如果全部满足，就返回true

[100, 200, 300,400].every((item, index) => {
    return item > 200
})

find

• 发现的意思，依次便历，参数为回调函数,找到符合规则的第一项，然后return出来,找到就停止便利，没找到就是undefined

[100, 200, 300,400].find((item, index) => {
    return item > 200
})

findIndex

• 发现的意思，依次便历，参数为回调函数,找到符合规则的第一项，然后return出来它的索引,找到就停止便利，没找到就是undefined

[100, 200, 300,400].findIndex((item, index) => {
    return item > 200
})

自行封装了一些

Array.prototype.myFilter = function myFilter(fn) {
    let obj = [];
    let res;
    if(typeof fn!=="function"&&fn==null)return;
    for (var i = 0; i < this.length; i++) {
        res = fn(this[i], i);
        if (res) {
            obj.push(this[i]);
        }
    }
    return obj;
}
let a = [1, 200, 300, 2];
let res = a.myFilter((item) => {
    return item > 1
})
console.log(res);

Array.prototype.mySome = function mySome(fn) {
    let res;
    if(typeof fn!=="function"&&fn==null)return;
    for (var i = 0; i < this.length; i++) {
        res = fn(this[i], i);
        if(res)return true;
    }
}

let a = [1, 200, 300, 2];
let res = a.mySome((item) => {
    return item > 1
})
console.log(res);

Array.prototype.myEvery = function myEvery(fn) {
    let res;
    if(typeof fn!=="function"&&fn==null)return;
    for (var i = 0; i < this.length; i++) {
        res = fn(this[i], i);
        if(!res)return false;
    }
    return res;
}

let a = [1, 200, 300, 2];
let res = a.myEvery((item) => {
    return item > 200
})
console.log(res);


Array.prototype.myFind = function myFind(fn) {
    let res;
    if(typeof fn!=="function"&&fn==null)return;
    for (var i = 0; i < this.length; i++) {
        res = fn(this[i], i);
        if(res)return this[i];
    }
}

let a = [1, 200, 300, 2];
let res = a.myFind((item) => {
    return item > 1
})
console.log(res);

数组去重

    //数组去重
    //思路：  需求：去重
    // var ary=[1,2,3,2,4]
    // 第一次：拿1与2，3，2，4比较
    // 第二次：拿2与3，2，4比较 有重复 删除2==》3,4
    // 第三次：拿3与4比较
    //第四次到最后了，不用比较
    //注意：如果是多个连着一起重复的话，删除第二个后第三项顶上去会没有识别，所以需要j--
    function unique(ary){
        for(var i=0;i<ary.length-1;i++){
        for(var j=i+1;j<ary.length;j++){
            if(ary[i]==ary[j]){
                ary.splice(j,1);
                j--;
            }
        }
    }
    return ary;
    }
    var ary=[1,1,1,2,3,2,4];
   var res=unique(ary);
   console.log(res);
   console.log(ary);

    //思路：先创建一个空对象，去遍历数组中的每一项，把数组的每项当成属性名和属性值，给此对象添加在添加的过程中，如果此对象已经有此项，说明重复，在数组中删除掉此项
    function unique(ary) {
        var obj = {};
        for (var i = 0; i < ary.length; i++) {
            // var item=ary[i];
            if (obj[ary[i]] == ary[i]) {
                //obj[ary[i]]==ary[i]的意义
                //当为0时，还没有存，所以不成立，没有进来,for外面语句 obj[ary[i]] = ary[i];执行就存进去
                //当为1时，此时对象内已经有了一个，所以看看他是否相等，因为我们在外面赋值的时候就给他的属性名属性值设置成一样的了，如果他相等，就证明我们给他设置过，所以他就重复，然后就会删除,删除以后怕他后面还有一样的顶进去所以要i--，然后就不用给他添加了，再次循环continue
                ary.splice(i, 1);
                i--;
                continue;
            }
            obj[ary[i]] = ary[i];
        }
        return ary;
    }
    var ary = [1, 1, 1, 2, 3, 2, 4];
    var res = unique(ary);
    console.log(res);


    //创建一个新数组，依次把它用indexOf检测，然后把数扔进去
    function unique(ary){
        var newAry=[];
        for(var i=0;i<ary.length;i++){
            if(newAry.indexOf(ary[i])==-1){
                newAry.push(ary[i]);
            }
        }
        return newAry;
    }
    var ary = [1, 1, 1, 2, 3, 2, 4];
    var res = unique(ary);
    console.log(res);

冒泡排序

 // var ary=[8,2,1,5];
    // 需求： 排序(升序)
    // 第一轮:[2,1,5,8] 经过一轮的比较，得到了第一个最大值
    // 第二轮:[2,1,5,8] 经过二轮的比较，得到了第二个最大值
    // 第三轮:[1,2,5,8] 经过三轮的比较，得到了第三个最大值
    // 第四轮不用比较，因为其他三个排好了，他就是最小的
   //n轮排出来n个最大值，最大值就扔那，不用管它啦

    function sort(ary){
       // 需要比较的轮数
       for(var i=0;i<ary.length-1;i++){
           //最后一轮不用比
           for(var j=0;j<ary.length-1-i;j++){
               //n轮就选出来n个最大值，最大值不用排了
               if(ary[j]>ary[j+1]){
                var item1=ary[j];
                   ary[j]=ary[j+1];
                   ary[j+1]=item1;
               }
           }
       }
       return ary;
   }

   var ary=[8,2,1,5];
   var res=sort(ary);
   console.log(res);

快速排序

//取中间值，然后小于中间值放左边盒子，大于等于放右边盒子
   function ksort(ary){
       if(ary.length<=1){
           return ary;
       }
       var centerValue=ary.splice(Math.floor(ary.length/2),1)[0];
       var leftAry=[],rightAry=[];
       for(var i=0;i<ary.length;i++){
           if(ary[i]<centerValue){
               leftAry.push(ary[i]);
           }else{
               rightAry.push(ary[i]);
           }
       }
       return ksort(leftAry).concat(centerValue,ksort(rightAry))
   }
   var ary=[8,2,1,5];
   var res=ksort(ary);
   console.log(res);

递归求和

//递归求和
function total(num){
    if(num>0){
        return 0;
    }
    return num+total(num+1);
    //total(num+1)一直在重复执行total函数
}
total(1);