【慕课网】JavaScript语句

JavaScript程序由语句组成，语句遵守特定的语法规则。例如：if语句、while语句、with语句等等。

block、break、continue、empty、if…else、switch、try catch、var、function、return、do…while、for、for…in、while、debugger、label、with

1.block语句、var语句

块语句可以组合0~多个语句，块语句用一对花括号定义，但是在实际开发中通常不会单独用块语句，而会和if,while等结合使用。

注意：

{a:1,b:2}   //会报语法错误，SyntaxError
var a = {a:1,b:2} //ok

因为直接以{开头的话，会被解析成块语句，如果需要被理解为对象自变量表达式可以以下面的形式书写。

JS中没有块级作用域！！！有函数作用域、全局作用域等。

常见误区：var a=b=1;虽然能达到给a,b都赋值为1，但是此时b是一个全局作用域，最好不要使用这种方法,在一个语句中定义多个变量，可以使用逗号隔开的方法，例如var a=1,b=1;

function foo(){
	var a = b =1;
}
foo();

console.log(typeof a);   //undefined
console.log()typeof b;   //number

2.try-catch语句

try语句如果抛出异常，则执行catch语句，否则不执行，无论有没有异常，都执行finally语句；try语句必须跟catch或finally语句中至少一个组合使用。
try catch语句的嵌套语句执行顺序：
1）如果内部嵌套的try语句抛出异常，但内部没有相配套的catch语句，先执行内部的finally语句，然后跳到最近一层的catch语句执行。
2）如果内部嵌套的try语句抛出异常，内部有相配套的catch语句，先执行此语句处理异常，再执行内部的finally语句。不会再在外部处理异常。
3）如果内部嵌套的try语句抛出异常，内部有相配套的catch语句，并且catch语句也抛出异常，如果内部的catch语句有对异常的处理，先执行异常处理语句，然后执行内部的finally语句，最后执行离内部catch语句抛出异常最近一层的catch语句处理异常。

try{
	throw "test";
}
catch(ex){
	console.log(ex);   //test
}
finally {
	console.log("finally");
}

//嵌套形式 执行顺序：try-finally-catch
try{
	try{
		throw new Error("oops");
	}
	finally{
		console.log("finally");
	}
}
catch(ex){
	conosle.log("outer",ex.message)
}

//嵌套形式 执行顺序：try-catch-finally,最外部的catch不执行，因为异常已经处理过了
try{
	try{
		throw new Error("oops");
	}
	catch(ex){
		console.log("inner",ex.message)
	}
	finally{
		console.log("finally");
	}
}
catch(ex){
	conosle.log("outer",ex.message)
}

//嵌套形式 执行顺序：try-catch-finally-catch,最外部的catch执行，因为catch中抛出另一个异常了，嵌套
try{
	try{
		throw new Error("oops");
	}
	catch(ex){
		console.log("inner",ex.message)
	}
	finally{
		console.log("finally");
	}
}
catch(ex){
	conosle.log("outer",ex.message)
}

3.函数、switch、循环

函数声明和函数表达式：

fd();   //true 函数可以在声明前执行
//这种形式是函数声明
function fd(){
    // do sth
    return true;
}

fd();   //TypeError。函数表达式不可以
//这种形式是函数表达式
var fe = function () {
    // do sth
};

for…in

顺序不确定
enumberable为false时不会出现
for in 对象属性时受原型链影响

var p;
var obj = {x:1,y:2};

for(p in obj){

}

with

with语句可以修改当前的作用域。

with({x:1}){
    console.log(x);
}
// 可以直接输出，不用对象.属性调用
with(document.forms[0]){
    console.log(name.value)
}
 
var form = document.forms[0];
console.log(form.name.value);
/*
使用with让JS引擎优化更难
可读性变差。 可被变量定义代替
严格模式下被禁用
*/

4.严格模式

严格模式：‘use strict’;

严格模式是一种特殊的执行模式，它修复了部分语言上的不足，提高错误检查，增强安全性。

1，不允许使用with语句；
2，不允许给未声明的变量赋值；
3，arguments,是与形参不同的变量副本；
4，delete不允许被删除的变量会报错，而不是返回false；
5，不允许重复的对象字面量属性名；
6，不允许八进制的字面量；
7，eval, arguments成为关键词，不允许用来作为变量名和函数名；
8，eval()会单独创建一个作用域，并在eval()返回时丢弃；

!function(a){
	arguments[0] = 100;
	console.log(a);
}(1);

解释器在解释一个语句时，如果以function开头，就会理解为函数声明。而前面加一个!可以让解释器理解为函数表达式，这样就可以立即调用了。

function是函数声明，在后面加()表示立即执行，由于JavaScript中function的{}后接上()会有语法错误，所以需要把function先变成函数表达式，!就是把function变成函数表达式。

例如：
!funciton() {

}();

而省略了!的话：
function() {

}();

就会理解为函数声明，而函数声明没有名字会报错。如果有函数名：
function f() {

}();

还是会报错，因为function f(){}函数声明会被前置，相当于：
function f(){}
(); // 这里报错

上面的代码，!function(){}(1)就是匿名函数立即执行,并以1作为参数。

因为定义函数的调用方式应该是 function()，但是，如果我们尝试为一个“定义函数”末尾加上()，解析器是无法理解的。而使用括号包裹定义函数体，解析器将会以函数表达式的方式去调用定义函数。也就是说，任何能将函数变成一个函数表达式的作法，都可以使解析器正确的调用定义函数。而 ! 就是其中一个，而 + - || 都有这样的功能。
那那个(1)的意思就很好理解了。等于var func = function(a){}; func(1);.