javascript-内置对象

内置对象：js语言自带的一些对象，这些对象供开发者使用，并提供一些常用的活是基本而必须的功能（属性和方法）

优点：快速开发

 

查文档

MDN/W3C

Math对象

        console.log(Math.PI);
        console.log(Math.max(1, 3, 99));//99
        console.log(Math.max(-1, -10));//-1
        console.log(Math.max(-1,10,'pink'));//NAN
//利用对象封装自己的数学对象，里面有pi最大值和最小值
        var myMath = {
            PI: 3.141592653,
            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.PI);
        console.log(myMath.max(1, 3, 6));
        console.log(myMath.min(1, 3, 6));
//1.绝对值
        console.log(Math.abs(-1));
        console.log(Math.abs('-1'));//隐式转换 会把字符串-1转换为数字型
        //2.三个取整数的方法
        //（1）Math.floor()向下取整
        console.log(Math.floor(1.1));//1
        //(2)Math.ceil()向上取整
        console.log(Math.ceil(1.1));//2
        //(2)Math.round()四舍五入
        console.log(Math.round(1.1));//1
        console.log(Math.round(1.5));//2
        console.log(Math.round(-1.1));//1
        console.log(Math.round(-1.5));//-1
//Math对象随机数方法 random（）返回一个随机的小数 
        //这个方法里面不跟参数
        console.log(Math.random());
        //得到两个数之间的随机整数，并包含这2个整数
        function getRandom(min, max) {
            return Math.floor(Math.random() * (max - min + 1)) + min;

        }
        console.log(getRandom(1, 10));
        //随机点名
        var arr = ['张三', 'zhangsanfeng', 'zhaosi', 'liunneg'];
        console.log(arr[getRandom(0, 3)]);
//猜数字游戏
        //1.随机生成1-10的整数
        //2.需要到猜到为止，所以需要循环
        //3.用while更好
        //4.核心算法if else if
        function getRandom(min, max) {
            return Math.floor(Math.random() * (max - min + 1)) + min;

        }
        var random = getRandom(1, 10);
        while (true) {
            var num = prompt('你来猜？1-10之间的数字');
            if (num > random) {
                alert('你猜大了');
            } else if (num < random) {
                alert('你猜小了');
            } else if (num == random) {
                alert('你猜对了');
                break;
            }

        }

日期对象

//构造函数，必使用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);
        var date2 = new Date('2019-10-01 8:8:8');
        console.log(date2);

        var date = new Date();
        console.log(date.getFullYear());//返回当前日期年
        console.log(date.getMonth() + 1);//月份小一个月 月份从0-11
        console.log(date.getDate());
        console.log(date.getDay());//周日返回0.周一返回1
        //我们写一个格式为2019年5月1日 星期三
        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]);

//格式化日期 时分秒
        var date = new Date();
        console.log(date.getHours());
        console.log(date.getMinutes());
        console.log(date.getSeconds());
        //封装一个函数返回当前的时分秒 格式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());
//获得Date总的毫秒数 不是当前时间的毫秒数，而是距离1970年1月1号过了多少毫秒
        //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());
//倒计时效果
        //1.用将来的时间减去现在的时间
        //2.用时间戳在做
        //3.把剩余时间总的毫秒数转换为天、时、分、秒
        function cutDown(time) {
            var nowTime = +new Date();//返回当前时间的总的毫秒数
            var inputTime = +new Date(time);//返回用户输入时间总的毫秒数
            var times = (inputTime - nowTime) / 1000;//times是剩余时间总的秒数
            var d = parseInt(times / 60 / 60 / 24);
            var h = parseInt(times / 60 / 60 % 24);//hour
            var m = parseInt(times / 60 % 60);//min
            var s = parseInt(times % 60);//miao
            return d + '天' + h + '时' + m + '分' + s + '秒';
        }
        console.log(cutDown(2022, 4, 1));

数组对象

//创建数组的方式
        //1.利用数组字面量
        var arr=[1,2,3];
        console.log(arr[0]);
        //2.利用new
        var arr1=new Array();//创建一个空的数组
        var arr2=new Array(2);//数组长度为2
        var arr3=new Array(2,3);//等价与[2,3]
 //检测是否为数组
        //（1）instanceof 运算符
        var arr = [];
        console.log(arr instanceof Array);
        //(2)Array.isArray(参数)；H5新增方法
        console.log(Array.isArray(arr));

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

        //3.pop()他可以删除最后一个元素
        arr.pop();
        console.log(arr);
        //(1)pop可以删除数组的最后一个元素，一次删一个
        //（2）pop没有参数
        //（3）pop完毕之后，返回结果是删除的那个元素
        //（4）愿数组发生变化
        //4.shift()可以删除数组的第一个元素一次删一个
        console.log(arr.shift());
        console.log(arr);
        //(1)shift可以删除数组的第一个元素，一次删一个
        //（2）shift没有参数
        //（3）shift完毕之后，返回结果是删除的那个元素
        //（4）愿数组发生变化
 //数组排序
        //1.翻转数组
        var arr = ['pink', 'red', 'blue']
        arr.reverse();
        console.log(arr);
        //2.数组排序（冒泡）
        var arr1 = [33, 4, 53, 1];
        arr1.sort(function (a, b) {
            // return a - b;//升序
            return b - a;//降序
        });
        console.log(arr1);
//数组索引
        //返回第一个满足条件的索引
        //如果找不到这个元素，则返回-1
        var arr = ['red', 'blue', 'green', 'black', 'blue'];
        console.log(arr.indexOf('blue'));//1
        console.log(arr.lastIndexOf('blue'));//4
//数组去重 ['c','a','z','a','x','a','x','c','b']
        //封装去重函数
        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 demo = unique(['c', 'a', 'z', 'a', 'x', 'a', 'x', 'c', 'b']);
        console.log(demo);
 //数组转字符串
        //1.toString()将数组转换为字符串
        var arr = [1, 2, 3]
        console.log(arr.toString());
        //2.join(分隔符)
        console.log(arr.join());
        console.log(arr.join('-'));

字符串对象

//基本包装类型 String Number Boolean
        var str = 'andy';
        console.log(str.length);
        //对象才有属性和方法 复杂数据类型才有属性和方法
        //简单数据类型为什么会有length属性呢
        //基本包装类型：就是把简单数据类型包装成为了 复杂数据类型
        //（1）把简单数据类型包装为复杂数据类型
        var temp = new String('andy');
        //(2)把临时变量的值 给str
        str = temp;
        //(3)销毁临时变量
        temp = null;

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

//字符串对象 根据字符返回位置
        var str = '12345167';
        console.log(str.indexOf('1', 4));//从索引号4的位置开始往后查找
        //查找字符串中所有o出现的位置以及次数
        var str1 = 'abhdcodfrogfgoedfeo';
        var num = 0;
        var index = str1.indexOf('o');
        while (index !== -1) {
            console.log(index);
            num++;
            index = str1.indexOf('o', index + 1);

        }
        console.log('o出现的次数：' + num);
//根据位置返回字符
        //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[2]);
//统计字符串里面出现次数最多的元素
        //1.利用charAt()遍历这个字符串
        //2.把每个字符都存储给对象，如果对象没有该属性，就为1，如果存在就+1
        //3.遍历对象，得到最大值和该字符
        var str = 'abhdcodfrogfgoedfeo';
        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);
        //遍历对象
        var max = 0;
        var ch = '';
        for (var k in o) {
            //k是属性名
            //o[k]属性值
            if (o[k] > max) {
                max = o[k];
                ch = k;
            }
        }
        console.log(max);
        console.log(ch);
//字符串操作方法
        //1.concat('str1','str2'.....)
        var str = 'andy';
        console.log(str.concat('red'));
        //2.substr('截取的起始位置','截取几个字符');
        var str1 = '改革经济抡大锤';
        console.log(str1.substr(2, 2));
//1.替换字符replace('被替换字符'，‘替换字符')只会替换第一个字符
        var str = 'andy';
        console.log(str.replace('a', 'b'));
        //替换字符串里面的o
        var str1 = 'abhdcodfrogfgoedfeo';
        while (str1.indexOf('o') != -1) {
            str1 = str1.replace('o', '*');

        }
        console.log(str1);
        //2.字符串转换为数组 split（'分隔符‘）  前面用join把数组转为字符串
        var str2 = 'red,pink,blue';
        console.log(str2.split(','));

简单类型和复杂类型 

简单类型：又称值类型，在存储的时变量中存储的是值本身，因此叫做值类型。string，number，boolean，undefined，null

存放在栈

 

复杂类型，：又称引用类型，在存储时变量中存储的仅仅是地址（引用），因此叫做引用数据类型，通过new关键字创建的对象（系统对象、自定义对象），如Object、Array、Date等

存放在堆（地址在栈，然后地址指向堆里面的数据）