频道栏目
首页 > 程序开发 > web前端 > JavaScript > 正文
JavaScript精粹基础进阶(3)语句
2016-12-06 09:33:00         来源:u013861109的博客  
收藏   我要投稿

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

语句

语句、严格模式

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

语句种类

Paste_Image.png

块 block

块语句常用于组合0 ~ 多个语句。块语句用一对花括号定义。

语法:
{
  语句1;
  语句2;
  ...
  语句n;
}
比如
{
    var str = "hi";
    console.log(str);
}//但在实际开发中,很少单独使用块语句
而是用if...else  或者for  while去结合起来使用,

if(true){
//然后{}是一个块,
然后{里面可以放多条语句}
 console.log('hi');
}

声明语句 var

声明变量语句
var a=1;

在一个var里也可以声明多个变量
var a=b=1;
这段语句确实创建了a,b两个变量并且赋值为1,但是其中b实际上是隐式的创建了全局变量,不信看下面的例子

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

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

在一条语句里定义多个变量的方式使用,号分隔
var a=1,b=1;

try catch语句

try {    //工作流程首先执行try,catch中的代码
    throw "test";    //如果抛出了异常  ,如果没有发生异常catch中的代码就会被忽略掉
} catch (ex) {    //会由catch去捕获
    console.log(ex); // test    //并执行
} finally {    //finally 不管有没有异常,finally 都会执行
    console.log('finally');
}

javascript中try...catch可以有三种形式
try {
    throw "test";
} catch (ex) {
    console.log(ex); // test
}

try {
    throw "test";
}finally {
    console.log('finally');
}

//还有一种就是两者皆有
try {
    throw "test";
} catch (ex) {
    console.log(ex); // test
} finally {
    console.log('finally');
}

例子1

try {
    // do sth.
} finally {
    console.log('finally');
}
//不管有没有异常最后都有执行finally中的内容

例子2

try {
    try {
        throw new Error("oops");
    }
    finally {
        console.log("finally");
    }
    //内部try没有catch,那么他会跳到最近的catch,也就是外层的catch去处理,再跳出block之前需要先执行finally
}
catch (ex) {
    console.error("outer", ex.message);
}
//所以这里的执行结果
"finally"
"outer" "oops"

例子3

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"

例子4

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);
}//由于内部catch再次抛出异常就会由外部catch来处理
执行结果是
"inner" "oops"
"finally"
"outer" "oops"

function语句

函数声明

fd(); // true
function fd() {
    // do sth.
    return true;
}

函数表达式

fe(); // TypeError
var fe = function() {  //定义变量fe,然后把一个匿名函数赋值给fe
    // do sth.
};

两者区别在函数声明前面调用函数也是可以的,函数表达式就不可以。

for…in语句

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

for (p in obj) {
}
顺序不确定 enumerable为false时不会出现 for in对象属性时受原型链影响

switch语句

例子1
var val = 2;

switch(val) {
    case 1:
        console.log(1);
        break;
    case 2:
        console.log(2);    //val==2,会执行这段代码
        break;             //使用 break 来阻止代码自动地向下一个 case 运行。
    default:               //使用 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

例子3

var val = 2;

switch(val) {
    case 1:
    case 2:
    case 3:
        console.log(123);
        break;
    case 4:
    case 5:
        console.log(45); 
        break;
    default:
        console.log(0);
}
//输出123

循环语句while

while (条件)
{
    需要执行的代码
}

例子

var x="",i=0;
while (i<5){
    x=x + "该数字为 " + i ;
    i++;
}
console.log(x);

do/while 循环

do
{
    需要执行的代码
}
while (条件);

例子

var x="",i=0;
do{
    x=x + "该数字为 " + i;
    i++;
}
while (i<5)  
console.log(x)
//该数字为 0该数字为 1该数字为 2该数字为 3该数字为 4

JavaScript for 循环

cars=["BMW","Volvo","Saab","Ford"];
for (var i=0;i<cars.length;i++){ bmw="" for="" pre="" saab="" volvo=""><blockquote>

不同类型的循环

JavaScript 支持不同类型的循环:

for - 循环代码块一定的次数

for/in - 循环遍历对象的属性

while - 当指定的条件为 true 时循环指定的代码块

do/while - 同样当指定的条件为 true 时循环指定的代码块

with语句

with 语句可以方便地用来引用某个特定对象中已有的属性,但是不能用来给对象添加属性。要给对象创建新的属性,必须明确地引用该对象

语法格式

with(object instance) 
{ 
        //代码块 
}  

举例

function Lakers() {
   this.name = "kobe bryant";
   this.age = "28";
   this.gender = "boy";
}
var people=new Lakers();
console.log(people)
with(people)
{
   var str = "姓名: " + name + "
";
   str += "年龄:" + age + "
";
   str += "性别:" + gender;
   document.write(str);
}
// 姓名: kobe bryant
// 年龄:28
// 性别:boy
让JS引擎优化更难 可读性差 可被变量定义代替 严格模式下被禁用

JavaScript 严格模式

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

function func() {
    'use strict';
}

'use strict';
function func() {

}

不允许用with

!function() {
     with({x : 1}) {
           console.log(x);
      }
}();
//输出1

!function() {
    'use strict';
     with({x : 1}) {
            console.log(x);
      }
}();
SyntaxError报错

不允许未声明的变量被赋值

!function() {
     x = 1;    //全局变量
      console.log(window.x);
}();
//输出1

!function() {
    'use strict';
     x = 1;
      console.log(window.x);
}();
//ReferenceError
//在use strict如果没有被声明的变量会报错

arguments变为参数的静态副本

arguments.length 属性返回函数调用过程接收到的参数个数: arguments属性返回函数调用过程接收到的值

一般模式下

!function(a) {
    arguments[0] = 100;//给函数第一个值变成100
    console.log(a);//输出的a变成100
}(1);
//输出100

!function(a) {
    arguments[0] = 100;
    console.log(a);
}();//如果()没有传值arguments长度为空所以更改arguments的值不成立
输出undefined

严格模式下

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

!function(a) {
    'use strict';
    arguments[0].x = 100;
    console.log(a.x);
}({x:1});
//100

delete参数、函数名报错

一般模式下

!function(a) {
    console.log(delete a);
}(1);
//false

‘use strict’;模式下

!function(a) {
    'use strict';
    delete a;
}(1);
SyntaxError报错语法错误

delete不可配置的属性报错

一般模式下

!function(a) {
    var obj = {};
    Object.defineProperty(obj, 
        'a', {configurable : false});
    console.log(delete obj.a);
}(1);
//false

‘use strict’;模式下

!function(a) {
    'use strict';
    var obj = {};
    Object.defineProperty(obj, 
        'a', {configurable : false});
    delete obj.a;
}(1);
//TypeError报错

对象字面量重复属性名报错

一般模式下

!function() {
    var obj = {x : 1, x : 2};//对象属性字面量去重复去写属性,这样也是合法的,属性以最后一个为准
    console.log(obj.x);
}();
//输出为2

‘use strict’;模式下

!function() {
    'use strict';
    var obj = {x : 1, x : 2};
}();

//严格模式下
//SyntaxError报错

禁止八进制字面量

一般模式下

!function() {
    console.log(0123);//8进制的值
}();
//输出83

在严格模式下是不允许8进制

!function() {
    'use strict';
    console.log(0123);
}();
//SyntaxError报错语法错误

eval, arguments变为关键字,不能作为变量、函数名

一般模式

!function() {
    function eval(){}
    console.log(eval);
}();
//function eval(){}

严格模式

!function() {
    'use strict';
    function eval(){}
}();
//SyntaxError语法错误

eval独立作用域

一般模式

!function() {
    eval('var evalVal = 2;');      //在eval函数下定义变量evalVal等于数字2
    console.log(typeof evalVal);   //evalVal所在的函数内部仍然可以拿到 evalVal
}();
//所以输出number

严格模式

!function() {
    'use strict';
    eval('var evalVal = 2;');    //eval代码会在独立作用域执行
    console.log(typeof evalVal); //这里拿evalVal是拿不到的
}();
//所以输出undefined

严格模式总结

不允许用with 所有变量必须声明, 赋值给为声明的变量报错,而不是隐式创建全局变量。 eval中的代码不能创建eval所在作用域下的变量、函数。而是为eval单独创建一个作用域,并在eval返回时丢弃。 函数中得特殊对象arguments是静态副本,而不像非严格模式那样,修改arguments或修改参数变量会相互影响。 删除configurable=false的属性时报错,而不是忽略 禁止八进制字面量,如010 (八进制的8) eval, arguments变为关键字,不可作为变量名、函数名等

一般函数调用时(不是对象的方法调用,也不使用apply/call/bind等修改this)this指向null,而不是全局对象。 若使用apply/call,当传入null或undefined时,this将指向null或undefined,而不是全局对象。 试图修改不可写属性(writable=false),在不可扩展的对象上添加属性时报TypeError,而不是忽略。 arguments.caller, arguments.callee被禁用

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

点击复制链接 与好友分享!回本站首页
相关TAG标签 JavaScript
上一篇:JavaScript精粹基础进阶(2)表达式和运算符
下一篇:JavaScript精粹基础进阶(4)对象
相关文章
图文推荐
点击排行

关于我们 | 联系我们 | 广告服务 | 投资合作 | 版权申明 | 在线帮助 | 网站地图 | 作品发布 | Vip技术培训 | 举报中心

版权所有: 红黑联盟--致力于做实用的IT技术学习网站