语句

条件控制语句

其中expression可以使用整型,字符串,甚至表达式

  1. if (expression0) {statement0}
  2. else if (expression1) {statement1}
  3. else {statement2}
  4. // JavaScript 中的 case 可以使用整型,字符串,甚至表达式
  5. switch(persion.type) {
  6. case "teacher":
  7. statement1
  8. break;
  9. case "student":
  10. statement2
  11. break;
  12. default:
  13. statement3
  14. break;
  15. }

循环控制语句

  1. while(expression) {statement}
  2. // 至少执行一次
  3. do {statement} while(expression);
  4. for (initialise; test_expresiion; increment) {statement}
  5. // 跳过下面代码并进入下一轮循环
  6. continue;
  7. // 退出当前循环
  8. break;

for-in

用于遍历对象的全部属性。

  1. function Car(id, type, color) {
  2. this.type = type;
  3. this.color = color;
  4. this.id = id;
  5. }
  6. var benz = new Car('benz', 'black', 'red');
  7. Car.prototype.start = function(){
  8. console.log(this.type + ' start');
  9. }
  10. for (var key in benz) {
  11. console.log(key + ':' benz[key]);
  12. }
  13. // 输出结果
  14. type:black
  15. color:red
  16. id:benz
  17. start:function (){
  18. console.log(this.type + ' start');
  19. }
  20. // -----------
  21. // 如不需原型对象上的属性可以使用 hasOwnProperty
  22. for (var key in benz) {
  23. if (benz.hasOwnProperty(key)) {
  24. console.log(key + ':' benz[key]);
  25. }
  26. }
  27. // 输出结果
  28. type:black
  29. color:red
  30. id:benz

如不需原型对象上的属性可以使用 hasOwnProperty

  1. for (var key in benz) {
  2. if (benz.hasOwnProperty(key)) {
  3. console.log(key + ':' benz[key]);
  4. }
  5. }
  6. /* 输出结果
  7. type:black
  8. color:red
  9. id:benz */

异常处理语句

  1. try{
  2. // statements
  3. throw new Error();
  4. catch(e){
  5. // statements
  6. }
  7. finally{
  8. // statements
  9. }

with 语句

with 语句是 JavaScript 中特有的语句形式,它主要有两个作用:

其一,其用于缩短特定情况下必须书写的代码量。它可以暂时改变变量的作用域。

  1. // 使用 with 之前
  2. (function(){
  3. var x = Math.cos(3 * Math.PI) + Math.sin(Math.LN10);
  4. var y = Math.tan(14 * Math.E);
  5. })();
  6. // 使用 with
  7. (function(){
  8. with(Math) {
  9. var x = cos(3 * PI) + sin(LN10);
  10. var y = tan(14 * E);
  11. }
  12. })();

语句 - 图1

其二,改变变量的作用域,将with语句中的对象添加至作用域链的头部。

  1. frame[1].document.forms[0].name.value = "";
  2. frame[1].document.forms[0].address.value = "";
  3. frame[1].document.forms[0].email.value = "";
  4. with(frame[1].document.[0]) {
  5. name.value = "";
  6. address.value = ""
  7. email.value = "";
  8. }

缺点就是导致 JavaScript 语句的可执行性下降,所以通常情况下因尽可能的避免使用。