深入浅出Javascript：语句和声明

Javascript 语句和声明

控制流程

Block

一个块语句可以用来管理零个或多个语句。该区块是由一对大括号分隔。

break

终止当前的循环，switch，label 语句，使程序跳到下一个语句执行。

continue

终止执行当前或标签循环的语句，直接执行下一个迭代循环。

Empty

空语句用来表示没有语句的情况，尽管 JavaScript 语法期望有语句提供。

if...else（常用~）

如果指定的条件是 true ，则执行相匹配的一个语句，若为 false，则执行另一个语句。

语法

if (condition) {
   statements1
} else {
   statements2
}

condition值为 true 或 false 的表达式

statement1如果条件值为 true 时执行的语句。可为任意语句，包括更深层的内部 if 语句。要执行多条语句，使用语句块 ({ ... }) 将这些语句分组；若不想执行语句，则使用空语句。

statement2如果条件值为 false 且 else 从句存在时执行的语句。可为任意语句，包括语句块和更深层的内部 if 语句。

注意：所有不是 undefined，null， 0，NaN，空字符串 ("")，以及任意对象，包括值为false的Boolean对象，在条件语句中都为true。
```
var b = new Boolean(false);
if (b) //表达式的值为true
```

switch（常用~）

计算表达式，将子句于表达式的值做匹配，执行与该值相关联的语句。

语法

 switch (expression) {
 case value1:
// 当 expression 的结果与 value1 匹配时，从此处开始执行
statements1；
[break;]
 case value2:
// 当 expression 的结果与 value2 匹配时，从此处开始执行
statements2;
[break;]
 ...
 case valueN:
// 当 expression 的结果与 valueN 匹配时，从此处开始执行
statementsN;
[break;]
 default:
// 如果 expression 与上面的 value 值都不匹配时，执行此处的语句
statements_def;
[break;]
}

expression一个用来与 case 子语句匹配的表达式。

case expressionN case 子语句，用来与 expression 匹配。

statementsN 如果 expression 匹配其对应的 case 子语句，则执行此处的语句。

statements_def 如果 expression 没有匹配到任何 case 子语句，则会执行此处的语句。

throw

抛出一个用户自定义的异常。

try...catch

标记一个语句块，并指定一个应该抛出异常的反馈。

声明

var（常用~）

声明一个变量，可同时初始化。

语法

var varname1 [= value1 [, varname2 [, varname3 ... [, varnameN]]]];

varnameN 变量名。变量名可以定义为任何合法标识符。
valueN 变量的初始化值。该值可以为任何合法表达式。

注意：

声明变量的作用域限制在其声明位置的上下文中，而非声明变量总是全局的。

function x() {
  y = 1;   // 在严格模式（strict mode）下会抛出ReferenceError异常。
  var z = 2;
}
x();    
console.log(y); // 打印"1" 。
console.log(z); // 抛出ReferenceError: z未在x外部声明。

声明变量在任何代码执行前创建，而非声明变量只有在执行赋值操作的时候才会被创建。

console.log(a); // 抛出ReferenceError。
console.log('still going...'); // 永不执行。

var a;
console.log(a);// 打印"undefined"或""（不同浏览器实现不同）。
console.log('still going...'); // 打印"still going..."。

声明变量是它所在上下文环境的不可配置属性（non-configurable property），非声明变量是可配置的（例如非声明变量可以被删除）。

var a = 1;
b = 2;
delete this.a; // 在严格模式（strict mode）下抛出TypeError，其他情况下执行失败并无任何提示。
delete this.b;
console.log(a, b); // 抛出ReferenceError。
// 'b'属性已经被删除。

let（ES6）

声明一个块级本地变量，可以同时初始化。

const（ES6）

声明一个只读的命名常量

函数和类

function（常用~）

声明一个指定参数的函数。

语法

function name([param,[, param,[..., param]]]) {
   [statements]
}

name 函数名

param 传递给函数的参数。一个函数最多有255个参数

statements 函数体

注意：一个被函数声明创建的函数是一个 Function 对象，具有 Function 对象的所有属性、方法和行为。函数也可以被表达式创建（两者区别在于函数声明提升，函数表达式不能提升）
```
hoisted(); // logs "foo"
function hoisted() {
  console.log("foo");
}    
//注意 function expressions 不会提升:
notHoisted(); // TypeError: notHoisted is not a function
var notHoisted = function() {
   console.log("bar");
};
```

Function*

构造函数使迭代器更容易使用。

return（常用~）

指定函数的返回值。

语法
```
return [[expression]];
```

expression 被返回的表达式。如果忽略，则返回 undefined。

用途1：中断一个函数的执行（用途2：闭包.默认情况下，函数是返回 undefined 的。想要返回一个其他的值，函数必须通过一个 return 语句指定返回值。关于闭包，参见深入浅出Javascript：闭包）

 function counter() {
 for (var count = 1; ; count++) {  // 无限循环
console.log(count + "A"); // 执行5次
  if (count === 5) {          
    return;
  }
  console.log(count + "B");  // 执行4次
}
 console.log(count + "C");  // 永远不会执行
}

counter();

// Output:
// 1A
// 1B
// 2A
// 2B
// 3A
// 3B
// 4A
// 4B
// 5A

class（ES6）

声明一个类。

迭代器

do...while

创建一个循环来执行语句，直到该语句条件表达式的值为false。先执行语句，再执行条件表达式，该语句至少会执行一次。

for（常用~）

创建一个由3个可选的表达式组成的循环，该循环用括号包裹，分号分割，并在循环体中执行语句。

语法

  for ([initialization]; [condition]; [final-expression])
  statement

initialization 一个表达式 (包含赋值语句) 或者变量声明。典型地被用于初始化一个计数器。该表达式可以使用var关键字声明新的变量。初始化中的变量不是该循环的局部变量，而是与该循环处在同样的作用域中。该表达式的结果无意义。

condition 一个条件表达式被用于确定每一次循环是否能被执行。如果该表达式的结果为true，循环体内的语句将被执行。这个表达式是可选的。如果被忽略，那么就被认为永远为true。如果计算结果为false，那么执行流程将被跳到for语句结构后面的第一条语句。

final-expression 每次循环的最后都要执行的表达式。执行时机是在下一次condition的计算之前。通常被用于更新或者递增计数器变量。

statement 只要condition的结果为true就会被执行的语句。要在循环体内执行多条语句，使用一个 block 结构 ({ ... }) 来包含要执行的语句。没有任何语句要执行，使用一个 empty 语句 (;)。

注意：for语句的所有的表达式都是可选的。当然可以忽略所有的表达式。同样的，确保使用了 break 语句来退出循环并且你还需要修改（递增）一个变量，以确保能够正常执行break语句。
```
var i = 0;
for (;;) {
  if (i > 3) break;
  console.log(i);
  i++;
}
```

for each...in（不建议使用）

通过指定的变量迭代对象所有属性的值。针对每个唯一的属性，会执行指定的语句块。

for...in

无序遍历对象的可枚举属性。语句针对每个唯一的属性。

for...of（ES6）

遍历可迭代的对象 (包括arrays, 类数组对象, iterators and generators)，对每个不同属性的属性，调用一个自定义的有执行语句的迭代钩子。

while

创建一个循环语句，循环会一直持续到该语句条件表达式的值为false。先执行条件表达式，然后执行语句。

其他

debugger

调用可用的调试功能。如果没有调试功能可用，该语句不生效。

export

用来导出函数，以便这些函数能够被导入到外部模块或其他script中。

import（ES6）

用来引入外部的模块或另一个script中导出的函数。

label

带标识的语句，与break或continue语句一起使用。

with（不建议使用）

拓展一个语句的作用域。