三阶段P114~P187（PJavaScript基础语法-dom-bom-js-es6新语法-jQuery- 数据可视化echarts 黑马pink老师前端入门基础视频教程（持续更新）

本文链接：https://blog.youkuaiyun.com/qq_31645143/article/details/118368875

这篇博客详细介绍了JavaScript中的函数概念、使用方法、参数、返回值，以及作用域、对象、内置对象的使用，包括Math对象和Date对象。通过实例展示了如何声明和调用函数，如何处理形参和实参，以及如何使用arguments对象。此外，还讲解了对象的创建、作用域链，以及预解析和对象的属性、方法。最后，博客提供了多个实践案例和作业，帮助读者巩固理解。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

JavaScript函数

1. 函数的概念

在 JS 里面，可能会定义非常多的相同代码或者功能相似的代码，这些代码可能需要大量重复使用。
虽然 for循环语句也能实现一些简单的重复操作，但是比较具有局限性，此时我们就可以使用 $\color{red}{JS 中的函数}$ 。
$\color{red}{函数：}$ 就是封装了一段 $\color{red}{可被重复调用执行的代码块}$ 。通过此代码块可以实现大量代码的重复使用。

<script>
        // 1. 求 1~100的累加和
        var sum = 0;
        for (var i = 1; i <= 100; i++) {
            sum += i;
        }
        console.log(sum);

        // 2. 求 10~50的累加和
        var sum = 0;
        for (var i = 10; i <= 50; i++) {
            sum += i;
        }
        console.log(sum);

        // 3. 函数就是封装了一段可以被重复执行调用的代码块  目的： 就是让大量代码重复使用
        function getSum(num1, num2) {
            var sum = 0;
            for (var i = num1; i <= num2; i++) {
                sum += i;
            }
            console.log(sum);
        }
        getSum(1, 100);
        getSum(10, 50);
        getSum(1, 1000);
    </script>

2. 函数的使用

函数在使用时分为两步： $\color{red}{声明函数}$ 和调用函数。

2.1 声明函数

在这里插入图片描述

function 是声明函数的关键字,必须小写
由于函数一般是为了实现某个功能才定义的，所以通常我们将函数名命名为动词，比如 getSum

<script>
        // 函数使用分为两步：声明函数和调用函数
        // 1. 声明函数
        function sayHi() {
            console.log('hi~~');
        }
        // （1）function 声明函数的关键字 全部小写
        // （2）函数是做某件事情，函数名一般是动词 sayHi
        // （3）函数不调用自己不执行
        // 2. 调用函数
        // 函数名();
        sayHi();
        // 调用函数的时候千万不要忘记加小括号
    </script>

2.2调用函数

在这里插入图片描述

调用的时候千万不要忘记添加小括号
口诀：函数不调用，自己不执行。
注意：声明函数本身并不会执行代码，只有调用函数时才会执行函数体代码。

2.3函数的封装

函数的封装是把一个或者多个功能通过函数的方式封装起来，对外只提供一个简单的函数接口
简单理解：封装类似于将电脑配件整合组装到机箱中 ( 类似快递打包）

案例：利用函数计算1-100之间的累加和

<script>
        // 利用函数计算 1~100 之间的累加和
        // 1. 声明函数
        function getSum() {
            var sum = 0;
            for (var i = 1; i <= 100; i++) {
                sum += i;
            }
            console.log(sum);
        }
        // 2. 调用函数
        getSum();
        getSum();
    </script>

2.4pink老师提问

1.函数是做什么的（作用）？
封装一段可以被重复调用执行的代码块
2.声明函数用什么关键词？
function
3.如何调用函数？
函数名（）
4.封装是什么意思？
打包，把函数整合在一起

3. 函数的参数

3.1 形参和实参

在声明函数时，可以在函数名称后面的小括号中添加一些参数，这些参数被称为形参，而在调用该函数时，同样也需要传递相应的参数，这些参数被称为实参。

参数的作用 : 在函数内部某些值不能固定，我们可以通过参数在调用函数时传递不同的值进去。

<script>
        // // 1. 函数可以重复相同的代码
        // function cook() {
        //     console.log('酸辣土豆丝');
        // }
        // cook();
        // cook();
        // // 2. 我们可以利用函数的参数实现函数重复不同的代码
        // function 函数名(形参1,形参2...) { // 在声明函数的小括号里面是 形参(形式上的参数)

        // }
        // 函数名(实参1,实参2...); // 在函数调用的小括号里面是实参 (实际的参数)
        // 3. 形参和实参的执行过程
        function cook(aru) { // 形参是接受实参的 aru = '酸辣土豆丝'  形参类似于一个变量
            console.log(aru);
        }
        cook('酸辣土豆丝');
        cook('大肘子');
    </script>

案例：利用函数求任意两个数的和

<script>
       // 1. 利用函数求任意两个数的和
       function getSum(num1,num2) {
           console.log(num1 + num2);
       }
       getSum(2,3);
       getSum(3,8);
       // 2. 利用函数求任意两个数之间的和
       function getSums(start,end) {
           var sum = 0;
           for(var i = start; i <= end; i++) {
               sum += i;
           }
           console.log(sum);
       }
       getSums(1,10);
       // 3. 注意点
       // (1) 多个参数之间用逗号隔开
       // (2) 形参可以看做是不用声明的变量
   </script>

3.3 函数形参和实参个数不匹配问题

在这里插入图片描述
注意：在JavaScript中，形参的默认值是undefined。

3.4小结

函数可以带参数也可以不带参数
声明函数的时候，函数名括号里面的是形参，形参的默认值为 undefined
调用函数的时候，函数名括号里面的是实参
多个参数中间用逗号分隔
形参的个数可以和实参个数不匹配，但是结果不可预计，我们尽量要匹配

4. 函数的返回值

4.1 return 语句

有的时候，我们会希望函数将值返回给调用者，此时通过使用 return 语句就可以实现。return 语句的语法格式如下：

在使用 return 语句时，函数会停止执行，并返回指定的值
如果函数没有 return ，返回的值是 undefined

<script>
        // 1. 函数是做某件事或者实现某种功能
        function cook(aru) {
            console.log(aru);
        }
        cook('大肘子');
        // // 2. 函数的返回值格式
        // function 函数名() {
        //     return 需要返回的结果;
        // }
        // 函数名();
        // (1) 我们函数只是实现某种功能，最终的结果需要返回给函数的调用者 函数名()  通过return 实现的
        // (2) 只要函数遇到 return 就把后面的结果  返回给函数的调用者  函数名 = return后面的结果
        // 3. 代码验证
        function getResult() {
            return 666;
        }
        getResult(); // getResut() = 666
        console.log(getResult());

        // function cook(aru) {
        //     return aru;
        // }
        // console.log(cook('大肘子'));
        // 4. 求任意两个数的和
        function getSum(num1, num2) {
            return num1 + num2;
        }
        console.log(getSum(1, 2));
    </script>

案例 1：利用函数求任意两个数的最大值

<script>
        // 利用函数 求两个数的最大值
        function getMax(num1, num2) {
            // if (num1 > num2) {
            //     return num1;
            // } else {
            //     return num2;
            // }
            return num1 > num2 ? num1 : num2;
        }
        console.log(getMax(1, 3));
        console.log(getMax(11, 3));
    </script>

案例 2：利用函数求任意一个数组中的最大值
求数组 [5,2,99,101,67,77] 中的最大数值。

<script>
        // 利用函数求数组 [5,2,99,101,67,77] 中的最大数值
        function getArrMax(arr) {
            var max = arr[0];
            for (var i = 1; i < arr.length; i++) {
                if (arr[i] > max)  {
                    max = arr[i];
                }
            }
            return max;
        }
        // getArrMax([5, 2, 99, 101, 67, 77]); // 实参是一个数组送过去
        // 在我们实际开发里面，我们经常用一个变量来接受函数的返回结果，使用更简单
        // var re = getArrMax([5, 2, 99, 101, 67, 77]);
        var re = getArrMax([3,77,44,99,143]);
        console.log(re);
        </script>

4.2 return 终止函数

return 语句之后的代码不被执行。

<script>
        // 函数返回值注意事项
        // 1. return 终止函数
        function getSum(num1,num2) {
            return num1 + num2; // return 后面的代码不会被执行
            alert('我是不会被执行的哦！')
        }
        console.log(getSum(1,2));
    </script>

4.3 return 的返回值

return 只能返回一个值。如果用逗号隔开多个值，以最后一个为准。

<script>
        // 函数返回值注意事项
        // 1. return 终止函数
        function getSum(num1,num2) {
            return num1 + num2; // return 后面的代码不会被执行
            alert('我是不会被执行的哦！')
        }
        console.log(getSum(1,2));
        // 2. return 只能返回一个值
        function fn(num1,num2) {
            return num1, num2; // 返回的结果是最后一个值
        }
        console.log(fn(1,2));
        // 3. 我们求任意两个数的 加减乘除 结果
        function getResult(num1,num2) {
            return [num1 + num2, num1 - num2, num1 * num2, num1 / num2];
        }
        var re = getResult(1,2); // 返回的是一个数组
        console.log(re);
    </script>

4.4 函数没有 return 返回 undefined

函数都是有返回值的
1.如果有return 则返回 return 后面的值
2.如果没有return 则返回 undefined

<script>
        // 函数返回值注意事项
        // 1. return 终止函数
        function getSum(num1, num2) {
            return num1 + num2; // return 后面的代码不会被执行
            alert('我是不会被执行的哦！')
        }
        console.log(getSum(1, 2));
        // 2. return 只能返回一个值
        function fn(num1, num2) {
            return num1, num2; // 返回的结果是最后一个值
        }
        console.log(fn(1, 2));
        // 3. 我们求任意两个数的 加减乘除 结果
        function getResult(num1, num2) {
            return [num1 + num2, num1 - num2, num1 * num2, num1 / num2];
        }
        var re = getResult(1, 2); // 返回的是一个数组
        console.log(re);
        // 4. 我们的函数如果有 return 则返回的是 return 后面的值，如果函数么有 return 则返回undefined
        function fn1() {
            return 666;
        }
        console.log(fn1()); // 返回 666
        function fn2() {

        }
        console.log(fn2()); // 函数返回的结果是  undefined
    </script>

4.5 break ,continue ,return 的区别

break ：结束当前的循环体（如 for、while）
continue ：跳出本次循环，继续执行下次循环（如 for、while）
return ：不仅可以退出循环，还能够返回 return 语句中的值，同时还可以结束当前的函数体内的代码

通过榨汁机看透函数

作业

① 写一个函数，用户输入任意两个数字的任意算术运算（简单的计算器小功能），并能弹出运算后的结果。
② 写一个函数，用户输入任意两个数字的最大值，并能出弹运算后的结果。
③ 写一个函数，用户输入任意三个不同数字的最大值，并能弹出运算后的结果。
④ 写一个函数，用户输入一个数判断是否是素数，并返弹出回值(又叫质数，只能被1和自身整数的数)

5. arguments的使用

当我们不确定有多少个参数传递的时候，可以用 arguments 来获取。在 JavaScript 中，arguments 实际上它是当前函数的一个内置对象。所有函数都内置了一个 arguments 对象，arguments 对象中存储了传递的所有实参。
arguments展示形式是一个伪数组，因此可以进行遍历。伪数组具有以下特点：

具有 length 属性
按索引方式储存数据
不具有数组的 push , pop 等方法

<script>
        // arguments 的使用  只有函数才有 arguments对象 而且是每个函数都内置好了这个arguments
        function fn() {
            // console.log(arguments); // 里面存储了所有传递过来的实参 arguments = [1,2,3]
            // console.log(arguments.length);
            // console.log(arguments[2]);
            // 我们可以按照数组的方式遍历arguments
            for (var i = 0; i < arguments.length; i++) {
                console.log(arguments[i]);
            }
        }
        fn(1, 2, 3);
        fn(1, 2, 3, 4, 5);
        // 伪数组 并不是真正意义上的数组
        // 1. 具有数组的 length 属性
        // 2. 按照索引的方式进行存储的
        // 3. 它没有真正数组的一些方法 pop()   push() 等等
    </script>

案例：利用函数求任意个数的最大值

<script>
        // 利用函数求任意个数的最大值
        function getMax() {
            var max = arguments[0];
            for (var i = 1; i < arguments.length; i++) {
                if (arguments[i] > max) {
                    max = arguments[i];
                }
            }
            return max;
        }
        console.log(getMax(1,2,3));
        console.log(getMax(1,2,3,4,5));
        console.log(getMax(11,2,34,444,5,100));
    </script>

6. 函数案例

案例 1：利用函数封装方式，翻转任意一个数组

<script>
        // 利用函数翻转任意数组  reverse翻转
        function reverse(arr) {
            var newArr = [];
            for (var i = arr.length -1; i >= 0; i--) {
                newArr[newArr.length] = arr[i]
            }
            return newArr;
        }
        var arr1 = reverse([1,3,4,6,9]);
        console.log(arr1);
        var arr2 = reverse(['red','blue','pink']);
        console.log(arr2);
    </script>

案例 2：利用函数封装方式，对数组排序 – 冒泡排序

<script>
        // 利用函数冒泡排序  sort 排序
        function sort(arr) {
            for (var i = 0; i < arr.length - 1; i++) {
                for (var j = 0; j < arr.length - i - 1; j++) {
                    if (arr[j] > arr[j + 1]) {
                        var temp = arr[j];
                        arr[j] = arr[j + 1];
                        arr[j + 1] = temp;
                    }
                }
            }
            return arr;
        }
        var arr1 = sort([1, 4, 2, 9]);
        console.log(arr1);
    </script>

案例 3：判断闰年
要求：输入一个年份，判断是否是闰年（闰年：能被4整除并且不能被100整除，或者能被400整除）

<script>
        // 利用函数判断闰年
        function isRunYear(year) {
            // 如果是闰年我们返回 true 否则返回 false
            var flag = false;
            if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {
                flag = true;
            }
            return flag;
        }
        console.log(isRunYear(2000));
        console.log(isRunYear(1999));
    </script>

函数可以调用另外一个函数
因为每个函数都是独立的代码块，用于完成特殊任务，因此经常会用到函数相互调用的情况。

<script>
        // // 函数是可以相互调用的
        // function fn1() {
        //     console.log(11);
        //     fn2(); // 在fn1 函数里面调用了 fn2 函数
        // }
        // fn1();
        // function fn2() {
        //     console.log(22);
        // }
        function fn1() {
            console.log(111); 
            fn2(); 
            console.log('fn1');
        }
        function fn2() { 
            console.log(222); 
            console.log('fn2');
        }
        fn1();
    </script>

案例 4：用户输入年份，输出当前年份2月份的天数
如果是闰年，则2月份是 29天，如果是平年，则2月份是 28天

<script>
        // 用户输入年份，输出当前年份 2月份的天数
        function backDay() {
            var year = prompt('请您输入年份：');
            if (isRunYear(year)) {  // 调用函数需要加小括号
                alert('当前年份是闰年2月份有29天');
            } else {
                alert('当前年份是平年2月份有28天');
            }
        }
        backDay();

        // 判断是否为闰年的函数
        function isRunYear(year) {
            // 如果是闰年我们返回 true 否则返回 false
            var flag = false;
            if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {
                flag = true;
            }
            return flag;
        }
    </script>

7. 函数的两种声明方式

1.自定义函数方式(命名函数)
利用函数关键字 function 自定义函数方式。

因为有名字，所以也被称为命名函数
调用函数的代码既可以放到声明函数的前面，也可以放在声明函数的后面

2.函数表达式方式(匿名函数）
利用函数表达式方式的写法如下：

因为函数没有名字，所以也被称为匿名函数
这个fn 里面存储的是一个函数
函数表达式方式原理跟声明变量方式是一致的
函数调用的代码必须写到函数体后面

JavaScript 作用域

1. 作用域

1.1 作用域概述

作用域通常来说，一段程序代码中所用到的名字并不总是有效/可用的，而限定这个名字的 $\color{red}{可用性的代码范围}$ 就是这个名字的作用域。 $\color{red}{作用域}$ 的使用提高了程序逻辑的局部性，增强程序的可靠性，减少名字冲突。

<script>
        // 1. JavaScript作用域：就是代码名字（变量）在某个范围内起作用和效果  目的是为了提高程序的可靠性更重要的是减少命名冲突
        // 2. js的作用域（es6）之前：全局作用域  局部作用域
        // 3. 全局作用域：整个script标签 或者是一个单独的js文件
        var num = 10;
        var num = 30;
        console.log(num);
        // 4. 局部作用域（函数作用域）在函数内部就是函数作用域  这个代码的名字只在函数内部起效果和作用
        function fn() {
            // 局部作用域
            var num = 20;
            console.log(num);
        }
        fn();
    </script>

2. 变量的作用域

2.1 变量作用域的分类

在JavaScript中，根据作用域的不同，变量可以分为两种：

全局变量
局部变量

2.2 全局变量

在全局作用域下声明的变量叫做 $\color{red}{全局变量（在函数外部定义的变量）}$ 。

全局变量在代码的任何位置都可以使用
在全局作用域下 var 声明的变量是全局变量
特殊情况下，在函数内不使用 var 声明的变量也是全局变量（不建议使用）

2.3 局部变量

在局部作用域下声明的变量叫做局部变量（在函数内部定义的变量）

局部变量只能在该函数内部使用
在函数内部 var 声明的变量是局部变量
函数的形参实际上就是局部变量

2.4 全局变量和局部变量的区别

全局变量：在任何一个地方都可以使用，只有在浏览器关闭时才会销毁，因此比较占内存
局部变量：只在函数内部使用，当其所在的代码块被执行时，会被初始化；当代码块运行结束后，就会被销毁，因此更节省内存空间

1.4 JS 没有块级作用域

<script>
        // js中没有块级作用域  js的作用域：全局作用域  局部作用域 现阶段我们 js 没有块级作用域
        // 我们 js 也是在 es6 的时候新增的 块级作用域
        // 块级作用域{}   if{}    for{}
        // java
        // if (XXX) {
        //     int num = 10;
        // }
        // 外面的是不能调用num的
        if (3 < 5) {
            var num = 10;
        }
        console.log(num); // 可以使用，现阶段没有块级作用域，{}外面也可以使用
    </script>

3. 作用域链

只要是代码，就至少有一个作用域
写在函数内部的局部作用域
如果函数中还有函数，那么在这个作用域中就又可以诞生一个作用域
根据在内部函数可以访问外部函数变量的这种机制，用链式查找决定哪些数据能够被内部函数访问

<script>
        // 作用域链： 内部函数访问外部函数的变量，采取的是链式查找的方式来决定取哪个值 这种结构我们称为作用域链  就近原则
        var num = 10;

        function fn() { // 外部函数
            var num = 20;

            function fun() { // 内部函数
                console.log(num);
            }
            fun();
        }
        fn();
    </script>

案例1：结果是几？

<script>
        // 案例1：结果是几？
        function f1() {
            var num = 123;

            function f2() {
                var num = 0;
                console.log(num); // 站在目标出发，一层一层的往外查找
            }
            f2();
        }
        var num = 456;
        f1();
        // 案例2：结果是几？
        var a = 1;

        function fn1() {
            var a = 2;
            var b = '22';
            fn2();

            function fn2() {
                var a = 3;
                fn3();

                function fn3() {
                    var a = 4;
                    console.log(a);　 // a的值？
                    console.log(b);　 // b的值？
                }
            }
        }
        fn1();
    </script>

JavaScript预解析

<script>
        // 1问
        // console.log(num);
        // 2问
        console.log(num); // undefined  坑1 
        var num = 10;
        // 3问
        fn();

        function fn() {
            console.log(11);
        }
        // 相当于执行了以下代码
        function fn() {
            console.log(11);
        }
        fn();

        // 4问
        fun(); // 报错 坑2
        var fun = function() {
                console.log(22);
            }
            // 函数表达式 调用必须写在函数
            // 相当于执行了以下diam
        var fun;
        fun();
        fun = function() {
                console.log(22);
            }
            // 1. 我们 js 引擎运行 js 分为两步： 预解析 代码执行
            // (1). 预解析 js引擎会把 js 里面所有的 var 还有 function 提升到当前作用域的最前面
            // (2). 代码执行  按照代码书写的顺序从上往下执行
            // 2. 预解析分为 变量预解析（变量提升） 和 函数预解析（函数提升）
            // (1) 变量提升 就是把所有的变量声明提升到当前作用域的最前面 不提升赋值操作
            // (2) 函数提升 就是把所有的函数声明提升到当前作用域的最前面 不调用函数
    </script>

预解析案例

<script>
        // 案例3
        var a = 18;
        f1();
        function f1() {
            var b = 9;
            console.log(a);
            console.log(b);
            var a = '123';
        }

        // // 相当于执行以下操作
        var a;
        function f1() {
            var b;
            var a;
            b = 9;
            console.log(a); // undefined
            console.log(b); // 9
            a = '123';
        }
        a = 18;
        f1();
        // 案例4
        f1();
        console.log(c);
        console.log(b);
        console.log(a);
        function f1() {
            var a = b = c = 9;  // 相当于 var a =9; b =9; c =9; b 和 c 直接赋值，没有var 声明，是全局变量   非集体声明，集体为 var a = 9, b =9, c=9
            console.log(a);
            console.log(b);
            console.log(c);
        }
        // 相当于执行以下操作
        function f1() {
            var a;
            a = b = c = 9;
            console.log(a);
            console.log(b);
            console.log(c);
        }
        f1();
        console.log(c);
        console.log(b);
        console.log(a);
    </script>

JavaScript 对象

1. 对象

1.1 什么是对象？

现实生活中：万物皆对象，对象是一个具体的事物，看得见摸得着的实物。例如，一本书、一辆汽车、一个人可以是“对象”，一个数据库、一张网页、一个与远程服务器的连接也可以是“对象”。

在 JavaScript 中，对象是一组无序的相关属性和方法的集合，所有的事物都是对象，例如字符串、数值、数组、函数等。
对象是由属性和方法组成的。
属性：事物的特征，在对象中用属性来表示（常用名词）
方法：事物的行为，在对象中用方法来表示（常用动词）

在这里插入图片描述

保存一个值时，可以使用变量，保存多个值（一组值）时，可以使用数组。如果要保存一个人的完整信息呢？例如，将“张三疯”的个人的信息保存在数组中的方式为：
JS 中的对象表达结构更清晰，更强大。张三疯的个人信息在对象中的表达结构如下：

2. 创建对象的三种方式

在 JavaScript 中，现阶段我们可以采用三种方式创建对象（object）：

用字面量创建对象
利用 new Object 创建对象
利用构造函数创建对象

2.1 利用字面量创建对象

对象字面量：就是花括号 { } 里面包含了表达这个具体事物（对象）的属性和方法。
{ } 里面采取键值对的形式表示

键：相当于属性名
值：相当于属性值，可以是任意类型的值（数字类型、字符串类型、布尔类型，函数类型等）

对象的调用

对象里面的属性调用 : 对象.属性名，这个小点 . 就理解为“ 的 ”
对象里面属性的另一种调用方式 : 对象[‘属性名’]，注意方括号里面的属性必须加引号，我们后面会用
对象里面的方法调用：对象.方法名() ，注意这个方法名字后面一定加括号

// 利用对象字面量创建对象 {}
        // var obj = {};  // 创建了一个空的对象
        var obj = {
                uname: '张三疯',
                age: 18,
                sex: '男',
                sayHi: function() {
                    console.log('hi~');
                }
            }
            // (1) 里面的属性或者方法我们采取键值对的形式  键 属性名： 值 属性值
            // (2) 多个属性或者方法中间用逗号隔开的
            // (3) 方法冒号后面跟的是一个匿名函数
            // 2. 使用对象
            // (1). 调用对象的属性 我们采取 对象名.属性名  . 我们理解为 的
        console.log(obj.uname);
        // (2). 调用属性还有一种方法 对象名['属性名']
        console.log(obj['age']);
        // (3). 调用对象的方法 sayHi  对象名.方法名()  千万别忘记添加小括号
        obj.sayHi();
    </script>

练习：请按照要求写出对象
请用对象字面量的形式创建一个名字为可可的狗对象。具体信息如下：

姓名：可可
类型(type)：阿拉斯加犬
年龄：5岁，
颜色：棕红色。
技能：汪汪汪(bark) ，演电影 (showFilm)

变量、属性、函数、方法总结+
变量：单独声明赋值，单独存在

属性：对象里面的变量称为属性，不需要声明，用来描述该对象的特征
函数：单独存在的，通过“函数名()”的方式就可以调用
方法：对象里面的函数称为方法，方法不需要声明，使用“对象.方法名()”的方式就可以调用，方法用来描述该对象的行为和功能。

2.2利用new Object创建对象

Object() ：第一个字母大写
new Object() ：需要 new 关键字
使用的格式：对象.属性 = 值;

<script>
        // 利用 new Object 创建对象
        var obj = new Object(); // 创建了一个空的对象
        obj.uname = '张三疯';
        obj.age = 18;
        obj.sex = '男';
        obj.sayHi = function() {
                console.log('hi~');
            }
            // (1) 我们是利用 等号 = 赋值的方法 添加对象的属性和方法
            // (2) 每个属性和方法之间用 分号结束
        console.log(obj.uname);
        console.log(obj['sex']);
        obj.sayHi();
    </script>

练习：请按照要求写出对象
请用new Object 形式创建一个鸣人对象。具体信息如下：

姓名：鸣人
性别：男
年龄：19岁
技能（skill）：影分身术

2.3利用构造函数创建对象

构造函数：是一种特殊的函数，主要用来初始化对象，即为对象成员变量赋初始值，它总与 new 运算符一起使用。我们可以把对象中一些公共的属性和方法抽取出来，然后封装到这个函数里面。
在 js 中，使用构造函数要时要注意以下两点：

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

注意
1.构造函数约定首字母大写。
2.函数内的属性和方法前面需要添加 this ，表示当前对象的属性和方法。
3.构造函数中不需要 return 返回结果。
4.当我们创建对象的时候，必须用 new 来调用构造函数。

<script>
        // 我们为什么需要使用构造函数
        // 就是因我们前面两种创建对象的方式一次只能创建一个对象
        var ldh = {
            uname: '刘德华',
            age: 55,
            sing: function() {
                console.log('冰雨');
            }
        }
        var zxy = {
                uname: '张学友',
                age: 58,
                sing: function() {
                    console.log('李香兰');
                }
            }
            // 因为我们一次创建一个对象，里面很多的属性和方法是大量相同的 我们只能复制
            // 因此我们可以利用函数的方法 重复这些相同的代码  我们就把这个函数称为 构造函数
            // 又因为这个函数不一样，里面封装的不是普通代码，而是 对象
            // 构造函数  就是把我们对象里面一些相同的属性和方法抽象出来封装到函数里面
    </script>

<script>
        // 利用构造函数创建对象
        // 我们需要创建四大天王的对象 相同的属性： 名字 年龄 性别   相同的方法：唱歌
        // 构造函数的语法格式
        // function 构造函数名() {
        //     this.属性 = 值;
        //     this.方法 = function () {
        //     }
        // }
        // new 构造函数名();
        function Star(uname, age, sex) {
            this.name = uname;
            this.age = age;
            this.sex = sex;
            this.sing = function(sang) {
                console.log(sang);
            }
        }
        var ldh = new Star('刘德华', 18, '男'); // 调用函数返回的是一个对象
        // console.log(typeof ldh);
        console.log(ldh.name);
        console.log(ldh['sex']);
        ldh.sing('冰雨');
        var zxy = new Star('张学友', 19, '男');
        console.log(zxy.name);
        console.log(zxy['age']);
        zxy.sing('李香兰');

        // 1.构造函数名字首字母要大写
        // 2.我们构造函数不需要 return 就可以返回结果
        // 3.我们调用构造函数 必须使用 new
        // 4.我们只要 new Star() 调用函数就创建一个对象 ldh {}
        // 5.我们的属性和方法前面必须添加this
    </script>

练习：请按照要求创建对象
利用构造函数创建两个英雄对象。函数中的公共部分包括：姓名属性(name)，类型属性（type），血量属性（blood）和攻击方式（attack）。
英雄对象的信息如下：

廉颇力量型 500血量攻击：近战
后羿射手型 100血量攻击：远程

2.4构造函数和对象

构造函数，如 Stars()，抽象了对象的公共部分，封装到了函数里面，它泛指某一大类（class）
创建对象，如 new Stars()，特指某一个，通过 new 关键字创建对象的过程我们也称为对象实例化

<script>
        // 构造函数和对象
        // 1. 构造函数  明星 泛指的某一大类  它类似于 java 语言里面的  类（class）
        function Star(uname, age, sex) {
            this.name = uname;
            this.age = age;
            this.sex = sex;
            this.sing = function(sang) {
                console.log(sang);
            }
        }

        // 2. 对象 特指 是一个具体的事物  刘德华 == {name:"刘德华"，age: 18, sex: "男", sing: f}
        var ldh = new Star('刘德华', 18, '男'); // 调用函数返回的是一个对象
        console.log(ldh);
        // 3. 我们利用构造函数创建对象的过程我们也称为对象的实例化
    </script>

3. new关键字

<script>
        // new关键字执行过程
        // 1. new 构造函数可以在内存中创建了一个空的对象
        // 2. this 就会指向刚才创建的空对象
        // 3. 执行构造函数里面的代码 给这个空对象添加属性和方法
        // 4. 返回这个对象
        function Star(uname, age, sex) {
            this.name = uname;
            this.age = age;
            this.sex = sex;
            this.sing = function(sang) {
                console.log(sang);
            }
        }
        var ldh = new Star('刘德华', 18, '男');
    </script>

new 在执行时会做四件事情：
1.在内存中创建一个新的空对象。
2.让 this 指向这个新的对象。
3.执行构造函数里面的代码，给这个新对象添加属性和方法。
4.返回这个新对象（所以构造函数里面不需要return）。

New 和构造函数确认了眼神
1.他们俩生了一个宝宝。
2.这个宝宝必须是亲生的 this指向。
3.教孩子读书一肚子墨水。4.长大挣钱回报父母。

4. 遍历对象属性

for…in 语句用于对数组或者对象的属性进行循环操作。其语法如下：

语法中的变量是自定义的，它需要符合命名规范，通常我们会将这个变量写为 k 或者 key。

<script>
        // 遍历对象
        var obj = {
                name: 'pink老师',
                age: 18,
                sex: '男',
                fn: function() {}
            }
            // console.log(obj.name);
            // console.log(obj['age']);
            // console.log(obj.sex);
            // for in 遍历我们的对象
            // for (变量 in 对象) {

        // }
        for (var k in obj) {
            console.log(k); // 变量输出  得到的是属性名
            console.log(obj[k]); // obj[k] 得到的是属性值
        }
        // 我们使用 for in 里面的变量  我们喜欢写 k 或者 key
    </script>

小结

1.对象可以让代码结构更清晰
2.对象复杂数据类型object。
3.本质：对象就是一组无序的相关属性和方法的集合。
4.构造函数泛指某一大类，比如苹果，不管是红色苹果还是绿色苹果，都统称为苹果。
5.对象实例特指一个事物，比如这个苹果、正在给你们讲课的pink老师等。
6.for…in 语句用于对对象的属性进行循环操作。

1.创建一个电脑对象，该对象要有颜色、重量、品牌、型号，可以看电影、听音乐、打游戏和敲代码。
2.创建一个按钮对象，该对象中需要包含宽，高，背景颜色和点击行为。
3.创建一个车的对象，该对象要有重量、颜色、牌子，可以载人、拉货和耕田。

① 写一个函数，实现反转任意数组。
② 写一个函数，实现对数字数组的排序。

小组项目：做一个简易计算器
在这里插入图片描述

JavaScript 内置对象

1. 内置对象

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

2. 查文档

2.1MDN

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

2.2如何学习对象中的方法

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

3. Math 对象

3.1Math 概述

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

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

<script>
        // Math数学对象 不是一个构造函数，所以我们不需要 new 来调用 而是直接使用里面的属性和方法即可
        console.log(Math.PI); // 一个属性 圆周率
        console.log(Math.max(1, 99, 3)); // 99
        console.log(Math.max(-1, -10)); // -1
        console.log(Math.max(1, 99, 'pink老师')); // NaN
        console.log(Math.max()); // NaN
    </script>

案例：封装自己的数学对象
利用对象封装自己的数学对象里面有 PI 最大值和最小值

<script>
        // 利用对象封装自己的数学对象 里面有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) {
                        max = arguments[i];
                    }
                }
                return min;
            }
        }
        console.log(myMath.PI);
        console.log(myMath.max(1, 5, 9));
        console.log(myMath.min(1, 5, 9));
    </script>

<script>
        // 1. 绝对值方法
        console.log(Math.abs(1)); // 1
        console.log(Math.abs(-1)); // 1
        console.log(Math.abs('-1')); // 1  隐式转换 会把字符串型 -1 转换为数字型
        console.log(Math.abs('pink')); // NaN
        // 2. 三个取整方法
        // (1) Math.floor() 向下取整 往最小了取值  floor地板
        console.log(Math.floor(1.1)); // 1
        console.log(Math.floor(1.9)); // 1
        // (２) Math.ceil() 向上取整 往最大了取值   ceil 天花板
        console.log(Math.ceil(1.1)); // 2
        console.log(Math.ceil(1.9)); // 2
        // (２) Math.round() 四舍五入  其他数字都是四舍五入， 但是 .5 特殊 它往大了取
        console.log(Math.round(1.1)); // 1
        console.log(Math.round(1.5)); // 2
        console.log(Math.round(1.9)); // 2
        console.log(Math.round(-1.1)); // -1
        console.log(Math.round(-1.5)); // 这个结果是 -1
    </script>

3.2随机数方法 random()

random() 方法可以随机返回一个小数，其取值范围是 [0，1)，左闭右开 0 <= x < 1
得到一个两数之间的随机整数，包括两个数在内
在这里插入图片描述

<script>
        // 1. Math对象随机数方法 random() 返回一个随机的小数  0 <= x < 1
        // 2. 这个方法里面不跟参数
        // 3. 代码验证
        console.log(Math.random());
        // 4. 我们想要得到两个数之间的随机整数 并且 包含这 2 个整数
        // Math.floor(Math.random() * (max - min + 1)) + min;
        function getRandom(min, max) {
            return Math.floor(Math.random() * (max - min + 1)) + min;
        }
        console.log(getRandom(1,10));
        // 5. 随机点名
        var arr = ['张三', '张三丰', '张三疯子', '李四', '李思思','pink老师'];
        // console.log(arr[0]);
        console.log(arr[getRandom(0,arr.length - 1)]);
    </script>

案例：猜数字游戏
程序随机生成一个 1~ 10 之间的数字，并让用户输入一个数字，
1.如果大于该数字，就提示，数字大了，继续猜；
2.如果小于该数字，就提示数字小了，继续猜；
3.如果等于该数字，就提示猜对了，结束程序。
案例分析
① 随机生成一个1~10 的整数我们需要用到 Math.random() 方法。
② 需要一直猜到正确为止，所以一直循环。
③ 用while 循环合适更简单。
④ 核心算法：使用 if else if 多分支语句来判断大于、小于、等于。

<script>
        // 猜数字游戏
        // 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~ 50 之间的一个数组 但是只有 10次猜的机会
    </script>

4. 日期对象

4.1 Date 概述

Date 对象和 Math 对象不一样，他是一个构造函数，所以我们需要实例化后才能使用
Date 实例用来处理日期和时间

4.2 Date()方法的使用

1.获取当前时间必须实例化
在这里插入图片描述
2.Date() 构造函数的参数
如果括号里面有时间，就返回参数里面的时间。例如日期格式字符串为‘2019-5-1’，可以写成new Date(‘2019-5-1’) 或者 new Date(‘2019/5/1’)

如果Date()不写参数，就返回当前时间
如果Date()里面写参数，就返回括号里面输入的时间

4.3日期格式化

我们想要 2019-8-8 8:8:8 格式的日期，要怎么办？
需要获取日期指定的部分，所以我们要手动的得到这种格式。

案例：输出当前日期
请写出这个格式的日期：2019年8月8日星期四

<script>
        // 格式化日期 年月日
        var date = new Date();
        console.log(date.getFullYear()); // 返回当前日期的年 2021
        console.log(date.getMonth() + 1); // 月份（0-11） 返回的月份小1个月  记得月份 +1 哟
        console.log(date.getDate()); // 返回的是 几号
        console.log(date.getDay()); // 返回的是周几 （周日0 周六6） 周一返回到的是1 周六返回的是6  但是 周日退回的是 0
        // 我们写一个 2020年 7月 28日 星期三
        var year = date.getFullYear();
        var month = date.getMonth() + 1;
        var dates = date.getDate();
        var arr = ['星期日','星期一','星期二','星期三','星期四','星期五','星期六'];
        var day = arr[date.getDay()];
        console.log('今天是: ' + year + ' 年' + month + '月' + dates + '日 '  + day );
    </script>

案例：输出当前时间
写一个函数，格式化日期对象，成为 HH:mm:ss 的形式比如 00:10:45

<script>
        // 格式化日期 时分秒
        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 ;
        }
        var time = getTime();
        console.log(time);
    </script>

4.4获取日期的总的毫秒形式

Date 对象是基于1970年1月1日（世界标准时间）起的毫秒数为什么计算机起始时间从1970年开始?
我们经常利用总的毫秒数来计算时间，因为它更精确

<script>
        // 获得 Date 总的毫秒数(时间戳)  不是当前时间的毫秒数 而是距离 1970年1月1日过了多少毫秒数
        // 1. 通过 valueOf()    getTime()
        var date = new Date();
        console.log(date.valueOf()); // 就是 我们现在时间 距离 1970.1.1 总的毫秒数
        console.log(date.getTime());
        // 2. 简单的写法(最常用的写法)
        var date1 = +new Date();  // +new Date() 返回的就是总的毫秒数
        console.log(date1);
        // 3. H5 新增的 获得总的毫秒数
        console.log(Date.now());
    </script>

案例：倒计时效果
做一个倒计时效果

案例分析
① 核心算法：输入的时间减去现在的时间就是剩余的时间，即倒计时，但是不能拿着时分秒相减，比如 05 分减去25分，结果会是负数的。
② 用时间戳来做。用户输入时间总的毫秒数减去现在时间的总的毫秒数，得到的就是剩余时间的毫秒数。
③ 把剩余时间总的毫秒数转换为天、时、分、秒（时间戳转换为时分秒）转换公式如下：

d = parseInt(总秒数/ 60/60 /24); // 计算天数
h = parseInt(总秒数/ 60/60 %24) // 计算小时
m = parseInt(总秒数 /60 %60 ); // 计算分数
s = parseInt(总秒数%60); // 计算当前秒数

<script>
        // 倒计时效果
        // 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('2021-07-31 12:00:00'));
        var time1 = prompt('请输入日期')
        console.log(countDown(time1));
        var date = new Date();
        console.log(date);  // 当前日期
    </script>

5. 数组对象

5.1数组对象的创建

创建数组对象的两种方式

字面量方式
new Array()

<script>
        // 创建数组的两种方式
        // 1. 利用数组字面量
        var arr = [1,2,3];
        console.log(arr[0]);

        // 2. 利用 new Array()
        // var arr1 = new Array(); // 创建了一个空的数组
        // var arr1 = new Array(2); // 这个2 表示 数组的长度为 2 里面有2 个空的数组元素
        var arr1 = new Array(2,3);  // 等价于 [2,33] 这样写表示  里面有 2 个数组元素，是 2和3
        console.log(arr1);
    </script>

5.2检测是否为数组

instanceof 运算符，可以判断一个对象是否属于某种类型
Array.isArray()用于判断一个对象是否为数组，isArray() 是 HTML5 中提供的方法

<script>
        // 翻转数组
        function reverse(arr) {
            // if (arr instanceof Array) {
            if (Array.isArray(arr)) {
                var newArr = [];
                for (var i = arr.length -1; i >= 0; i--) {
                    newArr[newArr.length] = arr[i];
                }
                return newArr;
            } else {
                return 'error 这个参数必须是数组格式 [1, 2, 3]'
            }

        }
        console.log(reverse([1,2,3]));
        console.log(reverse(1,2,3));
        // 检测是否为数组
        // (1) instanceof  运算符 它可以用来检测是否为数组
        var arr1 = [];
        var obj1 = {};
        console.log(arr1 instanceof Array);
        console.log(obj1 instanceof Array)
        // (2) Array.isArray（参数）; H5 新增的方法， ie9 以上版本支持
        var arr2 = [];
        var obj2 = {};
        console.log(Array.isArray(arr2));
        console.log(Array.isArray(obj2));
    </script>

5.3添加删除数组元素的方法

在这里插入图片描述

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

案例：筛选数组
有一个包含工资的数组[1500, 1200, 2000, 2100, 1800]，要求把数组中工资超过2000的删除，剩余的放到新数组里面

<script>
        // 有一个包含工资的数组 [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);
    </script>

5.4数组排序

在这里插入图片描述

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

5.5数组索引方法

在这里插入图片描述

<script>
        // 返回数组元素索引号方法  indexOf(数组元素)  作用就是返回改数组元素的索引号(从前面开始查找)
        // 它只返回第一个满足条件的索引号
        // 它如果在该数组里面找不到元素，则返回的是 -1
        var arr = ['red', 'green', 'blue', 'pink', 'blue'];
        console.log(arr.indexOf('blue'));  // 2
        console.log(arr.lastIndexOf('blue')); // 4 

        var arr1 = ['red', 'green', 'pink'];
        console.log(arr1.indexOf('blue')); // -1
        // 返回数组元素索引号方法 lastIndexOf(数组元素)   作用就是返回该数组元素的索引号(从后面开始查找)
        console.log(arr1.lastIndexOf('blue')); // -1
        console.log(arr.lastIndexOf('blue')); // 4
    </script>

案例：数组去重（重点案例）
有一个数组[‘c’, ‘a’, ‘z’, ‘a’, ‘x’, ‘a’, ‘x’, ‘c’, ‘b’]，要求去除数组中重复的元素。

案例分析
① 目标：把旧数组里面不重复的元素选取出来放到新数组中，重复的元素只保留一个，放到新数组中去重。
② 核心算法：我们遍历旧数组，然后拿着旧数组元素去查询新数组，如果该元素在新数组里面没有出现过，我们就添加，否则不添加。
③ 我们怎么知道该元素没有存在？利用新数组.indexOf(数组元素) 如果返回时 -1 就说明新数组里面没有改元素
旧数组[‘c’, ‘a’, ‘z’, ‘a’, ‘x’, ‘a’, ‘x’, ‘c’, ‘b’]
新数组 [ ]

<script>
        // 数组去重 ['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']);
        console.log(demo);
    </script>

5.6数组转换为字符串

在这里插入图片描述

<script>
        // 数组转换为字符串
        // 1. toString()  将我们的数组转换为字符串
        var arr = [1, 2, 3];
        console.log(arr);
        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
    </script>

5.7课下查询

在这里插入图片描述
slice() 和 splice() 目的基本相同，建议同学们重点看下 splice()

6. 字符串对象

6.1基本包装类型

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

按道理基本数据类型是没有属性和方法的，而对象才有属性和方法，但上面代码却可以执行，这是因为 js 会把基本数据类型包装为复杂数据类型，其执行过程如下：

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

6.2字符串的不可变

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

<script>
        // 字符串的不可变性
        var str = 'andy';
        console.log(str); // 'andy'
        str = 'red';
        console.log(str); // 'red'
        // 因为我们字符串的不可变所以不要大量的拼接字符串
        var str = '';
        for (var i = 1; i <= 100; i++) {
            str += i;
        }
        console.log(str);
    </script>

6.3根据字符返回位置

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

<script>
        // 字符串对象  根据字符返回位置   str.indexOf('要查找的字符',[起始的位置])
        var str = '改革春风吹满地，春天来了';
        console.log(str.indexOf('春'));  // 2
        console.log(str.lastIndexOf('春'));  // 8
        console.log(str.indexOf('春',3));  // 8  从索引号是 3 的位置开始往后查找
        console.log(str.lastIndexOf('春',5)); // 2
    </script>

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

案例：思路
查找字符串"abcoefoxyozzopp"中所有o出现的位置以及次数
① 核心算法：先查找第一个o出现的位置
② 然后只要indexOf 返回的结果不是 -1 就继续往后查找
③ 因为indexOf 只能查找到第一个，所以后面的查找，利用第二个参数，当前索引加1，从而继续查找

<script>
        // 查找字符串"oabcoefoxyozzopp"中所有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);

        // 课后作业  ['red', 'blue', 'red', 'green', 'pink', 'red'], 求 red 出现的位置和次数
        var str1 = ['red', 'blue', 'red', 'green', 'pink', 'red'];
        var index1 = str1.indexOf('red');
        var num = 0;
        while (index1 !== -1) {
            console.log(index1);
            num++;
            index1 = str1.indexOf('red', index1 + 1); 
        }
        console.log('red出现的次数为：' + num);
    </script>

6.4根据位置返回字符（重点）

在这里插入图片描述

<script>
        // 根据位置返回字符
        // 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[0]); // a
    </script>

案例：返回字符位置
判断一个字符串 ‘abcoefoxyozzopp’ 中出现次数最多的字符，并统计其次数。

案例：核心算法
判断一个字符串 ‘abcoefoxyozzopp’ 中出现次数最多的字符，并统计其次数。
① 核心算法：利用 charAt(）遍历这个字符串
② 把每个字符都存储给对象，如果对象没有该属性，就为1，如果存在了就 +1
③ 遍历对象，得到最大值和该字符
判断一个字符串 ‘abcoefoxyozzopp’ 中出现次数最多的字符，并统计其次数。对象 o { }

<script>
        // 有一个对象 来判断是否有该属性  对象['属性名']
        var o = {
            age: 18
        }
        if (o['age']) {
            console.log('里面有该属性');
        } else {
            console.log('没有该属性');
        }

        // 判断一个字符串 'abcoefoxyozzopp' 中出现次数最多的字符，并统计其次数。
        // 核心算法：利用 charAt(） 遍历这个字符串
        // 把每个字符都存储给对象， 如果对象没有该属性，就为1，如果存在了就 +1
        // 遍历对象，得到最大值和该字符
        // 判断一个字符串 'abcoefoxyozzopp' 中出现次数最多的字符，并统计其次数。对象 o { }
        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);
    </script>

6.5字符串操作方法（重点）

在这里插入图片描述

<script>
        // 字符串操作方法
        // 1. concat('字符串1', '字符串2'....)
        var str = 'andy';
        console.log(str.concat('red'));

        // 2. substr('截取的起始位置', '截取几个字符');
        var str1 = '改革春风吹满地';
        console.log(str1.substr(2,2)); // 第一个 2 是索引号的2 从第几个开始  第二个2 是取几个字符
    </script>

6.6replace()方法

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

6.7split()方法

split()方法用于切分字符串，它可以将字符串切分为数组。在切分完毕之后，返回的是一个新数组。例如下面代码：
在这里插入图片描述

<script>
        // 1. 替换字符  replace('被替换的字符', '替换为的字符')  它只会替换第一个字符
        var str = 'andyandy';
        console.log(str.replace('a','b'));
        // 有一个字符串 'abcoefoxyozzopp' 要求把里面所有的 o 替换为 *
        var str1 = 'abcoefoxyozzopp';
        while (str1.indexOf('o') !== -1) {
                str1 = str1.replace('o','*');
        }
        console.log(str1);

        // 2. 字符转换为数组 split('分隔符')  前面我们学过 join  把数组转换为字符串
        var str2 = 'red, pink, blue';
        console.log(str2.split(','));
        var str3 = 'red&pink&blue';
        console.log(str3.split('&'));
    </script>

6.8课下查阅

toUpperCase() //转换大写
toLowerCase() //转换小写

作业
给定一个字符串，如：“abaasdffggghhjjkkgfddsssss3444343”，问题如下： 1、字符串的长度
2、取出指定位置的字符，如：0,3,5,9等
3、查找指定字符是否在以上字符串中存在，如：i，c ，b等
4、替换指定的字符，如：g替换为22,ss替换为b等操作方法
5、截取指定开始位置到结束位置的字符串，如：取得1-5的字符串
6、找出以上字符串中出现次数最多的字符和出现的次数
7、遍历字符串，并将遍历出的字符两头添加符号“@”