11.JavaScript内置对象（Math对象、日期对象、数组

作者: 蔚完待旭 | 来源:发表于2020-06-08 13:01 被阅读0次

1 - 内置对象

1.1 内置对象

JavaScript 中的对象分为3种：自定义对象、内置对象、浏览器对象
前面两种对象是JS 基础内容，属于 ECMAScript；第三个浏览器对象属于 JS 独有的， JS API 讲解内置对象就是指 JS 语言自带的一些对象，这些对象供开发者使用，并提供了一些常用的或是最基本而必要的功能（属性和方法），内置对象最大的优点就是帮助我们快速开发

JavaScript 提供了多个内置对象：Math、 Date 、Array、String等

1.2 查文档

查找文档：学习一个内置对象的使用，只要学会其常用成员的使用即可，我们可以通过查文档学习，可以通过MDN/W3C来查询。
Mozilla 开发者网络（MDN）提供了有关开放网络技术（Open Web）的信息，包括 HTML、CSS 和万维网及 HTML5 应用的 API。
MDN:https://developer.mozilla.org/zh-CN/

1.3 Math对象

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

属性、方法名	功能
Math.PI	圆周率
Math.floor()	向下取整
Math.ceil()	向上取整
Math.round()	四舍五入版就近取整注意 -3.5 结果是 -3
Math.abs()	绝对值
Math.max()/Math.min()	求最大和最小值
Math.random()	获取范围在[0,1)内的随机值

注意：上面的方法使用时必须带括号

console.log(Math.max(-1, -10)); // -1
console.log(Math.max(1, 99, 'pink')); // NaN
console.log(Math.max()); // -Infinity
console.log(Math.abs('-1')); // 1 隐式转换 会把字符串型 -1 转换为数字型
console.log(Math.abs('pink')); // NaN 
console.log(Math.round(-1.1)); // -1
console.log(Math.round(-1.5)); // 其他数字都是四舍五入，但是 .5 特殊 它往大了取,所以这个结果是 -1

获取指定范围内的随机整数：

function getRandom(min, max) {
  return Math.floor(Math.random() * (max - min + 1)) + min; 
}

利用对象封装自己的数学对象里面有 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, 5, 9));
        console.log(myMath.min(1, 5, 9));

猜数字游戏

        // 1.随机生成一个1~10 的整数  我们需要用到 Math.random() 方法。
        // 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 {
                alert('你好帅哦，猜对了');
                break; // 退出整个循环结束程序
            }
        }

1.4 日期对象

Date 对象和 Math 对象不一样，Date是一个构造函数，所以使用时需要实例化后才能使用其中具体方法和属性。Date 实例用来处理日期和时间

使用Date实例化日期对象
- 获取当前时间必须实例化：
```
var now = new Date();
```
- 获取指定时间的日期对象
```
var future = new Date('2019/5/1');
```
注意：如果创建实例时并未传入参数，则得到的日期对象是当前时间对应的日期对象
使用Date实例的方法和属性

date.getMilliseconds(); // 获取当前毫秒数
date.toLocaleString(); // 显示系统语言的日期方式，包含时分秒
date.toLocaleDateString(); // 显示系统语言的日期方式，只是日期，不包含时分秒

当前年月日星期几

var date = new Date();
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]);

当前的时分秒格式 00:00:00

        var date = new Date();
        console.log(date.getHours()); // 时
        console.log(date.getMinutes()); // 分
        console.log(date.getSeconds()); // 秒
        // 要求封装一个函数返回当前的时分秒 格式 08:08:08
        function getTimer() {
            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(getTimer());

倒计时效果

        // 1.核心算法：输入的时间减去现在的时间就是剩余的时间，即倒计时 ，但是不能拿着时分秒相减，比如 05 分减去25分，结果会是负数的。
        // 2.用时间戳来做。用户输入时间总的毫秒数减去现在时间的总的毫秒数，得到的就是剩余时间的毫秒数。
        // 3.把剩余时间总的毫秒数转换为天、时、分、秒 （时间戳转换为时分秒）
        // 转换公式如下： 
        //  d = parseInt(总秒数/ 60/60 /24);    //  计算天数
        //  h = parseInt(总秒数/ 60/60 %24)   //   计算小时
        //  m = parseInt(总秒数 /60 %60 );     //   计算分数
        //  s = parseInt(总秒数%60);            //   计算当前秒数
        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('2019-5-1 18:00:00'));
        var date = new Date();
        console.log(date);

通过Date实例获取总毫米数

总毫秒数的含义

基于1970年1月1日（世界标准时间）起的毫秒数

获取总毫秒数

// 实例化Date对象
var now = new Date();
// 1. 用于获取对象的原始值
console.log(date.valueOf()); // 就是现在的时间 距离1970.1.1 总的毫秒数
console.log(date.getTime());    
// 2. 简单写可以这么做
var now = + new Date(); // +new Date()  返回的就是总的毫秒数          
// 3. HTML5中提供的方法，有兼容性问题
var now = Date.now();

1.5 数组对象

创建数组的两种方式

字面量方式
- 示例代码如下：
```
var arr = [1,"test",true];
```
利用new Array()
- 示例代码如下：
```
var arr = new Array();
```
  注意：上面代码中arr创建出的是一个空数组，如果需要使用构造函数Array创建非空数组，可以在创建数组时传入参数
  
  参数传递规则如下：
  - 如果只传入一个参数，则参数规定了数组的长度
  - 如果传入了多个参数，则参数称为数组的元素

检测是否为数组

instanceof 运算符

instanceof 可以判断一个对象是否是某个构造函数的实例

var arr = [1, 23];
var obj = {};
console.log(arr instanceof Array); // true
console.log(obj instanceof Array); // false

Array.isArray()

Array.isArray()用于判断一个对象是否为数组，isArray() 是 HTML5 中提供的方法

var arr = [1, 23];
var obj = {};
console.log(Array.isArray(arr));   // true
console.log(Array.isArray(obj));   // false

添加删除数组元素的方法

数组中有进行增加、删除元素的方法，部分方法如下表

注意：push、unshift为增加元素方法；pop、shift为删除元素的方法

筛选数组

 // 有一个包含工资的数组[1500, 1200, 2000, 2100, 1800]，要求把数组中工资超过2000的删除，剩余的放到新数组里面
        var arr = [1500, 1200, 2000, 2100, 1800];
        var newArr = [];
        for (var i = 0; i < arr.length; i++) {
            if (arr[i] < 2000) {
                // newArr[newArr.length] = arr[i];
                newArr.push(arr[i]);
            }
        }
        console.log(newArr);

数组排序

数组中有对数组本身排序的方法，部分方法如下表

注意：sort方法需要传入参数来设置升序、降序排序

翻转数组、数组排序

 // 1. 翻转数组
var arr = ['pink', 'red', 'blue'];
arr.reverse();
console.log(arr);
// 2. 数组排序（冒泡排序）
var arr1 = [13, 4, 77, 1, 7];
arr1.sort(function(a, b) {
//  return a - b; 升序的顺序排列
return b - a; // 降序的顺序排列
});
console.log(arr1);

如果传入“function(a,b){ return a-b;}”，则为升序
如果传入“function(a,b){ return b-a;}”，则为降序

数组索引方法

数组中有获取数组指定元素索引值的方法，部分方法如下表

数组去重

// 数组去重 ['c', 'a', 'z', 'a', 'x', 'a', 'x', 'c', 'b'] 要求去除数组中重复的元素。
// 1.目标： 把旧数组里面不重复的元素选取出来放到新数组中， 重复的元素只保留一个， 放到新数组中去重。
// 2.核心算法： 我们遍历旧数组， 然后拿着旧数组元素去查询新数组， 如果该元素在新数组里面没有出现过， 我们就添加， 否则不添加。
// 3.我们怎么知道该元素没有存在？ 利用 新数组.indexOf(数组元素) 如果返回时 - 1 就说明 新数组里面没有改元素
// 封装一个 去重的函数 unique 独一无二的 
        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'])
        var demo = unique(['blue', 'green', 'blue'])
        console.log(demo);

数组转换为字符串

数组中有把数组转化为字符串的方法，部分方法如下表

注意：join方法如果不传入参数，则按照 “ , ”拼接元素

数组转换为字符串

// 1. toString() 将我们的数组转换为字符串
var arr = [1, 2, 3];
console.log(arr.toString()); // 1,2,3
// 2. join(分隔符) 
var arr1 = ['green', 'blue', 'pink'];
console.log(arr1.join()); // green,blue,pink
console.log(arr1.join('-')); // green-blue-pink
console.log(arr1.join('&')); // green&blue&pink

其他方法

数组中还有其他操作方法，同学们可以在课下自行查阅学习

Array.of

//1.Array.of 用于将一组值转为数组
    let myArr=Array.of(11,2,8);
    console.log(Array.of()); // []
    console.log(Array.of(1)); // [1]
    console.log(myArr); //[11, 2, 8]
    //Array 和 Array.of的区别
    // console.log(Array());//空数组
    // console.log(Array(3));//数组长度为3
    // console.log(Array(3,11,8));//创建数组并且初始化数据

    /*Array方法：没有参数，一个参数，两个以上参数,返回的结果都不一样，只有当参数多于2时，Array方法才会返回由参数组成的新数组
    Array.of:总是返回参数值组成的数组，如果没有参数，就返回一个空数组*/

copyWithin,替换数组

    /*
    * Array.copyWithin(参1，参2，参3)
    * 参1：target(必须)：从该位置开始替换数据
    * 参2：start(可选)：从该位置开始读取数据，0开始读取
    * 参数3：end(可选)：到该位置前停止读取数据，默认等于数组长度
    */
    let myCopyArr=[1,2,3,4,5].copyWithin(1,3);
    console.log(myCopyArr); // [1, 4, 5, 4, 5]

1.6 字符串对象

基本包装类型

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

基本包装类型就是把简单数据类型包装成为复杂数据类型，这样基本数据类型就有了属性和方法。

// 下面代码有什么问题？
var str = 'andy';
console.log(str.length);

按道理基本数据类型是没有属性和方法的，而对象才有属性和方法，但上面代码却可以执行，这是因为

js 会把基本数据类型包装为复杂数据类型，其执行过程如下：

// 1. 生成临时变量，把简单类型包装为复杂数据类型
var temp = new String('andy');
// 2. 赋值给我们声明的字符变量
str = temp;
// 3. 销毁临时变量
temp = null;

字符串的不可变

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

当重新给字符串变量赋值的时候，变量之前保存的字符串不会被修改，依然在内存中重新给字符串赋值，会重新在内存中开辟空间，这个特点就是字符串的不可变。
由于字符串的不可变，在大量拼接字符串的时候会有效率问题

根据字符返回位置

字符串通过基本包装类型可以调用部分方法来操作字符串，以下是返回指定字符的位置的方法：

案例：查找字符串"abcoefoxyozzopp"中所有o出现的位置以及次数

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

var str = "oabcoefoxyozzopp";
        var index = str.indexOf('o');
        var num = 0;
        // console.log(index);
        while (index !== -1) {
            console.log(index);
            num++;
            index = str.indexOf('o', index + 1);
        }
        console.log('o出现的次数是: ' + num);

根据位置返回字符

字符串通过基本包装类型可以调用部分方法来操作字符串，以下是根据位置返回指定位置上的字符：

在上述方法中，charCodeAt方法返回的是指定位置上字符对应的ASCII码，ASCII码对照表如下：

案例：判断一个字符串 'abcoefoxyozzopp' 中出现次数最多的字符，并统计其次数

核心算法：利用 charAt(）遍历这个字符串
把每个字符都存储给对象，如果对象没有该属性，就为1，如果存在了就 +1
遍历对象，得到最大值和该字符

 var str = 'abcoefoxyozzopp';
        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.log(max);
        console.log('最多的字符是' + ch);

注意：在遍历的过程中，把字符串中的每个字符作为对象的属性存储在对象总，对应的属性值是该字符出现的次数

字符串操作方法

字符串通过基本包装类型可以调用部分方法来操作字符串，以下是部分操作方法：

replace()方法

replace() 方法用于在字符串中用一些字符替换另一些字符，其使用格式如下：

字符串.replace(被替换的字符串， 要替换为的字符串)；

 // 有一个字符串 'abcoefoxyozzopp'  要求把里面所有的 o 替换为 *
        var str1 = 'abcoefoxyozzopp';
        while (str1.indexOf('o') !== -1) {
            str1 = str1.replace('o', '*');
        }
        console.log(str1);

split()方法

split()方法用于切分字符串，它可以将字符串切分为数组。在切分完毕之后，返回的是一个新数组。

其使用格式如下：

字符串.split("分割字符")

search()方法

//搜索字符存不存在：search(“搜索的字符串”);
// -1  没有  ， 如果有则返回起始下标
    let str="hello world";
    result=str.search("e");
    console.log(result);// 1

trim()方法清除前后空格

    let str4="    苹     果      ";
    result=str4.trim(); 
    console.log(result);//苹     果(不会清除文字之间的空格)
    console.log("hello"=="  hello");//false

2 - 简单数据类型和复杂数据类型

2.1 简单数据类型

简单类型（基本数据类型、值类型）：在存储时变量中存储的是值本身，包括string ，number，boolean，undefined，null

简单数据类型 null 返回的是一个空的对象 object

2.2 复杂数据类型

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

2.3 堆栈

堆栈空间分配区别：

1、栈（操作系统）：由操作系统自动分配释放存放函数的参数值、局部变量的值等。其操作方式类似于数据结构中的栈；

简单数据类型存放到栈里面，里面直接开辟一个空间存放的是值

2、堆（操作系统）：存储复杂类型(对象)，（首先在栈里面存放地址十六进制表示，然后这个地址指向堆里面的数据）一般由程序员分配释放，若程序员不释放，由垃圾回收机制回收。

简单数据类型的存储方式

值类型变量的数据直接存放在变量（栈空间）中

复杂数据类型的存储方式

引用类型变量（栈空间）里存放的是地址，真正的对象实例存放在堆空间中

2.4 简单类型传参

函数的形参也可以看做是一个变量，当我们把一个值类型变量作为参数传给函数的形参时，其实是把变量在栈空间里的值复制了一份给形参，那么在方法内部对形参做任何修改，都不会影响到的外部变量。

function fn(a) {
    a++;
    console.log(a); 
}
var x = 10;
fn(x);
console.log(x)；

运行结果如下：

2.5 复杂数据类型传参

函数的形参也可以看做是一个变量，当我们把引用类型变量传给形参时，其实是把变量在栈空间里保存的堆地址复制给了形参，形参和实参其实保存的是同一个堆地址，所以操作的是同一个对象。

function Person(name) {
    this.name = name;
}
function f1(x) { // x = p
    console.log(x.name); // 2. 这个输出什么 ?    刘德华  
    x.name = "张学友";
    console.log(x.name); // 3. 这个输出什么 ?    张学友
}
var p = new Person("刘德华");
console.log(p.name);    // 1. 这个输出什么 ?   刘德华
f1(p);
console.log(p.name);    // 4. 这个输出什么 ?  张学友

运行结果如下：

11.JavaScript内置对象（Math对象、日期对象、数组

1 - 内置对象

1.1 内置对象

1.2 查文档

1.3 Math对象

1.4 日期对象

1.5 数组对象

创建数组的两种方式

检测是否为数组

添加删除数组元素的方法

数组排序

数组索引方法

数组转换为字符串

其他方法

Array.of

copyWithin,替换数组

1.6 字符串对象

基本包装类型

字符串的不可变

根据字符返回位置

根据位置返回字符

字符串操作方法

replace()方法

split()方法

search()方法

trim()方法清除前后空格

2 - 简单数据类型和复杂数据类型

2.1 简单数据类型

2.2 复杂数据类型

2.3 堆栈

2.4 简单类型传参

2.5 复杂数据类型传参

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

JavaScript

11.JavaScript内置对象（Math对象、日期对象、数组

1 - 内置对象

1.1 内置对象

1.2 查文档

1.3 Math对象

1.4 日期对象

1.5 数组对象

创建数组的两种方式

检测是否为数组

添加删除数组元素的方法

数组排序

数组索引方法

数组转换为字符串

其他方法

Array.of

copyWithin,替换数组

1.6 字符串对象

基本包装类型

字符串的不可变

根据字符返回位置

根据位置返回字符

字符串操作方法

replace()方法

split()方法

search()方法

trim()方法 清除前后空格

2 - 简单数据类型和复杂数据类型

2.1 简单数据类型

2.2 复杂数据类型

2.3 堆栈

2.4 简单类型传参

2.5 复杂数据类型传参

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

JavaScript

trim()方法清除前后空格