二：第二阶段：JavaScript基础（二）

m0_59817723

已于 2024-03-15 19:39:51 修改

阅读量77

点赞数

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

于 2023-10-26 10:16:37 首次发布

本文链接：https://blog.csdn.net/m0_59817723/article/details/134048752

版权

一：JavaScript函数

1.1:目标

能够说出为什么需要函数
能够根据语法书写函数
能够根据需求封装函数
能够说出形参和实参的传递过程
能够使用函数的返回值
能够使用arguments获取函数的参数

1.2: 目录

函数的概念

函数的使用

函数的参数

函数的返回值

arguments的使用

函数案例

函数的两种声明方式

1.3: 函数的概念

在JS 里面，可能会定义非常多的相同代码或者功能相似的代码，这些代码可能需要大量重复使用。虽然for循环语句也能实现一些简单的重复操作，但是比较具有局限性，此时我们就可以使用JS 中的函数。

函数：就是封装了一段可被重复调用执行的代码块。通过此代码块可以实现大量代码的重复使用。

<!DOCTYPE html>
<html lang="en">
 
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
    <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>
</head>
 
<body>
 
</body>
 
</html>

1.4: 函数的使用

函数在使用时分为两步：声明函数和调用函数。

1: 声明函数

//声明函数

function函数名(){

//函数体代码

}

function是声明函数的关键字,必须小写

由于函数一般是为了实现某个功能才定义的，所以通常我们将函数名命名为动词，比如getSum

2: 调用函数

//调用函数

函数名(); //通过调用函数名来执行函数体代码

调用的时候千万不要忘记添加小括号

口诀：函数不调用，自己不执行。

注意：声明函数本身并不会执行代码，只有调用函数时才会执行函数体代码。

3:函数的封装

函数的封装是把一个或者多个功能通过函数的方式封装起来，对外只提供一个简单的函数接口

简单理解：封装类似于将电脑配件整合组装到机箱中( 类似快递打包）

<!DOCTYPE html>
<html lang="en">
 
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
    <script>
        // 函数使用分为两步： 声明函数 和 调用函数
        // 1. 声明函数
        // function 函数名() {
        //     // 函数体
        // }
        function sayHi() {
            console.log('hi~~');
 
        }
        // (1) function 声明函数的关键字 全部小写
        // (2) 函数是做某件事情，函数名一般是动词 sayHi 
        // (3) 函数不调用自己不执行
        // 2. 调用函数
        // 函数名();
        sayHi();
        // 调用函数的时候千万不要忘记加小括号
    </script>
</head>
 
<body>
 
</body>
 
</html>

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

/*

计算1-100之间值的函数

*/

// 声明函数

function getSum( ) {

var sumNum = 0; //准备一个变量，保存数字和

for (var i = 1; i <= 100; i++) {

sumNum += i; // 把每个数值都累加到变量中

}

alert(sumNum);

}

// 调用函数

getSum();

<!DOCTYPE html>
<html lang="en">
 
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
    <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>
</head>
 
<body>
 
</body>
 
</html>

5: pink老师提问

1. 函数是做什么的（作用）？

2. 声明函数用什么关键词？

3. 如何调用函数？

4. 封装是什么意思？

1.5：函数的参数

1:形参和实参

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

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

2: 形参和实参

//带参数的函数声明

function函数名(形参1,形参2,形参3...){ //可以定义任意多的参数，用逗号分隔

//函数体}

//带参数的函数调用

函数名(实参1,实参2,实参3...);

<!DOCTYPE html>
<html lang="en">
 
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
    <script>
        // 1. 函数可以重复相同的代码
        // function cook() {
        //     console.log('酸辣土豆丝');
 
        // }
        // cook();
        // cook();
        // 2. 我们可以利用函数的参数实现函数重复不同的代码
        // function 函数名(形参1,形参2...) { // 在声明函数的小括号里面是 形参 （形式上的参数）
 
        // }
        // 函数名(实参1,实参2...); // 在函数调用的小括号里面是实参（实际的参数）
        // 3. 形参和实参的执行过程
        function cook(aru) { // 形参是接受实参的  aru = '酸辣土豆丝' 形参类似于一个变量
            console.log(aru);
 
        }
        cook('酸辣土豆丝');
        cook('大肘子');
        // 4. 函数的参数可以有，也可以没有个数不限
    </script>
</head>
 
<body>
 
</body>
 
</html>

3:案例-利用函数求任意两个数的和

<!DOCTYPE html>
<html lang="en">
 
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
    <script>
        // 1. 利用函数求任意两个数的和
        function getSum(num1, num2) {
            console.log(num1 + num2);
 
        }
        getSum(1, 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, 100);
        getSums(1, 10);
        // 3. 注意点
        // (1) 多个参数之间用逗号隔开
        // (2) 形参可以看做是不用声明的变量
    </script>
</head>
 
<body>
 
</body>
 
</html>

4: 函数参数的传递过程

//声明函数

function getSum(num1, num2) {

console.log(num1 + num2);

}

//调用函数

getSum(1, 3); // 4

getSum(6, 5); // 11

1. 调用的时候实参值是传递给形参的

2. 形参简单理解为：不用声明的变量

3. 实参和形参的多个参数之间用逗号（,）分隔

5: 函数形参和实参个数不匹配的问题

function sum(num1, num2) {

console.log(num1 + num2);

}

sum(100, 200); //形参和实参个数相等，输出正确结果

sum(100, 400, 500, 700); //实参个数多于形参，只取到形参的个数

sum(200); //实参个数少于形参，多的形参定义为undefined，结果为NaN

注意：在JavaScript中，形参的默认值是undefined。

<!DOCTYPE html>
<html lang="en">
 
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
    <script>
        // 函数形参实参个数匹配
        function getSum(num1, num2) {
            console.log(num1 + num2);
 
        }
        // 1. 如果实参的个数和形参的个数一致 则正常输出结果
        getSum(1, 2);
        // 2. 如果实参的个数多于形参的个数  会取到形参的个数 
        getSum(1, 2, 3);
        // 3. 如果实参的个数小于形参的个数  多于的形参定义为undefined  最终的结果就是 NaN
        // 形参可以看做是不用声明的变量  num2 是一个变量但是没有接受值  结果就是undefined 
        getSum(1); // NaN
        // 建议 我们尽量让实参的个数和形参相匹配
    </script>
</head>
 
<body>
 
</body>
 
</html>

6:小结

函数可以带参数也可以不带参数声明函数的时候，函数名括号里面的是形参，形参的默认值为undefined

调用函数的时候，函数名括号里面的是实参

多个参数中间用逗号分隔

形参的个数可以和实参个数不匹配，但是结果不可预计，我们尽量要匹配

1.6:函数的返回值

1: return语句

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

//声明函数function函数名（）{

.......

return需要返回的值；}

//调用函数

函数名(); //此时调用函数就可以得到函数体内return后面的值

在使用return 语句时，函数会停止执行，并返回指定的值

如果函数没有return，返回的值是undefined

2: return语句

有的时候，我们会希望函数将值返回给调用者，此时通过使用return 语句就可以实现。例如，声明了一个sum()函数，该函数的返回值为666，其代码如下：

//声明函数function sum（）{

...return666；}

//调用函数

sum(); //此时sum的值就等于666，因为return语句会把自身后面的值返回给调用者

 
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
    <script>
        // 1.函数是做某件事或者实现某种功能
        // function cook(aru) {
        //     console.log(aru);
 
        // }
        // cook('大肘子');
        // 2. 函数的返回值格式
        // function 函数名() {
        //     return 需要返回的结果;
        // }
        // 函数名();
        // (1) 我们函数只是实现某种功能，最终的结果需要返回给函数的调用者函数名() 通过return 实现的
        // (2) 只要函数遇到return 就把后面的结果 返回给函数的调用者  函数名() = return后面的结果
        // 3. 代码验证
        function getResult() {
            return 666;
        }
        getResult(); // getResult()   = 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>
</head>
 
<body>
 
</body>

3:案例

3.1: 利用函数求任意两个数的最大值

function getMax(num1, num2) {

return num1 > num2 ? num1 : num2;

}

console.log(getMax(1, 2));

console.log(getMax(11, 2));

<!DOCTYPE html>
<html lang="en">
 
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
    <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>
</head>
 
<body>
 
</body>
 
</html>

3.2:利用函数求任意一个数组中的最大值

求数组 [5,2,99,101,67,77] 中的最大数值。

<!DOCTYPE html>
<html lang="en">
 
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
    <script>
        // 利用函数求数组 [5,2,99,101,67,77] 中的最大数值。
        function getArrMax(arr) { // arr 接受一个数组  arr =  [5,2,99,101,67,77]
            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>
</head>
 
<body>
 
</body>
 
</html>

3.3: 利用函数求任意一个数组中的最大值

//定义一个获取数组中最大数的函数

function getMaxFromArr(numArray){

var maxNum = 0;

for(var i =0;i < numArray.length;i++) {

if(numArray[i] > maxNum) {

maxNum = numArray[i];

}

}

return maxNum;

}

var arrNum = [5,2,99,101,67,77];

var maxN = getMaxFromArr(arrNum); //这个实参是个数组

alert('最大值为：'+ maxN);

//
定义一个获取数组中最大数的函数
function getMaxFromArr(numArray)
{
var maxNum = 0;
for(var i =0;i < numArray.length;i++)
{
if(numArray[i] > maxNum)
{
maxNum = numArray[i]
;
}
}
return maxNum;
}
var arrNum = [5,2,99,101,67,77]
;
var maxN = getMaxFromArr(arrNum)
;
//
这个实参是个数组
alert('
最大值为：
'
+ maxN)
;

4: return终止函数

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

function add(num1，num2){

//函数体

return num1 + num2; //注意：return后的代码不执行

alert('我不会被执行，因为前面有return');

}

var resNum = add(21,6); //调用函数，传入两个实参，并通过resNum接收函数返回值 alert(resNum);// 27

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

function add(num1，num2){

//函数体

return num1，num2;

}

var resNum = add(21,6); //调用函数，传入两个实参，并通过resNum接收函数返回值alert(resNum) ; // 6

-函数返回值注意....项.html - 代码阅读
<!DOCTYPE html>
<html lang="en">
 
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
    <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 fun1() {
            return 666;
        }
        console.log(fun1()); // 返回 666
        function fun2() {
 
        }
        console.log(fun2()); // 函数返回的结果是 undefined
    </script>
</head>
 
<body>
 
</body>
 
</html>

4.3: 案例；创建一个函数，实现两个数之间的加减乘除运算，并将结果返回

var a = parseFloat (prompt ('请输入第一个数'));

var b = parseFloat(prompt ('请输入第二个数'));

function count(a, b) {

var arr = [a + b, a -b, a * b, a / b];

return arr;

}

var result = count(a, b);

console.log(result);

5:函数没有return 返回 undefined

函数都是有返回值的

1.如果有return 则返回return 后面的值

2.如果没有return 则返回undefined

6:break ,continue ,return 的区别

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

7:通过榨汁机看透函数

1.7:arguments的使用

1: 了解

当我们不确定有多少个参数传递的时候，可以用arguments来获取。在JavaScript中，arguments 实际上它是当前函数的一个内置对象。所有函数都内置了一个arguments对象，arguments对象中存储了传递的所有实参。

arguments展示形式是一个伪数组，因此可以进行遍历。伪数组具有以下特点：

具有length属性

按索引方式储存数据

不具有数组的push,pop等方法

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        //arguments 的使用  只有函数才有arguments对象  而且是每个函数都内置好了这个arguments
        function fc(){
            console.log(arguments); //里面存储了所有传递过来的实参
            console.log(arguments.length);
            console.log(arguments[2]);  //取第三个值

            //可以按照数组的方式遍历arguments
            for(var i = 0; i < arguments.length;i++){
                console.log(arguments[i]);
            }

        }
        fc(1,2,3);
        //伪数组  并不是真正意义上的数组
        //1: 具有数组的length属性
        //2: 按照索引的方式进行存取的
        //3; 它没有真正数组的一些方法 pop() push()等等
    </script>
</head>
<body>
    
</body>
</html>

1.8:案例

1: 利用函数求任意个数的最大值

function maxValue() {

var max = arguments[0] ；

for (var i = 0; i < arguments.length; i++) {

if (max < arguments[i]) {

max = arguments[i]；

}

}

return max;

}

console.log(maxValue(2, 4, 5, 9)）；

console.log(maxValue(12, 4, 9)）；

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        //利用函数求任意个数的最大值
        function getMax() {
            var max = arguments[0];
            for (var i = 1; i <= arguments.length; i++) {
                if (arguments[i] > max) {
                    max = arguments[1];
                }
            }
            return max;

        }
        console.log(1, 2, 3);
        console.log(1, 2, 3, 4, 5, 6);
        console.log(11, 2, 34, 444, 5, 100);
    </script>
</head>

<body>

</body>

</html>

2: 利用函数封装方法，翻转任意一个数组

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

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        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, 2, 3, 5, 6, 7, 8]);
        console.log(arr1);

        var arr2 = reverse(['red', 'pink', 'blue']);
        console.log(arr2);
    </script>
</head>

<body>

</body>

</html>

3:冒泡排序

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

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        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, 2, 10, 8]);
        console.log(arr1);
        var arr2 = sort([11, 7, 111]);
        console.log(arr2);
    </script>
</head>

<body>

</body>

</html>

4: 判断闰年

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

function isRun(year) {var flag = false;if (year % 4 === 0 && year % 100 !== 0 ||year % 400 === 0) {flag = true;}return flag;}console.log(isRun(2010));console.log(isRun(2012));

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        function isRunYear(year) {
            var flag = false;
            if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {
                flag = true;
            }
            return flag;
        }
        console.log(isRunYear(2000));
    </script>
</head>

<body>

</body>

</html>

5: 函数是可以调用另外一个函数

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

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        //函数是可以相互调用
        function fn1() {
            console.log(11);

            //调用fn2
            fn2();
        }
        fn1();

        function fn2() {
            console.log(22);
        }
    </script>
</head>

<body>

</body>

</html>

5.1:案例：用户输入年份，输出当前年份2月份的天数

如果是闰年，则2月份是29天，如果是平年，则2月份是28天

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        //1: 用户输入年份，输出当前年份2月份的天数
        function backDay() {
            var getYear = prompt('请您输入年份');
            //调用封装的函数
            if (isRunYear(getYear)) {
                alert('当前年份是闰年2月份有29天');
            } else {
                alert('当前年份是平年2月份有28天');
            }
        }
        backDay();

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

        isRunYear();
    </script>
</head>

<body>

</body>

</html>c

1.9:函数中的声明方式

1. 自定义函数方式(命名函数)

利用函数关键字function 自定义函数方式。

//声明定义方式

function fn() {...}

//调用

fn();

因为有名字，所以也被称为命名函数

调用函数的代码既可以放到声明函数的前面，也可以放在声明函数的后面

2: 函数表达式方式(匿名函数）

利用函数表达式方式的写法如下：

//这是函数表达式写法，匿名函数后面跟分号结束

var fn = function(){...}；

//调用的方式，函数调用必须写到函数体下面

fn();

因为函数没有名字，所以也被称为匿名函数

这个fn 里面存储的是一个函数

函数表达式方式原理跟声明变量方式是一致的

函数调用的代码必须写到函数体后面

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        //函数的2种声明方式
        //1:利用函数关键字自定义函数（命名函数）
        function fn(){

        }
        fn();

        //2: 函数表达式（匿名函数）
        var fun = function(aru){
            console.log('我是函数表达式');
            console.log(aru);
        }
        fun('pink老师');
        //(1):fun 是变量名，不是函数名
        //(2): 函数表达式声明方式跟声明变量名差不多，只不过变量里面存的是值 而 函数表达式里面存的是函数
        //(3): 函数表达式也可以进行传递参数
    </script>
</head>
<body>
    
</body>
</html>

二：JavaScript作用域

2.1: 目标

能够说出JS的两种作用域
能够区分全局变量和局部变量
能够说出如何在作用域链中查找变量的值

2.2: 目录

作用域
变量的作用域
作用域链

2.3:作用域

1: 作用域概述

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

JavaScript（es6前）中的作用域有两种：

全局作用域

局部作用域（函数作用域）

2: 全局作用域

作用于所有代码执行的环境(整个script标签内部)或者一个独立的js文件。

3:局部作用域

作用于函数内的代码环境，就是局部作用域。因为跟函数有关系，所以也称为函数作用域。

<!DOCTYPE html>
<html lang="en">
 
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
    <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>
</head>
 
<body>
 
</body>

2.4:变量作用域

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

全局变量

局部变量

1:全局变量

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

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

2: 局部变量

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

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

3:全局变量和局部变量的区别

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

<!DOCTYPE html>
<html lang="en">
 
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
    <script>
        // 变量的作用域： 根据作用域的不同我们变量分为全局变量和局部变量
        // 1. 全局变量： 在全局作用域下的变量 在全局下都可以使用
        // 注意 如果在函数内部 没有声明直接赋值的变量也属于全局变量
        var num = 10; // num就是一个全局变量
        console.log(num);
 
        function fn() {
            console.log(num);
 
        }
        fn();
        // console.log(aru);
 
        // 2. 局部变量   在局部作用域下的变量   后者在函数内部的变量就是 局部变量
        // 注意： 函数的形参也可以看做是局部变量
        function fun(aru) {
            var num1 = 10; // num1就是局部变量 只能在函数内部使用
            num2 = 20;
        }
        fun();
        // console.log(num1);
        // console.log(num2);
        // 3. 从执行效率来看全局变量和局部变量
        // (1) 全局变量只有浏览器关闭的时候才会销毁，比较占内存资源
        // (2) 局部变量 当我们程序执行完毕就会销毁， 比较节约内存资源
    </script>
</head>
 
<body>
 
</body>
 
</html>

4:js块级作用域

块作用域由{ }包括。

在其他编程语言中（如java、c#等），在if语句、循环语句中创建的变量，仅仅只能在本if语句、本循环语句中使用，如下面的Java代码：

java有块级作用域：

if(true){

int num=123;

system.out.print(num); //123

}

system.out.print(num); //报错

以上java代码会报错，是因为代码中{ }即一块作用域，其中声明的变量num，在“{ }”之外不能使用；而与之类似的JavaScript代码，则不会报错：

Js中没有块级作用域（在ES6之前）

if(true){

var num=123;

console.log(123); //123

}

console.log(123); //123

2.5:作用域链

只要是代码都一个作用域中，写在函数内部的局部作用域，未写在任何函数内部即在全局作用域中；如果函数中还有函数，那么在这个作用域中就又可以诞生一个作用域；根据在**[内部函数可以访问外部函数变量]**的这种机制，用链式查找决定哪些数据能被内部函数访问，就称作作用域链。

<!DOCTYPE html>
<html lang="en">
 
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
    <script>
        // 作用域链  ： 内部函数访问外部函数的变量，采取的是链式查找的方式来决定取那个值 这种结构我们称为作用域链   就近原则
        var num = 10;
 
        function fn() { // 外部函数
            var num = 20;
 
            function fun() { // 内部函数
                console.log(num);
 
            }
            fun();
        }
        fn();
    </script>
</head>
 
<body>
 
</body>
 
</html>

1:案例

function f1() {

var num=123;

function f2() {

console.log(num);

}

f2();

}

var num=456;

f1();

作用域链：采取就近原则的方式来查找变量最终的值。

vara=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();

三：JS预解析

3.1: 目标

能够知道解析器运行JS分为哪两步
能够说出变量提升的步骤和运行过程
能够说出函数提示的步骤和运行过程

3.2；目录

预解析
变量预解析和函数预解析
预解析案例

3.3:预解析

1:预解析的相关概念

JavaScript代码是由浏览器中的JavaScript解析器来执行的。JavaScript解析器在运行JavaScript代码的时候分为两步：预解析和代码执行。

预解析：在当前作用域下,JS代码执行之前，浏览器会默认把带有var和function声明的变量在内存中进行提前声明或者定义。

代码执行：从上到下执行JS语句。

预解析会把变量和函数的声明在代码执行之前执行完成。

2: 变量预解析

预解析也叫做变量、函数提升。变量提升（变量预解析）：变量的声明会被提升到当前作用域的最上面，变量的赋值不会提升。

console.log(num); // 结果是多少？

var num=10;//？

结果：undefined

注意：** 变量提升只提升声明，不提升赋值 **

3:函数预解析

函数提升：函数的声明会被提升到当前作用域的最上面，但是不会调用函数。

fn();functionfn(){

console.log('打印');

}

结果：控制台打印字符串---”打印“

注意：函数声明代表函数整体，所以函数提升后，函数名代表整个函数，但是函数并没有被调用！

4: 函数表达式声明函数问题

函数表达式创建函数，会执行变量提升，此时接收函数的变量名无法正确的调用：

fn();varfn=functio。(){。

console.log('想不到吧');

}

结果：报错提示”fnisnotafunction"

解释：该段代码执行之前，会做变量声明提升，fn在提升之后的值是undefined；而fn调用是在fn被赋值为函数体之前，此时fn的值是undefined，所以无法正确调用

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

5: 案例

<!DOCTYPE html>
<html lang="en">
 
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
    <script>
        // 预解析案例
        // 案例1
        // var num = 10;
        // fun();
 
        // function fun() {
        //     console.log(num);
        //     var num = 20;
        // }
        // // 相当于执行了以下操作
        // // var num;
 
        // // function fun() {
        // //     var num;
        // //     console.log(num);
        // //     num = 20;
        // // }
        // // num = 10;
        // // fun();
        // // 案例2
        // var num = 10;
 
        // function fn() {
        //     console.log(num);
        //     var num = 20;
        //     console.log(num);
        // }
        // fn();
        // // 相当于以下代码
        // // var num;
 
        // // function fn() {
        // //     var num;
        // //     console.log(num);
        // //     num = 20;
        // //     console.log(num);
        // // }
        // // num = 10;
        // // fn();
        // // 案例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);
        //     console.log(b);
        //     a = '123';
        // }
        // a = 18;
        // f1();
        // 案例4
        f1();
        console.log(c);
        console.log(b);
        console.log(a);
 
        function f1() {
            var a = b = c = 9;
            console.log(a);
            console.log(b);
            console.log(c);
        }
        // 以下代码
        // function f1() {
        //     var a;
        //     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);
        // }
        // f1();
        // console.log(c);
        // console.log(b);
        // console.log(a);
    </script>
</head>
 
<body>
 
</body>
 
</html>

四：JavaScript对象

4.1: 目标

能够说出为什么需要对象
能够使用字面量创建对象
能够使用构造函数创建对象
能够说出new的执行过程
能够遍历对象

4.2：目录

对象

创建对象的三种方法

new关键字

遍历对象属性

4.3: 对象

1:什么是对象？

在JavaScript中，对象是一组无序的相关属性和方法的集合，所有的事物都是对象，例如字符串、数值、数组、函数等。对象是由属性和方法组成的。

属性：事物的特征，在对象中用属性来表示（常用名词）。

方法：事物的行为，在对象中用方法来表示（常用动词）。

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

比如：明星（不是具体的，所以不是对象），周星驰（是一个具体的，所以是对象）！

2:为什么需要对象？

保存一个值时，可以使用变量，保存多个值（一组值）时，可以使用数组。如果要保存一个人的完整信息呢？例如，将“张三疯”的个人的信息保存在数组中的方式为：

vararr=[‘张三疯’,‘男',128,154];

数组里面存放的是值，而不知道值的含义是什么；比如：名字是什么，年龄是多少。。

上述例子中用数组保存数据的缺点是：数据只能通过索引值访问，开发者需要清晰的清除所有的数据的排行才能准确地获取数据，而当数据量庞大时，不可能做到记忆所有数据的索引值。为了让更好地存储一组数据，对象应运而生：对象中为每项数据设置了属性名称，可以访问数据更语义化，数据结构清晰，表意明显，方便开发者使用。

JS中的对象表达结构更清晰，更强大。张三疯的个人信息在对象中的表达结构如下：

张三峰，姓名 = ‘张三峰’； person.name = '张三峰'；

张三峰，性别 = ‘男’； person.sex = '男';

张三峰，年龄 = '128’; person.age = 128;

张三·峰，身高 = 158； person.height = 154;

4.4: 创建对象的三种方式

在JS中，🧵阶段我们可以采用三种方式创建对象（object)

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

1:利用字面量创建对象

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

{ }里面采取键值对的形式表示。

键：相当于属性名

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

1.1: 对象的使用

对象的属性

对象中存储具体数据的"键值对"中的"键"称为对象的属性，即对象中存储具体数据的项

对象的方法

对象中存储函数的"键值对"中的"键"称为对象的方法，即对象中存储函数的项

访问对象的属性

对象里面的属性调用:对象.属性名，这个小点.就理解为“的”

对象里面属性的另一种调用方式:对象[‘属性名’]，注意方括号里面的属性必须加引号

示例代码如下：

console.log(star.name) //调用名字属性

console.log(star['name']) //调用名字属性

调用对象的方法

对象里面的方法调用：对象.方法名()，注意这个方法名字后面一定加括号示例代码如下：

star.sayHi(); //调用sayHi方法, 注意，一定不要忘记带后面的括号

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        //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>
</head>

<body>

</body>

</html>

1.2: 变量、属性、函数、方法总结

属性是对象的一部分，而变量不是对象的一部分，变量是单独存储数据的容器

变量：单独声明赋值，单独存在

属性：对象里面的变量称为属性，不需要声明，用来描述该对象的特征

方法是对象的一部分，函数不是对象的一部分，函数是单独封装操作的容器

-函数：单独存在的，通过“函数名()”的方式就可以调用

-方法：对象里面的函数称为方法，方法不需要声明，使用“对象.方法名()”的方式就可以调用，方法用来描述该对象的行为和功能。

<!DOCTYPE html>
<html lang="en">
 
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
    <script>
        // 变量、属性、函数、方法的区别
        // 1.变量和属性的相同点 他们都是用来存储数据的 
        var num = 10;
        var obj = {
            age: 18,
            fn: function() {
 
            }
        }
 
        function fn() {
 
        }
        console.log(obj.age);
        // console.log(age);
 
        // 变量 单独声明并赋值  使用的时候直接写变量名 单独存在
        // 属性 在对象里面的不需要声明的 使用的时候必须是 对象.属性
        // 2. 函数和方法的相同点 都是实现某种功能  做某件事
        // 函数是单独声明 并且调用的 函数名() 单独存在的
        // 方法 在对象里面 调用的时候 对象.方法()
    </script>
</head>
 
<body>
 
</body>
 
</html>

2：利用new Object创建对象

2.1：创建空对象

var andy=new Obect ( );

通过内置构造函数Object创建对象，此时andy变量已经保存了创建出来的空对象

2.2:给空对象添加属性和方法

通过对象操作属性和方法的方式，来为对象增加属性和方法

示例代码如下：

andy.name='pink';

andy.age=18;

andy.sex='男';

andy.sayHi=function ( ) {

alert('大家好啊~');

}

注意：Object()：第一个字母大写

new Object()：需要new关键字

使用的格式：对象.属性=值

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <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>
</head>

<body>

</body>

</html>

3: 利用构造函数创建对象

3.1:为什么要使用函数？

YPE html>
<html lang="en">
 
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
    <script>
        // 我们为什么需要使用构造函数
        // 就是因我们前面两种创建对象的方式一次只能创建一个对象
        var ldh = {
            uname: '刘德华',
            age: 55,
            sing: function() {
                console.log('冰雨');
 
            }
        }
        var zxy = {
                uname: '张学友',
                age: 58,
                sing: function() {
                    console.log('李香兰');
 
                }
            }
            // 因为我们一次创建一个对象，里面很多的属性和方法是大量相同的 我们只能复制 
            // 因此我们可以利用函数的方法 重复这些相同的代码 我们就把这个函数称为 构造函数
            // 又因为这个函数不一样，里面封装的不是普通代码，而是 对象  
            // 构造函数 就是把我们对象里面一些相同的属性和方法抽象出来封装到函数里面
    </script>
</head>
 
<body>
 
</body>
 
</html>

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

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>

        //1:利用构造函数创建对象
        //我们需要创建四大天王的对象  相同的属性: 名字  年龄  性别  相同的方法:  唱歌
        //构造函数的语法格式
        // function 构造函数名() {
        //     this.属性 = 值;
        //     this.方法 = function () { }
        // }
        //new 构造函数名();


        //2: 
        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, '男');
        ldh.sing('冰雨');
        console.log(typeof ldh); //查看类型是对象
        console.log(ldh.name);

        var zxy = new Star('张学友', 19, '男');
        console.log(zxy.name);
         zxy.sing('李香兰');

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

<body>

</body>

</html>

4:构造函数和对象

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

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        //1:构造函数  明星  泛指的某一大类  它类似于  java  语言里面的 类（class)
        function Star(){
            this.name ;
            this.age;
            this.sex;
        }
        //2:对象  特指 是一个具体的事物  刘德华 == {name: '刘德华'，age : 18 , sex = ‘男‘， sing: f}
        var ldh = new Star('刘德华',25,'男');
        console.log(ldh);

        //3:利用构造函数创建对象的过程也称为对象的实例化


    </script>
</head>
<body>
    
</body>
</html>

4.5: new关键字

1.在构造函数代码开始执行之前，创建一个空对象；

2.修改this的指向，把this指向创建出来的空对象；

3.执行函数的代码

4.在函数完成之后，返回this---即创建出来的对象

YPE html>
<html lang="en">
 
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
    <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>
</head>
 
<body>
 
</body>
 
</html>

4.6: 遍历对象

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

for(变量in对象名字) { //在此执行代码}

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

for(var k in obj) {

console.log(k); //这里的k是属性名

console.log(obj[k]); //这里的obj[k]是属性值}

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        var obj = {
            name : 'pink',
            age : 18,
            sex : '男',
            fn : function(){

            }
        }

        // console.log(obj.name);
        // console.log(obj.sex);
        // for in 遍历我们的对象
        // for (变量 in 对象){

        // }

        for(var k in obj){
            // k变量  输出  得到的是  属性名
            console.log(k);

            //obj[k] 得到是 属性值
            console.log(obj[k]);
        }
    </script>
</head>
<body>
    
</body>
</html>

4.7:小结

1:对象可以让代码结构更清晰

2:对象复杂数据类型object

3:本质：对象就是一组无序的相关属性和方法的集合

4:构造函数泛指一个事物，比如这个苹果，正在讲课的老师等

5:构造函数泛指某一大类，比如苹果，不管是红色苹果还是绿色苹果，都统称为苹果

6：for...in 语句用于对对象的属性进行循环操作

五：内置对象

1.1:目标：

能够说出什么是内置对象

能够根据文档查询指定API的使用方法

能够使用Math对象的常用方法

能够使用Date对象的常用方法

能够使用Array对象的常用方法

能够使用String对象的常用方法

1.2:目录

内置对象

查文档

Math对象

日期对象

数组对象

字符串对象

1.3:内置对象

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

1.4:查文档

1:MDN

学习一个内置对象的使用，只要学会其常用成员的使用即可，我们可以通过查文档学习，可以通过MDN/W3C来查询。

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

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

2：如何学习对象中的方法

1: 查阅该方法的功能(干什么的）

2: 查看里面参数的意义和类型

3: 查看返回值的意义和类型

4: 通过demo进行测试

1.5: Math对象

1:概述

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

Math.PI //圆周率

Math.floor() //向下取整

Math.ceil() //向上取整

Math.round() //四舍五入版就近取整注意-3.5结果是-3

Math.abs() //绝对值

Math.max() / Math.min() //求最大和最小值

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

2：代码展示

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        //Math数学对象  不是一个构造函数，所以我们就不需要new来调用  而是直接使用里面的属性和方法即可
        console.log(Math.PI);  //一个属性  圆周率
        console.log(Math.max(1, 99, 79));  //99
        console.log(Math.max(-1, -10)); //-1
        console.log(Math.max(1, 99)); //99
        console.log(Math.max(1, 99, 'pink老师')); //NaN
        console.log(Math.max());  //-INFINITY

    </script>
</head>

<body>

</body>

</html>C

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        //1:绝对值方法
        console.log(Math.abs(1));  //1
        console.log(Math.abs(-1)); //1 
        console.log(Math.abs('-1'));  //1
        console.log(Math.abs('pink'));   //NaN

        //2:三个取整方法
        //(1): Math.floor ()  地板 向下取整   往最小了取值
        console.log(Math.floor(1.1));  //1
        console.log(Math.floor(1.9));  //1

        //(2):Math.ceil()  ceil 天花板 向上取整  往最大了取值
        console.log(Math.ceil(1.1));   //2
        console.log(Math.ceil(1.9));   //2

        //(3): 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>
</head>

<body>

</body>

</html>

3:案例

3.1: 封装自己的数学对象

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

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>

    <script>
        //利用对象封装自己的数学对象  里面有PI 最大值和最小值
        var obj = {
            PI: 3.1415926,
            //最大值
            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(obj.PI);
        console.log(obj.max(1, 3, 9));
        console.log(obj.min(1, 3, 9));
    </script>
</head>

<body>

</body>

</html>

4: 随机数方法random( )

看文档

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <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;
        }
        var ra = getRandom(1, 10);
        console.log(ra);

        //5: 随机点名
        var arr = ['张三', '张三疯', '王五', '李思思'];
        // console.log(arr[0]);
        console.log(arr[getRandom(0, arr.length - 1)]);

    </script>
</head>

<body>

</body>

</html>

2：案例

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        //猜数字游戏
        //案例1:
        //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; //退出整个循环结束程序，不然就是死循环
            }
        }

        //案例2:要求用户猜1～50之间的一个数字  但是只有10次猜的机会
        function getRandom(min, max) {
            return Math.floor(Math.random() * (max - min + 1)) + min;
        }
        var random = getRandom(1, 50);

        for (var i = 1; i <= 10; i++) {
            var num = prompt('你来猜?请输入1～10之间的一个数字');
            if (num > random) {
                alert('你猜大了');

            } else if (num < random) {
                alert('你猜小了');
            } else {
                alert('你很厉害，猜对了');
                break; //退出整个循环结束程序，不然就是死循环
            }

        }


    </script>
</head>

<body>

</body>

</html>

1.6: 日期对象

1:Date 概述

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

2 : Date( )方法的使用

2.1；获取当前时间必须实例化

var now = new Date();

console.log(now);

2.2: Date()构造函数的参数

如果括号里面有时间，就返回参数里面的时间。例如日期格式字符串为‘2019-5-1’，可以写成new Date('2019-5-1')或者new Date('2019/5/1')---这个不准，会大一个月。

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

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        //date()日期对象 是一个构造函数  必须是要new 来调用创建我们的日期对象
        var arr = new Array();  //创建一个数组对象
        var obj = new Object();  //创建一个对象实例

        //1:使用date  如果没有参数  返回当前系统的当前时间
        var date = new Date();
        console.log(date);

        //2:参数常用的写法  数字型  2019，10，01 或者是 字符串型'2019-10-1  8:8:8'
        var date1 = new Date(2019, 10, 1);
        console.log(date1);  //返回的是11月 而不是 10月

        var date2 = new Date('2019-10-1 8:8:8');
        console.log(date2);
    </script>
</head>

<body>

</body>

</html>

3: 日期格式化

我们想要2019-8-8 8:8:8格式的日期，要怎么办？

需要获取日期指定的部分，所以我们要手动的得到这种格式。

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        //格式化日期  年 月 日
        var date = new Date();
        console.log(date.getFullYear());  //返回当前日期的年 2023
        console.log(date.getMonth() + 1);  //月份  返回的月份小1个月  记得月份+1
        console.log(date.getDate()); //返回的是 几号
        console.log(date.getDay());  //3  周一返回的是 1  周六返回的是  6 但是  周日返回的是 0

        //我们写一个 2019年 5月1日  星期三
        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]);
    </script>
</head>

<body>

</body>

</html>

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        //格式化 时分秒
        var date = new Date();
        console.log(date.getHours()); //时
        console.log(date.getMinutes());  //秒
        console.log(date.getSeconds());  //分

        //要求封装一个函数返回当前的时分秒  格式 08:08:08
        function getTime() {
            var date = new Date();
            var h = date.getHours();
            //当是个位数的时候，就补零
            h = h < 10 ? '0' + h : h;
            var m = date.getMinutes();
            m = m < 10 ? '0' + m : m;
            var s = date.getSeconds();
            s = s < 10 ? '0' + s : s;

            return h + ':' + m + ':' + s;

        }
        var tm = getTime();
        console.log(tm);

    </script>
</head>

<body>

</body>

</html>

4: 获取日期的总的毫秒形式

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <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>
</head>

<body>

</body>

</html>

4.1；案例--倒计时效果

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <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('2023-10-28 18:00:00'));

        var date = new Date();
        console.log(date);
    </script>
</head>

<body>

</body>

</html>

1.7: 数组对象

1: 数组对象的创建

创建数组对象的两种方式：

字面量方式
new Array( )

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <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，3】 这样写表示  里面有2个数组元素 是 2 和 3
        console.log(arr1);
    </script>
</head>

<body>

</body>

</html>

2: 检测是否为数组

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

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        //翻转数组
        function reverse(arry) {
            //判断是否为数组
            if (arry instanceof Array) {
                //定义新数组
                var newArr = [];
                for (var i = arry.length - 1; i >= 0; i--) {
                    newArr[newArr.length] = arry[i];
                }
                return newArr;
            } else {
                return 'error 这个参数要求必须是数组格式[1,2,3]'
            }
        }
        // var re = reverse([1, 2, 3]);
        var re = reverse((1, 2, 3));
        console.log(re);

        // 2: 检测是否为数组
        //（1）：instanceof  运算符  它可以用来检测是否为数组
        var arr = [];  //数组
        var obj = {};  //对象
        console.log(arr instanceof Array);  //true
        console.log(obj instanceof Array);  //false

        //(2):Array.isArray(参数)； H5新增的方法  ie9以上版本支持
        console.log(Array.isArray(arr));
        console.log(Array.isArray(obj));
    </script>
</head>

<body>

</body>

</html>

3: 添加删除数组元素的方法

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <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（）参数直接写  数组元素就可以了
        //(3): push完毕之后，返回的结果是 新数组的长度
        //(4): 原数组也会发生变化

        //2: unshif 在数组的开头  添加一个或者多个数组元素
        console.log(arr.unshift('red', 'purple'));

        console.log(arr);
        //(1): unshift 是可以给数组前面追加新的元素
        //(2): unshif () 参数直接写到  新数组的长度
        //(3): unshif 完毕之后，返回的结果是  新数组的长度
        //(4): 原数组也会发生变化

        //3: pop()它可以删除数组的最后一个元素
        console.log(arr.pop());
        console.log(arr);
        //(1): pop 是可以删除数组的最后一个元素  记住一次只能删除一个元素
        //(2): pop() 没有参数
        //(3): pop完毕之后，返回的结果是 删除的那个元素
        //(4): 原数组也会发生变化

        //4: shift() 它可以删除数组的第一个元素
        console.log(arr.shift());
        console.log(arr);
        // (1):shift 是可以删除数组的第一个元素 记住 一次只能删除一个元素
        //(2): shift() 没有参数
        //(3): shift 完毕之后，返回的结果是 删除的那个元素
        //(4): 原数组也会发生变化


    </script>
</head>

<body>

</body>

</html>

4:案例

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        //有一个包含工资的数组[1500，1200，2000，2100，1800]，要求把数组中工资超过2000的删除，剩余的放到新数组里面
        var newArry = [];
        var arr = [1500, 1200, 2000, 2100, 1800];

        for (var i = 0; i <= arr.length; i++) {
            if (arr[i] < 2000) {
                // newArry[newArry.length] = arr[i];
                newArry.push(arr[i]);
            }
        }
        console.log(newArry);


    </script>
</head>

<body>

</body>

</html>

5: 数组排序

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        //数组排序
        //1；翻转数组
        var arr = ['pink', 'red', 'blue'];
        arr.reverse();
        console.log(arr);

        //2: 数组排序（冒泡排序）
        var arr1 = [13, 5, 7, 77, 8];
        arr1.sort(function (a, b) {
            // return a - b; //升序的顺序排列
            return b - a; //降序的顺序排列
        });
        console.log(arr1);

    </script>
</head>

<body>

</body>

</html>

6: 数组索引方法

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>

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

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

<body>

</body>

</html>

7: 重点案例

分析：

①目标：把旧数组里面不重复的元素选取出来放到新数组中，重复的元素只保留一个，放到新数组中去重。

②核心算法：我们遍历旧数组，然后拿着旧数组元素去查询新数组，如果该元素在新数组里面没有出现过，我们就添加，否则不添加。

③我们怎么知道该元素没有存在？利用新数组.indexOf(数组元素)如果返回时-1 就说明新数组里面没有改元素旧数组[‘c’,‘a’,‘z’,‘a’,‘x’,‘a’,‘x’,‘c’,‘b’]新数组[

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        //1:数组去重['c','a','z','a','x','a','x','c','b']要求去除数组中重复的元素
        //2:目标： 把旧数组里面不重复的元素选取出来放在新数组中，重复的元素只保留一个，放在新数组中去重。
        //3:核心算法：我们遍历旧数组，然后拿着旧数组元素去查询新数组，如果该元素在新数组里面没有出现过，
        //            我们就添加，否则不添加
        //4: 我们怎么知道该元素没有存在？ 利用  新数组.indexof(数组元素) 如果返回 -1 就说明  新数组里面没有改元素
        //5: 封装一个 去重的函数  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 un = unique([1, 2, 2, 5, 6, 7, 8, 8, 9]);
        console.log(un);
    </script>
</head>

<body>

</body>

</html>

8: 数组转换为字符串

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        //数组转换为字符串
        //1: toString() 将我们的数组转换为字符串
        var arr = [1, 2, 3];
        console.log(arr.toString());

        //2:join(分隔符)
        var arr1 = ['green', 'blue', 'green'];
        console.log(arr1.join());    //green,blue,green
        console.log(arr1.join('-'));  //green-blue-green
        console.log(arr1.join('&'));  //green&blue&green
    </script>
</head>

<body>

</body>

</html>

9: 课下查询

看文档

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        //1: concat()连接两个或多个数组  不影响原数组  返回一个新的数组
        // var arr1 = [1, 2, 3];
        // var arr2 = ['a', 'b', 'c'];
        // var arr3 = arr1.concat(arr2);
        // console.log(arr3);  //[1, 2, 3,'a', 'b', 'c']

        //2: slice() 数组截取slice(begin, end) 返回被截取项目的新数组，从下标0开始
        var a = [1, 2, 3, 4, 5, 6];
        //2.1://从下标1开始到最后的数
        var b = a.slice(1);   //[2,3,4,5,6]
        // console.log(b);

        //2.2: 包括start参数,end参数是不包括的
        var c = a.slice(1, 2);  //[2]
        var c = a.slice(1, 3);  //[2,3]
        // console.log(c);

        //2.3: 参数是负数，则是从右到左数,下标就是从1开始
        var d = a.slice(-1);  //[6]
        // console.log(d);

        var e = a.slice(-2); //[5,6]
        // console.log(e);



        //3:splice(参数一，参数二，参数三) 数组删除splice(第几个开始，要删除个数)  返回被删除项目的新数组，会影响原数组
        //参数一：表示下标； 参数二：表示删除元素的个数； 参数三：表示添加的元素

        //3.1: 移除索引 2 之前的 0（零）个元素，并插入“drum”
        var myFish = ['angel', 'clown', 'mandarin', 'sturgeon'];
        var mf = myFish.splice(2, 1, 'drum'); //返回被删除的元素
        console.log(mf);
        console.log(myFish);   //返回删除，添加元素后的新数组 ['angel', 'clown', 'drum', 'sturgeon']

        //3.2:移除索引 2 之前的 0（零）个元素，并插入“drum”和“guitar”
        var f = ["angel", "clown", "mandarin", "sturgeon"];
        var f1 = f.splice(2, 0, 'drum', 'sturgeon');
        console.log(f1);
        console.log(f);  //['angel', 'clown', 'drum', 'sturgeon', 'mandarin', 'sturgeon']

        //3.3:在索引 3 处移除 1 个元素
        var g = ["angel", "clown", "drum", "mandarin", "sturgeon"];
        var g1 = g.splice(3, 1);  //返回mandarin
        console.log(g1);
        console.log(g);  //['angel', 'clown', 'drum', 'sturgeon']

        //3.4:从索引 -2 处移除 1 个元素(负数是从后往前数)
        var h = ["angel", "clown", "mandarin", "sturgeon"];
        var h1 = h.splice(-2, 1);
        console.log(h1);   //mandarin
        console.log(h);    //['angel', 'clown', 'sturgeon']

        //3.5:从索引 2 开始删除所有元素
        var i = ["angel", "clown", "mandarin", "sturgeon"];
        var i1 = i.splice(2);
        console.log(i1);  //['mandarin', 'sturgeon']
        console.log(i);   //['angel', 'clown']


    </script>
</head>

<body>

</body>

</html>

1.8: 字符串对象

1: 基本包装类型

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

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

// 下面代码有什么问题？

var str = 'andy' ;

console.log(str.length);

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

// 1. 生成临时变量，把简单类型包装为复杂数据类型

var temp = new String('andy');

// 2. 赋值给我们声明的字符变量

str = temp;

// 3. 销毁临时变量

temp = null;

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        //基本包装类型
        var str = 'andy';
        console.log(str.length);  //4

        // 对象 才有  属性和方法  复杂数据类型才有  属性和方法
        // 基本数据类型为什么会有length 属性呢？
        // 基本包装类型： 就是把简单数据类型  包装成为了 复杂数据类型
        //(1): 把简单数据类型包装为复杂数据类型
        var temp = new String('andy');

        //(2):把临时变量的值  给 str
        str = temp;

        //(3):销毁这个临时变量
        temp = null;
    </script>
</head>

<body>

</body>

</html>

2: 字符串的不可变

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

var str = 'abc';

str = 'hello';

//当重新给str赋值的时候，常量'abc'不会被修改，依然在内存中

//重新给字符串赋值，会重新在内存中开辟空间，这个特点就是字符串的不可变

//由于字符串的不可变，在大量拼接字符串的时候会有效率问题

var str = '';

for (var i = 0; i < 100000; i++) {

str += i;

}

console.log(str);

//这个结果需要花费大量时间来显示，因为需要不断的开辟新的空间

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        //字符串的不可变性
        var str = 'andy';
        // console.log(str);

        str = 'red';
        // console.log(str);

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

<body>

</body>

</html>

3: 根据字符返回位置

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        //字符串对象，根据字符串返回位置 str.indexOf('要查找的字符',[起始的位置])
        var str = '改革春风吹满地，春天来了';
        console.log(str.indexOf('春'));
        console.log(str.indexOf('春', 3));  //从索引号是 3的位置开始往后查找
    </script>
</head>

<body>

</body>

</html>

4:案例：返回字符位置

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        //查找字符串‘abcoefoxyozzopp‘中所有o出现的位置以及次数
        //核心算法： 先查找第一个·0出现的位置
        //然后 只要indexof 返回的结果不是-1，所以后面的查找，一定是当前索引加1，从而继续查找
        var str = 'abcoefoxyozzopp';
        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);
    </script>
</head>

<body>

</body>

</html>

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

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        //根据位置返回字符
        //1: charAt(index) 根据位置返回字符
        var str = 'andy';
        console.log(str.charAt(3));  //y 
        //遍历所有的字符
        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>
</head>

<body>

</body>

</html>

6: 案例-返回字符位置

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        //有一个对象  来判断是否有该属性  对象['属性名']
        var o = {
            age: 18
        }

        if (o['age']) {
            console.log('里面有该属性');
        } else {
            console.log('没有该属性');
        }

        //1:判断一个字符串'abcoefoxyozzopp' 中出现次数最多的字符，并统计其次数
        // o.a = 1
        // o.b = 1
        // o.c = 1
        // o.o = 4
        // 核心算法：利用 charAt(） 遍历这个字符串
        // 把每个字符都存储给对象， 如果对象没有该属性，就为1，如果存在了就 +1
        // 遍历对象，得到最大值和该字符

        var str = 'abcoefoxyozzopp';
        //对象
        var obj = {};
        for (var i = 0; i < str.length; i++) {
            //把下标转换成字符元素
            var chars = str.charAt(i);

            //如果newArry中有这个元素，则++
            if (obj[chars]) {
                obj[chars]++;

                //否则就统计为1
            } else {
                obj[chars] = 1;
            }
        }
        console.log(obj);

        //2:遍历对象
        //定义属性值
        var max = 0;
        //定义属性名
        var ch = '';
        for (var k in obj) {
            //k 得到是 属性名
            //obj[k] 得到的 属性值
            if (obj[k] > max) {
                max = obj[k];
                ch = k;
            }
        }
        console.log(max);
        console.log('最多的字符是' + ch);

    </script>
</head>

<body>

</body>

</html>

7:字符串操作方法（重点）

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <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 是取几个字符

        //3:替换字符 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);

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

    </script>
</head>

<body>

</body>

</html>

六：JavaScript简单类型与复杂类型

6.1:目标

能够说出简单数据类型的内存分配
能够说出复杂数据类型的内存分配
能够说出简单类型如何传参
能够说出复杂类型如何传参

6.2: 目录

简单类型与复杂类型

堆和栈

简单类型的内存分配

复杂类型的内存分配

简单类型传参

复杂类型传参

6.3: 简单类型与复杂类型

简单类型又叫做基本数据类型或者值类型，复杂类型又叫做引用类型。

值类型：简单数据类型/基本数据类型，在存储时变量中存储的是值本身，因此叫做值类型string，number，boolean，undefined，null

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

6.4:堆和栈

堆栈空间分配区别：

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

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

注意： JavaScript中没有堆栈的概念，通过堆栈的方式，可以让大家更容易理解代码的一些执行方式，便于将来学习其他语言。

6.5: 简单类型的内存分配

值类型（简单数据类型）：string，number，boolean，undefined，null
值类型变量的数据直接存放在变量（栈空间）中

6.6: 复杂类型的内存分配

引用类型（复杂数据类型）：通过new 关键字创建的对象（系统对象、自定义对象），如Object、Array、Date等
引用类型变量（栈空间）里存放的是地址，真正的对象实例存放在堆空间中

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        //简单数据类型 null  返回的是一个空的对象  object
        var timer = null;
        console.log(typeof timer);   //object

        //如果有个变量我们以后打算存储为对象 ，暂时没想好放啥，这个时候就给null
        //1: 简单数据类型 是存放在栈里面  里面直接开辟一个空间存放的是值
        //2: 复杂数据类型  首先在栈里面存放地址  十六进制表示  然后这个地址指向堆里面的数据
    </script>
</head>

<body>

</body>

</html>

6.7:简单类型传参

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

function fn(a) {

a++;

console.log(a);

}

var x = 10;

fn(x);

console.log(x)；

YPE html>
<html lang="en">
 
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
    <script>
        // 简单数据类型传参
        function fn(a) {
            a++;
            console.log(a);
        }
        var x = 10;
        fn(x);
        console.log(x);
    </script>
</head>
 
<body>
 
</body>

6.8: 复杂类型传参

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

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.这个输出什么?

<!DOCTYPE html>
<html lang="en">
 
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
    <script>
        // 复杂数据类型传参
        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. 这个输出什么 ?   张学友
    </script>
</head>
 
<body>
 
</body>
 
</html>

m0_59817723

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
二：第二阶段：JavaScript基础（二）

Math 对象不是构造函数，它具有数学常数和函数的属性和方法。跟数学相关的运算（求绝对值，取整、最大值等）可以使用Math 中的成员。Math.PI //圆周率Math.floor() //向下取整Math.ceil() //向上取整。
复制链接

扫一扫