JS-内置对象

7次阅读
没有评论

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

内置对象

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

查文档

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

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

Math(数学)对象

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

属性 描述
Math.PI 圆周率
Math.floor() 向下取整
Math.ceil() 向上取整
Math.round() 四舍五入 就近取证(.5往大取整),-1.5 取整是 -1
Math.abs() 绝对值
Math.max() 求最大值
Math.min() 求最小值
Math.pow() 幂运算
Math.random() 随机数

生成任意范围

    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)

日期格式化

方法名 说明
getFullYear() 获取当年
getMonth() 获取当月(0 ~ 11)
getDate() 获取当天日期
getDay() 获取当星期几(周日 0 到 周六6)
getHours() 获取当前小时
getMinutes() 获取当前分钟
getSeconds() 获取当秒钟
getTime() 获取时间戳
    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(参数1, ...) 末尾添加一个或多个元素,修改了原数组 返回新的长度
pop() 删除数组最后一个元素,数组长度减 1 无参数、修改了原数组 返回删除元素的值
unshift(参数1, ...) 向数字的开头添加一个或更多元素、修改了原数组 返回新的长度
shift() 删除数组第一个元素,数组长度减 1 无参数、修改了原数组 返回第一个元素的值
    // push() 在后面追加新元素,返回值是新数组的长度
    arr.push('red');
    // unshift() 在前面追加新元素,返回值是新数组的长度
    arr.push('red');
    // pop() 没有参数,删除数组最后一个元素,返回值是删除的元素
    arr.pop();
    // shift() 没有参数,删除数组第一个元素,返回值是删除的元素
    arr.shift();

数组排序

方法名 说明 返回值
reverse() 颠倒数组中元素的顺序,无参数、该方法会改变原来的数组 返回新数组
sort() 对数组的元素进行排序,无参数、该方法会改变原来的数组 返回新数组
    // 翻转数组
    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
lastIndexOf() 在数组中的最后一个索引 如果存在返回索引号 不存在返回 -1
    // 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() 把数组转化为字符串,逗号分隔每一项 返回一个字符串
join('分隔符') 方法用于把数组中的所有元素转换为一个字符串 返回一个字符串
    // 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

其他数组方法

方法名 说明 返回值
concat() 连接两个或多个数组 不影响原数组 返回一个新数组
slice() 数组截取 slice(begin, end) 返回被截取项目的新数组
splice() 数组删除 splice(第几个开始, 要删除的个数) 返回被删除项目的新数组 会影响原数组

String(字符串)对象

基本包装数据类型

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

字符串的不可变性

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

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

根据字符返回位置

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

方法名 说明
indexOf('查找的字符', 开始位置) 返回指定内容在元字符串中的位置,如果找不到就返回 -1,开始的位置是 index 索引号
lastIndexOf() 从后往前找,只找第一个匹配的
    // 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);
    }

根据位置返回字符

方法名 说明 使用
charAt(index) 返回指定位置的字符(index 字符串的索引号) str.charAt(0)
charCodeAt(index) 获取指定位置处字符串的 ASCII 码(index 索引号) str.charCodeAt(0)
str[index] 获取指定位置处字符 HTML5、IE8+ 支持 和 str.charAt() 等效

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

  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);

字符串操作方法

方法名 说明
concat(str1, str2, str3, ...) 用于连接两个或多个字符串,拼接字符串,等效于 +
substr(start, length) 从 start 位置开始(索引号)length 取得个数
slice(start, end) 从 start 位置开始,截取到 end 位置,end 取不到(它们俩都是索引号)
substring(start, end) 从 start 位置开始,截取到 end 位置,end 取不到、基本和 slice 相同但是不接受负值

替换字符 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()

正文完
 0
qiaofugui.cn
版权声明:本站原创文章,由 qiaofugui.cn 于2024-05-20发表,共计6500字。
转载说明:除特殊说明外本站文章皆由CC-4.0协议发布,转载请注明出处。
评论(没有评论)
验证码