05（补）js数组操作

数组(Array)是一个有序的集合，用逗号隔开的每一个值就是一个元素、
每一个元素都有自己的位置，叫下标也叫索引(0~n),读取数组可以通过下标
数组有一个内置的属性 length，属性值存在的是数组的元素个数（长度）

for(var i =0 ; i < array.length ; i++){
   console.log("这是第"i"个数组："li[i]);
   //依次打印出来数组的下标及每个数组元素
}

给数组最后一位添加一个数字array[array.length] = "需要添加的数值"
数组循环 for in 循环

for(var key in arr){
   console.log(arr[key]);
   //依次输出数组arr的每一个元素
}

多维数组：array[2][2]三行三列

array = [['1','2','3'],
         ['1','2','3'],
         ['1','2','3']]

push()
作用：在一个数组的末尾追加元素
参数：追加的元素
返回值：追加数组的长度
是否改变原数组：是
   

 var colors = ['red', 'pink'];
    var res = colors.push('blue');
    // 原数组
    console.log(colors);//['red', 'pink', 'blue']
    // 返回值
    console.log(res);//

pop()
作用：删除末尾的最后一个
参数：没有
返回值：被删除的元素
是否改变原数组：是
 

 var colors = ['red', 'pink'];
   var res = colors.pop();
   // 原数组
   console.log(colors);//['red']
   // 返回值
   console.log(res);//pink

shift()
作用：删除数组的第一项
参数：没有
返回值：被删除的元素
是否改变原数组：是
 

 var colors = ['red', 'pink'];
   var res = colors.shift();
   // 原数组
   console.log(colors);//['pink']
   // 返回值
   console.log(res);//red

unshift()
作用：在数组前面追加元素
参数：追加的东西
返回值：追加数组的长度
是否改变原数组：是
 

  var colors = ['red', 'pink'];
   var res = colors.unshift('blue', 'green');
   // 原数组
   console.log(colors);//['blue', 'green', 'red', 'pink']
   // 返回值
   console.log(res);//

reverse()
作用：把数组的每一项翻转
参数：没有
返回值：一个新数组
是否改变原数组：是
   

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

sort()
作用：排序
参数：没有
返回值：一个新数组（排完后）
是否改变原数组：是
如果没有传参数，只能对 10 以内的数进行排序
需要在 sort（）括号内传入一个函数（回调函数）进行判断排序

 var oldAry = [3, 1, 5, 11, 20];
 var returnValue = oldAry.sort((a,b)=>a-b)
 console.log(oldAry, returnValue);

splice()
作用：怎删改一体化
参数：多个
返回值：删除的元素(返回值是一个数组)
是否改变原数组：是
删除必须要有 2 个参数
第一个参数 表示你要开始删除的下标
第二个参数 表示你要删除的个数
 

 var nums = [1, 2, 3, 4, 5, 6];
   var res = nums.splice(0, 2);
   console.log(nums);// [3, 4, 5, 6]
   console.log(res);// [1,2]

增加需要传递三个参数
第一个参数 表示你要开始删除的下标
第二个参数 表示你要删除的个数
第三个参数 表示你要新增的元素
   

var nums = [1, 2, 3, 4, 5, 6];
   var res = nums.splice(3, 0, 7, 8, 9);
   console.log(nums);//[1, 2, 3, 7, 8, 9, 4, 5, 6] 
   console.log(res);// []

修改需要传递三个参数
修改也需要传递 3 个参数
第一个参数：开始的位置
第二个参数：要删除的元素数量
第三个参数: 要插入的元素（任意个）
 

 var nums = [1, 2, 3, 4, 5, 6];
   var res = nums.splice(0, 3, 7, 8, 9);
   console.log(nums);//[7, 8, 9, 4, 5, 6] 
   console.log(res);// [1, 2, 3]

slice()
作用：截取你选中的特定的内容
参数：1 个或者 2 个
返回值：截取的数组
是否改变原数组：否
如果不传参数或者参数只有一个（0），表示将原数组复制一遍

如果只传入一个参数，slice()会返回该索引到数组末尾的所有元素
 

 var nums = [1, 2, 3, 4, 5, 6];
   var res = nums.slice(1);
   console.log(nums);//[1, 2, 3, 4, 5, 6]
   console.log(res);// [2, 3, 4, 5, 6]

2.  如果有两个参数，slice()返回从开始索引到结束索引对应的所有元素
    > 两个参数 表示开始下标到结束下标，包含开始，不包含结束
    > 如果开始的位置大于结束的位置，返回值是空数组没有返回值

   var nums = [1, 2, 3, 4, 5, 6];
   var res = nums.slice(1, 5);
   console.log(nums);//[1, 2, 3, 4, 5, 6]
   console.log(res);// [2, 3, 4, 5]

concat()

作用：实现多个数组或者值得凭借
参数：数组或者值
返回值：返回值是拼接后的新数组
是否改变原数组：否
 

 var ary1 = [1, 2, 3];
   var ary2 = [4, 5, 6];
   var res = ary1.concat(ary2, "学校", "同学");
   console.log(ary1);//[1, 2, 3]
   console.log(res);//[1, 2, 3, 4, 5, 6, '学校', '同学']

toString()

作用：把数组转化成字符串
参数：没有
返回值：字符串
是否改变原数组：否
   

var ary1 = [1, { a: 1 }, null, undefined, 3];
   var res = ary1.toString();
   console.log(ary1);//[1, {a:1},null, undefined, 3]
   console.log(res)//1,[object Object]

join()

作用：用指定的字符凭借数组
参数：字符
返回值：拼接完的字符串
是否改变原数组：否
 

  var ary1 = [1, 2, undefined, 3, { a: 1 }];
   var res = ary1.join("|");
   console.log(ary1);//[1, 2, undefined, 3, { a: 1 }]
   console.log(res)// 1|2||3|[object Object]
   eval(res) //==> eval  执行计算

includes()

作用：检测数组中是否包含某一项
参数：具体项
返回值：布尔值
是否改变原数组:否
2022 年 3 月 22 日
indexOf/lastIndexOf
作用：获取某项在数组中(首次出现/最后出现的) 索引（也可以用来是否包含某项）
参数：（n,m）
返回值：-1 或者具体的索引值
是否改变原数组：否
indexOf(第一次出现)
第一个参数 你要检索的项
第二个参数 从哪里开始检索
 

 var ary = [1,2,3,1,1,2,3];
   var returnVlue = ary.indexOf(1,2);
   console.log(returnVlue,ary);//3,原数组

lastIndexOf（最后一次出现的位置)
第一个参数 你要检测的项
第二个参数 到那个位置结束检索
 

 var ary = [1,2,3,1,1,2,3];
   var returnVlue = ary.lastIndexOf(1,2);
   console.log(returnVlue,ary);//4,原数组

数组的迭代方法
forEach 遍历数组
括号中传入函数，函数由三个形参，第一形参是数组的每一项的数据，第二项是数组下标，第三项是原数组

   var ary = [1,2,3,1,1,2,3];
   ary.forEach(function(item,value){
         console.log(item,value);
     })

map 遍历数组方法
和 forEach 使用方法相同，但是它有返回值，它映射了一个新数组，内容里面要写 return
 

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

算法值数组去重
数组去重会出现下标塌陷问题

   

  var ary = [1, 2, 3, 1, 1, 2, 3];
     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--;
                 //解决下标塌陷问题，删除重复数组后将下标前移
             }
         }
     }
     console.log(ary);

       

 var ary = [1, 2, 3, 43, 2, 1, 2, 3, 4, 11, 1, 1, 1, 1, 1, 1];
     var obj = {};
     for (var i = 0; i < ary.length; i++) {
         var key = ary[i];
         if (typeof obj[key] == "undefined") {
             obj[key] = ary[i];
         } else {
             ary.splice(i, 1);
             i--;
         }
     }
     console.log(ary);

   

 var ary = [1, 2, 3, 43, 2, 1, 2, 3, 4,11,1,1,1,1,1,1];
     var obj = {};
     var ary1 = [];
     for (var i = 0; i < ary.length; i++) {
         var key = ary[i];
             obj[key] = ary[i];
      //对象的属性名不能重复的特性
     }
     for(var i in obj){
         ary1.push(obj[i]);
     }
     console.log(ary1);

       

 var ary = [1,2,3,4,2,1,3,4,5,6];
     var newAry = [];
     for(var i in ary){
         var item = ary[i];
         if(newAry.indexOf(item) == -1){
             newAry.push(ary[i]);
         }
     }
     console.log(newAry);

算法值冒泡排序

var ray = [1, 4, 3, 2, 6, 5, 7];
var npm;
for (var i = 0; i < ray.length - 1; i++) {
   for (var j = 0; j < ray.length - 1 - i; j++){
      if(ray[j] > ray[j+1]){
          npm = ray[i];
          ray[i] = ray[j];
          ray[j] = npm;
      }
   }
}
console.log(ray);

递归
     

function total(num) {
          if (num > 100) return 0;
          return num + total(num + 1);
      }
      console.log(total(1));