JS-内置对象

共计 6500 个字符，预计需要花费 17 分钟才能阅读完成。

内置对象

• JavaScript 中的对象分为 3 种：自定义对象、内置对象、浏览器对象
• 内置对象就是指 JS 语言自带的一些对象，这些对象供开发者使用，并提供了一些常用的或是基本而必要的功能（属性和方法）
• 内置对象最大的优点就是帮助我们快速开发

查文档

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

1. 查阅该方法功能
2. 查看里面参数的意义和类型
3. 查看返回值的意义和类型
4. 通过demo进行测试

Math（数学）对象

Math 对象不是构造函数，它具有数学常数和函数的属性和方法
跟数学相关的运算（就绝对值、取整、最大值等）可以使用 Math 中的成员

生成任意范围

    Math.floor(Math.random() * (max - min + 1)) + min;

    function getRandomIntInclusive(min, max) {
        min = Math.ceil(min);
        max = Math.floor(max);
        return Math.floor(Math.random() * (max - min + 1)) + min; //含最大值，含最小值 
    }
    //1~10随机数
    console.log(getRandomIntInclusive(1, 10))

Date（日期）对象

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

    // Date()里面没有跟参数返回的是当前的时间
    // 如果括号里面有时间，就返回参数里面的时间
    let date = new Date();
    console.log(date)

日期格式化

    let date = new Date();
    let year = date.getFullYear(); // 返回当前日期的年
    let month = date.getMonth() + 1; // 返回月份0~11，要加1
    let dates = date.getDate(); // 返回的是当前几号
    let arr = ['星期日', '星期一', '星期二', '星期三', '星期四', '星期五', '星期六'];
    let day = date.getDay(); // 返回的是0~6 周日是0
    let h = date.getHours(); // 时
    h = h < 10 ? '0' + h : h; // 数字小于10前面补0
    let m = date.getMinutes(); // 分
    m = m < 10 ? '0' + m : m; // 数字小于10前面补0
    let s = date.getSeconds(); // 秒
    s = s < 10 ? '0' + s : s; // 数字小于10前面补0

    // 获取距离1970年1月1号总毫秒数（时间戳）的方法
    console.log(date.valueOf());
    console.log(date.getTime());
    let date = +new Date();
    console.log(date);
    // H5新增的获得时间戳
    console.log(Date.now());

    // 封装一个函数返回当前年月日 星期 时分秒
    function getTimer() {
        let date = new Date();
        let year = date.getFullYear(); // 返回当前日期的年
        let month = date.getMonth() + 1; // 返回月份0~11，要加1
        let dates = date.getDate(); // 返回的是当前几号
        let arr = ['星期日', '星期一', '星期二', '星期三', '星期四', '星期五', '星期六'];
        let day = date.getDay(); // 返回的是0~6 周日是0
        let h = date.getHours(); // 时
        h = h < 10 ? '0' + h : h; // 数字小于10前面补0
        let m = date.getMinutes(); // 分
        m = m < 10 ? '0' + m : m; // 数字小于10前面补0
        let s = date.getSeconds(); // 秒
        s = s < 10 ? '0' + s : s; // 数字小于10前面补0
        return `${year}年${month}月${dates}号 ${arr[day]} ${h}时${m}分${s}秒`;
    }
    // 调用该函数
    console.log(getTimer());

倒计时案例

算法

d = parseInt(总秒数 / 60 / 60 / 24); // 计算天数

h = parseInt(总秒数 / 60 / 60 % 24); // 计算小时

m = parseInt(总秒数 / 60 % 60); // 计算分数

s = parseInt(总秒数 % 60); // 计算秒数

    function countDown(time) {
        let nowTime = +new Date(); // 返回当前总毫秒数
        let inputTime = +new Date(time); // 返回输入时间的总毫秒数
        let times = (inputTime - nowTime) / 1000; // 计算获得times剩余时间的总秒数
        let d = parseInt(times / 60 / 60 / 24);  // 计算天数
        d = d < 10 ? '0' + d : d; // 小于10前面补0
        let h = parseInt(times / 60 / 60 % 24);  // 计算小时
        h = h < 10 ? '0' + h : h; // 小于10前面补0
        let m = parseInt(times / 60 % 60);  // 计算分数
        m = m < 10 ? '0' + m : m; // 小于10前面补0
        let s = parseInt(times % 60);  // 计算秒数
        s = s < 10 ? '0' + s : s; // 小于10前面补0
        return `${d}天${h}时${m}分${s}秒`
    }
    // 调用函数
    console.log(countDown('2023-11-11 00:00:00'));

Array（数组）对象

检测是否为数组

    // instanceof 运算符 可以检测是否为数组
    let arr = [];
    let obj = {};
    console.log(arr instanceof Array); // true
    console.log(obj instanceof Array); // false
    // Arr.isArray(参数); H5新增的方法
    console.log(Array.isArray(arr)); // true
    console.log(Array.isArray(obj)); // false

添加删除数组元素

    // push() 在后面追加新元素，返回值是新数组的长度
    arr.push('red');
    // unshift() 在前面追加新元素，返回值是新数组的长度
    arr.push('red');
    // pop() 没有参数，删除数组最后一个元素，返回值是删除的元素
    arr.pop();
    // shift() 没有参数，删除数组第一个元素，返回值是删除的元素
    arr.shift();

数组排序

    // 翻转数组
    let arr = ['red', 'grenn', 'blue'];
    arr.reverse();

    // 数组排序（冒泡排序）
    let arr = [5, 4, 3, 2, 1];
    arr.sort(function (a, b) {
        return a - b; // 升序顺序排列
        return b - a; // 降序顺序排列
    });

数组索引方法

    // indexOf(数组元素) 作用就是返回该数组的索引号 从前面开始查找
    // 只返回第一个满足条件的索引号，如果该数组数组找不到元素则返回 -1
    let arr = ['red', 'green', 'blue', 'blue'];
    console.log(arr.indexOf('blue')); //2
    // lastIndexOf(数组元素) 作用就是返回该数组的索引号 从后面开始查找
    console.log(arr.lastIndexOf('blue')); //3

数组去重案例

1. 把旧数组里面不重复的元素选取出来放到新数组中，重复的元素只保留一个，放到新数组中去重
2. 核心算法：遍历旧数组，然后拿着旧数组元素去查询新数组，如果该元素在新数组里面有出现过，我们就添加，否则不添加
3. 利用 新数组 .indexOf (数组元素)如果返回是 -1 就说明新数组里面没有该元素

    function unique(arr) {
        let newArr = [];
        for (let i = 0; i < arr.length; i++) {
            if (newArr.indexOf(arr[i]) === -1) {
                newArr.push(arr[i]);
            }
        }
        return newArr;
    }

数组转换为字符串

    // toString()
    let arr = [1, 2, 3];
    console.log(arr.toString()); // 1,2,3
    // join('分隔符') 默认逗号
    let arr = ['red', 'grenn', 'blue'];
    console.log(join('&')); // 1&2&3

其他数组方法

String（字符串）对象

基本包装数据类型

为了方便操作基本数据类型，JavaScript 还提供了三个特殊的引用类型：String、Number和Boolean
基本包装数据类型就是把简单数据类型包装成复杂数据类型，这样基本数据类型就有了属性和方法

字符串的不可变性

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

    let str = 'abc';
    str = 'hello';
    // 当重新给 str 赋值的时候，常量'abc'不会被修改，依然存在内存中
    // 重新给字符串赋值，会重新在内存中开辟空间，这个特点就是字符串的不可变
    // 由于字符串的不可变，在大量拼接字符串的时候会有效率问题

根据字符返回位置

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

    // str.indexOf('要查找的字符', [起始的位置])
    let str = '盼望着，盼望着，东风来了，春天的脚步近了';
    console.log(str.indexOf('着')); // 2
    // 从索引号是3的位置开始往后查找
    console.log(str.indexOf('着', 3)); // 6

求字符串出现的位置及次数案例

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

    let str = 'abcoefoxyozzopp';
    let index = str.indexOf('o');
    let num = 0;
    while (index !== -1) {
        console.log(index);
        num++;
        index = str.indexOf('o', index + 1);
    }

    let arr = ['red', 'blue', 'red', 'grenn', 'red']
    let index = arr.indexOf('red')
    let num = 0
    while (index !== -1) {
        console.log(index);
        num++;
        index = arr.indexOf('red', index + 1);
    }

根据位置返回字符

判断一个字符串出现次数最多的字符，并统计次数

1. 利用 charAt() 遍历这个字符串
2. 把每个字符都储存给对象，如果对象没有该属性，就为 1，如果存在了就 +1
3. 遍历对象，得到最大值和该字符

    let str = 'abcoefoxyozzopp';
    let o = {};
    for (let i = 0; i < str.length; i++) {
        let chars = str.charAt(i); // chars是字符串的每一个字符
        if (o[chars]) {
            o[chars]++;
        } else {
            o[chars] = 1;
        }
    }
    console.log(o);

    let max = 0;
    let ch = '';
    for (let k in o) {
        // k 得到的是属性名
        // o[k] 得到的是属性值
        if (o[k] > max) {
            max = o[k];
            ch = k;
        }
    }
    console.log(max);
    console.log('最多的字符是' + ch);

字符串操作方法

替换字符 replace('被替换的字符', '替换为的字符') 他只会替换第一个字符

    let str = 'andy';
    console.log(str.replace('a', 'b'));  // dndy

    // 字符串 'abcoefoxyozzopp' 里面把所有的o替换为*
    let str = 'abcoefoxyozzopp';
    while (str.indexOf('o') !== -1) {
        str = str.replace('o', '*');
    }

字符转换为数组 split('分隔符')

    let str = 'red, grenn, blue';
    console.log(str.split(',')); // ['red', 'grenn', 'blue']
    let str = 'red&grenn&blue';
    console.log(str.split(',')); // ['red', 'grenn', 'blue']

字符转换为大写 toUpperCase()

字符转换为小写 toLowerCase()