9.11-day07-js基础

1. 索引思维

// var arr1 = [11, 22, 33, 44];
      // var arr2 = arr1;// arr2引用了arr1的地址
      // arr1[0] = 'AA';
      // console.log(arr2);

      var arr = [11, 22, 33, 44]; //引用类型,地址相同
      function fn(a) {
        // a = a.slice(0);  拷贝一份新的,而且地址与原来的arr地址不同
        a[0] = "BB"
      }
      fn(arr);
      console.log(arr);  // ['BB',22,33,44]; 出入的参数属于什么样的
      //类型很重要

      var arr = 100; //是值类型
      function fn(a) {
        a = 200;
      }
      fn(arr);
      console.log(arr); // ? 100

2. 排序算法

//冒泡
      var arr = [8, 5, 9, 3, 6];
      for (var i = 0; i < arr.length - 1; i++) {
        for (var j = 0; j < arr.length - 1 - i; j++) {
          if (arr[j] > arr[j + 1]) {
            var temp = arr[j + 1];
            arr[j + 1] = arr[j];
            arr[j] = temp;
          }
        }
      }
      console.log(arr);

      //选择排序
      var arr = [8, 5, 9, 3, 6];
      for (var i = 0; i < arr.length - 1; i++) {
        var win = i;
        for (var j = i + 1; j < arr.length; j++) {
          if (arr[win] > arr[j]) {
            win = j;
          }
        }
        if (win != i) {
          var temp = arr[i];
          arr[i] = arr[win];
          arr[win] = temp;
        }
      }

      //快速排序
      var arr = [8, 5, 9, 3, 6];
      var quickSort = function (list) {
        //如果传入的不是数组,返回数组
        if (!Array.isArray(list)) return [];
        //如果数组的长度小于2,返回当前数组
        if (list.length < 2) return list;
        var middleIndex = parseInt(list.length / 2);
        var middleVal = list.splice(middleIndex, 1);
        var left = [], right = [];
        for (var i = 0; i < list.length; i++) {
          list[i] > middleVal ?
            right.push(list[i]) :
            left.push(list[i]);
        }
        return quickSort(left).concat(middleVal, quickSort(right));
      }
      console.log(quickSort(arr));

3. 作业

// 2,  冒泡排序自己写一遍.
      console.log('---------------------------');
      var arr = [8, 5, 9, 3, 6];
      for (var i = 0; i < arr.length - 1; i++) {
        for (var j = 0; j < arr.length - 1 - i; j++) {
          if (arr[j] > arr[j + 1]) {
            var temp = arr[j + 1];
            arr[j + 1] = arr[j];
            arr[j] = temp;
          }
        }
      }
      console.log(arr);
      // 3,  给定一个含有n个元素的整型数组a，求a中所有元素的和
      console.log('---------------------------');
      // 方式1
      var a = [11, 22, 33, 44];
      var sum = 0;
      for (var i = 0; i < a.length; i++) {
        sum += a[i]
      }
      console.log(sum);
      console.log('---------------------------');
      //方式2 
      var arr = [11, 22, 33, 44];
      var sum = arr.reduce(function (pre, cur) {
        return pre + cur;
      }, 0);
      console.log(sum);
      // 4,  给定一个含有n个元素的整型数组a，打印其中的最大值和最小值. 
      console.log('---------------------------');
      //方式1
      var arr = [8, 5, 9, 3, 6];
      var max = arr[0];
      var min = arr[0];
      for (var i = 1; i < arr.length; i++) {
        if (arr[i] > max) {
          max = arr[i]
        }
        if (min > arr[i]) {
          min = arr[i]
        }
      }
      console.log(max, min);
      console.log('---------------------------');
      //方式2
      var arr = [8, 5, 9, 3, 6];
      var max = arr.reduce(function (pre, cur) {
        return pre > cur ? pre : cur;
      });
      var min = arr.reduce(function (pre, cur) {
        return pre > cur ? cur : pre
      })
      console.log(max, min);
      // 5,  给定一个'不存在重复'元素的整数数组，例如[6,4,7,2,5,8]和一个数字，
      //例如10，请设计一个函数找出两个元素(或同一个元素加自身)，并且使这两个数的和为给定数字，并打印出来
      // 例如[6,4,7,2,5,8]和数字10. 打印结果为: 6,4  2,8  5,5 
      console.log('---------------------');
      var arr = [6, 4, 7, 2, 8, 5];
      for (var i = 0; i < arr.length; i++) { //5
        for (var j = i; j < arr.length; j++) { //5
          if (arr[i] + arr[j] == 10) {
            console.log(arr[i], arr[j]);
            break;
          }
        }
      }
      // 6,  随机给出一个10位以内的数，然后输出该数共有多少位，并将每位的数字保存到数组中. 
      //      如:1342, 位数为:4, 数组为:[1,3,4,2]
      console.log('---------------------------');
      var num = 1342;
      var arr = [];
      while (num) {
        console.log(num % 10);   // [2,4,3,1]
        arr.unshift(num % 10)
        num = parseInt(num / 10)
      }
      console.log(arr.length + "个", "[" + arr.join() + "]");
      // 7,  给定两个升序整型数组a和b，打印其共同元素，
      //比如：a = [0, 1, 2, 3, 4]，b = [1, 3, 5, 7, 9]，输出 1, 3
      console.log('---------------------------');
      var a = [0, 1, 2, 3, 4], b = [1, 3, 5, 7, 9]
      for (var i = 0; i < a.length; i++) {
        for (var j = 0; j < b.length; j++) {
          if (a[i] == b[j]) {
            console.log(a[i]);
            break;
          }
        }
      }

      // 8,  有一个从小到大排好序的数组。现输入一个数，要求按原来的规律将它插入数组中,      
      //      如: [2,3,4,56,67,98]    //63, 100
      console.log('---------------------------');
      //方式1
      var index = -1; //下标没有负数,通过循环比较,是否有条件更改index,如果没有更改,数组的最位置
      var arr = [2, 3, 4, 56, 67, 98];
      var num = 100;
      for (var i = 0; i < arr.length; i++) {
        if (arr[i] > num) {
          console.log(i);
          index = i;
          break;
        }
      }
      if (index != -1) {
        arr.splice(index, 0, num);
      } else {
        arr.push(num);
      }
      console.log(arr);
      console.log('---------------------------');
      //方式2
      var arr = [2, 3, 4, 56, 67, 98];
      var num = 63;
      var index = arr.findIndex(function (item) {
        return item > num
      })
      console.log(index);
      if (index != -1) {
        arr.splice(index, 0, num);
      } else {
        arr.push(num);
      }
      console.log(arr);
      // 9, 取出数组[1,3,1,4,2,3,6,2,6,1,5]中的重复项,存入一个新的数组,并从大到小排序 
      console.log('---------------------------');
      //1. 
      var arr = [1, 3, 1, 4, 2, 3, 6, 2, 6, 1, 5];
      var newArr = [];
      for (var i = 0; i < arr.length - 1; i++) {
        for (var j = i + 1; j < arr.length; j++) {
          if (arr[i] == arr[j] && newArr.indexOf(arr[i]) == -1) {
            newArr.push(arr[i]);
            break;
          }
        }
      }
      console.log(newArr.sort(function (a, b) {
        return b - a
      }));
      // 10, 生成13位条形码(对之前的知识综合练习)
      //   Ean-13码规则：第十三位数字是前十二位数字经过计算得到的校验码。
      //     例如：690123456789  -> [6,9,0,1,2,3,4,5,6,7,8,9]
      //     第十三位计算其校验码的过程为：
      //   	1，前十二位的奇数位和6+0+2+4+6+8=26
      //   	2，前十二位的偶数位和9+1+3+5+7+9=34
      //   	3，将奇数和与偶数和的三倍相加26+34*3=128
      //   	4，取结果的个位数：128的个位数为8
      //   	5，用10减去这个个位数10-8=2
      //         所以校验码为2（注：如果取结果的个位数为0，那么校验码不是（10-0=10），而是0
      //   实现函数ean13(n)计算验证码，输入12位条码，返回带验证码的条码。
      //   例如：输入：692223361219输出：6922233612192
      var num = 692223361219;
      function ean13(n) {
        var arr = [];
        while (n) {
          arr.unshift(n % 10)
          n = parseInt(n / 10);
        }
        var odd = 0;//奇数
        var even = 0;//偶数
        for (var i = 0; i < arr.length; i++) {
          if (i % 2 == 0) {
            odd += arr[i];
          } else {
            even += arr[i]
          }
        }
        var res = (odd + even * 3) % 10;
        if (res == 0) {
          arr.push(0);
        } else {
          arr.push(10 - res);
        }
        return arr.join("");
      }

      console.log(ean13(num));


      //   11, 开发一个标题为“FlipFlop”的游戏应用程序。它从1计数到100，
      //   遇到3的倍数就替换为单词“Flip”，
      //   5的倍数就替换为单词“Flop”，既为3的倍数又为5的倍数则替换为单词“FlipFlop”。

      var arr = [];
      for (var i = 0; i < 100; i++) {
        arr[i] = i + 1; //赋值
        if (arr[i] % 3 == 0 && arr[i] % 5 == 0) {
          arr[i] = "FlipFlop"
        } else if (arr[i] % 3 == 0) {
          arr[i] = "Flip"
        } else if (arr[i] % 5 == 0) {
          arr[i] = "Flop"
        }
      }
      console.log(arr);

4. 字符串

//1.什么是字符串?
      // 有一组双引号或单引号组成字符,它是一个'值类型'

      //2.字符串的语法?
      // 2.1字面量表达式
      var str = "你好呀!";          //string
      var str1 = '老罗真的好帅哦~';  //string

      // 2.2 
      var str = String("你好");     //string

      // 2.3 构造函数创建字符串  new 引用类型
      var str = new String("你好呀");  //object
      var str1 = "abc";
      console.log(typeof str1);


      var str2 = new String("你好呀");
      // console.log(typeof str2);
      console.log(typeof str2.toString()); //string

      // 装箱与拆箱的概念
      // 值类型-->转换--->引用类型  装箱
      //    new  装箱
      // 引用类型 --> 转换-->值类型 拆箱
      //    toString() 拆箱

5. 字符串方法

// 1.字符串的有恒定性,不会发生改变,
      // 接下所有的字符串方法,不会改变原来的字符串

      // var str = "abc123";
      // for (var i = 0; i < str.length; i++) {
      //   console.log(str[i]);
      //   str[i] = "a";
      // }
      // console.log(str);

      // var str = "abc123";
      // str = str + "zzzz";
      // console.log(str);


      //1.通过下标找字符
      var str = "abc123";
      console.log(str[2]); //重点
      // console.log(str.charAt(2)); //了解

      //2.charCodeAt   unicode
      var str = "我爱你a";
      console.log(str.charCodeAt(0)); //25105
      console.log(str.charCodeAt(1)); //29233
      console.log(str.charCodeAt(2)); //20320
      console.log(str.charCodeAt(3)); //97

      //3.把unicode转换字符
      // String.fromCharCode() 静态方法 
      var str = String.fromCharCode(25105, 29233, 20320);
      console.log(str);

      //4.查找
      // 4.1 search 找到了返回下标,找不到返回-1
      //    支持正则
      var str = "abc123";
      console.log(str.search("c"));
      console.log(str.search("z"));
      console.log(str.search(/a/));

      //4.2 indexof 找到了返回下标,找不到返回-1
      // 第2个参数,默认是从0开始,也可以指定位置
      // 不支持正则
      var str = "abc123";
      console.log(str.indexOf("c"));
      console.log(str.indexOf("z"));
      console.log(str.indexOf(/a/));

      //4.3 match 找到了返回数组,找不到 返回null 
      var str = "abc123";
      console.log(str.match("c"));  //返回数组
      console.log(str.match("1c")); //返回null

      //4.4 lastIndexOf
      var str = "abc123abc";
      console.log(str.lastIndexOf("c")); // 8
      console.log(str.lastIndexOf("c", 5)); // 2

      //5.截取系列
      //5.1  slice 包含开始位置,包包含结束
      var str = '台上有一位绝世美男子,今年18岁';
      console.log(str.slice(7, 10));
      console.log(str.slice(7));
      //5.2  substring 包含开始位置,包包含结束,可以自动调整参数的顺序
      var str = '台上有一位绝世美男子,今年18岁';
      console.log(str.substring(10, 7));
      console.log(str.substring(7));

      //5.3 substr 第2个参数,表示截取的 个数
      var str = '台上有一位绝世美男子,今年18岁';
      console.log(str.substr(7));
      console.log(str.substr(7, 3));

      //6.合并  concat
      var str1 = "我是";
      var str2 = "美男子";
      var str3 = str1 + str2;
      var str4 = str1.concat(str2, "!");
      console.log(str3);
      console.log(str4);

      //7.切割 返回一个新的数组
      var str = "abc-123";
      console.log(str.split());
      console.log(str.split(""));
      console.log(str.split("-"));
      //8.替换
      var str = "台上有一个男子"; //男  --> 美男
      var str1 = str.replace("男", "美男");
      console.log(str);// 
      console.log(str1);// 
      //9.转大写
      var str = "abc123";
      var str1 = str.toUpperCase()
      console.log(str1);
      //10.转小写
      var str = "ABCDEGGSASDASDFD";
      var str1 = str.toLowerCase()
      console.log(str1);

      //11.重复多少次
      var str = "我爱你!";
      var str1 = str.repeat(100);
      console.log(str1);

      //12.字符串模板 ES6 
      // var s = "很";
      // var str = "今天天气" + s + "好";//很
      // console.log(str);

      var s = "很";
      var str = `今天天气${s}好`;
      console.log(str);

      //计算结果是
      var a = 10;
      var b = 20
      var str = "计算的结果:" + a + b;  //计算结果是30  劳神
      console.log(str);

      var str = `计算结果是:${a + b}`;
      console.log(str);

      var str1 = `aaa`;
      console.log(typeof str1); //string


      var str = "     你好 帅哦!     ";
      console.log(str.trim());
      console.log(str.trimEnd());
      console.log(str.trimStart());

      //padStart()
      //padEnd(), 不够就填充

      var str = "我是帅哥";
      console.log(str.padStart(10, "."));
      console.log(str.padEnd(10, "."));


      //includs 是否包含
      var str = "abc123";
      console.log(str.includes("1c"));



      //字符的方法
      //1. charAt() 通过下标找字符
      //2. charCodeAt()  根据下标返回字符串的unicode
      //3. String.fromCharCode() 把unicode转换字符
      //4. search()  支持正则,找到了返回下标,找不到返回-1
      //5. match()   支持正则,找到了返回数组,找不到返回null
      //6. indexOf() 找到了返回下标,找不到返回-1 ,第2个参数,默认是从0开始,也可以指定位置
      //7. lastIndexOf()
      //8. slice()  截取 包含开始位置,不包含结束位置
      //9. substring() 截取 2个参数,大小位置随便写 包含开始位置,不包含结束位置
      //10.substr()   第2个参数,截取个数
      //11.concat()  合并,拼接
      //12.repalce()  替换
      //13.split()  切割
      //14.repeat() 重复
      //15.toUpperCase() 转大写
      //16.toLowerCase() 转小写
      //17.trim() 去掉前后的空白
      //18.padStart() 前面填充
      //19.padEnd()   后面填充
      //20.includes() 是否包含指定的字符

      // g global 全局
      var str = "H e  l  ** l    o    Wo r         L d  !";
      console.log(str.replace(/\*/g, "").replace(/ /g, ""));