JavaScript基础后篇

最新推荐文章于 2024-06-20 20:20:21 发布

2301_79112482

最新推荐文章于 2024-06-20 20:20:21 发布

阅读量51

点赞数

文章标签： javascript 开发语言 ecmascript 前端学习

本文链接：https://blog.csdn.net/2301_79112482/article/details/132415852

版权

六、JavaScript对象

6.1、类和对象的概念

6.1.1、为什么要有对象？

函数的参数如果特别多的话，可以使用对象简化

6.1.2、什么是对象？

对象就是真实世界中的实体，对象与实体是一一对应的，也就是说现实世界中每一个实体都是一个

对象，它是一种具体的存在

比如一只狗，那么它的属性有名称、品种、颜色、体重；行为有吠叫、摇摆、跑等

6.1.3.JavaScript中的对象

JavaScript语言没有类，而改用构造函数（constructor）作为对象的模板。

所谓构造函数，就是专门用来生成对象的函数。它提供模板，作为对象的基本结构

JavaScript的所有数据都可以被视为对象。对象是一个容器，封装了属性(propert)和方(method)。所谓属性，就是对象的静态状态；所谓方法，就是对象的动态行为

JavaScript的对象是无序属性的集合。

对象的行为和特征:

特征—属性：事物的特征在对象中用属性来表示。

行为—方法：事物的行为在对象中用方法来表示。

var o = {
            p: "Hello World",
            sayHello: function () {
                return p;
            }
        };

定义了一个对象o,这个对象内部包含2个键值对:p和sayHello，其中p键值对是描述静态属性的;sayHello键值对是描述对象的动态行为的。

属性名与属性值之间用冒号分隔。

对象内部包含多个属性对，每个属性对之间用逗号分隔。需要注意的是，上面的代码后台隐式调用

了new Object()这个构造函数创建了一个对象o,再通过键值对定义静态属性动态行为

6.2、对象的使用

6.2.1、对象的创建方式

对象字面量：

// 对象字面量
        var hero = {
            name: '黄忠',
            weapon: '弓箭',
            equipment: ['头盔', '靴子', '盔甲'],
            blood: 100,
            attack: function () {
                //this.name  是hero.name 黄忠
                console.log(this.name + '：射箭');
            },
            run: function () {
                console.log(this.name + ': 加速跑');
            }
        }
        //调用属性
        console.log(hero.name);
        console.log(hero.equipment);
        //调用方法
        hero.attack();//黄忠射箭
        hero.run();//黄忠加速跑

new Object()创建对象：

 // new Object()创建对象
        var hero = {};
        hero.name = '关羽';
        hero.age = 18;
        hero.attack = function () {
            console.log(this.name + ': 射箭');
        }

        console.log(hero.name);//关羽
        console.log(hero.age);//18
        // console.log(hero.attack());
        hero.attack()//关羽射箭

工厂函数创建对象：

// 工厂函数创建对象
        function createhero(name, age, height) {
            var hero = {};

            hero.name = name;
            hero.age = age;
            hero.height = height;

            hero.attack = function () {
                console.log(this.name + '：攻击0');
            }
            return hero;

        }

        var hero1 = createhero('关羽', 30, '2m');
        console.log(hero1);//{name: "关羽", age: 30, height: "2m", attack: ƒ}
        hero1.attack()//关羽:攻击0

自定义构造函数：

// 自定义构造函数
//this代表的是当前对象
        function create(name, age, height) {
            this.name = name;
            this.age = age;
            this.height = height;
            hero.attack = function () {
                console.log(this.name + '：攻击l');
            }


        }
        var hero2 = new create('关羽', 30, '2m');
        console.log(hero2);//create {name: "关羽", age: 30, height: "2m"}
        hero.attack()//关羽:攻击1

this代表的是当前对象

但是构造函数方有个缺点，就是对象的方法放在了构造函数内部，这样每创建一个方法就会需要多占用一些内存，所以js给构造函数设计了一个prototype属性，用来存放对象的方法：

 function Student(name, age, id) {
            this.name = name;
            this.age = age;
            this.id = id;
        }
        Student.prototype = {
            work: function (skill) {
                alert(this.name + "做" + skill + "开发相关的工作");
            },
            classId: "Java1班"
        }
        var stu1 = new Student("李明", 18, 20151515);//得到的就是字面量对象
        var stu2 = new Student("王磊", 18, 20141000);//得到的就是字面量对象
        console.log(stu2.work == stu1.work);//ture，节省了内存空间
        stu1.work("Java");
        stu2.work("PHP");
        console.log(stu1.classId);//20151515
        console.log(stu2.classId);//20141000

6.2.2、属性和方法

如果一个变量属于一个对象所有，那么该变量就可以称之为该对象的一个属性，属性一般是名词，用来描述事物的特征。
如果一个函数属于一个对象所有，那么该函数就可以称之为该对象的一个方法，方法是动词，描述事物的行为和功能。

6.2.3、关键字详解

new关键字：

构造函数 ，是一种特殊的函数。主要用来在创建对象时初始化对象，即为对象成员变量赋初始

值，总与new运算符一起使用在创建对象的语句中。

构造函数用于创建一类对象，首字母要大写。
构造函数要和new一起使用才有意义。

// create自定义构造函数
// 属性：name, age, height
// 方法：attack
        function create(name, age, height) {
            this.name = name;
            this.age = age;
            this.height = height;
            this.attack = function () {
                console.log(this.name + '：攻击l');
            }


        }
        var hero2 = new create('关羽', 30, '2m');
        console.log(hero2.name, hero2.age, hero2.height);
        console.log(hero2);//create {name: "关羽", age: 30, height: "2m"}
        // create.attack()//关羽:攻击1

new在执行时会做四件事情：

new会在内存中创建一个新的空对象
new 会让this指向这个新的对象
执行构造函数目的：给这个新对象加属性和方法
new会返回这个新对象

this详解：

JavaScript中的this指向问题，有时候会让人难以捉摸，随着学习的深入，我们可以逐渐了解

现在我们需要掌握函数内部的this几个特点

函数在定义的时候this是不确定的，只有在调用的时候才可以确定
一般函数直接执行，内部this指向全局window
函数作为一个对象的方法，被该对象所调用，那么this指向的是该对象
构造函数中的this其实是一个隐式对象，类似一个初始化的模型，所有方法和属性都挂载到了这个隐式对象身上，后续通过new关键字来调用，从而实现实例化

6.2.4 对象方法的使用

对象属性的使用：

1、可以用点符号访问对象属性值

2、也可以通过数组的方式，即用[“属性名称”]

对象方法的使用：

可以使用对象名.方法名()来调用

简单类型和复杂类型的区别：

基本类型又叫做值类型，复杂类型又叫做引用类型

**值类型：**简单数据类型，基本数据类型，在存储时，变量中存储的是值本身，因此叫做值类型。

Number String Boolean Null Undefined

**引用类型：**复杂数据类型，在存储是，变量中存储的仅仅是地址（引用），因此叫做引用数据类

型。Object Array

堆和栈

堆|栈空间分配区别：

1、栈（操作系统）：由操作系统自动分配释放，存放函数的参数值，局部变量的值等。

2、堆（操作系统）：存储复杂类型(对象)，一般由程序员分配释放，若程序员不释放，由垃圾回收机制回收。

注意：JavaScript中没有堆和栈的概念，此处我们用堆和栈来讲解，目的方便理解和方便以后的学习。

在这里插入图片描述

// 构造函数
        function Person(name, age, salary) {
            this.name = name;
            this.age = age;
            this.salary = salary;
        }
        // 普通函数
        function f1(person) { // person为形参
            person.name = "lisi";
            person = new Person("aa", 18, 10);
        }
        var p = new Person("zhangsan", 18, 1000);
        console.log(p.name); // zhangsan
        f1(p); // 把p对应的地址复制一份给person,person和p对应一个地址,那么修改地址对应的内容,会影响p
        console.log(p.name); // lisi

//1.
        var num1 = 10;
        var num2 = num1; // num2 = 10;
        num1 = 20;
        console.log(num1); // 20
        console.log(num2); // 10
        //2.
        var num = 50;
        function f1(num) {
            num = 60;
            console.log(num);


        }
        f1(num); // 60
        console.log(num); // 50

七、JavaScript内置对象

JavaScript中的对象分为3种：内置对象、自定义对象、浏览器对象

JavaScript 提供多个内置对象：Math/Array/Date…

对象只是带有属性和方法的特殊数据类型。

学习一个内置对象的使用，只要学会其常用的成员的使用（通过查文档学习）

可以通过MDN/W3C来查询

内置对象的方法很多，我们只需要知道内置对象提供的常用方法，使用的时候查询文档。

Mozilla 开发者网络（MDN）提供有关开放网络技术（Open Web）的信息，包括 HTML、CSS 和万维网及 HTML5 应用的 API。

如何学习一个方法？

方法的功能
参数的意义和类型
返回值意义和类型
demo进行测试

7.1、Array对象

7.1.1、Array构造函数

// new关键字创建空数组
        var arr = new Array();
        // new关键字创建包含元素的数组
        var arr = new Array(值1, 值2,值N);
        // new关键字创建指定元素个数的数组
        var arr = new Array(数值);
        // 也可以使用[]直接创建数组
        var arr = [];
        var arr = [值1, 值2,值N];
        // 可以使用length属性获取数组的长度;并且可以给一个数组长度赋值。

检测一个对象是否是数组：

instanceof
Array.isArray() HTML5中提供的方法，有兼容性问题

函数的参数，如果要求是一个数组的话，可以用这种方式来进行判断。

sort排序底层源码（了解）：

        function sort(array, fnCompare) {
            // 外层循环 控制趟数
            for (var i = 0; i < array.length - 1; i++) {
                // 假设排好序了
                var isSort = true;
                // 内层循环 控制比较的次数
                for (var j = 0; j < array.length - 1 - i; j++) {
                    if (fnCompare(array[j], array[j + 1]) > 0) {
                        isSort = false;
                        // 交换位置
                        var tmp = array[j];
                        array[j] = array[j + 1];
                        array[j + 1] = tmp;
                    }
                }
                // 判断是否排好了
                if (isSort) {
                    break;
                }
            }
        }

7.1.2、Array对象方法

程序运行时通常需要读取数组中的数据，有时候需要对数据进行修改。

读取数据：可以使用索引查询获取数组元素和添加数组元素；

//读取数据：可以使用索引查询获取数组元素和添加数组元素；
        var arr = [72, 33, 12, 44, 24];
        console.log(arr[0]);
        console.log(arr[1]);
        console.log(arr[2]);
        console.log(arr[3]);
        console.log(arr[4]);
        arr[5] = 6
        arr[6] = 8
        arr[7] = 8
        console.log(arr);//[72, 33, 12, 44, 24,6,8,8]

添加数据：使用 push()方法 将新元素添加到数组尾部；

// 添加数据：使用 push()方法 将新元素添加到数组尾部；
        var arr = [72, 33, 12, 44, 24];
        arr.push(6, 7, 7, 8, 9)
        // arr.push() // 6, 7, 7, 8, 9
        console.log(arr);[72, 33, 12, 44, 24 ,6, 7, 7, 8, 9 ]

删除数据：可以使用 delete运算符删除指定的元素；

   // 删除数据：可以使用 delete运算符 删除指定的元素；
        var arr = [72, 33, 12, 44, 24];
        delete arr[0]//72
        delete arr[4]//72
        console.log(arr);//[ 33, 12, 44]

删除末尾元素 : pop()方法，该方法会返回删除的元素；

  // 删除末尾元素 : pop()方法，该方法会返回删除的元素；
        var arr = [72, 33, 12, 44, 24];
        console.log(arr.pop());//24
        // arr.pop()
        console.log(arr);//[72, 33, 12, 44]

删除顶端的元素：shift()方法；

// 删除顶端的元素：shift()方法；
        var arr = [72, 33, 12, 44, 24];
        console.log(arr.shift());//72
        // arr.shift()
        console.log(arr);//[ 33, 12, 44, 24]

在数组顶端添加元素 : unshift()方法，返回值为新数组的长度；

        // 在数组顶端添加元素 : unshift()方法，返回值为新数组的长度；
        var arr = [72, 33, 12, 44, 24];
        console.log(arr.unshift(2, 3, 4, 'hello'));
        console.log(arr);//[2, 3, 4, "hello", 72, 33, 12, 44, 24]

字符转换：toString()方法将数组表示为字符串；

 // 字符转换：toString()方法将数组表示为字符串；
        var arr = [72, 33, 12, 44, 24];
        console.log(arr.toString());//72, 33, 12, 44, 24

数组转字符串：join方法输出数组元素，输出结果会转换成字符串；

 // 数组转字符串：join方法输出数组元素，输出结果会转换成字符串；
        //可以在数组之间添加符号
        var arr = [72, 33, 12, 44, 24];
        console.log(arr.join());// 72,33,12,44,24
        console.log(arr.join('-'));// 72-33-12-44-24
        console.log(arr.join('|'));//72|33|12|44|24
        console.log(arr.join('()'));//72()33()12()44()24

数组逆序：reverse()方法 颠倒数组元素的顺序;返回值为逆序后的新数组；

        // 数组逆序：reverse()方法 颠倒数组元素的顺序;返回值为逆序后的新数组；
        var arr = [72, 33, 12, 44, 24, 'hello', 'hi'];
        console.log(arr.reverse());// ["hi", "hello", 24, 44, 12, 33, 72]

数组排序：sort()方法 可以实现数组排序；

 // 数组名.sort(sortfunction)：
        // 1、sortfunction若省略，默认为从按照ASII字符顺序进行升序排列
        // 2、sortfunction必须返回：正值、零、负值三者之一。
        // 正直表示第一个值大于第二个值，负值反之，零则相等。

        // 数组排序：sort()方法 可以实现数组排序；
        //倒序
        var arr1 = [72, 33, 12, 44, 24, 'hello', 'hi'];
        arr1.sort(function (a, b) { return b - a; });
        //arr1.sort((a, b) => b - a)
        console.log(arr1);//[72, 44, 33, 24, 12, "hello", "hi"]

        //顺序
        var arr1 = [72, 33, 12, 44, 24, 'hello', 'hi'];
        arr1.sort(function (a, b) { return a - b; });
        //  arr1.sort((a, b) => a - b)
        console.log(arr1);//[12, 24, 33, 44, 72, "hello", "hi"]

扩充数组：concat()方法 将多个数组的元素合并为一个新的数组；

 // 扩充数组：concat()方法 将多个数组的元素合并为一个新的数组；
        var s = ['孙悟空']
        var a = ['猪八戒']
        console.log(s.concat(a));// ['孙悟空','猪八戒']

splice方法：删除、替换、插入元素,会更改原数组；

 // splice方法：删除、替换、插入元素,会更改原数组；
        // 第一参数为起始位置索引；
        // 第二参数为切取元素个数；
        // 第三个参数为插入元素，可选项；
        var arr = ['孙悟空', '猪八戒', '沙和尚', '唐僧']
        // arr.splice(2,0,'白龙马','hyrz')//插入元素
        // arr.splice(2,1,'白龙马','hyrz')
        arr.splice(2, 1)//删除   ["孙悟空", "猪八戒", "唐僧"]
        // arr.splice(2,1,'白龙马')//替换
        console.log(arr);//["孙悟空", "猪八戒", "沙和尚", "唐僧"]

截取数组：slice() 切取数组的一段元素；

// 截取数组：slice() 切取数组的一段元素；
        // 切取部分作为新数组返回，不会对原数组改变。
        // 第一参数为起始位置索引(包含)。
        // 第二参数为结束位置索引，注意区分splice(不包含)。
        // 若省略第二个参数则直接切取到结尾
        var arr = ['孙悟空', '猪八戒', '沙和尚', '唐僧']
        console.log(arr.slice());
        console.log(arr.slice(1));//  ["猪八戒", "沙和尚", "唐僧"]
        console.log(arr.slice(1, 3));//["猪八戒", "沙和尚"]
        console.log(arr.slice(1, 2));//["猪八戒"]

valueOf() 返回数组对象本身

7.1.3、Array对象应用

将一个字符串数组输出为分割的形式,a|b|c使用两种方式实现：

     //手写join的方法实现
        function myjoin(array, step) {
            if (array.length == 0) {
                return '';
            }
            var str = array[0];
            for (var i = 1; i < array.length; i++) {
                str += step + arr[i];
            }
            return str;

        }
        var array = ['孙悟空', '猪八戒', '沙和尚', '唐僧'];
        console.log(myjoin(array, '-')); //孙悟空-猪八戒-沙和尚-唐僧
        // console.log(arr.join('|'));

将一个字符串数组的元素的顺序进行反转。使用两种种方式实现:

 var array = ['a', 'b', 'c', 'd'];
        function myReverse(arr) {
            if (!arr || arr.length == 0) {
                return [];
            }
            for (var i = 0; i < arr.length / 2; i++) {
                var tmp = arr[i];
                arr[i] = arr[arr.length - i - 1];
                arr[arr.length - i - 1] = tmp;
            }
            return arr;
        }
        console.log(myReverse(array));

        // console.log(array.reverse());

7.2 Date对象

Date是JavaScript的内置对象，系统在Date对象中封装了与日期和时间相关的属性和方法。

Date使用UTC1970年1月1日0时开始经过的毫秒数来存储时间。

GMT 格林尼治时间；

UTC 国际协调时间；

January(Jan.)一月； February(Feb.)二月； March(Mar.)三月； April(Apr.)四月； May五月

June(六月； July（jul）七月； August(Aug.)八月； September(Sep.)九月； October(Oct.)十月；

November(Nov.)十一月； December(Dec.)十二月

Monday 星期一 Tuesday 星期二 Wednesday 星期三 Thursday 星期四 Friday 星期五 Saturday

星期六 Sunday 星期日

7.2.1、Date构造函数

            // 无参数的情况下返回值为当前时间。不同浏览器显示的时间格式会有细微差异
        var date = new Date()

        // 参数为毫秒值,距1970年1月1日（世界标准时间）起的毫秒数
        var date = new Date(50000000000);
        //Tue Aug 03 1971 00:53:20 GMT+0800 (中国标准时间)

        // 必选值:year, month, day；
        var date = new Date(2023, 8, 17, 15, 53, 20, 30);
        //Sun Sep 17 2023 15:53:20 GMT+0800 (中国标准时间)

        // 参数为日期字符串
        var date = new Date('2023-8-6');
        //Sun Aug 06 2023 00:00:00 GMT+0800 (中国标准时间)
        console.log(date);

7.2.2、Date对象方法

通过使用针对日期对象的方法，我们可以很容易地对日期进行操作：

方法名	作用
get/set FullYear()	从 Date 对象以四位数字返回年份
get/set Month()	从 Date 对象返回月份 (0 ~ 11)
get/set Date()	从 Date 对象返回一个月中的某一天 (1 ~ 31)
get/set Day()	从 Date 对象返回一周中的某一天 (0 ~ 6)
get/set Hours()	返回 Date 对象的小时 (0 ~ 23)
get/set Minutes()	返回 Date 对象的分钟 (0 ~ 59)
get/set Seconds()	返回 Date 对象的秒数 (0 ~ 59)
get/set Time()	返回 1970 年 1 月 1 日至今的毫秒数

Date对象相关的字符串表示方法：

方法名	作用
toSting()	获取Date实例的字符串表示
toDateSting()	获取Date的日期部分字符串表示
toTimeSting()	获取Date的时间部分字符串表示
toLocaleString()	据本地时间格式，把 Date 对象转换为字符串
toLocaleDateString()	根据本地时间格式，把 Date 对象的时间部分转换为字符串
toLocaleTimeString()	根据本地时间格式，把 Date 对象的时间部分转换为字符串
valueOf()	返回1970年1月1日午夜到指定日期的毫秒数
Date.now()	返回1970年1月1日午夜到指定日期的毫秒数

Date对象解析相关方法:

Date.parse()返回1970年1月1日午夜到指定日期（字符串）的毫秒数。
Date.parse()参数支持的时间格式如下：

1/24/2021；得到 Sun Jan 24 2021 10:10:10 GMT+0800

格式不正确会返回无效的时间

写一个函数，格式化日期对象，返回yyyy-MM-dd HH:mm:ss的形式：

  function mydate(dt) {
            // var dt = new Date()
            var year = dt.getFullYear()
            var month = dt.getMonth() + 1
            var date = dt.getDate()
            var hour = dt.getHours()
            var minute = dt.getMinutes()
            var second = dt.getSeconds()
            return year + "-" + month + '-' + date + ' ' + hour + ':' + minute + ':' + second
            month = month < 10 ? "0" + month : month
            date = date < 10 ? "0" + date : date
            hour = hour < 10 ? "0" + hour : hour
            minute = minute < 10 ? "0" + minute : minute
            second = second < 10 ? "0" + second : second
        }

        // var dt = new Date(2023, 8, 17, 16, 56, 50)
        // var time = mydate(dt);
        // console.log(time);

        console.log(mydate(new Date(2023, 8, 17, 16, 56, 50)));//其他输出方法

计算时间差，返回相差的天/时/分/秒

function getInterval(start, end) {
            var day, hour, minute, second, interval;
            interval = end - start;
            interval /= 1000;
            day = Math.round(interval / 60 / 60 / 24);
            hour = Math.round(interval / 60 / 60 % 24);
            minute = Math.round(interval / 60 % 60);
            second = Math.round(interval % 60);
            return {
                day: day,
                hour: hour,
                minute: minute,
                second: second
            }
        }
console.log(getInterval(new Date("2019-12-31"),new Date("2020-5-2")))

7.3、string对象

字符串的不可变：

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

7.3.1、string构造函数

可以通过new 关键字创建字符串对象：

var str=”hello”; // 字符串字面量
var str=new String(); // 字符串对象

注：创建出来的类型虽说不同，但是对于内置的方法和属性都是可以使用的。

length 属性返回字符串的长度(字符数)

7.3.2string对象方法

方法名	作用
charAt(index)	返回在指定位置的字符。
charCodeAt	返回在指定的位置的字符的 Unicode 编码
concat([string1,string2…)	连接字符串
slice(start,end)	提取字符串n到m之间的片断(不包括m位置的字符串)，并在新的字符串中返回被提取的部分
substring(star,end)	提取字符串中两个指定的索引号之间的字符。大多数情况和上一个作用相同，当参数为负值时会有不同，
substr(start,length)	从起始索引号提取字符串中指定数目的字符
split(separator,limit)	把字符串分割为字符串数组
indexOf(subString[,startIndex])	检索字符串,返回某个指定的字符串值在字符串中首次出现的位置。注意，如果查找不到会返回 -1
lastIndexOf(subString[,startIndex])	返回指定字符串在字符串最后出现的位置
toLowerCase()	把字符串转换为小写
toUpperCase()	把字符串转换为大写
match()	找到一个或多个正则表达式的匹配。(正则表达式后续课程会讲),该方法会返回一个数组，数组中包含了所符合条件的文本
replace(rgExp, replaceText)	替换与正则表达式匹配的子串，并返回替换后的字符串，注意原字符串不会改变
search(rgExp)	回与正则表达式查找内容匹配的第一个子字符串的位置。(与

练习：

var str = 'abcdefga'

        console.log(str.charAt(1));//b   返回在指定位置的字符

        console.log(str.charCodeAt(1))   // 98返回在指定的位置的字符的 Unicode 编码。

        var str2 = 'fjhi'
        console.log(str.concat(str2));//bcdefgfjhi    连接字符串。

   // slice  提取字符串n到m之间的片断(不包括m位置的字符串)，并在新的字符串中返回被提取的部分
        console.log(str.slice(2, 4));//cd   


   // 提取字符串中两个指定的索引号之间的字符。大多数情况和上一个作用相同，当参数为负值时会有不同
        console.log(str.substring(2, 4));//cd
        console.log(str.substring(2, -1));//ab

        //从起始索引号提取字符串中指定数目的字符
        console.log(str.substr(2, str.length));//cdefg

        //把字符串分割为字符串数组。
        console.log(str.split());//["abcdefg"]

       //检索字符串,返回某个指定的字符串值在字符串中首次出现的位置。注意，如果查找不到会返回 -1
        // var index=-1
        // console.log(str.indexOf('a',index+1));
        console.log(str.indexOf('b'));//1
        console.log(str.indexOf('a'));//0
        console.log(str.indexOf('a', 0));//0
        console.log(str.indexOf('a', 1));//7

        //返回指定字符串在字符串最后出现的位置
        console.log(str.lastIndexOf('a'));//7

        //toUpperCase()把字符串转换为大写。toLowerCase()把字符串转换为小写。
        console.log(str.toUpperCase());//ABCDEFGA

        //替换与正则表达式匹配的子串，并返回替换后的字符串，注意原字符串不会改变。
        console.log(str.replace('a', 'b'));//bbcdefga

        //回与正则表达式查找内容匹配的第一个子字符串的位置。(与indexOf相似)
        console.log(str.search('a'));//0

        //找到一个或多个正则表达式的匹配。,该方法会返回一个数组，数组中包含了所符合条件的文本。
        console.log(str.match());
        //["", index: 0, input: "abcdefga", groups: undefined]

把字符串中所有的o替换成!：

方法1：

 var s = 'abcoefoxyozzopp';
        var index = -1;
        do {
            index = s.indexOf('o', index + 1);
            if (index !== -1) {
                // 替换
                s = s.replace('o', '!');
            }
        } while (index !== -1);
        console.log(s);

方法2：

        var s = 'abcoefoxyozzopp';
        var index = -1;
        while ((index = s.indexOf('o', index + 1)) !== -1) {
            s = s.replace('o', '!');

        }
        console.log(s);

7.4Math对象

Math对象不是构造函数，它具有数学常数和函数的属性和方法，都是以静态成员的方式提供
跟数学相关的运算来找Math中的成员（求绝对值，取整）
Math 对象并不像 Date 和 String 那样是对象的类，因此没有构造函数 Math()

方法名/属性名	作用
Math.PI	返回圆周率3.1415926
Math.ceil（x）	返回大于等于其数值参数的最小整数
Math.floor（x）	返回小于等于其数值参数的最大整数
Math.round（x）	把数四舍五入为最接近的整数
Math.random（）	返回介于 0 和 1 之间的伪随机数。注:产生的伪随机数介于 0 和 1 之间（含0，不含 1），也就是，返回值可能为0，但总是小于1。
Math.max(x,y)	返回 x 和 y 中的最高值
Math.min(x,y)	返回 x 和 y 中的最低值
Math.abs(x)	返回x的绝对值

练习：

//Math.abs(x) 返回x的绝对值
        //Math.min(x,y) 返回 x 和 y 中的最低值
        // Math.max(x,y) 返回 x 和 y 中的最高值
        // Math.round(x) 把数四舍五入为最接近的整数
        //Math.ceil(x) 返回大于等于其数字参数的最小整数
        //Math.floor(x) 返回小于等于其数值参数的最大整数


        // math.ceil表示向上取整 
        console.log(Math.ceil(3.1));
        console.log(Math.ceil(3.5));
        console.log(Math.ceil(3.7));


        // math.floor表示向上取整 
        console.log(Math.floor(3.1));
        console.log(Math.floor(3.5));
        console.log(Math.floor(3.7));


        // math.round表示四舍五入
        console.log(Math.round(3.1));
        console.log(Math.round(3.5));
        console.log(Math.round(3.7));

        //[0-1]随机数
        //  console.log(Math.random());
        console.log(Math.floor(Math.random() * 10));//[1-10]

        //Math.min(x,y) 返回 x 和 y 中的最低值
        console.log(Math.max(1, 2, 8));//8

        // Math.max(x,y) 返回 x 和 y 中的最高值
        console.log(Math.min(1, 2, 8));//1

        //Math.abs(x) 返回x的绝对值
        console.log(Math.abs(-10));//10

        console.log(Math.PI);  // Math.PI 返回圆周率（约等于3.14159）
        console.log(Math.E); // Math.E 返回e= 2.718281828459045
        console.log(Math.LN2); // Math.LN2 返回ln2=约为 0.693
        console.log(Math.SQRT1_2); // Math.SQRT1_2 属性表示 1/2 的平方根，约为 0.707
        console.log(Math.SQRT2); //Math.SQRT2 属性表示 2 的平方根，约为 1.414
        console.log(Math.LOG10E); //Math.LOG10E 属性表示以 10 为底数e的对数，约0.434
        console.log(Math.sin(Math.PI / 2));//sin90=1
        console.log(Math.pow(2, 3));//  2*2*2=8
        console.log(Math.cbrt(8));//  8的立方根2  
        console.log(Math.sqrt(9));  //  9的平方根3

7.5全局对象

1、parseInt

parseInt() 函数可解析一个字符串，并返回一个整数。

2、parseFloat方法

parseFloat()函数可解析一个字符串，并返回一个浮点数。
该函数指定字符串中的首个字符是否是数字。如果是，则对字符串进行解析，直到到达数字的末端

为止，然后以数字返回该数字，而不是作为字符串。

如果参数字符串的第一个字符不能被解析成为数字，则 parseFloat 返回 NaN。

3、isNaN()方法

isNaN(x)：函数用于检查其参数是否是非数字值。
参数x是要检测的值，如果x是特殊的非数字值NaN（或者能被转换为这样的值），返回的值就是

true。如果 x 是其他值,则返回 false。

isNaN()函数可用于判断其参数是否是NaN，该值表示一个非法的数字（比如被 0 除后得到的结

果），如果把NaN与任何值(包括其自身)相比得到的结果均是false，所以要判断某个值是否是

NaN，不能使用 == 或 === 运算符。正因为如此，isNaN() 函数是必需的。

**提示：**isNaN()函数通常用于检测parseFloat()和parseInt()的结果，以判断它们表示的是否是合法的数

字。当然也可以用isNaN()函数来检测算数错误，比如用0作除数的情况

判断：

var loginName = parseInt('amigo1121');
        if (isNaN(loginName)) {
            //如果loginName不是数值,执行如下语句
            alert("parseInt('amigo1121')的结果是: " + loginName);
        } else {
            alert("parseInt('amigo1121')的结果是数值!");
        }

7.6基本包装类型

为了方便操作简单数据类型，JavaScript还提供了三个特殊的简单类型类型：String/Number/Boolean

s1是基本类型，基本类型是没有方法的：

// s1是基本类型，基本类型是没有方法的
        var s1 = 'zhangsan';
        var s2 = s1.substring(5);

当调用s1.substring(5)的时候，先把s1包装成String类型的临时对象，再调用substring方法，最

后销毁临时对象,：

// 当调用s1.substring(5)的时候，先把s1包装成String类型的临时对象，再调用substring方法，最后销毁临时对象：
        var s1 = new String('zhangsan');
        var s2 = s1.substring(5);

创建基本包装类型的对象：

// 创建基本包装类型的对象
        var num = 18; //数值，基本类型
        var num = Number('18'); //类型转换
        var num = new Number(18); //基本包装类型，对象

Number和Boolean基本包装类型基本不用，使用的话可能会引起歧义：

 // Number和Boolean基本包装类型基本不用，使用的话可能会引起歧义。
        var b1 = new Boolean(false);
        var b2 = b1 && true; // 结果是什么