javascript基本语法标准 javascript的语法

认识JavaScript

1、什么是 JavaScript 语言？

JavaScript 是一种轻量级的脚本语言。所谓“脚本语言”，指的是它不具备开发操作系统的能力，而是只用来编写控制其他大型应用程序（比如浏览器）的“脚本”。

JavaScript 也是一种嵌入式语言。它本身提供的核心语法不算很多，只能用来做一些数学和逻辑运算。JavaScript 本身不提供任何与 I/O（输入/输出）相关的 API，都要靠宿主环境（host）提供，所以 JavaScript 只合适嵌入更大型的应用程序环境，去调用宿主环境提供的底层 API。

目前，已经嵌入 JavaScript 的宿主环境有多种，最常见的环境就是浏览器，另外还有服务器环境，也就是 Node 项目。

2、JavaScript 的基本语法

2.1、语句

JavaScript 程序的执行单位为行（line），也就是一行一行地执行。一般情况下，每一行就是一个语句。

语句和表达式的区别在于，前者主要为了进行某种操作，一般情况下不需要返回值；后者则是为了得到返回值，一定会返回一个值。语句以分号结尾，一个分号就表示一个语句结束。多个语句可以写在一行内。

var a = 1 + 3 ; var b = 'abc';

分号前面可以没有任何内容，JavaScript 引擎将其视为空语句。

;;;       // 3个空语句

表达式不需要分号结尾。一旦在表达式后面添加分号，则 JavaScript 引擎就将表达式视为语句，这样会产生一些没有任何意义的语句。

1 + 3;
'abc';

2.2、变量

2.2.1 概念

变量是对“值”的具名引用。变量就是为“值”起名，然后引用这个名字，就等同于引用这个值。变量的名字就是变量名。

var a = 1;

上面的代码先声明变量a，然后在变量a与数值1之间建立引用关系，称为将数值1“赋值”给变量a。以后，引用变量名a就会得到数值1。最前面的var，是变量声明命令。它表示通知解释引擎，要创建一个变量a。

注意，JavaScript 的变量名区分大小写，A和a是两个不同的变量。

//  var a = 1; => 变量的声明和赋值，是分开的两个步骤
var a;
a = 1;

如果只是声明变量而没有赋值，则该变量的值是undefined。undefined是一个特殊的值，表示“无定义”。

var a;
a // undefined
a = 1;    // 基本等同  var a = 1;

但是，不写var的做法，不利于表达意图，而且容易不知不觉地创建全局变量，所以建议总是使用var命令声明变量。

如果一个变量没有声明就直接使用，JavaScript 会报错，告诉你变量未定义。

x  // ReferenceError: x is not defined

可以在同一条var命令中声明多个变量。

var a, b;

JavaScript 是一种动态类型语言，也就是说，变量的类型没有限制，变量可以随时更改类型。

var a = 1;   // 数值
a = 'hello';   // 字符串
// 第二次赋值的时候，因为变量a已经存在，所以不需要使用var命令。

如果使用var重新声明一个已经存在的变量，是无效的。

var x = 1;
var x;   // 变量x声明了两次，第二次声明是无效的。
x  // 1

如果变量第二次声明的时候还进行了赋值，则会覆盖掉前面的值。

var x = 1;
var x = 2;
// 等同于
var x = 1;
var x;
x = 2;

2.2.2 变量提升

JavaScript 引擎的工作方式是，先解析代码，获取所有被声明的变量，然后再一行一行地运行。 这造成的结果，就是所有的变量的声明语句，都会被提升到代码的头部，这就叫做 变量提升（hoisting）。

console.log(a);
var a = 1;

上面代码首先使用console.log方法，在控制台显示变量a的值。这时变量a还没有声明和赋值，按理说这是一种错误的做法，但是实际上不会报错。因为存在变量提升，真正运行的是下面的代码。

var a;
console.log(a);
a = 1;

最后的结果是显示undefined，表示变量a已声明，但还未赋值。

2.3、标识符

标识符（identifier）指的是用来识别各种值的合法名称。最常见的标识符就是变量名，以及后面要提到的函数名。JavaScript 语言的标识符对大小写敏感，所以a和A是两个不同的标识符。

标识符有一套命名规则，不符合规则的就是非法标识符。JavaScript 引擎遇到非法标识符，就会报错。

简单说，标识符命名规则如下：

• 第一个字符，可以是任意 Unicode 字母（包括英文字母和其他语言的字母），以及美元符号（$）和下划线（_）。
• 第二个字符及后面的字符，除了 Unicode 字母、美元符号和下划线，还可以用数字0-9。

下面这些都是合法的标识符：

abc0
_tyu
$ghjk
π
var 临时变量 = 1;       // 中文是合法的标识符，可以用作变量名。

下面这些则是不合法的标识符:

1a  // 第一个字符不能是数字
23  // 同上
***  // 标识符不能包含星号
a+b  // 标识符不能包含加号
-d  // 标识符不能包含减号或连词线

JavaScript 有一些保留字，不能用作标识符：

arguments、break、case、catch、class、const、continue、
debugger、default、delete、do、else、enum、eval、export、
extends、false、finally、for、function、if、implements、import、
in、instanceof、interface、let、new、null、package、private、
protected、public、return、static、super、switch、this、throw、
true、try、typeof、var、void、while、with、yield

2.4、注释

源码中被 JavaScript 引擎忽略的部分就叫做注释，它的作用是对代码进行解释。JavaScript 提供两种注释的写法：一种是单行注释，用//起头；另一种是多行注释，放在/和/之间。

// （单行注释）哈哈哈哈哈哈

/*
 （多行注释）
  啦啦啦啦啦
  嘻嘻嘻嘻
*/

2.5、区块

2.5.1 概念

JavaScript 使用大括号，将多个相关的语句组合在一起，称为“区块”（block）。

对于var命令来说，JavaScript 的区块不构成单独的作用域。

{
  var a = 1;
}

a // 1

上面代码在区块内部，使用var命令声明并赋值了变量a，然后在区块外部，变量a依然有效，区块对于var命令不构成单独的作用域，与不使用区块的情况没有任何区别。在 JavaScript 语言中，单独使用区块并不常见，区块往往用来构成其他更复杂的语法结构，比如for、if、while、function等。

2.5.2 作用域

简单来说，作用域就是变量与函数的可访问范围，即作用域控制着变量与函数的可见性和生命周期。

js的作用域是靠函数来形成的，也就是说一个函数的变量在函数外不可以访问。

作用域可分为：

• 全局作用域
• 局部作用域
• ES6的块级作用域

全局作用域：任何地方都能访问到的对象

1、函数外面定义的变量

var a = 7;

function test(){
	var t = 4;
	return t;
}

console.log(a)               // 7
console.log(t)				 // error报错
console.log(test())          // 4

2、函数内未使用var声明的变量

var a = 7;

function test(){
	t = 4;
	return t;
}

console.log(a)               // 7
console.log(t)				 // 4
console.log(test())          // 4

3、window对象的属性

局部作用域：一般只在固定的代码片段内可访问到的对象

function test(){
	var t = 4;
	return t;
}

console.log(t)				 // error报错
console.log(test())          // 4

块级作用域：let & const

2.5.3 作用域链

1.当执行函数时，总是先从函数内部找寻局部变量
2.如果内部找不到（函数的局部作用域没有），则会向创建函数的作用域（声明函数的作用域）寻找，依次向上

var a = 1;

function fun(){
	var a = 10;
	function fn1(){
		var a = 20;
		console.log(a)
	}
	function fn2(){
		console.log(a)
	}
	fn1();
	fn2();
}

fun();
console.log(a)

// 20
// 10
// 1

当执行fn1时，作用域链的链表的结构是 fn1 -> fun -> window，从链表的开头寻找变量a，即fn1函数内部找变量a，找到了，结果是20。

同样，执行fn2时，作用域链的链表的结构是 fn2 -> fun -> window，从链表的开头寻找变量a，即fn2函数内部找变量a，没找到，于是从fn内部找变量a，找到了，结果是10。

最后在最外层打印出变量a，直接从变量a的作用域即全局作用域内寻找，结果为1。

2.5.4 闭包

2.5.4.1 概念

正常情况下函数外部是访问不到函数内部的作用域变量，而闭包可以让我们从内部函数访问外部函数作用域。在本质上，闭包就是将函数内部和函数外部连接起来的一座桥梁。

2.5.4.2 举例说明

案例1

function init() {
    var name = "ABC";       // name 是一个被 init 创建的局部变量
    function displayName() {       // displayName() 是内部函数，一个闭包
       console.log (name);           // 使用了父函数中声明的变量
    }
    displayName();
}
init();

// ABC

案例2

function makeFunc() {
    var name = "ABC";
    function displayName() {
        console.log(name);
    }
    return displayName;
}

var myFunc = makeFunc();
myFunc();

// ABC

闭包是由函数以及声明该函数的词法环境组合而成的。该环境包含了这个闭包创建时作用域内的任何局部变量。在本例子中，myFunc 是执行 makeFunc 时创建的 displayName 函数实例的引用。displayName 的实例维持了一个对它的词法环境（变量 name 存在于其中）的引用。因此，当 myFunc 被调用时，变量 name 仍然可用，其值 Mozilla 就被传递到alert中。

2.5.4.3 特点

表象：函数套函数

优点：闭包可以形成独立的空间，永久的保存局部变量。

缺点：保存中间值的状态缺点是容易造成内存泄漏，因为闭包中的局部变量永远不会被回收

2.6、条件语句

JavaScript 提供if结构和switch结构，完成条件判断，即只有满足预设的条件，才会执行相应的语句。

2.6.1 if 结构

if结构先判断一个表达式的布尔值，然后根据布尔值的真伪，执行不同的语句。所谓布尔值，指的是 JavaScript 的两个特殊值，true表示真，false表示伪。

if (布尔值)
	 语句;
// 或者
if (布尔值) 语句;

上面是if结构的基本形式。需要注意的是，“布尔值”往往由一个条件表达式产生的，必须放在圆括号中，表示对表达式求值。如果表达式的求值结果为true，就执行紧跟在后面的语句；如果结果为false，则跳过（不执行）紧跟在后面的语句。

if (m === 1)
  m = m + 1;

上面代码表示，只有在m等于1时，才会将其值加上1。

这种写法要求条件表达式后面只能有一个语句。如果想执行多个语句，必须在if的条件判断之后，加上大括号，表示代码块（多个语句合并成一个语句）。

if (m === 1) {
  m += 1;
}

建议总是在if语句中使用大括号，因为这样方便插入语句。

注意，if后面的表达式之中，不要混淆赋值表达式（=）、严格相等运算符（===）和相等运算符（= =）。尤其是赋值表达式不具有比较作用。

var x = 1;
var y = 2;
if (x = y) {
  console.log(x);      // "2"
}

2.6.2 if…else 结构

if代码块后面，还可以跟一个else代码块，表示不满足条件时，所要执行的代码。

if () {
  // 满足条件时，执行的语句
} else {
  // 不满足条件时，执行的语句
}

对同一个变量进行多次判断时，多个if…else语句可以连写在一起。

if (m === 0) {
  // 语句1...
} else if (m === 1) {
  // 语句2...
} else if (m === 2) {
  // 语句3...
} else {
  // 语句4...
}

else代码块总是与离自己最近的那个if语句配对。

2.6.3 switch 结构

多个if…else连在一起使用的时候，可以转为使用更方便的switch结构。

switch (m) {
  case "1":
    // ...
    break;
  case "2":
    // ...
    break;
  default:
    // ...
}

上面代码根据变量m的值，选择执行相应的case。如果所有case都不符合，则执行最后的default部分。需要注意的是，每个case代码块内部的break语句不能少，否则会接下去执行下一个case代码块，而不是跳出switch结构。

2.6.4 三元运算符

三元运算符可以被视为if…else…的简写形式：

(条件) ? 表达式1 : 表达式2

上面代码中，如果“条件”为true，则返回“表达式1”的值，否则返回“表达式2”的值。

2.7、循环语句

循环语句用于重复执行某个操作，它有多种形式。

2.7.1 while 循环

While语句包括一个循环条件和一段代码块，只要条件为真，就不断循环执行代码块。

while (条件)
  语句;

// 或者
while (条件) 语句;

while语句的循环条件是一个表达式，必须放在圆括号中。代码块部分，如果只有一条语句，可以省略大括号，否则就必须加上大括号。

while (条件) {
  语句;
}

案例：

var i = 0;

while (i < 100) {
  console.log('i 当前为：' + i);
  i = i + 1;
}

上面的代码将循环100次，直到i等于100为止。

无限循环案例：

while (true) {
  console.log('Hello, world');
}

因为循环条件总是为真，所以上面代码将无限循环。

2.7.2 for 循环

for语句是循环命令的另一种形式，可以指定循环的起点、终点和终止条件。它的格式如下：

for (初始值; 条件; 递增)
  语句

// 或者

for (初始值; 条件; 递增) {
  语句
}

• 初始值：确定循环变量的初始值，只在循环开始时执行一次。
• 条件：每轮循环开始时，都要执行这个条件表达式，只有值为真，才继续进行循环。
• 递增：每轮循环的最后一个操作，通常用来递增循环变量。

案例：

for (var i = 0; i < 3; i++) {
  console.log(i);
}
// 0
// 1
// 2

所有for循环，都可以改写成while循环。上面的例子改为while循环，代码如下：

var x = 3;
var i = 0;

while (i < x) {
  console.log(i);
  i++;
}

for语句的三个部分（初始值、条件、递增），可以省略任何一个，也可以全部省略。

// 无限循环
for ( ; ; ){
  console.log('Hello World');
}

2.7.3 do…while 循环

do…while循环与while循环类似，唯一的区别就是先运行一次循环体，然后判断循环条件。

do
  语句
while (条件);

// 或者
do {
  语句
} while (条件);

不管条件是否为真，do…while循环至少运行一次，这是这种结构最大的特点。另外，while语句后面的分号注意不要省略。

案例：

var x = 3;
var i = 0;

do {
  console.log(i);
  i++;
} while(i < x);
// 0
// 1
// 2

2.7.4 break 语句和 continue 语句

break语句用于跳出代码块或循环。

var i = 0;

while(i < 100) {
  console.log('i 当前为：' + i);
  i++;
  if (i === 10) break;
}

上面代码只会执行10次循环，一旦i等于10，就会跳出循环。
for循环也可以使用break语句跳出循环。

for (var i = 0; i < 5; i++) {
  console.log(i);
  if (i === 3)
    break;
}
// 0
// 1
// 2
// 3

continue语句用于立即终止本轮循环，返回循环结构的头部，开始下一轮循环。

var i = 0;

while (i < 100){
  i++;
  if (i % 2 === 0) continue;
  console.log('i 当前为：' + i);
}
// i 当前为：1
// i 当前为：3
// i 当前为：5
// i 当前为：7
// i 当前为：9

上面代码只有在i为奇数时，才会输出i的值。如果i为偶数，则直接进入下一轮循环。