数组基础方法 排序 余数规律 判断是否为整数 个位补齐 翻转数组

题1

1.看数组 观察变化规律
初始 ['a','b','c','d','e'] 01234 下标加2
第一次 ['d','e','a','b','c'] 23456 ==> 23401 想要在这个数组内部循环
第二次 ['b','c','d','e','a']
第三次 ['e','a','b','c','d']
...
请问第五次 地十五次数组是如何？
   每一次下标进位2 在这个数组内部循环
   使用余数规律
   0 % 5  0
   1 % 5  1
   2 % 5  2
   3 % 5  3
   4 % 5  4
   5 % 5  0
   6 % 5  1
           `var arr = ['a','b','c','d','e'];
            var len = arr.length;
            var resultArr = [];
            for(var j = 1; j <= 15; j++){
              resultArr = [];//每一次都要有新的空数组 
              for(var i = 0; i < len; i++){
                resultArr[(i + 2) % len] = arr[i];
              }
              arr = resultArr;//每一次的变化之后 要附上
              console.log(resultArr + '第' + j + '次');
            }`

2.var arr = ['鸡腿',101,'3','奥利奥',9,false,'333a',1.33,'巧克力']；
  求数组中所有类型为number的整数之和
            `//条件 1.类型为number 2.整数
            var arr = ['鸡腿',101,'3','奥利奥',9,false,'333a',1.33,'巧克力'];
            var sum = 0;
            // for(var i = 0, len = arr.length; i < len; i++){
            //   if(typeof arr[i] === 'number' && arr[i] % 1 === 0){
            //     sum += arr[i];
            //   }
            // }

            for(var i = 0, len = arr.length; i < len; i++){
              if(~~(arr[i]) === arr[i]){//双否是为了取整
                sum += arr[i];
              }
            }
            console.log(sum);`
            
      判断是否为整数
          1.num % 1 === 0
          2.parseInt(num) === num
          3.~~num === num

3.数组替换switch实现根据0-6打印星期一 到 星期日
    数组映射 空间换时间（用于分支值或 可能性非常多并且有规律的时候）
        `var weekDay = ['日','一','二','三','四','五','六'];
        var day = 0;
        console.log('星期' + weekDay[day]);`

个位补齐 01，02，03，04，05，06，07，08，09，10...
        `for(var i = 1; i <= 20; i++){
          console.log(String(i)[1] && String(i) || '0' + i);
        }`
        假设i为数字1
            false && '1' || '0' + 1
            false || '0' + 1
            '0' + 1
            返回01

数组基础方法

join()

将一个数组的所有元素连接成一个字符串，并返回这个字符串
null和undefined在数组里面被认定为空字符串
    `var arr = ['你','好',1,null,undefined];
    console.log(arr.join('-'));`返回值为 你-好-1- - 

push()

将一个或多个元素添加到数组的末尾，并返回该数组的新长度
    `var arr = [1];
    arr.push(2);
    var len = arr.push('ha')
    console.log(arr,len);`

unshift()

将一个或多个元素添加到数组的前端，并返回该数组的新长度

pop()

从数组中删除最后一个元素，并返回被删除的这个元素
删空了返回undefined
    `var arr = [1,2];
    console.log(arr.pop());`

shift()

从数组中删除最前面的元素，并返回被删除的这个元素

slice()

切割(包含起始下标，不包含末尾) 一直都是从左到右，可以是负数（从后往前切割) 
    不传参 就是全部切割 并且返回新数组 也就是浅拷贝
    `var arr = ['西瓜','苹果','葡萄'];
    console.log(arr.slice(1,2));`

浅拷贝 
    方法一：
        `var arr = ['西瓜','苹果','葡萄'];
        var newArr = arr.slice();`
    方法二三：
        `var arr = ['西瓜','苹果','葡萄'];
        var newArr = [];
        for(var i = 0, len = arr.length; i < len; i++){
          // newArr.push(arr[i]); 
          newArr[i] = arr[i];//对比赋值
        }
        console.log(newArr);`

concat()

合并两个或多个数组 也可以用于浅拷贝
    `var arr = ['西瓜','苹果','葡萄'];
    var otherArr = ['李子','梨子'];
    var otherArr1 = ['香蕉'];
    var newArr = arr.concat(otherArr,otherArr1);
    console.log(newArr);`
浅拷贝
    `var arr = ['西瓜','苹果','葡萄'];
    var newArr = arr.concat();//返回拼接后的新数组
    console.log(newArr);`
    

indexOf()

在数组中可以找到一个给定元素的第一个索引，如果不存在，就返回-1
没有第二个参数，就从头开始找，有第二个参数，就从参数表示的下标开始找
    `var arr = ['西瓜','苹果','葡萄','西瓜'];
    console.log(arr.indexOf('西瓜',2));`

排序

冒泡排序

相邻的比较大小，前面的比后面的大就交换
   `var arr = [1,6,7,4,3,8,9];
    var len = arr.length;
    var temp;
    for(var i = 0; i < len; i++){
      for(var j = 0; j < len - 1 - i; j++){ //len-1-i，len-1是因为有j+1，-i是因为每排一次就减一
        if(arr[j] > arr[j + 1]){
          temp = arr[j];
          arr[j] = arr[j + 1];
          arr[j + 1] = temp;
        }
      }
    }
    console.log(arr);`

选择排序

第一个和后面的依次比较看谁比自己小，将小的下标索引赋值给最小索引变量minIdx，
1.找最小索引2.交换值
        `var arr = [1,6,7,4,3,8,9];
        var len = arr.length;
        var minIndex,temp;
        for(var i = 0; i < len -1; i++){
          minIndex = i;
          for(var j = i + 1; j < len; j++){
            if(arr[j] < arr[minIndex]){
              minIndex = j;
            }
          }
          temp = arr[i];
          arr[i] = arr[minIndex];
          arr[minIndex] = temp;
        }
        console.log(arr);`

插入排序

从后面拿牌，和前面的比，比哪张小就放哪张前面
外层循环从1下标开始，和0下标的值比较。1下标的值比0下标的值小，两个值互换（将0下标的值赋值给1下标，在将之前1下标的值赋值给0下标）
        `var arr = [1,6,7,4,3,8,9];
        var len = arr.length;
        for(var i = 1; i < len; i++){
         var key = arr[i], j = i - 1;
         while(arr[j] > key){
           arr[j + 1] = arr[j];
           j--;
         }
         arr[j + 1] = key;
        }
        console.log(arr);`

题2

1.求一组数中的所有数的和和平均值
       `var arr = [1,6,7,4,3,8,9];
        var len = arr.length;
        var count = 0, avg = 0;
        for(var i = 1; i < len; i++){
         count += arr[i];
        }
        avg = count / len;
        console.log(count, avg);`
2.求一组数中的最大值和最小值，以及所在的位置
       `var arr = [1,6,7,4,3,8,9];
        var len = arr.length;
        var max = arr[0], min = arr[0], maxIdx = 0, minIdx = 0;
        for(var i = 1; i < len; i++){
          if(arr[i] >= max){
            maxIdx = i;
            max = arr[i];
          }
          if(arr[i] <= min){
            minIdx = i;
            min = arr[i];
          }
        }
        console.log(max, min, maxIdx, minIdx);`
3.将字符串数组用|或其他符号拼接成字符串
       `var arr = ['大','家','好'];
        console.log(arr.join('|'));`
4.将字符串单独分割成字符串，形成数组
       `var str = '大家好';
        console.log(str.split(''));`
5.将字符串数组中的0项去掉，将不为0的值存入一个新的数组，生成新的数组
       `var arr = [1,6,7,4,3,8,9,0];
        var len = arr.length;
        var newArr = [];
        for(var i = 0; i < len; i++){
          if(arr[i] !== 0){
            newArr.push(arr[i]);
          }
        }
        console.log(newArr);`
4.查找数组中所有值为1的项的下标 输出为新数组
       `var arr = [1,6,7,4,1,1,3,1,8,9,0,1];
        var len = arr.length;
        var newArr = [];
        for(var i = 0; i < len; i++){
          if(arr[i] == 1){
            newArr.push(i);
          }
        }
        console.log(newArr);`
翻转数组
       `var arr = [1,6,7,4,3,1,8,9];
        var len = arr.length;
        var newArr = [];
        //用push
        // for(var i = len - 1; i >= 0; i--){
        //   newArr.push(arr[i]);
        // }

        //用unshift
        // for(var i = 0; i < len; i++){
        //   newArr.unshift(arr[i]);
        // }

        //不用新数组 第一位和最后一位对调
        var temp;
        for(var i = 0; i < len / 2; i++){
          temp = arr[i];
          arr[i] = arr[len - 1 - i];
          arr[len - 1 - i] = temp;
        }
        console.log(arr);`