js内置对象

js中对象分为：自定义对象、内置对象、浏览器对象。

前两种是js基础 ，第三种属于js独有的

内置对象的优点帮助我们快速开发

js提供的多个内置对象： Math、Date、Array、String等

使用MDN/M3C查阅文档

1.Math对象

 <script>
        // Math数学对象  不是一个构造函数   所以我们不需要new调用  而是直接使用里面的属性和方法即可
        console.log(Math.PI);  //一个属性  圆周率
        console.log(Math.max(1,99,3));  //99
        console.log(Math.max(-1,-10));  //-1
    </script>

如果给定的参数中至少有一个参数无法被转换成数字，则会返回NaN

如果没有参数返回-Infinity

1.1.封装自己的数学对象

 // 利用对象封装自己的数学对象    里面有PI 最大值和最小值
        var myMath = {
            PI:3.141592653,
            max: function() {
                var max = arguments[0];
                for(var i = 1;i < arguments.length;i++) {
                    if(argument[i] > max) {
                        max = arguments[i];
                    }
                }
                return max;
            },
            min: function() {
                var min = arguments[0];
                for(var i = 1;i < arguments.length;i++) {
                    if(argument[i] < min) {
                        min = arguments[i];
                    }
                }
                return min;
            }
        }

1.2Math绝对值和三个取整方法

 // 1.绝对值方法
        console.log(Math.abs(-1));  //1
        console.log(Math.abs('-1'));  // 1  隐式转换  会把字符串型的-1转换成数字型

  // 2.三个取整方法
        //向下取整
        console.log(Math.floor(2.9));  //  2
        //向上取整
        console.log(Math.ceil(3.1));  //  4
        //四舍五入    5特殊  5往大了取
        console.log(Math.round(5.5));   //6
        console.log(Math.round(9.4));  //9
        console.log(Math.round(-1.5));  //-1

1.3随机数方法

（1）Math.random()函数 返回一个浮点数 (返回一个随机小数) [0,1)

（2）这个方法里面不跟参数

// 0到1之间随机数不含1
        console.log(Math.random());
        // 得到两个数之间的随机整数  包含这两个整数
        function getRandom(min, max) {
            return Math.floor(Math.random() * (max - min + 1)) + min;
        }
        console.log(getRandom(10, 100));

2.Date日期对象的使用

<script>
// Date() 日期对象  是一个构造函数  必须使用new  来调用创建的日期对象
        var arr = new Array(); // 创建一个数组对象
        var obj = new Object();  // 创建一个对象实例
// 1.使用Date  如果没有参数  返回当前系统的当前时间
        var date = new Date();
        console.log(date);
// 2.参数常用写法  数字型   2019 ， 10 ， 01 或者是  字符串型 '2019-10-1 8：8：8'
        var date1 = new Date(2019, 10, 1);
        console.log(date1); // 返回的是11月  不是10月
        var date2 = new Date('2019-10-1 8:8:8');
        console.log(date2);
</script>

Date对象和Math对象不一样 他是一个构造函数 所以需要实例化后才能使用

Date实例用来处理日期问题

2.1日期格式化

 // 格式化日期  年月日
        var date = new Date();
        console.log(date.getFullYear());  //返回当前日期的年 2019
        console.log(date.getMonth());  // 月份  返回的月份小1个月   月份+1
        console.log(date.getDate());   //返回的是 几号
  		console.log(date.getDay());   //周天返回的是0
//打印****年**月**日  星期*
		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]););
// 封装一个函数要求返回当前的时分秒    格式  08：08：08
        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());

2.2Date总的毫秒数

// 获得Date总的毫秒数  不是当前时间的毫秒数  而是距离1970年1月1号过了多少毫秒
// 1、 通过  valueOf()   getTime()
        var date = new Date();
        console.log(date.valueOf());
        console.log(date.getTime());
// 2.简单写法
        var date1 = +new Date();  //+new Date  返回的就是总的毫秒数
        console.log(date1);
// 3.H5新增的  获得的总毫秒数
        console.log(Date.now());

2.3倒计时案例

<script>
        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-4-12 22:00:00'));
</script>

3.数组对象

3.1检测是否为数组的两种方法

 //   检测是否有为数组
    // 1. instanceof  运算符   它可以用来检测是否为数组
    var arr = [];
    var obj = {};
    console.log(arr instanceof Array);  //true
    console.log(obj instanceof Array);  //false
    // 2. Array.isArray(参数)
    console.log(Array.isArray(arr));
    console.log(Array.isArray(obj))

Array.isArray优先于instanceof

3.2添加数组元素

// 添加删除数组元素方法
        //  1.push（）在我们数组的末尾  添加一个或者多个数组元素
        var arr = [1,2,3];
        arr.push(6);
        console.log(arr);
        // (1).push  是可以给数组追加新的元素
        // (2).push（）参数直接写  数组元素就可以
        // (3).push完毕之后，返回的结果是  新数组的长度
        // (4).原数组也会发生变化

        // 2.unshift 在数组开头  添加一个或者多个数组元素
        arr.unshift('pink');
        console.log(arr);
        // (1).unshift在数组前面追加新的元素
        // (2).unshift()  参数直接写数组元素
        // (3).unshift完毕之后，返回的结果是  新数组的长度
        // (4).原数组也会发生变化

3.3删除数组元素

 // 3.pop()  可以删除数组的最后一个元素
        arr.pop();
        console.log(arr.pop())  //3
        console.log(arr);
        // (1).pop可以删除数组的最后一个元素   只能删除一个
        // (2).pop（）没有参数
        // (3).pop完毕之后  返回的结果是  删除的那个元素
        // (4).原数组也会发生变化

        // 4.shift()  可以删除数组的第一个元素
        arr.shift();
        console.log(arr.shift())  // 1
        console.log(arr);
        // (1).shift可以删除数组的第一个元素   只能删除一个
        // (2).shift（）没有参数
        // (3).shift完毕之后  返回的结果是  删除的那个元素
        // (4).原数组也会发生变化

3.4数组排序

 // 数组排序
        // 1.翻转数组
        var arr = ['pink','red','green','blue'];
        arr.reverse();
        console.log(arr);
        
        // 2.数组排序（冒泡排序）
        var arr1 = [3,4,7,1];
        arr1.sort();
        console.log(arr1);
//这种只能解决个位数排序

  // 2.数组排序（冒泡排序）  多位数排序
        var arr1 = [3,4,7,1];
        arr1.sort(function(a,b) {
            return a - b;//按照升序的顺序排列
            return b - a;//按照降序的顺序排列
        });
        console.log(arr1);

3.5获取数组索引号

 // 返回数组元素索引号方法    indexOf(数组元素)   从前查找
        var arr = ['pink','red','green','blue','blue'];
        console.log(arr.indexOf('blue'));
        // 只返回第一个满足条件的索引号
        // 如果找不到元素返回-1

        // lastIndexOf（数组元素）   从后查找
        console.log(arr.lastIndexOf('blue'));

3.6数组去重

 <script>
        var arr = ['c' ,'a', 'b' ,'a' ,'c' ,'a' ,'d' ,'a'];
        function unique(arr) {
            var newArr = [];
            for(var i = 0 ; i < arr.length ; i++){
                
                    if(newArr.indexOf(arr[i]) === -1){
                        newArr.push(arr[i]);
                }
            }
            return newArr;
        }
        var arr1 = unique(arr);
        console.log(arr1);
    </script>

3.7数组转换成字符串型

 // 数组转换成字符串
        // 1. toString()  将我们的数组转换成字符串
        var arr2 = [1,2,3];
        console.log(arr2.toString());   //1,2,3
        // 2.join(分隔符)
        var arr3 = ['green' , 'blue' , 'red'];
        console.log(arr3.join('-'));
        // 括号不写默认用逗号隔开

concat() 链接连个或多个数组，不影响原数组

slice() 数组截取slice(begin,end);

splice() 数组删除splice(第几个开始，要删除个数)

4.字符串对象

4.1基本包装类型

 <script>
        // 基本包装类型
        var str = 'andy';
        console.log(str.lenght);
        // 对象和复杂数据类型才有属性和方法
        // 基本包装类型：就是把简单数据类型包装成为了复杂数据类型

        // （1）把简单数据类型包装为复杂数据类型
        var temp = new String('andy');
        // （2）把临时变量的值给str
        str = temp;
        // （3）删除临时变量
        temp = null;
    </script>

为了方便操作基本数据类型，js还提供了三个特殊的引用类型：String、Number、Boolean

4.2字符串不可变

 // 字符串的不可变
        var str = 'andy';
        console.log(str);
        str = 'red';
        console.log(str);
        // 因为我们字符串的不可变性所以不要大量的拼接字符串
        var str = '';
        for(var i=1;i<=100;i++){
            str += i;
        }
        console.log(str);

4.3根据字符返回位置

字符串所有的方法，都不会修改字符串本身（字符串是不可变的） 操作完成会返回一个新的字符串

  // 字符串对象   根据字符返回位置   str.indexOf('要查找的字符'，[起始的位置])
        var str = 'asdfghj，a';
        console.log(str.indexOf('g'));
        console.log(str.indexOf('a',2));

4.4求某个字符出现的位置及次数

思路：（1）先查找第一个字符出现的位置

（2）然后返回indexOf返回的结果不是-1，就继续往后查找

（3）indexOf只能查找第一个，所以后面的查找，利用第二个参数，当前索引加1，从而继续查找

     var arr = 'asdfghasdfghasdfaqgh';
        var index = arr.indexOf('a');
        var num = 0;
        while(index !== -1) {
            console.log(index);
            num++;
            index = arr.indexOf('a',index+1);
        }
        console.log('o出现的个数' + num);

4.5根据位置返回字符

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

4.6统计出现次数最多的字符

算法： 利用charAt() 遍历这个字符串

把每个字符都储存给对象 ，如果对象没有该属性 就为1 ，如果存在就+1

遍历对象，得到最大值和该字符

 <script>
        // 有一个对象   来判断是否有该属性    对象['属性名']
        var o = {
            age: 18
        }
        if(o['age']) {
            console.log('里面有该属性');
        } else {
            console.log('没有该属性');
        }

        var str = 'abcdzpoofxabcoo';
        var o  = {};
        for(var i = 0;i<str.length;i++){
            var chars = str.charAt(i);   //chars是字符串的每一个字符
            if(o[chars]) {   //o[chars]得到的是属性值
                o[chars]++;
            } else {
                o[chars] = 1;
            }
        }
        console.log(o);

        // 2.遍历对象
        var max = 0;
        var ch = '';
        for(var k in o) {
            // k得到的是属性名
            // o[k]得到的是属性值
            if(o[k]>max){
                max = o[k];
                ch = k;
            }
        }
        console.loh(max);
        console.log('最多的字符是' + ch);
</script>

4.7拼接及截取、替换字符串、字符串转换为数组

 <script>
        // 1.concat('字符串','字符串'....)
        var str = 'andy';
        console.log(str.concat('red'));

        // 2.substr('截取的起始位置','截取几个字符');
        var str1 = 'asdfgdfg';
        console.log(str1.substr(3,3));
        
        // 3.替换字符 replace('被替换的字符','替换为的字符')  它只会替换第一个字符
        var str2 = 'andy';
        console.log(str2.replace('a','b'));
        // 要求把里面所有相同的字符全部替换
        var str3 = 'andyandyandy';
        while(str3.indexOf('a') !== -1) {
            str3 = str3.replace('a','*');
        }
        console.log(str3);

        // 4.替换字符串为数组  split('分隔符')    前面学过的join把数组转换为字符串
        var str4 = 'red, pink, blue, red';
        console.log(str4.split(','));
        var str4 = 'red&pink&blue&red';
        console.log(str4.split('&'));
</script>

toUpperCase() 转换大写

toLowerCase() 转换小写