【JS笔记】JavaScript语法 《基础+重点》 知识内容，快速上手（一）

JavaScript基础语法

  • HTML ：标记语言
  • JavaScript ：编程语言（脚本）

序言

JavaScript发展历史（JS）

1. 1994年，网景公司(Netscape)发布了Navigator浏览器0.9版，这是世界上第一款比较成熟的网络浏览器，轰动一时。但是这是一款名副其实的浏览器--只能浏览页面，浏览器无法与用户互动,当时解决这个问题有两个办法，一个是采用现有的语言,许它们直接嵌入网页。另一个是发明一种全新的语言。liveScript ==> javaScript ==> ECMAscript2. 1995年Sun公司将Oak语言改名为Java，正式向市场推出。Sun公司大肆宣传，许诺这种语言可以"一次编写，到处运	 行"(Write Once, Run Anywhere)，它看上去很可能成为未来的主宰。3. 网景公司动了心，决定与Sun公司结成联盟4. 34岁的系统程序员Brendan Eich登场了。1995年4月，网景公司录用了他,他只用10天时间就把Javascript设计出来了。（多肽语言，弱类型，脚本）5. (1)借鉴C语言的基本语法(2)借鉴Java语言的数据类型和内存管理(3)借鉴Scheme语言，将函数提升到"第一等公民"(first class)的地位(4)借鉴Self语言，使用基于原型(prototype)的继承机制

JavaScript能干什么

1. 常见的网页效果【表单验证，轮播图。。。】
2. 与H5配合实现游戏【水果忍者： http://www.jq22.com/demo/html5-fruit-ninja/】
3. 实现应用级别的程序【http://naotu.baidu.com】
4. 实现统计效果【http://echarts.baidu.com/examples/】
5. 地理定位等功能【http://lbsyun.baidu.com/jsdemo.htm#i4_5】
6. 在线学编程【https://codecombat.163.com/play/】
7. js可以实现人工智能【面部识别】
8. 后端 。。。

JavaScript的组成

1. ECMASCRIPT: 定义了javascript的语法规范,描述了语言的基本语法和数据类型  es5 es6
2. BOM (Browser Object Model): 浏览器对象模型 - 有一套成熟的可以操作浏览器的 API，通过 BOM 可以操作浏览器。比如： 弹出框、浏览器跳转、获取分辨率等
3. DOM (Document Object Model): 文档对象模型- 有一套成熟的可以操作页面元素的 API，通过 DOM 可以操作页面中的元素。比如： 增加个 div，减少个 div，给 div 换个位置等

总结： JS 就是通过固定的语法去操作 浏览器 和 标签结构 来实现网页上的各种效果

一、JavaScript代码的书写位置

  • 和 css 一样，我们的 js 也可以有多种方式书写在页面上让其生效
  • js 也有多种方式书写，分为 行内式， 内嵌式，外链式

行内式 JS 代码（不推荐）

  • 写在标签上的 js 代码需要依靠事件（行为）来触发
<!-- 写在 a 标签的 href 属性上 -->
<a href="javascript:alert('我是一个弹出层');">点击一下试试</a><!-- 写在其他元素上 -->
<div onclick="alert('我是一个弹出层')">点一下试试看</div><!--注：onclick 是一个事件（点击事件），当点击元素的时候执行后面的 js 代码
-->

内嵌式 JS 代码

  • 内嵌式的 js 代码会在页面打开的时候直接触发
<!-- 在 html 页面书写一个 script 标签，标签内部书写 js 代码 -->
<script type="text/javascript">alert('我是一个弹出层')
</script><!--注：script 标签可以放在 head 里面也可以放在 body 里面
-->

外链式 JS 代码（推荐）

  • 外链式 js 代码只要引入了 html 页面，就会在页面打开的时候直接触发
  • 新建一个 .js 后缀的文件，在文件内书写 js 代码，把写好的 js 文件引入 html 页面
// 我是 index.js 文件
alert('我是一个弹出层')

<!-- 我是一个 html 文件 --><!-- 通过 script 标签的 src 属性，把写好的 js 文件引入页面 -->
<script src="index.js"></script><!-- 一个页面可以引入多个 js 文件 -->
<script src="index1.js"></script>
<script src="index2.js"></script>
<script src="index3.js"></script>

怪坡

js代码书写是时候 所有的符号都是英文符号

二、JS 中的注释

  • 学习一个语言，先学习一个语言的注释，因为注释是给我们自己看的，也是给开发人员看的
  • 写好一个注释，有利于我们以后阅读代码

单行注释

  • 一般就是用来描述下面一行代码的作用
  • 可以直接写两个 / ，也可以按 ctrl + /
// 我是一个单行注释// 下面代码表示在浏览器里面出现一个弹出层
alert('我是一个弹出层')

多行注释

  • 一般用来写一大段话，或者注释一段代码
  • 可以直接写 /**/ 然后在两个星号中间写注释，也可以按 shift + alt + a
/*我是一个多行注释
*//*注释的代码不会执行alert('我是一个弹出层')alert('我是一个弹出层')
*/
alert('我是一个弹出层')

三、变量（重点）

  • 变量指的是在程序中保存数据的一个容器
  • 变量是计算机内存中存储数据的标识符，根据变量名称可以获取到内存中存储的数据
  • 也就是说，我们向内存中存储了一个数据，然后要给这个数据起一个名字，为了是我们以后再次找到他
  • 语法： var 变量名 = 值

定义变量及赋值

// 定义一个变量
var num;// 给一个变量赋值
num = 100;
num = 200// 定义一个变量的同时给其赋值
var num2 = 200;
  • 注意：
    1. 一个变量名只能存储一个值
    2. 当再次给一个变量赋值的时候，前面一次的值就没有了
    3. 变量名称区分大小写（JS 严格区分大小写）

变量的命名规则和命名规范

  • 规则： 必须遵守的，不遵守就是错
    1. 一个变量名称可以由 数字、字母、英文下划线（_）、美元符号（$） 组成
    2. 严格区分大小写
    3. 不能由数字开头，不要使用中文汉字命名
    4. 不能是 保留字 或者 关键字
    5. 不要出现空格
  • 规范： 建议遵守的（开发者默认），不遵守不会报错
    1. 变量名尽量有意义（语义化）
    2. 遵循驼峰命名规则，由多个单词组成的时候，从第二个单词开始首字母大写

四、数据类型（重点）

  • 是指我们存储在内存中的数据的类型
  • 我们通常分为两大类 基本数据类型（原始数据类型） 和 复杂数据类型（引用类型，复合类型）

基本数据类型（原始数据类型）

  1. 数值类型（number）

    • 一切数字都是数值类型（包括二进制，十进制，十六进制等）
    • NaN（not a number），一个非数字

    var a = 1;

    typeof a;->number

  2. 字符串类型（string）

    • 被引号包裹的所有内容（可以是单引号也可以是双引号）

    var str = ‘hello’

    typeof str ->string

  3. 布尔类型（boolean）

    • 只有两个（true 或者 false）

  4. null类型（null）

    • 只有一个，就是 null，表示空的意思

  5. undefined类型（undefined）

    • 只有一个，就是 undefined，表示没有值的意思

复杂数据类型object（暂时先不讲）

  1. 对象类型（object）
  2. 函数类型（function）
  3. 。。。

判断数据类型

  • 既然已经把数据分开了类型，那么我们就要知道我们存储的数据是一个什么类型的数据
  • 使用 typeof 关键字来进行判断
// 第一种使用方式
var n1 = 100;
console.log(typeof n1);//number // 第二种使用方式
var s1 = 'abcdefg';
console.log(typeof(s1));//stringconsole.log(typeof typeof n1);//string console.log (typeof true);//boolean
console.log( typeof null);//object
console.log( typeof undefined);//undefined
console.log( typeof {});//object
判断一个变量是不是数字
  • 可以使用 isNaN 这个方法来判断一个变量是不是 不是数字
  • isNaN ：is not a number
// 如果变量是一个数字
var n1 = 100;
console.log(isNaN(n1)); //=> false// 如果变量不是一个数字
var s1 = 'Jack'
console.log(isNaN(s1)); //=> true

数据类型转换

  • 数据类型之间的转换，比如数字转成字符串，字符串转成数字，数字转成布尔等
其他数据类型转成数值
  1. Number(变量)
  • 可以把一个变量强制转换（显示转换）成数值类型
    • 可以转换小数，会保留小数
    • 可以转换布尔值
    • 遇到不可转换的都会返回 NaN(出现字母)
  1. parseInt(变量)
  • 从第一位开始检查，是数字就转换，直到一个不是数字的内容
    • 开头就不是数字，那么直接返回 NaN
    • 不认识小数点，只能获取整数
  1. parseFloat(变量)

  • 从第一位开始检查，是数字就转换，直到一个不是数字的内容

  • 开头就不是数字，那么直接返回 NaN

  • 认识一次小数点

  1. 除了加法以外的数学运算

    • 运算符两边都是可运算数字才行
    • 如果运算符任何一边不是一个可运算数字，那么就会返回 NaN
    • 加法不可以用
其他数据类型转成字符串
  1. 变量.toString()
    • 有一些数据类型不能使用 toString() 方法，比如 undefined 和 null
  2. String(变量)
    • 所有数据类型都可以
  3. 使用加法运算
    • 在 JS 里面，+ 由两个含义
    • 字符串拼接： 只要 + 任意一边是字符串，就会进行字符串拼接
    • 加法运算：只有 + 两边都是数字的时候，才会进行数学运算
其他数据类型转成布尔
  1. Boolean(变量)
    • 在 js 中，只有 ''、0、null、undefined、NaN，这些是 false，其余都是 true

五、运算符

  • 就是在代码里面进行运算的时候使用的符号，不光只是数学运算，我们在 js 里面还有很多的运算方式

算术运算符

  1. +
  • 只有符号两边都是数字的时候才会进行加法运算
    • 只要符号任意一边是字符串类型，就会进行字符串拼接
  1. -
  • 会执行减法运算
  • 会自动把两边都转换成数字进行运算
  1. *
  • 会执行乘法运算
    • 会自动把两边都转换成数字进行运算
  1. /
  • 会执行除法运算
    • 会自动把两边都转换成数字进行运算
  1. %
  • 会执行取余运算
    • 会自动把两边都转换成数字进行运算
  1. **
    2**4----- 2的4次方

赋值运算符

  1. =

    • 就是把 = 右边的赋值给等号左边的变量名
    • var num = 100
    • 就是把 100 赋值给 num 变量
    • 那么 num 变量的值就是 100

  2. +=

    var a = 10;
a += 10;// a = a + 10
console.log(a); //=> 20
    • a += 10 等价于 a = a + 10

  3. -=

    var a = 10;
a -= 10;
console.log(a); //=> 0
    • a -= 10 等价于 a = a - 10

  4. *=

    var a = 10;
a *= 10;
console.log(a); //=> 100
    • a *= 10 等价于 a = a * 10

  5. /+

    var a = 10;
a /= 10;
console.log(a); //=> 1
    • a /= 10 等价于 a = a / 10

  6. %=

    var a = 10;
a %= 10;
console.log(a); //=> 0
    • a %= 10 等价于 a = a % 10

比较运算符

  1. ==
    • 比较符号两边的值是否相等，不管数据类型
    • 1 == '1'
    • 两个的值是一样的，所以得到 true
  2. ===
    • 比较符号两边的值和数据类型是否都相等
    • 1 === '1'
    • 两个值虽然一样，但是因为数据类型不一样，所以得到 false
  3. !=
    • 比较符号两边的值是否不等
    • 1 != '1'
    • 因为两边的值是相等的，所以比较他们不等的时候得到 false
  4. !==
    • 比较符号两边的数据类型和值是否不等
    • 1 !== '1'
    • 因为两边的数据类型确实不一样，所以得到 true
  5. >=
    • 比较左边的值是否 大于或等于 右边的值
    • 1 >= 1 结果是 true
    • 1 >= 0 结果是 true
    • 1 >= 2 结果是 false
  6. <=
    • 比较左边的值是否 小于或等于 右边的值
    • 1 <= 2 结果是 true
    • 1 <= 1 结果是 true
    • 1 <= 0 结果是 false
  7. >
    • 比较左边的值是否 大于 右边的值
    • 1 > 0 结果是 true
    • 1 > 1 结果是 false
    • 1 > 2 结果是 false
  8. <
    • 比较左边的值是否 小于 右边的值
    • 1 < 2 结果是 true
    • 1 < 1 结果是 false
    • 1 < 0 结果是 false

逻辑运算符

  1. && and
    • 进行 且 的运算
    • 符号左边必须为 true 并且右边也是 true，才会返回 true
    • 只要有一边不是 true，那么就会返回 false
    • true && true 结果是 true
    • true && false 结果是 false
    • false && true 结果是 false
    • false && false 结果是 false
  2. || or
    • 进行 或 的运算
    • 符号的左边为 true 或者右边为 true，都会返回 true
    • 只有两边都是 false 的时候才会返回 false
    • true || true 结果是 true
    • true || false 结果是 true
    • false || true 结果是 true
    • false || false 结果是 false
  3. ! 非
    • 进行 取反 运算 !flag
    • 本身是 true 的，会变成 false
    • 本身是 false 的，会变成 true
    • !true 结果是 false
    • !false 结果是 true

自增自减运算符（一元运算符）

  1. ++

    • 进行自增运算

    • 分成两种，前置++ 和 后置++

    • 前置++，会先把值自动 +1，在返回

      var a = 10;
console.log(++a);//++a 表达式的值的 
// 会返回 11，并且把 a 的值变成 11

    • 后置++，会先把值返回，在自动+1

      var a = 10;
console.log(a++);//a++ 表达式的值的 
// 会返回 10，然后把 a 的值变成 11

  2. --

    • 进行自减运算
    • 分成两种，前置– 和 后置–
    • 和 ++ 运算符道理一样

六、分支结构(条件语句 判断)

  • 我们的 js 代码都是顺序执行的（从上到下）
  • 逻辑分支就是根据我们设定好的条件来决定要不要执行某些代码

IF 条件分支结构（重点）

if 语句

  • 通过一个 if 语句来决定代码是否执行

  • 语法： if (条件) { 要执行的代码 }

  • 通过 () 里面的条件是否成立来决定 {} 里面的代码是否执行

    // 条件为 true 的时候执行 {} 里面的代码
if (true) {alert('因为条件是 true，我会执行')
}// 条件为 false 的时候不执行 {} 里面的代码
if (false) {alert('因为条件是 false，我不会执行')    
}
如果代码块中代码只有一句，可以把花括号省略
if else 语句

  • 通过 if 条件来决定，执行哪一个 {} 里面的代码

  • 语法： if (条件) { 条件为 true 的时候执行 } else { 条件为 false 的时候执行 }

  • 两个 {} 内的代码一定有一个会执行

    // 条件为 true 的时候，会执行 if 后面的 {} 
if (true) {alert('因为条件是 true，我会执行')
} else {alert('因为条件是 true，我不会执行')
}// 条件为 false 的时候，会执行 else 后面的 {}
if (false) {alert('因为条件为 false，我不会执行')
} else {alert('因为条件为 false，我会执行')
}
if else if … 语句

  • 可以通过 if 和 else if 来设置多个条件进行判断

  • 语法：if (条件1) { 条件1为 true 的时候执行 } else if (条件2) { 条件2为 true 的时候执行 }

  • 会从头开始依次判断条件

    • 如果第一个条件为 true 了，那么就会执行后面的 {} 里面的内容
    • 如果第一个条件为 false，那么就会判断第二个条件，依次类推

  • 多个 {} ，只会有一个被执行，一旦有一个条件为 true 了，后面的就不在判断了

    // 第一个条件为 true，第二个条件为 false，最终会打印 “我是代码段1”
if (true) {alert('我是代码段1')
} else if (false) {alert('我是代码段2')           
}// 第一个条件为 true，第二个条件为 true，最终会打印 “我是代码段1”
// 因为只要前面有一个条件满足了，就不会继续判断了
if (true) {alert('我是代码段1')
} else if (true) {alert('我是代码段2')
}// 第一个条件为 false，第二个条件为 true，最终会打印 “我是代码段2”
// 只有前一个条件为 false 的时候才会继续向后判断
if (false) {alert('我是代码段1')
} else if (true) {alert('我是代码段2')
}// 第一个条件为 false，第二个条件为 false，最终什么也不会发生
// 因为当所有条件都为 false 的时候，两个 {} 里面的代码都不会执行
if (false) {alert('我是代码段1')
} else if (false) {alert('我是代码段2')
}
if else if … else 语句

  • 和之前的 if else if ... 基本一致，只不过是在所有条件都不满足的时候，执行最后 else 后面的 {}

    // 第一个条件为 false，第二个条件为 false，最终会打印 “我是代码段3”
// 只有前面所有的条件都不满足的时候会执行 else 后面的 {} 里面的代码
// 只要前面有一个条件满足了，那么后面的就都不会执行了
if (false) {alert('我是代码段1')
} else if (false) {alert('我是代码段2')
} else {alert('我是代码段3')
}

SWITCH 条件分支结构（重点）

  • 也是条件判断语句的一种

  • 是对于某一个变量的固定值判断

  • 语法：

    switch (要判断的变量) {case 情况1:  //要判断的变量 === 情况1 情况1要执行的代码breakcase 情况2:情况2要执行的代码breakcase 情况3:情况3要执行的代码breakdefault:上述情况都不满足的时候执行的代码
}default 默认
case 情况
break 中断
switch 开关
    • 要判断某一个变量 等于 某一个值得时候使用

  • 例子🌰： 根据变量给出的数字显示是星期几

    var week = 1switch (week) {case 1://week===1alert('星期一')breakcase 2:alert('星期二')breakcase 3:alert('星期三')breakcase 4:alert('星期四')breakcase 5:alert('星期五')breakcase 6:alert('星期六')breakcase 7:alert('星期日')breakdefault:alert('请输入一个 1 ～ 7 之间的数字')
}

  • case 不写break 穿透效果

三元运算（扩展）

  • 三元运算，就是用 两个符号 组成一个语句

  • 三元运算只是对 if else 语句的一个简写形式

  • 语法： 条件 ? 条件为 true 的时候执行 : 条件为 false 的时候执行

    var age = 18;
age >= 18 ? alert('已经成年') : alert('没有成年')

七、循环结构（重点）

  • 循环结构，就是根据某些给出的条件，重复的执行同一段代码
  • 循环必须要有某些固定的内容组成
    1. 初始化 i=0
    2. 条件判断 i<10
    3. 要执行的代码
    4. 自身改变 i

WHILE 循环

  • while，中文叫 当…时，其实就是当条件满足时就执行代码，一旦不满足了就不执行了

  • 语法 while (条件) { 满足条件就执行 }

  • 因为满足条件就执行，所以我们写的时候一定要注意，就是设定一个边界值，不然就一直循环下去了

    // 1. 初始化条件
var num = 0;
// 2. 条件判断
while (num < 10) {// 3. 要执行的代码console.log('当前的 num 的值是 ' + num)// 4. 自身改变num = num + 1
}
    • 如果没有自身改变，那么就会一直循环不停了

DO WHILE 循环

  • 是一个和 while 循环类似的循环

  • while 会先进行条件判断，满足就执行，不满足直接就不执行了

  • 但是 do while 循环是，先不管条件，先执行一回，然后在开始进行条件判断

  • 语法： do { 要执行的代码 } while (条件)

    // 下面这个代码，条件一开始就不满足，但是依旧会执行一次 do 后面 {} 内部的代码
var num = 10
do {console.log('我执行了一次')num = num + 1
} while (num < 10)

FOR 循环(常用)

  • 和 while 和 do while 循环都不太一样的一种循环结构

  • 道理是和其他两种一样的，都是循环执行代码的

  • 语法： for (var i = 0; i < 10; i++) { 要执行的代码 }

    // 把初始化，条件判断，自身改变，写在了一起
for (var i = 0; i < 10; i++) {// 这里写的是要执行的代码console.log(i)
}// 控制台会依次输出 0 ~ 9

  • 这个只是看起来不太舒服，但是用起来比较好用

BREAK 终止循环(常用)

  • 在循环没有进行完毕的时候，因为我设置的条件满足，提前终止循环

  • 比如：我要吃五个包子，吃到三个的时候，不能在吃了，我就停止吃包子这个事情

  • 要终止循环，就可以直接使用 break 关键字

  • 结束整个循环，break所在的循环完全结束了

    for (var i = 1; i <= 5; i++) {// 每循环一次，吃一个包子console.log('我吃了一个包子')// 当 i 的值为 3 的时候，条件为 true，执行 {} 里面的代码终止循环// 循环就不会继续向下执行了，也就没有 4 和 5 了if (i === 3) {break}
}

CONTINUE 结束本次循环

  • 在循环中，把循环的本次跳过去，继续执行后续的循环

  • 比如：吃五个包子，到第三个的时候，第三个掉地下了，不吃了，跳过第三个，继续吃第四个和第五个

  • 跳过本次循环，就可以使用 continue 关键字

    for (var i = 1; i <= 5; i++) {// 当 i 的值为 3 的时候，执行 {} 里面的代码// {} 里面有 continue，那么本次循环后面的代码就都不执行了// 自动算作 i 为 3 的这一次结束了，去继续执行 i = 4 的那次循环了if (i === 3) {console.log('这个是第三个包子，掉地下了，我不吃了')continue}console.log('我吃了一个包子')
}

八、函数

  • 我们代码里面所说的函数和我们上学的时候学习的什么三角函数、二次函数之类的不是一个东西

函数的概念

  • 对于 js 来说，函数就是把任意一段代码放在一个 盒子 里面

  • 在我想要让这段代码执行的时候，直接执行这个 盒子 里面的代码就行

  • 先看一段代码

    // 这个是我们以前写的一段代码
for (var i = 0; i < 10; i++) {console.log(i)
}// 函数，这个 {} 就是那个 “盒子”
function fn() {// 这个函数我们以前写的代码for (var i = 0; i < 10; i++) {console.log(i)}
}
fn()

函数的两个阶段（重点）

  • 按照我们刚才的说法，两个阶段就是 放在盒子里面 和 让盒子里面的代码执行
函数定义阶段

  • 定义阶段就是我们把代码 放在盒子里面

  • 我们就要学习怎么 放进去，也就是书写一个函数

  • 我们有两种定义方式 声明式 和 赋值式

声明式

  • 使用 function 这个关键字来声明一个函数

  • 语法：

    function fn() {// 一段代码  函数体
}
// function: 声明函数的关键字，表示接下来是一个函数了
// fn: 函数的名字，我们自己定义的（遵循变量名的命名规则和命名规范）
// (): 必须写，是用来放参数的位置（一会我们再聊）
// {}: 就是我们用来放一段代码的位置（也就是我们刚才说的 “盒子”）
赋值式

  • 其实就是和我们使用 var 关键字是一个道理了

  • 首先使用 var 定义一个变量，把一个函数当作值直接赋值给这个变量就可以了

  • 语法：

    var fn = function () {// 一段代码
}
// 不需要在 function 后面书写函数的名字了，因为在前面已经有了
函数调用阶段
  • 就是让 盒子里面 的代码执行一下
  • 让函数执行
  • 两种定义函数的方式不同，但是调用函数的方式都以一样的
调用一个函数

  • 函数调用就是直接写 函数名() 就可以了

    // 声明式函数
function fn() {console.log('我是 fn 函数')
}// 调用函数
fn()// 赋值式函数
var fn2 = function () {console.log('我是 fn2 函数')
}// 调用函数
fn2()
    • 注意： 定义完一个函数以后，如果没有函数调用，那么写在 {} 里面的代码没有意义，只有调用以后才会执行
调用上的区别

  • 虽然两种定义方式的调用都是一样的，但是还是有一些区别的

  • 声明式函数： 调用可以在 定义之前或者定义之后

    
// 可以调用
fn()// 声明式函数
function fn() {console.log('我是 fn 函数')
}// 可以调用
fn()

  • 赋值式函数： 调用只能在 定义之后

    // 会报错
fn()// 赋值式函数
var fn = function () {console.log('我是 fn 函数')
}// 可以调用
fn()

函数的参数（重点）

  • 我们在定义函数和调用函数的时候都出现过 ()

  • 现在我们就来说一下这个 () 的作用

  • 就是用来放参数的位置

  • 参数分为两种 形参 和 实参

    // 声明式
function fn(行参写在这里) {// 一段代码
}fn(实参写在这里)// 赋值式函数
var fn = function (行参写在这里) {// 一段代码
}
fn(实参写在这里)
形参和实参的作用

  1. 行参

    • 就是在函数内部可以使用的变量，在函数外部不能使用

    • 每写一个单词，就相当于在函数内部定义了一个可以使用的变量（遵循变量名的命名规则和命名规范）

    • 多个单词之间以 , 分隔

      // 书写一个参数
function fn(num) {// 在函数内部就可以使用 num 这个变量
}var fn1 = function (num) {// 在函数内部就可以使用 num 这个变量
}// 书写两个参数
function fun(num1, num2) {// 在函数内部就可以使用 num1 和 num2 这两个变量
}var fun1 = function (num1, num2) {// 在函数内部就可以使用 num1 和 num2 这两个变量
}

    • 如果只有行参的话，那么在函数内部使用的值个变量是没有值的，也就是 undefined

    • 行参的值是在函数调用的时候由实参决定的

  2. 实参

    • 在函数调用的时候给行参赋值的

    • 也就是说，在调用的时候是给一个实际的内容的

      function fn(num) {// 函数内部可以使用 num 
}// 这个函数的本次调用，书写的实参是 100
// 那么本次调用的时候函数内部的 num 就是 100
fn(100) // 这个函数的本次调用，书写的实参是 200
// 那么本次调用的时候函数内部的 num 就是 200
fn(200)

    • 函数内部的行参的值，由函数调用的时候传递的实参决定

    • 多个参数的时候，是按照顺序一一对应的

      function fn(num1, num2) {// 函数内部可以使用 num1 和 num2
}// 函数本次调用的时候，书写的参数是 100 和 200
// 那么本次调用的时候，函数内部的 num1 就是 100，num2 就是 200
fn(100, 200)
参数个数的关系

  1. 行参比实参少

    • 因为是按照顺序一一对应的

    • 行参少就会拿不到实参给的值，所以在函数内部就没有办法用到这个值

      function fn(num1, num2) {// 函数内部可以使用 num1 和 num2
}// 本次调用的时候，传递了两个实参，100 200 和 300
// 100 对应了 num1，200 对应了 num2，300 没有对应的变量
// 所以在函数内部就没有办法依靠变量来使用 300 这个值
fn(100, 200, 300)

  2. 行参比实参多

    • 因为是按照顺序一一对应的

    • 所以多出来的行参就是没有值的，就是 undefined

      function fn(num1, num2, num3) {// 函数内部可以使用 num1 num2 和 num3
}// 本次调用的时候，传递了两个实参，100 和 200
// 就分别对应了 num1 和 num2
// 而 num3 没有实参和其对应，那么 num3 的值就是 undefined
fn(100, 200)

函数的return（重点）

  • return 返回的意思，其实就是给函数一个 返回值 和 终断函数
终断函数

  • 当我开始执行函数以后，函数内部的代码就会从上到下的依次执行

  • 必须要等到函数内的代码执行完毕

  • 而 return 关键字就是可以在函数中间的位置停掉，让后面的代码不在继续执行

    function fn() {console.log(1)console.log(2)console.log(3)// 写了 return 以后，后面的 4 和 5 就不会继续执行了returnconsole.log(4)console.log(5)
}// 函数调用
fn()
返回值

  • 函数调用本身也是一个表达式，表达式就应该有一个值出现

  • 现在的函数执行完毕之后，是不会有结果出现的

    // 比如 1 + 2 是一个表达式，那么 这个表达式的结果就是 3
console.log(1 + 2) // 3function fn() {// 执行代码
}// fn() 也是一个表达式，这个表达式就没有结果出现
console.log(fn()) // undefined

  • return 关键字就是可以给函数执行完毕一个结果

    function fn(a) {// 执行代码return 100
}// 此时，fn() 这个表达式执行完毕之后就有结果出现了
console.log(fn()) // 100
    • 我们可以在函数内部使用 return 关键把任何内容当作这个函数运行后的结果

函数的优点

  • 函数就是对一段代码的封装，在我们想调用的时候调用
  • 函数的几个优点
    1. 封装代码，使代码更加简洁
    2. 复用，在重复功能的时候直接调用就好
    3. 代码执行时机，随时可以在我们想要执行的时候执行

预解析（重点） 声明提升

  • 预解析 其实就是聊聊 js 代码的编译和执行
  • js 是一个解释型（脚本）语言，就是在代码执行之前，先对代码进行通读和解释，然后在执行代码
  • 也就是说，我们的 js 代码在运行的时候，会经历两个环节 解释代码 和 执行代码
解释代码

  • 因为是在所有代码执行之前进行解释，所以叫做 预解析（预解释）

  • 需要解释的内容有两个

    • 声明式函数
      • 在内存中先声明有一个变量名是函数名，并且这个名字代表的内容是一个函数
    • var 关键字
      • 在内存中先声明有一个变量名

  • 看下面一段代码

    fn()
console.log(num)//undefinedfunction fn() {console.log('我是 fn 函数')console.log(a)//undefinedvar a = 200;
}var num = 100

  • 经过预解析之后可以变形为(声明提升)

    function fn() {var a;console.log('我是 fn 函数')console.log(a)  var a = 200  
}
var numfn()
console.log(num)
num = 100

  • 赋值式函数会按照 var 关键字的规则进行预解析

作用域（重点）

  • 什么是作用域（上下文），就是一个变量可以生效的范围
  • 变量不是在所有地方都可以使用的，而这个变量的使用范围就是作用域
全局作用域

  • 全局作用域是最大的作用域

  • 在全局作用域中定义的变量可以在任何地方使用

  • 页面打开的时候，浏览器会自动给我们生成一个全局作用域 window

  • 这个作用域会一直存在，直到页面关闭就销毁了

    // 下面两个变量都是存在在全局作用域下面的，都是可以在任意地方使用的
var num = 100
var num2 = 200
局部作用域

  • 局部作用域就是在全局作用域下面有开辟出来的一个相对小一些的作用域

  • 在局部作用域中定义的变量只能在这个局部作用域内部使用

  • 在 JS 中只有函数能生成一个局部作用域，别的都不行

  • 每一个函数，都是一个局部作用域

    // 这个 num 是一个全局作用域下的变量 在任何地方都可以使用
var num = 100function fn() {// 下面这个变量就是一个 fn 局部作用域内部的变量// 只能在 fn 函数内部使用var num2 = 200
}fn()

变量使用规则（重点）

  • 有了作用域以后，变量就有了使用范围，也就有了使用规则
  • 变量使用规则分为两种，访问规则 和 赋值规则
访问规则

  • 当我想获取一个变量的值的时候，我们管这个行为叫做 访问

  • 获取变量的规则：

    • 首先，在自己的作用域内部查找，如果有，就直接拿来使用
    • 如果没有，就去上一级作用域查找，如果有，就拿来使用
    • 如果没有，就继续去上一级作用域查找，依次类推
    • 如果一直到全局作用域都没有这个变量，那么就会直接报错（该变量 is not defined）
    var num = 100function fn() {var num2 = 200function fun() {var num3 = 300console.log(num3) // 自己作用域内有，拿过来用console.log(num2) // 自己作用域内没有，就去上一级，就是 fn 的作用域里面找，发现有，拿过来用console.log(num) // 自己这没有，去上一级 fn 那里也没有，再上一级到全局作用域，发现有，直接用console.log(a) // 自己没有，一级一级找上去到全局都没有，就会报错}fun()
}fn()

  • 变量的访问规则 也叫做 作用域的查找机制

  • 作用域的查找机制只能是向上找，不能向下找

    function fn() {var num = 100
}
fn()console.log(num) // 发现自己作用域没有，自己就是全局作用域，没有再上一级了，直接报错
赋值规则

  • 当你想给一个变量赋值的时候，那么就先要找到这个变量，在给他赋值

  • 变量赋值规则：

    • 先在自己作用域内部查找，有就直接赋值
    • 没有就去上一级作用域内部查找，有就直接赋值
    • 还没有再去上一级作用域查找，有就直接赋值
    • 如果一直找到全局作用域都没有，那么就把这个变量定义为全局变量，再给他赋值
    function fn() {num = 100
}
fn()// fn 调用以后，要给 num 赋值
// 查看自己的作用域内部没有 num 变量
// 就会向上一级查找
// 上一级就是全局作用域，发现依旧没有
// 那么就会把 num 定义为全局的变量，并为其赋值
// 所以 fn() 以后，全局就有了一个变量叫做 num 并且值是 100
console.log(num) // 100

递归函数（难点）

  • 什么是递归函数

  • 在编程世界里面，递归就是一个自己调用自己的手段

  • 递归函数： 一个函数内部，调用了自己，循环往复

    // 下面这个代码就是一个最简单的递归函数
// 在函数内部调用了自己，函数一执行，就调用自己一次，在调用再执行，循环往复，没有止尽
function fn() {fn()
}
fn()

  • 其实递归函数和循环很类似

  • 需要有初始化，自增，执行代码，条件判断的，不然就是一个没有尽头的递归函数，我们叫做 死递归(爆栈)

简单实现一个递归

  • 我们先在用递归函数简单实现一个效果

  • 需求： 求 1 至 5 的和

    • 先算 1 + 2 得 3
    • 再算 3 + 3 得 6
    • 再算 6 + 4 得 10
    • 再算 10 + 5 得 15
    • 结束

  • 开始书写，写递归函数先要写结束条件（为了避免出现 “死递归”）

    function add(n) {// 传递进来的是 1// 当 n === 5 的时候要结束if (n === 5) {return 5}
}add(1)

  • 再写不满足条件的时候我们的递归处理

    function add(n) {// 传递进来的是 1// 当 n === 5 的时候要结束if (n === 5) {return 5} else {// 不满足条件的时候，就是当前数字 + 比自己大 1 的数字return n + add(n + 1)}
}
add(1)简单了解对象

常见的的事件 和利用事件触发函数执行

给按钮设置id为btn
var fn = function(){}
fn()
//点击事件
btn.onclick = function(){}
给输入框设置id为ipt
//内容改变事件
ipt.onchange = function(){}

简单了解对象

  • 对象是一个复杂数据类型

  • 其实说是复杂，但是没有很复杂，只不过是存储了一些基本数据类型的一个集合.o

    var obj = {num: 100,str: 'hello world',boo: true
}

  • 这里的 {} 和函数中的 {} 不一样

  • 函数里面的是写代码的，而对象里面是写一些数据的

  • 对象就是一个键值对的集合

  • {} 里面的每一个键都是一个成员,属性

  • 也就是说，我们可以把一些数据放在一个对象里面，那么他们就互不干扰了

  • 其实就是我们准备一个房子，把我们想要的数据放进去，然后把房子的地址给到变量名，当我们需要某一个数据的时候，就可以根据变量名里面存储的地址找到对应的房子，然后去房子里面找到对应的数据obj.num

创建一个对象

字面量的方式创建一个对象

// 创建一个空对象
var obj = {}// 像对象中添加成员
obj.name = 'Jack'
obj.age = 18

内置构造函数的方式创建对象

// 创建一个空对象
var obj = new Object()// 向对象中添加成员
obj.name = 'Rose'
obj.age = 20

Object是js` 内置给我们的构造函数，用于创建一个对象使用的

构造函数

构造函数就是一个普通的函数，但是有自己的特征和用法。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/589326.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

Mybatis Java API - SqlSessionFactoryBuilder

Mybatis Java API - SqlSessionFactoryBuilder

在MyBatis中&#xff0c;用于与数据库进行交互的主要Java接口是SqlSession。通过这个接口&#xff0c;您可以执行命令、获取映射器并管理事务。稍后我们将更详细地讨论SqlSession本身&#xff0c;但首先我们必须学习如何获取SqlSession的实例。SqlSession是由SqlSessionFactory…
阅读更多...
C++17中的内联变量

C++17中的内联变量

在C11中&#xff1a; (1).声明为constexpr的函数隐式地是内联函数; (2).deleted函数隐式地是一个内联函数。 在内联函数中&#xff1a; 1.所有函数定义中的函数局部静态对象(function-local static object)在所有翻译单元之间共享(它们都引用一个翻译单…
阅读更多...
【c++————————构造函数和析构函数】

【c++————————构造函数和析构函数】

【c————————构造函数和析构函数】 欢迎阅读新一期的c模块————构造函数和析构函数 ✒️个人主页&#xff1a;-Joker- &#x1f3f7;️专栏&#xff1a;C &#x1f4dc;代码仓库&#xff1a;c_code &#x1f339;&#x1f339;欢迎大佬们的阅读和三连关注&#xff0c…
阅读更多...
软件集成测试

软件集成测试

软件集成测试是将各个独立的软件模块组合起来&#xff0c;并测试它们之间的接口和交互是否正常工作的过程。下面是软件集成测试的一般步骤&#xff1a; 确定测试策略&#xff1a;确定集成测试的目标、范围和测试策略。确定要测试的软件模块和它们之间的依赖关系。 设计测试用例…
阅读更多...
Dependency Track：智能组件分析平台。

Dependency Track：智能组件分析平台。

Dependency Track：智能组件分析平台。 ############################# 免责声明：工具本身并无好坏，希望大家以遵守《网络安全法》相关法律为前提来使用该工具，支持研究学习，切勿用于非法犯罪活动，对于恶意使用该工具造成的损失，和本人及开发者无关。 ################…
阅读更多...
基于关键点的人脸对齐方法

基于关键点的人脸对齐方法

人脸旋转校正的一般步骤&#xff1a; 1.人脸检测&#xff1a;首先使用人脸检测算法来检测图像中的人脸位置。 2.人脸关键点检测&#xff1a;对于每张检测到的人脸&#xff0c;使用人脸关键点检测算法来检测人脸中的关键点&#xff0c;如眼睛、鼻子、嘴巴等。 &#xff08;项目…
阅读更多...
【leetcode100-026】【链表/快慢指针】环形链表II

【leetcode100-026】【链表/快慢指针】环形链表II

【题干】 给定一个链表的头节点 head &#xff0c;返回链表开始入环的第一个节点。 如果链表无环&#xff0c;则返回 null。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了表示给定链表中的环&#xff0c;评测系统…
阅读更多...
Linux | 解决问题Ubuntu重启无法进入系统以及网络无法连接【图文详解】

Linux | 解决问题Ubuntu重启无法进入系统以及网络无法连接【图文详解】

Ubuntu18.04重启无法进入系统&#xff0c;重开后如图 一直在加载系统内核4.15.0-213-generic,无法加载 错误原因 原本的系统是Ubuntu16.04,使用命令升级到Ubuntu18.04版本&#xff0c;升级重启后&#xff0c;远程无法连接&#xff01; 错误解决 第一步&#xff1a;进入GRUB…
阅读更多...
AIGC入门系列1：感性的认识扩散模型

AIGC入门系列1：感性的认识扩散模型

1、序言 大家好&#xff0c;欢迎来到AI手工星的频道&#xff0c;我是专注AI领域的手工星。AIGC已经成为AI又一个非常爆火的领域&#xff0c;并且与之前的AI模型不同&#xff0c;AIGC更适合普通人使用&#xff0c;我们不仅可以与chatgpt对话&#xff0c;也能通过绘画模型生成想…
阅读更多...
基于SpringBoot的线上学习资源智能推荐系统

基于SpringBoot的线上学习资源智能推荐系统

文章目录 项目介绍主要功能截图：部分代码展示设计总结项目获取方式🍅 作者主页：超级无敌暴龙战士塔塔开 🍅 简介：Java领域优质创作者🏆、 简历模板、学习资料、面试题库【关注我，都给你】 🍅文末获取源码联系🍅 项目介绍 基于SpringBoot的线上学习资源智能推荐系…
阅读更多...
使用ASP.NET MiniAPI 调试未匹配请求路径

使用ASP.NET MiniAPI 调试未匹配请求路径

本文将介绍如何在使用ASP.NET MiniAPI时调试未匹配到的请求路径。我们将详细讨论使用MapFallback方法、中间件等工具来解决此类问题。 1. 引言 ASP.NET MiniAPI是一个轻量级的Web API框架&#xff0c;它可以让我们快速地构建和部署RESTful服务。然而&#xff0c;在开发过程中如…
阅读更多...
Hystrix相关面试题及答案

Hystrix相关面试题及答案

1、什么是Hystrix&#xff0c;它是如何工作的&#xff1f; Hystrix是一个由Netflix开源的库&#xff0c;主要用于在分布式系统中提供延迟和容错功能&#xff0c;通过阻止服务故障的蔓延和提供回退机制来保护系统。它在服务架构中扮演着重要的角色&#xff0c;特别是在微服务架…
阅读更多...
PACC：数据中心网络的主动 CNP 生成方案

PACC：数据中心网络的主动 CNP 生成方案

PACC&#xff1a;数据中心网络的主动 CNP 生成方案 文章目录 PACC&#xff1a;数据中心网络的主动 CNP 生成方案PACC算法CNP数据结构PACC参数仿真结果参考文献 PACC算法 CNP数据结构 PACC参数 仿真结果 PACC Hadoop Load0.2 的情况&#xff1a; PACC Hadoop Load0.4 的情况&a…
阅读更多...
go slice源码探索（切片、copy、扩容）和go编译源码分析

go slice源码探索（切片、copy、扩容）和go编译源码分析

文章目录 概要一、数据结构二、初始化2.1、字面量2.2、下标截取2.2.1、截取原理 2.3、make关键字2.3.1、编译时 三、复制3.1、copy源码 四、扩容4.1、append源码 五&#xff1a;切片使用注意事项六&#xff1a;参考 概要 Go语言的切片&#xff08;slice&#xff09;是对数组的…
阅读更多...
axios的使用及说明

axios的使用及说明

目录 1.说明 2.直接使用 3.封装使用 4.注意 1.说明 官网&#xff1a;Axios 实例 | Axios中文文档 | Axios中文网 Axios 是一个基于 promise 网络请求库&#xff0c;作用于node.js 和浏览器中。 它是 isomorphic 的(即同一套代码可以运行在浏览器和node.js中)。在服务端它使…
阅读更多...
Java超高精度无线定位技术--UWB (超宽带)人员定位系统源码

Java超高精度无线定位技术--UWB (超宽带)人员定位系统源码

UWB室内定位技术是一种全新的、与传统通信技术有极大差异的通信新技术。它不需要使用传统通信体制中的载波&#xff0c;而是通过发送和接收具有纳秒或纳秒级以下的极窄脉冲来传输数据&#xff0c;从而具有GHz量级的带宽。 UWB&#xff08;超宽带&#xff09;高精度定位系统是一…
阅读更多...
java零拷贝zero copy MappedByteBuffer

java零拷贝zero copy MappedByteBuffer

目录 调用操作系统的 mmap 未使用 mmap 的文件通过网络传输的过程 使用 mmap 的文件通过网络传输的过程 使用例子 调用操作系统的 sendfile() 在 java 中的具体实现 mmap的优劣 mmap 的不足 mmap 的优点 mmap 的使用场景 对于零拷贝&#xff08;zero copy&#xff09…
阅读更多...
C语言实验4：指针

C语言实验4：指针

目录 一、实验要求 二、实验原理 1. 指针的基本概念 1.1 指针的定义 1.2 取地址运算符&#xff08;&&#xff09; 1.3 间接引用运算符&#xff08;*&#xff09; 2. 指针的基本操作 2.1 指针的赋值 2.2 空指针 3. 指针和数组 3.1 数组和指针的关系 3.2 指针和数…
阅读更多...
【Linux】内核编译 镜像制作

【Linux】内核编译 镜像制作

文章目录 一、Ubuntu内核编译1.1 为什么自己编译内核1.2 Ubuntu 内核源码下载1.21 内核的作用1.22 Linux内核与ubuntu内核1.23 Ubuntu内核源码获取 1.3 在Windows系统下编译ubuntu内核1.4 在Linux系统下编译ubuntu内核 二、镜像制作 一、Ubuntu内核编译 1.1 为什么自己编译内核…
阅读更多...
用LCD循环右移显示“Welcome to China“

用LCD循环右移显示“Welcome to China“

#include<reg51.h> //包含单片机寄存器的头文件 #include<intrins.h> //包含_nop_()函数定义的头文件 sbit RSP2^0; //寄存器选择位&#xff0c;将RS位定义为P2.0引脚 sbit RWP2^1; //读写选择位&#xff0c;将RW位定义为P2.1引脚 sbit EP2^2; //使能…
阅读更多...
最新文章

Copyright @ 2022~2023