JavaScript基础_console.log(0 && 1 + 2 && 456 * 56789);-CSDN博客

（此笔记资料全来自b站pink老师）

2.3 if else if语句（多分支语句）

2.4 三元表达式

2.5 switch语句

2.6 switch 语句和 if else if 语句的区别

5.1 通过修改 length 长度新增数组元素

5.2 break，continue，return 的区别

2.2 利用 new Object 创建对象

一、数据

1.1 数据存储单位

bit < byte < kb < GB < TB < ...

位（bit）：1bit 可以保存一个0或者1（最小的存储单位）
字节（Byte）：1B = 8b
千字节（KB）：1KB = 1024B
兆字节（MB）：1MB = 1024KB
吉字节（GB）：1GB = 1024MB
太字节（TB）：1TB = 1024GB
......

二、JS 初体验

JS有三种书写位置，分为行内，内嵌和外部。

1.行内式JS

<input type="button" value="点我试试" onclick="alert(‘Hello World’)"/>

可以将单行或少量JS代码写在HTML标签的事件属性中（以on开头的属性），如：onclick
注意单双引号的使用：在HTML中我们推荐使用双引号，JS中我们推荐使用单引号
可读性差，在HTML中国编写JS大量代码时，不方便阅读；
引号易错，引号多层嵌套匹配时，容易混乱；
特殊情况下使用

2.内嵌JS

<script>
    alert('Hello World~!');
</script>

可以将多行JS代码写到<script>标签中
内嵌JS是学习时常用的方式

3.外部JS文件

<script src="my.js"></script>

利于HTML页面代码结构化，把大段JS代码独立到HTML页面之外，既美观，也方便文件级别的复用
引用外部JS文件的script标签中间不可以写代码
适合于JS代码量比较大的情况

三、JS注释

单行注释

//单行注释   快捷键：ctrl+/

多行注释

/*多行注释
  多行注释      快捷键：shift+alt+a */

四、JS输入输出语句

常用语句：

方法	说明	归属
alert(msg)	浏览器弹出警示框	浏览器
console.log(msg)	浏览器控制台打印输出信息	浏览器
prompt(info)	浏览器弹出输入框，用户可以输入	浏览器

五、变量的使用

变量在使用时分为两步：1.声明变量 2.赋值

1.声明变量

var age;
//声明一个名称为age的变量

var是一个JS关键字,用来声明变量（variable变量的意思）。使用该关键字声明变量后，计算机会自动为变量分配内存空间不需要管理员管。
age是程序员定义的变量名，我们要通过变量名来访问内存中分配的空间

2.赋值

age = 10;//给age这个变量赋值为10

=用来把右边的值赋给左边的变量空间中，此处代表赋值的意思
变量值是程序员保存到变量空间的值

3.变量的初始化

var age = 18;//声明变量同时赋值为18

声明一个变量并赋值，我们称之为变量的初始化。

4.变量命名规范

由字母（A-Z，a-z）、数字（0-9）、下划线（_）、美元符号（$）组成，如：usrAge，num01，_name
严格区分大小写。var app;和var APP;是两个变量
不能以数字开头。18age 是错误的
不能是关键字、保留字。例如：var、for、while
变量名必须有意义。MMD BBD nl→ age
遵守驼峰命名法。首字母小写，后面单词的首字母需要大写。myFirstName
推荐翻译网站：有道爱词霸

六、变量的数据类型

1.数据类型

变量是用来存储值的所在处，它们有名字和数据类型。变量的数据类型决定了如何将代表这些值的位存储到计算机的内存中。JavaScript是一种弱类型或者动态语言。这意味着不用提前声明变量的类型，在程序运行过程中，类型会被自动确定。

var age = 10;       //这是一个数字型
var a = '文字';     //这是一个字符串

在代码运行时，变量的数据类型是由JS引擎根据 = 等号右边变量值的数据类型来判断的，运行完毕之后，变量就确定了数据类型。

JavaScript拥有动态类型，同时也意味着相同的变量可用作不同的类型：

var x = 6;        //x为数字
var x = "Bill";   //x为字符串

2.数据类型的分类

JS把数据类型分为两类：

简单数据类型（Number，String，Boolean，Undefined，Null）
复杂数据类型（object）

2.1 简单数据类型（基本数据类型）

简单数据类型	说明	默认值
Number	数字型，包含整型值和浮点型值，如21、0.21	0
Boolean	布尔值类型，如true、false，等价于1和0	false
String	字符串类型，如"张三" 注意js里字符串都带引号	""
Undefined	var a; 声明了变量a但是没有给值，此时a = undefined	undefined
Null	var a = null; 声明了变量a为空值	null

1.数字型

数字型进制

最常见的进制有二进制、八进制、十进制、十六进制。

//八进制数字序列范围：0~7
var num1 = 07;    //对应十进制的7
var num2 = 019;   //对应十进制的19
var num3 = 08;    //对应十进制的8

//十六进制数字序列范围：0~9以及A~F
var num = 0xA;

现阶段我们只需要记住，在JS中八进制前面加0，十六进制前面加0x

2.字符串型String

字符串可以是引号中的任意文本，其语法为双引号""和单引号''。

因为HTML标签中的属性用的是双引号，JS更推荐使用单引号。

2.1字符串引号嵌套

JS可以用单引号嵌套双引号，或者用双引号嵌套单引号（外双内单，外单内双）

2.2字符串转义符

转义符都是\开头，写在引号内：

转义符	解释说明
\n	换行符，n是newline的意思
\\	斜杠\
\'	'单引号
\"	"双引号
\t	tab缩进
\b	空格，b是blank的意思

2.3字符串长度

通过字符串的length属性可以获取整个字符串的长度。

var str = "我是程序员！";
alert(str.length);       //显示6

2.4字符串拼接

多个字符串之间可以使用+进行拼接，其拼接方式为字符串+任何类型=拼接之后的新字符串
拼接前会把字符串相加的任何类型转成字符串，再拼接成一个新的字符串

console.log(12+12);       //数字+数字，输出数字24
console.log('12'+12);     //字符串+数字，输出字符串1212

+号口诀：数值相加，字符相连。

2.5字符串拼接加强

var age = 18;
console.log('我' + age + '岁了');    //输出结果为：我18岁了

变量方便修改里面的值
变量是不能添加引号的，因为加引号的变量会变成字符串
如果变量两侧都有字符串拼接，口诀“引引加加”，删掉数字，变量写加号中间

3.获取变量数据类型

//prompt取过来的值是字符型的
var age = prompt('请输入您的年龄');
console.log(age);
console.log(typeof age);

4.数据类型转换

4.1转换为字符串

方式	说明	案例
toString()	转成字符串	var num=1; alert(num.toString()); //变量.toString()
String()强制转换	转成字符串	var num=1; alert(String(num)); //String(变量)
加号拼接字符串	和字符串拼接的结果都是字符串	var num=1; alert(num+"我是字符串");

4.2转换为数字型（重点）

方式	说明	案例
parseInt(string)函数	将string类型转成整数数值型	parseInt('78')
parseFloat(string)函数	将string类型转成浮点数数值型	parseFloat('78.21')
Number()强制转换函数	将string类型转换为数值型	Number('12')
js隐式转换(- * /)	利用算术运算隐式转换为数值型	'12'-0

var age = prompt('请输入您的年龄')；
//parseInt(变量)  可以把字符型的转换为数字型 得到的是整数
console.log(parseInt(age));
console.log(parseInt('3.14'));         //输出3，取整
console.log(parseInt('3.94'));         //输出3，取整
console.log(parseInt('120px'));        //输出120，会去掉px单位
console.log(parseInt('rem120px'));     //输出NaN

案例：

功能：用户先后输入两个数值，最后警示框弹出两个数值之和。

//先弹出第一个输入框，提示用户输入第一个值  保存起来
//再弹出第二个输入框，提示用户输入第二个值  保存起来
//把这两个值相加，并将结果赋给新的变量（注意数据类型转换）
//弹出警示框(alert)，并将结果输出
var num1 = prompt('请您输入第一个值：');
var num2 = prompt('请您输入第二个值：');
var result = parseFloat(num1) + parseFloat(num2);
alert('您的结果是：' + result);

4.3转换为布尔型

方式	说明	案例
Boolean()函数	其他类型转成布尔值	Boolean(变量)；

代表空，否定的值会被转换为false，如''、0、NaN、null、undefined
其余值都会被转换为true

七、运算符

运算符（operator）也被称为操作符，是用于实现赋值、比较和执行算数运算等功能的符号。

JavaScript中常用的运算符有：

算术运算符
递增和递减运算符
比较运算符
逻辑运算符
赋值运算符

1.算术运算符

运算符	描述	实例
+	加	10 + 20 = 30
-	减	10 - 20 = -10
*	乘	10 * 20 = 200
/	除	10 / 20 = 0.5
%	取余数（取模）	返回除法的余数9 % 2 = 1

注意：浮点数在算数运算里面会有问题，不能直接拿着浮点数确认是否相等

2.递增和递减运算符

如果需要反复给数字变量添加或减去1，可以使用递增（++）和递减（--）运算符来完成。

在JS中，递增和递减既可以放在变量前面，也可以放在变量后面。

注意：递增和递减运算符必须和变量搭配使用。

前置自增和后置自增：

1.前置自增和后置自增如果单独使用，效果是一样的

2.前置自增口诀：先自加1，后返回值

var age = 10;
console.log(++age + 10);  //等同于11+10，输出结果为21

3.后置自增口诀：先返回原值，后自加1

var age = 10;
console.log(age++ + 10);   //等同于10+10，输出结果为20
console.log(age);          //输出结果为11

案例：

var e = 10;
var f = e++ + ++e;   //①e++ = 10,然后e = 11  ②则++e = 12，e = 12
console.log(f);      //等同于10+12，输出结果为22

3.比较运算符

比较运算后，会返回一个布尔值（true/false）作为比较运算的结果。

运算符名称	说明	案例	结果
<	小于号	1 < 2	true
>	大于号	1 > 2	false
>=	大于等于号	2 >= 2	true
<=	小于等于号	3 <= 2	false
==	判等号（会转型，默认将字符串型转换为数字型）	37 == '37'	true
!=	不等号	37 != 37	false
=== !==	全等和全不等（要求值和数据类型都一致）	37 === '37'	false

4.逻辑运算符

概念：逻辑运算符是用来进行布尔值运算的运算符，其返回值也是布尔值。后面开发中经常用于多个条件的判断

逻辑运算符	说明	案例
&&	与，and	true && false
\|\|	或，or	true \|\| false
!	非，not	! true

4.1短路运算（逻辑中断）

短路运算的原理：当有多个表达式（值）时，左边的表达式值可以确定结果时，就不再继续运算右边的表达式的值；

4.1.1 逻辑与

语法：表达式1 && 表达式2
如果第一个表达式的值为真，则返回表达式2
如果第一个表达式的值为假，则返回表达式1

//true && false == false
console.log(123 && 456);                     //输出456
console.log(0 && 456);                       //输出0
console.log(0 && 1 + 2 && 456 * 56789);      //输出0
console.log('' && 1 + 2 && 456 * 56789);     //输出''
//如果有空的或者否定的为假，其余是真的，如：0，''，null，undefined，NaN

4.1.2 逻辑或

语法：表达式1 ||表达式2
如果第一个表达式的值为真，则返回表达式1

如果第一个表达式的值为假，则返回表达式2

console.log(123 || 456);            //输出123
console.log(0 || 456);              //输出456
console.log(123 || 456 || 789);     //输出123
//逻辑中断会影响值
var num = 0;
console.log(123 || num++);          //输出123，num++不执行
console.log(num);                   //输出0

5. 赋值运算符

赋值运算符	说明	案例
=	直接赋值	var usrName = '值';
+=、-=	加、减一个数，再赋值	var age = 10; age += 5; //输出15
*=、/=、%=	乘、除、取模，再赋值	var age = 2; age *= 5; //输出10

6.运算符优先级

优先级	运算符	顺序
1	小括号	（）
2	一元运算符	++ -- !
3	算术运算符	*先 / % 后+ -**
4	关系运算符	> >= < <=
5	相等运算符	== != === !==
6	逻辑运算符	先&& 后\|\|
7	赋值运算符	=
8	逗号运算符	,

八、流程控制

流程控制主要有三种结构，分别是顺序结构，分支结构和循环结构，这三种结构代表三种代码执行的顺序。

1.顺序结构

自上而下按顺序执行。

2.分支结构

2.1 if语句

//条件成立则执行代码，否则什么也不做

if (条件表达式) {

//条件成立执行的代码语句

}

2.2 if else语句（双分支语句）

//条件成立执行if里面的代码，否则执行else里面的代码

if (条件表达式) {

//条件成立执行的代码

}

else {

//条件不成立执行的代码

}

2.3 if else if语句（多分支语句）

//适合于检查多重条件。

if (条件表达式1) {

语句1;

} else if (条件表达式2) {

语句2;

} else if (条件表达式3) {

语句3;

}...

else {

//上述条件都不成立执行此处代码

}

2.4 三元表达式

//条件表达式 ? 表达式1 : 表达式2
//若表达式结果为真，则返回 表达式1 的值，否则返回 表达式2 的值
var num = 10;
var result = num > 5 ? '是的' : '不是的';   //表达式是有返回值的，赋予变量result
console.log(result);                       //输出是的

案例：

功能：数字补0，小于10的数字前面补上一个0

//用户输入0~59之间的一个数字
//如果数字小于10，则在前面补个0，（加0 拼接）否则 不做操作
//用一个变量介接收这个返回值，输出
var time = prompt('请您输入一个 0 ~ 59 之间的一个数字');
//三元表达式   条件句 ? 表达式1 : 表达式2
var result = time < 10 ? '0' + time : time;   //把返回值赋值给一个变量
alert(result);

2.5 switch语句

switch（表达式）{

case value1：

//表达式等于 value1 时要执行的代码

break；

case value2：

//表达式等于 value2 时要执行的代码

break；

default：

//表达式不等于任何一个value时要执行的代码

}

注意事项：

1. 表达式经常写成变量

2. 表达式的值和 case里面的值相匹配的时候是全等，必须是值和数据类型一致才可以

3. 如果当前的case里面没有break 则不会退出switch，会继续执行下一个case

2.6 switch 语句和 if else if 语句的区别

一般情况下，他们两个语句可以相互替换
switch...case 语句通常处理 case 为比较确定值的情况，而 if...else...语句更加灵活，常用语范围判断（大于等于某个范围）
switch 语句进行条件判断后直接执行到程序的条件语句，效率更高。而if...else 语句有几种条件，就得判断多少次。
当分支比较少时，if...else 语句的执行效率比 switch语句高。
当分支比较多时，switch语句的执行效率比较高，而且结构更清晰。

3.循环结构

3.1 for 循环

//for重复执行某些代码，通常和计数有关

for （初始化变量；条件表达式；操作表达式）{

//循环体

}

//初始化变量就是用var 声明的一个普通变量，通常用于作为计数器使用

//条件表达式就是用来决定每一次循环是否继续执行就是终止的条件

//操作表达式是每次循环最后执行的代码经常用于我们计数器变量进行更新（递增或递减）

案例1：

功能：分别求1-100之间所有偶数和奇数的和

//我们需要一个偶数的和 变量even 还需要一个奇数 odd
var even = 0;
var odd = 0;
for (var i = 1; i <= 100; i++) {
   if (i % 2 == 0) {
      even= even + i；
   }
   else {
      odd = odd + i;
   }
}
console.log('1~100 之间所有的偶数之和为' + even);
console.log('1~100 之间所有的奇数之和为' + odd);

案例2：

功能：输入班级总人数，再分别输入成绩，最终得到班级总成绩和平均成绩

//弹出输入框输入总的班级人数（num）
//依次输入学生的成绩（保存起来 score），此时我们需要用到
//for 循环，弹出的次数跟班级总人数有关系  条件表达式 i <= num
//进行业务处理：计算成绩。先求总成绩（sum），之后求平均成绩（average）
//弹出结果
var num = prompt('请输入班级的总人数：');     // num 总的班级人数
var sum = 0;                //求和的变量
var average = 0;            //求平均值的变量
for (var i = 1; i <= num; i++) {
    var score = prompt('请您输入第' + i + '个学生成绩');
    //因为从prompt取过来的数据是 字符串型的  需要转换为数字型
    sum = sum + parseFloat(score);
}
average = sum / num;
alert('班级的总成绩是'+sum);
alert('班级平均分是：'+average);

案例3：

一行打印多颗星星

var num = ('请输入星星的个数');
var str = '';
for (var i = 1; i <= num; i++) {
    str = str +'※'      //追加字符串的方式
}
console.log(str);

3.2 双重for循环

循环嵌套是指在一个循环语句中再定义一个循环语句的语法结构，例如在for循环语句中，可以在潜逃一个for 循环，这样的for 循环语句我们称之为双重for循环。

for (外层的初始化变量; 外层的条件表达式; 外层的操作表达式) {

for (里层的初始化变量; 里层的条件表达式; 里层的操作表达式) {

//执行语句;

}

}

//可以把里面的循环看作是外层循环的语句

//外层循环循环一次，里面的循环执行全部

案例1：

打印n行n列的星星

//打印n行n列的星星
var rows = prompt('请您输入行数：');
var cols = prompt('请您输入列数：');
var str = '';
for (var i = 1; i <= rows; i++) {
    for (var j = 1; j <= cols; j++) {
     //打印倒三角形时，把j=1改为j=i即可
     //打印正三角形时，把j<=cols该为j<=i即可
        str = str + '※';
    }
    str += '\n';    //换行
}
console.log(str);

案例2：

九九乘法表

var str = '';
for (var i = 1; i <= 9; i++) {
    for (var j = 1; j <= i; j++) {
        //str = str + '※';
        str += j + 'x' + i + '=' + i * j + '\t';    //1 x 2 = 2
    }
    str += '\n';    //换行
}
console.log(str);

3.3 while 循环

whlie (条件表达式) {

//循环体代码

}

var num = 1;
while (num <= 100) {
      console.log('好的');
      num++;
}
//内有计数器  初始化变量
//内有操作表达式  完成计数器的更新  防止死循环

案例：

弹出一个提示框，A or B? 如果输入A，则提示结束，否则一直询问。

var message = prompt('A or B?');
while (message !== 'A') {
     message = prompt('A or B?');
}
alert('输入正确！');

3.4 do while 循环

do {

//循环体

} while (条件表达式)

跟while不同的地方在于 do while 先执行一次循环体，再判断条件
至少会执行一次循环体代码

3.5 continue 关键字

退出本次循环，继续执行剩余次数循环

for (var i = 1; i<= 5; i++) {
    if (i == 3) {
         continue;    //退出本次循环。直接跳到 i++
    }
    console.log('我正在吃第' + i + '个包子');
}

3.6 break 关键字

退出整个循环

for (var i = 1; i<= 5; i++) {
    if (i == 3) {
         break;
    }
    console.log('我正在吃第' + i + '个包子');
}

九、数组

1.数组概述

数组是指一组数据的集合，其中的每个数据被称作元素，在数组中可以存放任意类型的元素。数组是一种将一组数据存储在单个变量名下的优雅方式。

//普通变量一次只能存储一个值

var num = 10;

//数组一次可以存储多个值

var arr = [1,2,3,4,5];

2.创建数组

数组中可以存放任意类型的数据，例如字符串，数字，布尔值等。

2.1 数组的创建方式

利用 new 创建数组
利用数组字面量创建数组

2.2 利用 new 创建数组

var 数组名 =new Array( ) ;

var arr =new Array( ) ; //创建一个新的空数组

2.3 利用数组字面量创建数组

var 数组名 = [ ] ;

var 数组名 = ['小白','小黑',1,2] ; //声明数组并赋值称为数组的初始化

3.获取数组元素

3.1 数组的索引

索引（下标）：用来访问数组元素的序号（数组下标从0开始）。

数组可以通过索引来访问，设置，修改对应的数组元素，我们可以通过“数组名[索引]”的形式来获取数组中的元素。

这里的访问就是获取得到的意思。

//定义数组

var arrStus = [1,2,3];

//获取数组中的第2个元素

alert(arrStus[1]); //输出结果为2

4.遍历数组

遍历：就是把数组中的每个元素从头到尾都访问一次。

var arr = ['red', 'green', 'blue'];
for (var i = 0; i < 3; i++) {
    console.log(arr[i]);
}
//因为数组索引号从0开始，所以 i 必须从 0 开始  i<3
//输出的时候 arr[i]  i 计数器当索引号使用

4.1 数组长度

使用“数组名.length”可以访问数组元素的数量（数组长度）。

var arr = ['red', 'green', 'blue',1,5];
for (var i = 0; i < arr.length; i++) {   // arr.length 动态监测数组元素的个数
    console.log(arr[i]);
}
// 数组的长度是元素个数 不要跟索引号混淆

4.2 求数组中的最大值

分析步骤：

求数组[2,6,1,77,52,25,7]中的最大值
声明一个保存最大元素的变量 max
默认最大值可以取数组中的第一个元素
遍历这个数组，把里面每个数组元素和 max 相比较
如果这个数组元素大于 max 就把这个数组元素保存到 max 里面，否则继续下一轮比较
最后输出这个 max

var arr = [2,6,1,77,52,25,7,99];
var max = arr[0];
for (var i = 1; i < arr.length; i++) {
    if (arr[i] > max) {
       max = arr[i];
    }
}
console.log('该数组里面的最大值是：' + max)；

5.数组中新增元素

可以通过修改length长度或索引号增加数组元素

5.1 通过修改 length 长度新增数组元素

可以通过修改length 长度来实现数组扩容的目的
length 属性是可读写的

var arr = ['red','green','blue'];
console.log(arr.length);
arr.length = 5;           //长度修改为5，应有五个元素
console.log(arr);         //前三个正常显示，后两个为空
console.log(arr[3]);      //输出 undefined
console.log(arr[4]);      //输出 undefined

5.2 新增数组元素

通过修改数组索引的方式追加数组元素
不能直接给数组名赋值，否则会覆盖掉以前的数据

var arr = ['red', 'green','blue'];
arr[3] = 'pink';
console.log(arr);
arr[0] = 'yellow';    //这里会替换原来的数组元素
console.log(arr);

6. 筛选数组

选出大于10的数组元素放入一个新的数组

方法一：

var arr = [2,0,6,1,77,0,52,0,25,7];
var j = 0;
for (var i = 0; i < arr.length; i++) {
    if (arr[i] >= 10) {
       //新数组索引号应该从0开始 依次递增
       newArr[j] = arr[i];
       j++;
    }
}
console.log(newArr);

方法二：

var arr = [2,0,6,1,77,0,52,0,25,7];
var newArr = [];
for (var i = 0; i < arr.length; i++) {
    if (arr[i] >= 10) {
       //新数组索引号应该从0开始 依次递增
       newArr[newArr.length] = arr[i];
    }
}
console.log(newArr);

7.翻转数组

将数组['red','green','blue','pink','purple']的内容反过来存放

声明一个新的数据 newArr
把旧数索引号第4个取过来（arr.length -1），给新数组索引号第0个元素（newArr.length）
我们采取递减的方式 i--

var arr = ['red','green','blue','pink','purple'];
var newArr = [];
for (var i =arr.length -1; i>=0 ; i--) {
    newArr[newArr.length] = arr[i]
}
console.log(newArr);

8.冒泡排序

var arr = [4,1,2,3,5];
for (var i = 0;i <= arr.length -i - 1; i++) {          //外层循环 管躺数
    for (var j = 0; j <= arr.length -i -1;; j++) {     //里面的循环 管每一趟的交换次数
        // 内部交换2个变量的值 前一个和后面一个数组元素相比较
        if (arr[j] < arr[j + 1]) {
           var temp = arr[j];
           arr[j] = arr[j + 1];
           arr[j + 1] = temp;
        }
    }
}
console.log(arr);

十、函数

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

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

1. 声明函数

// 声明函数

function 函数名（） {

//函数体代码

}

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

2. 调用函数

// 调用函数

函数名（）；//通过调用函数名来执行函数体代码

调用的时候千万不能忘记添加小括号
口诀：函数不调用，自己不执行。

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

3.函数的封装

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

4.函数的参数

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

参数	说明
形参	形式上的参数函数定义的时候传递的参数类似是变量
实参	实际上的参数函数调用的时候传递的参数实参类似带入的值

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

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

参数个数	说明
实参个数等于形参个数	输出正确结果
实参个数多于形参个数	只取到形参的个数
实参个数小于形参个数	多的形参定义为undefined，结果为NaN

5.函数的返回值return

function 函数名（）{

return 需要返回的结果;

}

函数名（）;

// 求任意两个数的和
function getSum(num1,num2) {
      return num1 +num2;
}
console.log(getSum(1,2));

案例：

利用函数求数组中最大值：

function getArrMax(arr) {
    var max = arr[0];
    for (var i =1;i <= arr.length; i++) {
        if (arr[i] > max) {
           max = arr[i];
        }
    }
    return max;
}
//实际开发中，经常用一个变量来接受 函数的返回结果 使用更简单
var re = getArrMax([3,77,44,99,142]);
console.log(re);

5.1 return 终止函数

return 语句之后的代码不会被执行
return 只能返回一个值返回的结果是最后一个值
需要求多个值时可以用数组
函数如果有return 则返回的是 return 后面的值，如果函数没有 return 则返回 undefined

案例：求任意两个数的加减乘除的结果

function getResult(num1, num2) {
      return [num1 + num2, num1 - num2, num1 * num2, num1 / num2];
}
var re = getResult(1,2);     //返回的是一个数组
console.log(re);

5.2 break，continue，return 的区别

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

6. arguments的使用

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

只有函数才有arguments 对象

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

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

7.函数可以相互调用

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

function backDay() {
    var year = prompt('请您输入年份：');
    if (isRunYear(year)) {
        alert('当前年份是闰年，2月份有29天');
    } else {
        alert('当前年份是平年，2月份有28天');
    }
}
backDay();

//判断是否为闰年的函数
function isRunYear(year) {
    var flag = false;
    if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {
        falg = true;
    }
    return flag;
}

8.函数的两种声明方式

函数表达式声明方式跟声明变量差不多，只不过变量里面存的是值，而函数表达式里面存的是函数

// 1.利用韩束关键字自定义函数（命名函数）
function fn() {
     // 函数体
}
fn();

// 2.函数表达式（匿名函数）
// var 变量名 = function() {}
var fun = function(aru) {           // fun是变量名 不是函数名
    console.log('我是函数表达式');
    console.log(aru);
}
fun('123');                         // 函数表达式也可以进行传递参数

十一、作用域

JavaScript 作用域：就是代码名字（变量）在某个范围内起作用和效果目的是为了提高程序的可靠性和减少命名冲突
js的作用域（es6）之前：全局作用域局部作用域
全局作用域：整个script标签或者是一个单独的js文件
局部作用域（函数作用域）在函数内部就是局部作用域这个代码的名字只在函数内部起效果和作用

1.变量的作用域

1.1 局部变量

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

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

1.2 全局变量

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

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

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

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

2.作用域链

只要是代码，就至少有一个作用域
写在函数内部的局部作用域
如果函数中还有函数，那么在这个作用域中就可以诞生一个作用域

根据在内部函数可以访问外部函数变量的这种机制，用链式查找决定哪些数据能被内部函数访问，就称作作用域链

// 作用域链（就近原则）
var num = 10;
function fn() {                //外部函数
     var num = 20;
     function fun() {
          console.log(num);    //内部函数
     }
     fun();
}
fn();

3.预解析

1.js引擎运行js分为两步：预解析代码执行

（1）预解析 js引擎会把js 里面所有的var 还有 function 提升到当前作用域的最前面

（2）代码执行按照代码书写的顺序从上往下执行

2.预解析分为变量预解析（变量提升）和函数预解析（函数提升）

（1）变量提升就是把所有的变量声明提升到当前的作用域最前面不提升赋值操作

（2）函数提升就是把所有的函数声明提升到当前的作用域最前面不调用函数

十二、对象

1.对象概述

对象是由属性和方法组成的。

属性：事物的特征，在对象中用属性来表示（常用名词）
方法：事物的行为，在对象中用方法来表示（常用动词）

JS 中的对象表达结构更清晰。小明的个人信息在对象中的表达结构如下：

person.name = '小明';

person.sex = '男';

person.age = 18;

person.height = 178;