JavaScript深入浅出——语句（三）

一、block语句，var语句

JavaScript程序由语句组成,语句遵守特定的语法规则.
   例如:if语句,while语句,with语句等等.

   1.块block
   块语句常用于组合0——多个语句。块语句用一对花括号定义。
   语法：
   {
    语句1;
    语句2;
    ....
    语句n;
   }
   
   {a:1,b:2}//SyntaxError:Unexpected token
   var o={a:1,b:2};//ok
   
   请注意:没有块级作用域(即在块的外面还是可以访问到块里面定义的变量)
   {       var x=1;
    var x=1;    {
    //....   =         //...
   }       }
   
   for(var i=0;i<10;i++){     var i=0;
    var str = "hi";    =       for(;i<10;i++){
    console.log(str);      var str = "hi";
   }           console.log(str);
             }
   
   //2.var
   var a=1;
   var 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

二、try catch

try{
    throw "test";
   }catch(ex){
    console.log(ex);//test
   }finally{
    console.log("finally");
   }
   
   javaScript中try后面必须跟着catch或finally

try{
    try{
     throw new Error("oops");
    }finally{
     console.log("finally");
    }
   }catch(ex){
    console.error("outer",ex.message);
   }
   //结果为先“finally”,再"outer" "oops"
   
   try{
    try{
     throw new Error("oops");
    }catch(ex){
     console.error("inner",ex.message);
    }finally{
     console.log("finally");
    }
   }catch(ex){
    console.error("outer",ex.message);
   }
   //结果为先"inner" "oops",再"finally"(内部已将异常处理，不会再跳到外面处理)
 
   try{
    try{
     throw new Error("oops");
    }catch(ex){
     console.error("inner",ex.message);
     throw ex;
    }finally{
     console.log("finally");
    }
   }catch(ex){
    console.error("outer",ex.message);
   }
   //结果为先"inner" "oops",再"finaly",再"outer" "oops"
   

三、函数，switch，循环

//   1.function
//   函数声明
   function fd(){
    //do sth
    return true;
   }
   
//   函数表达式
   var fe=function(){
    //do sth
   }
//   函数声明与函数表达式有很多区别，但最主要的是：函数声明前调用函数不会报错，而变量声明前调用会报错

   //2.for...in
   var p;
   var obj={x:1,y:2};
   
   for(p in obj){
    console.log(p);
   }
   注意：
   (1)顺序不确定
   (2)对象属性的enumerable为false时不会出现
   (3)for in 对象属性受原型链影响

3.switch

var val=2;
   switch(val){
    case 1:
     console.log("1");
     break;
    case 2:
     console.log("2");
     break;
    default:
     console.log("0");
     break;
   }
   //结果为2
   
   var val=2;
   switch(val){
    case 1:
     console.log("1");
    case 2:
     console.log("2");
    default:
     console.log("0");
   }
   //结果为2，0
   var val=2;
   switch(val){
    case 1:
    case 2:
    case 3:
     console.log("1");
     break;
    case 4:
    case 5:
     console.log("2");
     break;
    default:
     console.log("0");
     break;
   }
   //结果为1

4.循环

while(isTrue){
    //do sth
   }
   
   do{
    //do sth
   }while(isTrue)
   
   var i;
   for(i=0li<n;i++){
    //do sth
   }

5.with

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

with({x:1}){
    console.log(x);//1
   }
   
   with(document.forms[0]){
    console.log(name.value);//相当于document.forms[0].name.value
   }

var form=document.forms[0];

console.log(form.name.value);

javaScript中不建议使用with,因为：

（1）让JS引擎优化更难

（2）可读性差

（3）可被变量定义代替

（4）严格模式下被禁用

四、严格模式

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

//func()内部使用严格模式
   function func(){
    ""use strict;
   }
   
   //全局使用严格模式
   "use strict";
   function func(){
    
   }

严格模式与一般模式的区别
   1.严格模式下不允许使用with
   一般模式:
   !function() {
    with({x:1}){
     console.log(x);
    }
   }
   
   严格模式:
   !function() {
    "use strict";
    with({x:1}){
     console.log(x);
    }
   }
   严格模式下使用with会报SyntaxError(语法错误)

2.不允许为声明的变量被赋值
   一般模式下:
   !function(){
    x=1;//一般模式下，未声明的变量允许赋值，此时未声明的变量x为全局变量
    console.log(window.x);
   }
   
   严格模式:
   !function(){
    "use strict";
    x=1;
    console.log(window.x);
   }
   严格模式下会报错RefenceError;

3.arguments变为参数的静态副本
   !function(a){
    arguments[0]=100;
    console.log(a);//100
   }(1);
   
   !function(a){
    "use strict";
    arguments[0]=100;
    console.log(a);//1
   }(1);
   
   !function(a){
    "user strict";
    arguments[0].x=100;
    console..log(a.x);//100
   }({x:1});

4.delete参数,函数名报错
   !function(a){
    console.log(delete a);
   }(1);
   
   !function(a){
    "use strict";
    delete a;
   }(1);
   //严格模式下会报错SyntaxError(语法错误)；

5.delete不可配置的属性报错
   !function(a){
    var obj={};
    Object.defineProperty(obj,"a",{configurable:false});
    console.log(delete obj.a);//false
   }(1);
   
   !function(a){
    "use strict";
    var obj={};
    Object.defineProperty(obj,"a",{configurable:false});
    console.log(delete obj.a);//false
   }(1);
   //严格模式下会报错TypeError

6.对象字面量重复属性名报错
   !function(){
    var obj={x:1,x:2};
    console.log(obj.x);//2
   }();
   
   !function(){
    "use strict";
    var obj={x:1,x:2};
   }();
   //严格模式下会报错SyntaxError

7.禁止八进制字面量
   !function(){
    console.log(Object123);//83
   }();
   
   !function(){
    "use strict";
    console.log(O123);
   }();
   //严格模式下会报错SyntaxError;

8.eval,arguments变为关键字,不能作为变量,函数名
   !function(){
    function eval(){}
    console.log(eval);
   }
 
   !function(){
    "use strict";
    function eval(){}
   }();
   //严格模式下会报错SyntaxError

9.eval独立作业域
   !function(){
    eval("var evalVal=2;");
    console.log(typeof evalVal);//number
   }
   
   !function(){
    "use strict";
    eval("var evalVal=2;");
    console.log(typeof evalVal);//undefined
   }();

总结:
   不允许用with
   所有变量必须声明,赋值给未声明的变量报错,而不是隐式创建全局变量.
   eval中的代码不能创建eval所在作用域下的变量,函数.而是为eval单独创建一个作用域,并在eval返回时丢弃.
   函数中的特殊对象arguments是静态副本,而不像非严格模式那样,修改arguments或修改参数变量会相互影响.
   删除configurable=false的属性时报错,而不是忽略
   禁止八进制字面量,如O10(八进制的8)
   eval,arguments变为关键字,不可作为变量名,函数名等
   一般函数调用时(不是对象的方法调用,也不使用apply/call/bind等修改this)this指向null,而不是全局对象.
   若使用apply/call,当传入null或undefined时,this将指向null或undefined,而不是全局对象
   试图修改不可写属性(writable=false),在不可扩展的对象上添加属性时报TypeError,而不是忽略
   arguments.caller,arguments.callee被禁用