一、内置对象
  1. 3种内置对象：
  2. 自定义对象（ECMAScript）
  3. 内置对象（ECMAScript）
  4. 浏览器对象（JS API）

二、Math对象
  1. Math对象不是构造函数，所以不需要new来调用，可以直接使用里面的属性和方法
  2. Math对象 不需要通过new就可以直接使用
  4. 1、圆周率：Math.PI
  5. 2、求最大和最小值：Math.max(参数)/Math.min(参数)
  6.     Math.max():括号中可以有参数也可以没有参数。
  7.     不带参数时输出的是-Infinity
  8.     带参数时：若里面参数都是数字，返回最大值；若里面参数有字符串，则返回NaN
  9. 3、绝对值：Math.abs() 有一个隐式转换
  10. 4、向下取整：Math.floor()
  11. 5、向上取整：Math.ceil()
  12.     注意：如果是小数，小数点后面跟了15个0 那么是取整数
  13. 6、四舍五入 就近取整：Math.round()
  14.     注意：其他数字都是四舍五入，但是 .5特殊 它往大了取（当数为负数时：如 -3.5 结果是  -3）
  15. 7、获取范围在[0,1)内的随机值：Math.random()
  16.     注意：
  17.     1、Math对象随机数方法 random() 返回一个随机的小数 0=<X<1
  18.     2、这个方法里不跟参数
  20.     //[0,1]内的随机值:Math.floor(Math.random() * (max - min + 1)) + min;
  22.     例题1：得到两个数之间的随机整数，并且包含这两个整数
  23.       function getRandom(min, max) {
  24.         return Math.floor(Math.random() * (max - min + 1)) + min;
  25.       }
  26.       console.log(getRandom(1, 10));
  27.     例题2：随机点名：
  28.      var arr = ["张三", "李四", "王五", "老刘"];
  29.       function getRandom(min, max) {
  30.         return Math.floor(Math.random() * (max - min + 1)) + min;
  31.       }
  32.       console.log(arr[getRandom(0, arr.length - 1)]);
  33.    例题3： 猜数字游戏
  34.       function getRandom(min, max) {
  35.           return Math.floor(Math.random() * (max - min + 1)) + min;
  36.         }
  37.         //   console.log(getRandom(1, 10));
  38.         var random = getRandom(1, 10);
  39.         //死循环 所有需要有一个break退出程序
  40.         while (true) {
  41.           var num = prompt("你来猜？输入1~10之间的一个数字");
  42.           if (num > random) {
  43.             alert("你猜大了");
  44.           } else if (num < random) {
  45.             alert("你猜小了");
  46.           } else {
  47.             alert("你猜对啦");
  48.             break; //退出整个循环 结束程序
  49.           }
  50.         }

三、日期对象
  1. Date() 日期对象是一个构造函数 必须使用new 来调用创建日期对象
  2.     var date=new Date();
  3. 1、使用Date 如果没有参数 返回当前系统的当前时间
  4. 2、参数常用的写法:1、数字型：2021,01,06(返回的比实际的月份大一个月)
  5.                  2、字符串型：'2020-01-06 21:22:33' '2020/01/08'
  6. 3、格式化日期年月日
  7.     //若要输出 2021年 1月7日 星期四
  8.       var year = date.getFullYear();
  9.       var month = date.getMonth() + 1;//返回当前的月份 注意：getMonth()返回的月份比当前月份小一个月
  10.       var dates = date.getDate();
  11.       var arr = ["星期日","星期一","星期二","星期三","星期四","星期五","星期六",];
  12.       var day = date.getDay();
  13.       console.log("今天是:" + year + "年" + month + "月" + dates + "日 " + arr[day]);
  15. 4、格式化日期时分秒
  16.     //要求封装一个函数返回当前的时分秒 格式*：08:08:08
  17.       function getTime() {
  18.         var time = new Date();
  19.         var h = time.getHours();
  20.         h = h < 10 ? "0" + h : h;
  21.         var m = time.getMinutes();
  22.         m = m < 10 ? "0" + m : m;
  23.         var s = time.getSeconds();
  24.         s = s < 10 ? "0" + s : s;
  25.         return h + ":" + m + ":" + s;
  26.       }
  27.       console.log(getTime());
  29. 5、获取日期的总的毫秒形式（Date对象毫秒数是从1070年开始的）
  30.     获取Date总的毫秒数 不是当前时间的毫秒数 而是距离1970年1月1日过了多少毫秒数
  31.     //   1、通过valueOf()或通过getTime()获取Date总的毫秒数
  32.       var date = new Date();
  33.       console.log(date.valueOf());
  34.       console.log(date.getTime());
  35.       //   2、简单写法(最常用的写法)
  36.       var date1 = +new Date(); //+new Date() 返回的就是总的毫秒数
  37.       //   3、H5新增的 获取总的毫秒数
  38.       console.log(Date.now());
  40. 6、倒计时
  41.    核心算法：输入的时间减去现在的时间就是剩余的时间，即倒计时（不能拿时分秒相减）
  42.          1、可以用时间戳来做，用户输入时间总的毫秒数减去现在的时间的总的毫秒数得到的就是剩余时间的毫秒数
  43.          2、把剩余时间总的毫秒数转换为天、时、分、秒(时间戳转换为时分秒)
  44.    转换公式：
  45.       天数：d=parseInt(总秒数/60/60/24)
  46.       小时：h=parseInt(总秒数/60/60%24)
  47.       分数：m=parseInt(总秒数/60%60)
  48.       秒数：s=parseInt(总秒数%60)
  50. function countDown(time) {
  51.         var nowTime = +new Date(); //返回的是当前时间总的毫秒数
  52.         var inputTime = +new Date(time); //返回的是用户输入时间总的毫秒数
  53.         // var times = inputTime - nowTime; //剩余时间总的毫秒数(1秒=1000毫秒)
  54.         var times = (inputTime - nowTime) / 1000; //剩余时间总的秒数
  55.         var d = parseInt(times / 60 / 60 / 24);
  56.         d = d < 10 ? "0" + d : d;
  57.         var h = parseInt((times / 60 / 60) % 24);
  58.         h = h < 10 ? "0" + h : h;
  59.         var m = parseInt((times / 60) % 60);
  60.         m = m < 10 ? "0" + m : m;
  61.         var s = parseInt(times % 60);
  62.         s = s < 10 ? "0" + s : s;
  63.         return d + "天" + h + "时" + m + "分" + s + "秒";
  64.       }
  65.       console.log(countDown("2021-1-30 12:12:12"));

四、数组对象
  1. 1、创建数组的方式：
  2.     1、利用new Array()创建数组
  3.            var arr = new Array(); //创建了一个空的数组
  4.            var arr = new Array(2); //创建了一个长度为2的数组 即里面有2个空的数组元素
  5.            var arr = new Array(2，3); //等价于 var arr =[2,3] 即里面有两个数组元素 是2
  6.      即：如果小括号里写了一个值 那么代表的是 新数组的长度 这个时候没有值 全是empty
  7.          如果写了两个及两个以上的值(值与值之间用逗号隔开)那么就是新数组里边的元素了
  8.     2、利用数组字面量创建数组[]（最常用）
  9.            var arr = [1，2，pink,true];//创建了一个数组
  1. 2、检测是否为数组方法
  2.     1、instanceof 运算符 它可以用来检测是否为数组
  3.         var arr = [];
  4.         var obj = {}; //对象
  5.         console.log(arr instanceof Array); //true
  6.         console.log(obj instanceof Array); //flase
  7.     2、Array.isArray(参数) ie及以上版本支持
  8.         console.log(Array.isArray(arr));//true
  10.        function fn() {
  11.         console.log(arguments instanceof Array); //false 说明arguments不是数组
  12.       }
  13.       fn(1, 2, 3, 4);
  1. 3、添加删除数组元素方法
  2.       1、push()在数组末尾添加一个或多个数组元素
  3.       2、unshift()在数组开头添加一个或多个数组元素
  4.       注意：
  5.         1、push给数组追加新的元素
  6.         2、数组元素直接写在push()里
  7.         3、push完毕后，返回的结果是新数组的长度
  8.         4、push完毕后，原数组会发生变化
  9.         unshift()同理
  1. 4、 删除数组元素方法
  2.        1、pop()只能删除数组的最后一个元素
  3.        注意：
  4.           1、pop()删除数组的最后一个元素，一次只能删一个元素
  5.           2、pop()没有参数
  6.           3、pop完毕后，返回的结果是删除的那个元素
  7.           4、pop完毕后，原数组会发生变化
  8.         2、shift()只能删除数组开头的第一个元素
  9.         注意：
  10.           1、shift()删除数组的最后一个元素，一次只能删一个元素
  11.           2、shift()没有参数
  12.           3、shift完毕后，返回的结果是删除的那个元素
  13.           4、shift完毕后，原数组会发生变化
  1. 5、数组筛选
  2.  // 要求把大于7的数字删除，剩余的放到新数组里
  3.       var arr = [1, 5, 6, 7, 2, 3, 4, 8, 9, 10];
  4.       var newArr = [];
  5.       for (var i = 0; i < arr.length; i++) {
  6.         if (arr[i] < 7) {
  7.           //   newArr[newArr.length] = arr[i];
  8.           newArr.push(arr[i]);
  9.         }
  10.       }
  11.       console.log(newArr);
  1. 6、数组排序：sort()
  2.   //   1、翻转数组
  3.       var arr = ["pink", "purple", "red"];
  4.       arr.reverse();
  5.       console.log(arr);js
  6.       //   2、数组排序(冒泡排序)
  7.       var arr1 = [13, 4, 77, 1, 7];
  8.       arr1.sort(function (a, b) {
  9.         // return a - b; //升序
  10.         return b - a; //降序
  11.       });
  12.       console.log(arr1);
  1. 7、获取数组元素的索引号：indexof() 
  2. 但是只返回第一个满足条件的索引号，
  3. 如果在该数组中找不到元素，则返回-1
  4. var arr = ["red", "green", "blue", "pink"];
  5.       console.log(arr.indexOf("blue"));
  6.  了解：lastindeOf()从后面开始查找
  8.  数组去重：
  9.   // 核心算法：遍历旧数组，然后拿着旧数组元素去查询新数组，如果该元素在新数组中没有出现过就添加，否则不添加
  10.    function unique(arr) {
  11.         var newArr = [];
  12.         for (var i = 0; i < arr.length; i++) {
  13.           if (newArr.indexOf(arr[i]) === -1) {
  14.             newArr.push(arr[i]);
  15.           }
  16.         }
  17.         return newArr;
  18.       }
  19.       var demo = unique(["c",  "n", "c", "g", "a"]);
  20.       console.log(demo);
  1. 8、数组转换为字符串:toString()
  2. //   1、toString()
  3.       var arr = [1, 2, 3];
  4.       console.log(arr.toString()); //1,2,3
  5. //   2、join(分隔符)
  6.       var arr1 = [1, 2, 3];
  7.       console.log(arr1.join("&")); //1&2&3
  1. 9、concat(str1,str2...):连接两个或多个数组 不影响原数组 返回一个新的数组
  2. 10、substr(start,length):从start位置开始(索引号)，length取得个数 重点记住这个
  3. 11、slice(start,end):从start位置开始(索引号),截取到end位置(索引号)，end取不到。返回被截取项目的新数组
  4. 12、(重点看)splice():数组删除splice(从第几个开始，要删个数) 返回被删除项目的新数组 注意 这个会影响原数组
  1. 12、基本包装类型：把简单数据类型包装成复杂数据类型(可以使用里面的属性和方法)
  2. 基本包装类型：String、Number、Boolean
  3.       步骤
  4.       1、把简单数据类型包装成复杂数据类型
  5.       2、把临时变量的值给str
  6.       3、销毁这个临时变量
  7.       //var str = "andy";
  8.       var temp = new String("andy");
  9.       str = temp;
  10.       temp = null;
  11.       console.log(str.length); //4

五、字符串对象
  1. 1、字符串的不可变
  2. 指的是里面的值不可变，虽然看上去可以改变内容，但其实是地址变了，内存中新开辟了一个内存空间
  1. 2、根据字符返回位置
  2. str.indexOf('要查找的字符',[索引号的起始位置])
  4. 案例：查找字符串"jseabchsdakascj"中所有a出现的位置以及次数
  5.       // 核心算法：
  6.       // 1、先查找第一个a出现的位置，
  7.       // 2、只有indexOf返回的结果不是-1就继续往后查找
  8.       // 3、因为indexOf只能查找到第一个，所以后面的查找，需要利用第二个参数，当前索引加1,从而继续查找
  9.       var str = "jseabchsdakascj";
  10.       var index = str.indexOf("a");
  11.       var num = 0;
  12.       // console.log(index);//3
  13.       while (index !== -1) {
  14.         console.log(index); //3 9 11
  15.         num++;
  16.         index = str.indexOf("a", index + 1);
  17.       }
  18.       console.log("a出现的次数是：" + num);
  1. 3、根据位置返回字符（重点）
  2.     1、charAt(index索引号)返回指定位置的字符
  3.     2、charCodeAt(index索引号)获取指定位置处字符的ASCII码 目的：判断用户按下了哪个键
  4.         注：A：65 a:97
  5.     3、str[index索引号]获取指定位置处字符
  1. 4、判断是否有某个属性 对象['属性名']
  2. // 案例：  统计出现最多的字符和次数'hjkccsc'
  3. //   核心算法：
  4.       // 1、利用charAt()遍历这个字符串
  5.       // 2、把每个字符都存储给对象，如果对象没有该属性，就为1，如果存在了就+1
  6.       // 3、遍历对象，得到最大值和该字符
  8.       //   1、利用charAt()遍历这个字符串，把每个字符都存储给对象
  9.       var str = "hjkccsc";
  10.       var a = {};
  11.       for (var i = 0; i < str.length; i++) {
  12.         var chars = str.charAt(i); //chars是字符串的每一个字符
  13.         if (a[chars]) {
  14.           //a[chars]得到的属性值
  15.           a[chars]++;
  16.         } else {
  17.           a[chars] = 1;
  18.         }
  19.       }
  20.       console.log(a);
  21.       //2、遍历对象
  22.       var max = 0;
  23.       var ch = "";
  24.       for (var k in a) {
  25.         //K 得到的是属性名
  26.         //a[k] 得到的是属性值
  27.         if (a[k] > max) {
  28.           max = a[k];
  29.           ch = k;
  30.         }
  31.       }
  32.       console.log(max);
  33.       console.log("最多的字符是：" + ch);
  1. 5、字符串操作方法（重点）
  2. concat(str1，str2...):拼接字符串 等价于'+'
  3. 重点：substr(start,length是取得个数)
  4. slice(start,end取不到)
  5. substring(start,end取不到)和slice基本相同，但是不接受负值
  1. 6、替换字符replace('被替换的字符','替换为的字符') 它只会替换第一个字符
  2. 案例： 把一个字符串中的a都替换为*
  3. var str='hagafadasa'
  4. while(str.indexOf('a')!==-1){
  5.   str=str.replace('a','*')
  6. }
  7. console.log(str)
  8. 7、字符转换为数组split('分隔符')
  9.   之前学的： 数组转换为字符串join('分隔符')
  10.    var str='red,pink,blue'
  11.    colsole.log(str.split(','))
  13.    var str='red&pink&blue'
  14.    colsole.log(str.split('&'))
  1. 7、toUpperCase()//转换大写
  2.    toLowerCase()//转换小写