内置对象

标签：arr 内置 console log 对象数组 var Math

内置对象基本概念

1. js中的对象分为3种：自定义对象、内置对象、浏览器对象
1. 前面两种对象是js基础，属于ES；第三个浏览器对象啊是js独有的，js API讲解
1. 内置对象就是指js语言自带的一些对象，这些对象供开发者使用，并提供了一些常用的或是最基本而必要的功能（属性和方法）
1. 内置对象最大的优点是帮助我们快速开发
1. js提供了多个内置对象：Math、Date、Array、String等

查文档

学习一个内置对象的使用，只要学会其常用成员的使用即可，可以通过查文档学习，可以通过mdn/菜鸟来查询。

mdn:https://developer.mozilla.org/zh-CN/

菜鸟:https://www.runoob.com/js/js-tutorial.html

1:Math对象最大值

Math是数学对象，不是一个构造函数，所以不需要new来调用，而是直接使用里面的属性和方法即可

  <script>
      // Math对象最大值
      console.log(Math.PI); //3.141592653589793
      console.log(Math.max(1, 22, 33, 4)); //33
      console.log(Math.max(1, 22, "hello")); //NaN
      console.log(Math.max()); //-Infinity
  </script>

  <script>
      // Math对象最小值
      console.log(Math.min(1, 22, 33, 4)); //1
      console.log(Math.min(1, 22, "hello")); //NaN
      console.log(Math.min()); //Infinity
  </script>

2:封装自己的数学对象

解释：

这段代码创建了一个对象 myMath，该对象有两个属性：max 和 min。这两个属性都是函数，分别用于求取最大值和最小值。
max 函数使用了一个 for 循环，循环遍历了函数的参数列表中的所有数字，并比较每个数字的大小，最终找出最大的那个数字。
min 函数与 max 函数的实现方法类似，只是比较的是最小值而已。
最后，使用了两次 console.log 调用来打印结果。首先是调用 myMath.max 求出参数列表中的最大值（这里的参数列表是 1, 2, 36, 7），然后是调用 myMath.min 求出参数列表中的最小值（这里的参数列表是 12, -1, 2, 36, 7）。
执行结果将会是： 36和-1

<script>
      var myMath = {
        max: function () {
          var max = arguments[0];
          for (var i = 1; i < arguments.length; i++) {
            if (arguments[i] > max) {
              max = arguments[i];
            }
          }
          return max;
        },
        min: function () {
          var min = arguments[0];
          for (var i = 1; i < arguments.length; i++) {
            if (arguments[i] < min) {
              min = arguments[i];
            }
          }
          return min;
        },
      };
      console.log(myMath.max(1, 2, 36, 7));//36
      console.log(myMath.min(12, -1, 2, 36, 7));//-1
    </script>

3:Math绝对值和3个取整方法

<script>
      // 1:绝对值的方法
      console.log(Math.abs(1)); //1
      console.log(Math.abs(-1)); //1
      console.log(Math.abs("pink")); //NaN
      console.log(Math.abs("-1")); // 1 隐式转换 注意: 会把字符串型-1 装换为数字型

      // 2：三个取整方法
      //   (1)Math.floor() 向下取整，往最小取值
      console.log(Math.floor(1.1)); //1
      console.log(Math.floor(1.9)); //1

      //   (2)Math.ceil() 向上取整，往最大取整
      console.log(Math.ceil(1.1));
      console.log(Math.ceil(1.9));

      //   (3)Math.round() 四舍五入，其他数字都是四舍五入，但是 .5 特殊，他只取大的
      console.log(Math.round(1.1)); //1
      console.log(Math.round(1.5)); //2
      console.log(Math.round(1.9)); //2
      console.log(Math.round(1.5)); //2
      console.log(Math.round(-1.1)); //-1
      console.log(Math.round(-1.5)); //-1(因为-1 > -2，所以取大的)
</script>

4: Math对象随机数方法

Math对象随机数方法random()返回随机一个小数(大于或等于0并且小于1)
这个方法里面不用跟参数

<script>
      // 代码验证↓
      console.log(Math.random());

      //想要的到两个数之间的随机整数，并且包含这两个2整数
      function getRandom(min, max) {
        min = Math.ceil(min);
        max = Math.floor(max);
        return Math.floor(Math.random() * (max - min + 1)) + min; //含最大值，含最小值
      }
       //console.log(getRandom(1, 10));

      var arr = ["a", "b", "c", "d", "e", "f"];
      console.log(arr[getRandom(0, arr.length - 1)]);
</script>

5: 猜数字游戏(案例)

解释：

这段代码实现了一个简单的猜数字游戏，具体流程如下：

首先，定义了一个函数 getRandom，用于生成一个在指定范围内的随机数。
然后，使用 getRandom 函数生成一个在 1~11 范围内的随机数，并将它赋值给变量 random。
接下来，使用一个 for 循环，循环次数为 3。每次循环，使用 prompt 函数弹出一个输入框，提示用户输入 1~11 范围内的数字。
将用户输入的数字赋值给变量 num。然后使用 if 语句判断 num 与 random 的大小关系。如果 num 大于 random，则弹出一个提示框，提示 "猜大了"；如果 num 小于 random，则弹出一个提示框，提示 "猜小了"；如果 num 等于 random，则弹出一个提示框，提示 "猜对了"，并退出循环。

注意，每次循环完成后，循环变量 i 的值都会减 1。因此，用户有 3 次机会来猜数字。

<script>
      function getRandom(min, max) {
        return Math.floor(Math.random() * (max - min + 1)) + min;
      }
      var random = getRandom(1, 11);
      for (var i = 2; i >= 0; i--) {
        var num = prompt("猜数字游戏,请输入1~11之间的数字,只有3次机会");
        if (num > random + "\n你还剩" + i + "次机会") {
          alert("猜大了");
        } else if (num < random) {
          alert("猜小了" + "\n你还剩" + i + "次机会");
        } else {
          alert("猜对了" + "\n答案就是" + random);
          break;
        }
      }
 </script>

6:Date日期对象

<script>
      // Date()日期对象 是一个构造函数 必须使用new来调用创建的日期对象
      var arr = new Array(); //创建了一个空的数组对象
      var arr = new Object(); //创建了一个空的对象实例

      // 1：使用Date 如果没有参数，会返回当前系统的时间
      var date = new Date();
      console.log(Date());

      // 2: 参数的写法，数字型2022, 12, 31 或者是 字符串型"2022-11-31 6:6:6"
      var date1 = new Date(2022, 12, 31);
      console.log(date1);
      var date2 = new Date("2022-11-31 6:6:6");
      console.log(date2);
</script>

7:格式化日期年月日

<script>
      var date = new Date();
      console.log(date.getFullYear()); //返回当前的年份 getFullYear
      console.log(date.getMonth() + 1); //返回当前的月份，返回的月份会当前月份小1，记得月份+1
      console.log(date.getDate()); //返回的当前几号
      console.log(date.getDay()); //返回当前周几，但是周日会返回0
</script>

案例: 写一个 2022年12月31日星期六

这段代码创建了一个Date对象，然后使用 getFullYear、getMonth、getDate、getDay 等方法获取当前的年、月、日、星期几。其中，getFullYear 返回 4 位数的年份，getMonth 返回月份（0-11），getDate 返回日期（1-31），getDay 返回星期几（0-6）。
然后将获取到的年、月、日、星期几拼接起来，并使用一个数组来将星期几的数字转换为对应的中文名称。最后使用 console.log 将拼接好的字符串输出到控制台。

var date = new Date();
      var year = date.getFullYear();
      var month = date.getMonth() + 1;
      var dates = date.getDate();
      var arr = [
        "星期日",
        "星期一",
        "星期二",
        "星期三",
        "星期四",
        "星期五",
        "星期六",
      ];
      var day = date.getDay();
      console.log(year + "年" + month + "月" + dates + "日 " + arr[day]);
    </script>

8:格式化日期时分秒

<script>
     var date = new Date();
     console.log(date.getHours());   //时
     console.log(date.getMinutes()); //分
     console.log(date.getSeconds()); //秒
</script>

案例：封装一个函数返回当前的时分秒格式06:06:06

这段代码定义了一个名为getTime的函数。函数内部会创建一个 Date 对象，然后使用 getHours()、getMinutes() 和 getSeconds() 方法来获取当前的小时数、分钟数和秒数。
然后，将这些值存储在变量 h、m 和 s 中。接下来，使用三目运算符来确保这些值都是两位数。如果小时数、分钟数或秒数小于 10，则在前面添加一个 0。
最后，函数返回时间字符串,格式为 hh:mm:ss。代码的最后一行使用console.log()来输出函数的返回值。

 <script>
function getTime() {
        var time = new Date();
        var h = time.getHours();
        h = h < 10 ? "0" + h : h;
        var m = time.getMinutes();
        m = m < 10 ? "0" + m : m;
        var s = time.getSeconds();
        s = s < 10 ? "0" + s : s;
        return h + ":" + m + ":" + s;
      }
      console.log(getTime());
 </script>

9:获得Date总的毫秒数

获得Date总的毫秒数(时间戳) 不是当前时间的毫秒数而是距离1970年1月1号过了多少毫秒数

 <script>
      //1. 通过 valueOf() 或者getTime()
      var date = new Date();
      console.log(date.valueOf());
      console.log(date.getTime());

      //2. 简单并常用的写法
      var date1 = +new Date();
      console.log(date1);

      //3. H5新增的 获得总的毫秒数
      console.log(Date.now());
</script>

10:倒计时效果(案例)

核心算法：输入的时间减去现在的时间就是剩余的时间，即倒计时，但是不能拿着时分秒相减，比如 05 分减去25分，结果会是负数的。
用时间戳来做。用户输入时间总的毫秒数减去现在时间的总的毫秒数，得到的就是剩余时间的毫秒数。
把剩余时间总的毫秒数转换为天、时、分、秒（时间戳转换为时分秒）

 <script>
      // 转换公式如下：
      //  d = parseInt(总秒数/ 60/60 /24);    //  计算天数
      //  h = parseInt(总秒数/ 60/60 %24)     //   计算小时
      //  m = parseInt(总秒数 /60 %60 );      //   计算分数
      //  s = parseInt(总秒数%60);            //   计算当前秒数
      function countDown(time) {
        var nowTime = +new Date(); //返回的是当前时间的总的毫秒数
        var inputTime = +new Date(time); //返回的是用户输入时间总的毫秒数
        var times = (inputTime - nowTime) / 1000; //times是剩余世界总的秒数
        var d = parseInt(times / 60 / 60 / 24); //天
        d = d < 10 ? "0" + d : d;
        var h = parseInt((times / 60 / 60) % 24); //时
        h = h < 10 ? "0" + h : h;
        var m = parseInt((times / 60) % 60); //分
        m = m < 10 ? "0" + m : m;
        var s = parseInt(times / 60); //当前的秒
        s = s < 10 ? "0" + s : s;
        return d + "天" + h + "时" + m + "分" + s + "秒";
      }
      console.log(countDown("2023-1-1 18:00:00"));
      var date = new Date();
      console.log(date);
    </script>

代码解释：
1：这段代码定义了一个函数
    countDown，该函数接收一个时间字符串作为参数，返回一个倒计时字符串。
    
2：首先，使用 +new Date() 获取当前的时间戳，并将结果赋值给变量
    nowTime。然后，使用 +new Date(time)
    获取输入的时间的时间戳，并将结果赋值给变量 inputTime。接着，用 inputTime
    减去 nowTime，得到两者之间的时间差，再除以
    1000，得到时间差的秒数，并将结果赋值给变量 times。
    
3：接下来，使用 parseInt()
    函数将秒数转换成天、小时、分钟和秒。首先计算出天数，将结果赋值给变量
    d。然后，计算出小时数，将结果赋值给变量
    h。接着，计算出分钟数，将结果赋值给变量
    m。最后，计算出秒数，将结果赋值给变量 s。
    
4：在转换完成后，使用三目运算符对
    d、h、m 和 s 进行判断，如果数值小于 10，则在前面补
    0。最后，将转换后的天、小时、分钟和秒拼接成字符串并返回。
    
5：最后两行代码是使用该函数计算倒计时，并输出当前时间。

11:创建数组的两种方式

利用数组字面量创建
利用 new Array()创建

 <script>
      var arr = [1, 2, 3];
      console.log(arr[0]);

      //   var arr1 = new Array(); //创建了一个空数组
      //   var arr1 = new Array(4); //这个4表示数组的长度为4，里面有4个空的数组元素
      var arr1 = new Array(2, 3); //等价于[2,3],表示里面有两个数组元素分别是2和3
      console.log(arr1);
 </script>

12:检测是否为数组方法

instanceof 运算符，他可以用来检测是否为数组
Array.isArray(参数)；H5新增的方法

 <script>
      var arr = [];
      var obj = {};
      console.log(arr instanceof Array);
      console.log(obj instanceof Array);

      console.log(Array.isArray(arr));
      console.log(Array.isArray(obj));
 </script>

案例

解释：

这段代码定义了一个函数 reverse，该函数的作用是将传入的数组反转。函数的逻辑如下：

使用 Array.isArray 函数判断传入的参数是否为数组类型，如果不是，则返回一个字符串 "error 这个参数要求必须是数组格式,例如[1,2,3]"。
如果传入的参数是数组类型，则创建一个新的空数组 newArry。然后使用循环，将传入的数组从末尾开始，逐个取出元素，并将元素添加到 newArry 中。
循环完成后，将 newArry 返回。
最后，调用函数 reverse 两次，分别传入一个数组和三个独立的数字，并使用 console.log 函数输出函数的返回值。

 <script>
function reverse(arr) {
        // if (arr instanceof Array) { // 两种方法都可以
        if (Array.isArray(arr)) {
          var newArry = [];
          for (var i = arr.length - 1; i >= 0; i--) {
            newArry[newArry.length] = arr[i];
          }
          return newArry;
        } else {
          return "error 这个参数要求必须是数组格式,例如[1,2,3]";
        }
      }
      console.log(reverse([1, 2, 3]));
      console.log(reverse(1, 2, 3));
      //第一次调用时，传入的是一个数组 `[1, 2, 3]`，函数会将数组反转并返回 `[3, 2, 1]`，然后将其  		  输出到控制台。

     //第二次调用时，传入的是三个数字 `1`，`2` 和 `3`，由于不是数组类型，函数会返回字符串 "error 		  这个参数要求必须是数组格式,例如[1,2,3]"，然后将其输出到控制台。
</script>

13:添加和删除数组元素方法

push()在数组的末尾，添加一个或多个数组元素

push()可以给数组的末尾添加新的元素

push()参数直接写数组元素就可以了

push完毕之后，返回的结果是新数组的长度

unshift()在数组的开头，添加一个或多个数组元素

unshift()可以给数组的末尾添加新的元素

unshift()参数直接写数组元素就可以了

unshift完毕之后，返回的结果是新数组的长度
pop()可以删除数组的最后一个元素

pop可以删除数组的最后一个元素记住一次只能删除一个元素

pop没有参数

pop完毕之后，返回的结果是删除的那个元素
shift()可以删除数组的开头一个元素

shift可以删除数组的开头一个元素记住一次只能删除一个元素

shift没有参数

shift完毕之后，返回的结果是删除的那个元素

相同点

这四个方法都是 js中数组的操作方法，用于对数组的元素进行添加或删除。

不同点

push() 和 unshift() 方法用于向数组的开头或末尾添加一个或多个元素，并返回修改后数组的长度。
push() 方法会在数组的末尾添加一个或多个元素，而 unshift() 方法会在数组的开头添加一个或多个元素。
pop() 和 shift() 方法用于从数组的开头或末尾删除一个元素，并返回被删除的元素。
pop() 方法会删除数组的最后一个元素，而 shift() 方法会删除数组的第一个元素。

 <script>
     //push()在数组的末尾，添加一个或多个数组元素
      var arr = [3, 4];
      console.log(arr.push(5, "hello"));
      console.log(arr);

      //unshif()t在数组的开头，添加一个或多个数组元素
      console.log(arr.unshift(1, 2, 3));
      console.log(arr);

      //pop()可以删除数组的最后一个元素
      console.log(arr.pop());
      console.log(arr);
	  //shift()可以删除数组的开头一个元素
      console.log(arr.shift());
      console.log(arr);
</script>

14:筛选数组(案例)

解释：

这段代码定义了一个数组 arr 并将其初始化为 [220, 120, 200, 150, 300]。它还定义了一个新的空数组 newArry。
接下来，它使用了一个循环来遍历 arr 数组。在每一次迭代中，它检查当前数组元素是否小于 200。如果是，就将该元素添加到 newArry 数组中。
最后，它使用 console.log() 函数打印出 newArry 数组。因此，最终输出的将是一个包含所有小于 200 的数组元素的新数组。

 <script>
      //有一个成绩单 [220, 120, 200, 150, 300]。要求把成绩小于200的数组找出来
      var arr = [220, 120, 200, 150, 300];
      var newArry = [];
      for (var i = 0; i < arr.length; i++) {
        if (arr[i] < 200) {
          newArry.push(arr[i]);
        }
      }
      console.log(newArry);
    </script>

15:数组排序

翻转数组 reverse()
数组排序-冒泡排序 sort()

 <script>
      var arr = ["red", "blue", "pink"];
      arr.reverse();
      console.log(arr);

      var arr1 = [12, 16, 1, 6, 3];
      arr1.sort(function (a, b) {
        return a - b; //升序的顺序排列
     // return b - a; //降序的顺序排列
      });
      console.log(arr1);
    </script>

16: 获取数组元素索引方法

返回数组元素索引号方法indexOf(数组元素)作用就是返回该数组元素的索引号，从前面开始找
他只返回第一个满足条件的索引号
他如果在该数组里面找不到元素，则会返回-1

   <script>
    //var arr = ["red", "blue", "pink", "yellow", "black"];
      var arr = ["pink", "red", "pink"];
      console.log(arr.indexOf("pink"));//0
      console.log(arr.indexOf("blue"));//-1

    // 1：返回数组元素索引号方法 lastIndexOf(数组元素) 作用就是返回该数组元素的索引号，从后面开			 始找(了解)
      var arr = ["red", "blue", "pink", "yellow", "black"];
      console.log(arr.lastIndexOf("black"));//4
    </script>

17:数组去重

数组去重 ["red", "blue", "blue", "red", "blue", "red"] 要求去除数组中重复的元素。

目标：把旧数组里面不重复的元素选取出来放到新数组中，重复的元素只保留一个，放到新数组中去重。
核心算法：我们遍历旧数组，然后拿着旧数组元素去查询新数组，如果该元素在新数组里面没有出现过，我们就添加，否则不添加。
我们怎么知道该元素没有存在？利用新数组.indexOf(数组元素) 如果返回时 - 1 就说明新数组里面没有改元素
封装一个去重的函数 unique 独一无二的

<script>
      function unique(arr) {
        var newArry = [];
        for (var i = 0; i < arr.length; i++) {
          if (newArry.indexOf(arr[i]) === -1) {
            newArry.push(arr[i]);
          }
        }
        return newArry;
      }
      var demo = unique(["red", "blue", "blue", "red", "blue", "red"]);
      console.log(demo);
    </script>

解释
这段代码定义了一个函数 `unique`，该函数的作用是去除数组中重复的元素，并返回一个新的数组。函数的逻辑如下：

1. 创建一个新的空数组 `newArry`。
2. 使用循环，遍历传入的数组 `arr`。
3. 对于每一个元素，使用 `indexOf` 方法检查它是否在 `newArry` 中出现过。
4. 如果没有出现过，则使用 `push` 方法将该元素添加到 `newArry` 的末尾。
5. 循环完成后，将 `newArry` 返回。

最后，调用函数 `unique`，并传入一个含有重复元素的数组 `["red", "blue", "blue", "red", "blue", "red"]`，将函数的返回值赋值给变量 `demo`，然后使用 `console.log` 函数输出变量的值。函数的返回值应该是一个去重后的数组 `["red", "blue"]`，即只包含两种颜色的数组。

18：数组转换为字符串

<script>
      // 1:toString(),将数组转换为字符串
      var arr = [1, 2, 3, 4, 5, 6];
      console.log(arr.toString()); // 1,2,3,4,5,6
      // 2:join("分隔符")
      var arr1 = ["black", "blue", "red"];
      console.log(arr1.join()); // black,blue,red
      console.log(arr1.join("&")); // black&blue&red

      //3：splice() 方法通过删除或替换现有元素或者原地添加新的元素来修改数组
      // 从索引 2 的位置开始删除 0 个元素，并插入“red”
      var myFish = ["1", "2", "3", "4"];
      var removed = myFish.splice(2, 0, "red");
      console.log(myFish); //['1', '2', 'red', '3', '4']

      // 从索引 3 的位置开始删除 1 个元素  被删除的元素：["mandarin"]
      var myFish = ["angel", "clown", "drum", "mandarin", "sturgeon"];
      var removed = myFish.splice(3, 1);
      console.log(myFish); //["angel", "clown", "drum", "sturgeon"]

      // 从索引 2 的位置开始删除 1 个元素，插入“trumpet” 被删除的元素：["drum"]
      var myFish = ["angel", "clown", "drum", "sturgeon"];
      var removed = myFish.splice(2, 1, "trumpet");
      console.log(myFish); //["angel", "clown", "trumpet", "sturgeon"]
    </script>

19:基本包装类型

对象和复杂属性才有属性和方法
简单数据类型为什么会有length属性呢?
基本包装类型：就是把简单数据类型包装称为复杂数据类型

   <script>
      var str = "hello";
      console.log(str.length);
      //1: 把简单数据类型包装称为复杂数据类型
      var temp = new String("hello");
      //2：把临时变量的值给 str
      str = temp;
      //3：销毁这个临时变量
      temp = null;
      console.log(temp);
    </script>

20:字符串的不可变性

字符串的不可变性，指的是里面的值不可变，虽然看上去可以改变内容，但其实是地址变了，内存中新开辟了一个内存空间。

 <script>
      var str = "andy";
      console.log(str);
      var str = "red";
      console.log(str);

      //字符串的不可变所以不要大量的拼接字符串
      var str = "";
      for (var i = 1; i <= 100; i++) {
        str = str + i;
      }
      console.log(str);
 </script>

21:根据字符返回位置

字符串对象，根据字符返回位置 str.indexOf('查找的字符',起始位置)

 <script>
      var str = "啊对对对,不对哦";
      console.log(str.indexOf("对"));
      console.log(str.indexOf("对", 4));//查找第四个'对'的位置
 </script>

22：查找字符串中某个字符出现的次数

查找字符串"abcoefoxyozzopp"中所有o出现的位置以及次数

核心算法：先查找第一个o出现的位置
然后只要indexOf 返回的结果不是 -1 就继续往后查找
因为indexOf 只能查找到第一个，所以后面的查找，一定是当前索引加1，从而继续查找

解释：

这个代码片段使用了js的 indexOf() 函数和 while 循环来统计字符串 str 中字符 "o" 出现的次数。

首先，它使用 indexOf() 函数在 str 中查找字符 "o" 的位置，并将结果赋值给变量 index。如果找到了 "o"，那么 index 的值将是 "o" 的位置；如果没有找到，那么 index 的值将是 -1。

然后，它使用 while 循环，每次执行循环体的条件是 index !== -1，也就是说，只要 index 的值不是 -1，就一直执行循环体。在每次循环中，它会打印出 index 的值，并将变量 num 加 1。然后，它会使用 indexOf() 函数在 str 中查找下一个 "o" 的位置，并将结果赋值给 index。这样就可以一直查找 "o" 的位置，直到找不到为止。

最后，它会打印出 "o出现的次数是: " 和变量 num 的值，以显示 "o" 在字符串 str 中出现的次数。 */

 <script>
      var str = "oabcoefoxyozzopp";
      var index = str.indexOf("o");
      var num = 0;
      // console.log(index);
      while (index !== -1) {
        console.log(index);
        num++;
        index = str.indexOf("o", index + 1);
      }
      console.log("o出现的次数是: " + num);
    </script>

23:根据位置返回字符

  <script>
      // 1：chartAt(index) 根据位置返回字符
      var str = "world";
      console.log(str.charAt(1));
      //遍历所有字符
      for (var i = 0; i < str.length; i++) {
        console.log(str.charAt(i));
      }
      // 2: chartCodeAt 返回相应索引号的ASCII值，目的：判断用户按下了哪个键
      console.log(str.charCodeAt(0)); //119
      //3:str[index] H5新增的
      console.log(str[0]); //w
    </script>

24:统计出现最多的字符和次数

解释：

这段代码的目的是统计字符串 str 中各字符出现的次数，并找出其中出现次数最多的字符。

首先定义一个空对象 o，然后从字符串 str 的第二个字符开始（下标为 1），每次循环取出一个字符，如果在对象 o 中已经有该字符了，就将该字符的出现次数加 1，否则就在对象 o 中添加该字符并将其出现次数设为 1。这样循环一遍之后，对象 o 就记录了字符串 str 中每个字符的出现次数。

接下来，再遍历对象 o，并找出出现次数最多的字符。在循环中，如果当前字符的出现次数比当前的最大出现次数还要大，就更新最大出现次数，并将当前字符设为出现次数最多的字符。最后，输出最大出现次数和出现次数最多的字符。 */

   <script>
      //  判断一个字符串 'abcoefoxyozzopp' 中出现次数最多的字符，并统计其次数。
      // o.a = 1
      // o.b = 1
      // o.c = 1
      // o.o = 4
      // 核心算法：利用 charAt(） 遍历这个字符串
      // 把每个字符都存储给对象， 如果对象没有该属性，就为1，如果存在了就 +1
      // 遍历对象，得到最大值和该字符
      var str = "abcoefoxyozzopp";
      var o = {};
      for (var i = 1; i < str.length; i++) {
        var chars = str.charAt(i);
        if (o[chars]) {
          o[chars]++;
        } else {
          o[chars] = 1;
        }
      }
      console.log(0);

      var max = 0;
      var ch = "";
      for (var k in o) {
        if (o[k] > max) {
          max = o[k];
          ch = k;
        }
      }
      console.log(max); //4
      console.log("出现做多的字符是" + ch); //出现做多的字符是o
    </script>

25:字符串操作方法

 <script>
      var str = "andy";
      console.log(str.concat("-red")); //andy-red 

      var str1 = "改革春风吹满地";
      console.log(str1.substr(2, 2)); //春风
    </script>

26：其他方法

  <script>
      // 1:替换元素 replace('被替换的字符'，'替换为的字符')
      var str = "hello hello";
      console.log(str.replace("h", "a"));//aello hello

      // 2：字符串转换为数组 split('分隔符')  前面学过的join把数组转换为字符串
      var str2 = "red,blue,pink";
      console.log(str2.split(","));// ['red', 'blue', 'pink']
      var str3 = "red&blue&pink";
      console.log(str3.split("&"));;// ['red', 'blue', 'pink']
    </script>

案例：有一个字符串"abcdefgabcdefabxdef"，把里面的a全部替换为*

这段代码声明了一个字符串变量 str1，然后使用了一个 while 循环，当 str1 中包含字符 "a" 时，循环会不断执行。在每次循环中，使用字符串的 replace 方法将 "a" 替换为 "*"。最后，使用 console.log 打印出最终的字符串。

简单来说，这段代码的作用是将字符串 str1 中的所有 "a" 都替换为 "*"，并将最终的字符串输出到控制台。

<script>
var str1 = "abcdefgabcdefabxdef";
      while (str1.indexOf("a") !== -1) {
        str1 = str1.replace("a", "*");
      }
      console.log(str1); //"*bcdef*bcdef*bcdef"
<script>

标签：arr,内置,console,log,对象,数组,var,Math
From： https://www.cnblogs.com/jokerwen/p/17024576.html