是时刻把JS的学问点总结下，而且会延续施工，每一个学问点假如有更深切的手艺讨论和学问会连续增添进去。

ECMAScirpt中的变量，函数名，操纵符都辨别大小写。

标识符

标识符指的多是：

• 变量名

• 函数名

• 属性名

• 函数的参数

标识符的称号：

• 第一个字符只能是字母，下划线_，或许美圆标记$；

• 其他的可所以字母，数字，下划线_，或许美圆标记$。

• 根据通例，标识符称号应运用驼峰法，即首字母小写，剩下的每一个单词首字母大写。

• 不能把关键字、保留字、TRUE、FALSE、NULL作为标识符称号。

解释：

//单行解释

/*
多行解释
多行解释
*/

严厉情势：

ES5引入了严厉情势，严厉情势下，某些旧版本（ES3）的一些不肯定行动将获得处置惩罚，而对某些不安全的操纵也会抛出毛病。支撑严厉情势的浏览器：IE10+ Firefox 4+ Safari 5.1+ Opera 12+ Chrome

//在全部剧本中引入严厉情势，则在script标签顶部或许*.js文件顶部增添以下代码即可。
"use strict";

//在指定函数中引入严厉情势：
function f1(){
     "use strict";
     //TODO...
};

TODO : 引入了严厉情势与没引入严厉情势的js文件怎样处理争执以及共存？

语句：

ES中的语句以一个分号末端，省略分号虽然有用但不引荐。

    var sum = 1 + 2;

关键字与保留字：

// 关键字
break case catch continue debugger default delete do instanceof else new finally return for switch function this if throw in try typeof var void while with

// ES3定义的保留字
abstract boolean byte char class const debugger double enum export extends final float goto implements import int interface long native package private protected public short static super synchronized throws transient volatile

//ES5中非严厉情势下的保留字缩减为这些：
class enum extends super const export import

//ES5中严厉情势下的相对非严厉情势增添的保留字，个中let与yield是新增的。
implements interface let package private protected public static yield
//现实开辟中，发起将ES3定义的保留字外加新增的let与yield作为参考。

须要注重的是，ES5的严厉情势下，eval与arguments也不能作为标识符与属性名，不然会抛出毛病。

变量：

ES中的变量是松懈范例的，即变量能够保留任何范例的数据。
定义变量运用var操纵符，后跟变量名（即一个标识符），
运用var操纵符定义的变量会成为该作用域下的局部变量，该变量在函数退出以后就会被烧毁：

var a; //定义一个名为a的变量，值是undefined
var b = null; //定义一个名为b的变量，值为null（空）
var c = 'percy'; //定义一个名为c的变量，值为字符串“percy”

function f1(){
  var name = 'jon'; //函数f1()下的局部变量
  alert(name); 
}
f1(); //jon
alert(name); //外部不能直接接见函数的内部变量

//运用一条语句定义多个变量，用逗号分开即可。
var name='jon', age=25, isMarried=false;

数据范例：

ES中有
5种简朴数据范例（基本数据范例）：Undefined、Null、Boolean、Number、String
1种庞杂数据范例：Object

检测给定变量的数据范例 —— typeof操纵符

返回值：

• undefined——给定的值未定义；

• boolean——给定的值是布尔值；

• string——给定的值是字符串；

• number——给定的值是数值；

• object——给定的值是对象或许null；

• function——给定的是函数；

function f2(){
    console.log('Hi!');
}
var name = 'jon';
var age = 25;

alert(typeof f2); //function
alert(typeof name); //string
alert(typeof age); //number

ES数据范例之 Undefined 范例

只需一个值：undefined

var name; 
/*var name = undefined;*/ //无需把变量显式设置undefined值
alert(name == undefined); //true 

变量的值为undefined与未声明的变量并不一样，但运用typeof操纵符均会返回undefined，但输出值时未声明的变量会发生毛病：

var job; //该变量已声明但未赋值，默许值为undefined
// var name2; 该变量并未声明

alert(typeof job); //测试变量范例，输出undefined
alert(typeof name2); //测试变量范例，纵然变量未声明也会输出undefined

//输出值时
alert(job); //undefined
alert(name2); //发生毛病：Uncaught ReferenceError: name2 is not defined

ES数据范例之 Null 范例

只需一个值：null；
undefined值派生自null值，所以用==测试二者时会返回true ；
null值示意一个空对象指针，所以运用typeof操纵符时会返回object；
假如建立的变量未来用于保留对象，那末初始声明该变量时应把值设置为null；

var name = null;
alert(typeof name); //object

ES数据范例之 Boolean 范例

有两个值：true、false；

//注重Boolean范例字面值是辨别大小写的，True、False以及其他大小写夹杂的情势均不属于Boolean范例值；
var isBoy = true;
var isGirl = false;

运用Boolean()函数把其他值转为Boolean值

var name = 'jon';
var nameBool = Boolean(name); //true

转换划定规矩以下表：

转换划定规矩关于流程掌握语句自动实行响应的Boolean转换非常重要：

var name = 'jon';
if(name){ //name转换为true，实行下面的语句
    alert('name is defined!');
}

ES数据范例之 Number 范例

包括整数和浮点数（双精度数值），NaN。

整数

var intN1 = 123; //十进制整数
var intN2 = 013; //十进制的11
var intN3 = 018; //无效的八进制，会被转成十进制的18，而且在严厉情势下回抛出毛病
var intN4 = 0xB; //十六进制，会被转为十进制的11
alert(-0 == +0); //true,ES中正零相称于负零;

浮点数

var fN1 = 0.1;
var fN2 = 1.1;
var fN3 = .1; //不引荐
var fN4 = 1. //被剖析为整数1
var fN5 = 1.0; //被剖析为整数1
var fN6 = 1.05e5; //e示意法，即科学记数法，会被剖析成105000，即1.05乘以10的7次方
var fN7 = 3e-6; //会被剖析成0.000003

浮点数的准确度远远不如整数，所以永久不要用盘算浮点数来举行前提测试：

if(a + b = 0.3){ //不要做如许的测试！
    //DO STH...
}

数值局限

console.log(Number.MIN_VALUE); //ES能示意的最小数，效果是5e-324
console.log(Number.MAX_VALUE); //ES能示意的最大数，效果是1.7976931348623157e+308
/*
若一次运算中，盘算效果超过了ES的最大或最小数，那末这个效果会被转换成特别的Infinity或-Infinity，该值没法介入运算；以下两个属性也保留着上述两个值；
*/
alert(Number.NEGATIVE_INFINITY); //-Infinity
alert(Number.POSITIVE_INFINITY); //Infinity

肯定某个效果是不是为有穷的（是不是位于ES能示意的最大与最小数之间的有用数值），运用isFinite()函数；

var a = 10.4e-8;
alert(isFinite(a)); //true，该数值在有用局限以内

NaN (Not a Number，非数值（中文名字）是一个特别的数值)

用于示意一个原本要返回数值的操纵数没有返回数值的状况，如许就不会抛出毛病；

• ES中0除以0都邑返回NaN；(其他数值除以0会返回Infinity或许-Infinity)

• 任何触及NaN的运算操纵也会返回NaN；

• NaN不即是任何值，包括它自己；

alert(NaN == NaN); //false

isNaN()函数，吸收一个参数，肯定该参数是不是“不是数值”，假如该参数是数值或许能转换成数值，则会返回false，不然返回true；

alert(isNaN(1)); //false
alert(isNaN('2')); //false，能够把字符串2转换成数值2
alert(isNaN(true)); //false，能够把布尔值true转换成数值1，假如false则转换成0
alert(isNaN('1024cl')); //true，数值与字符串不能转换成数值
alert(isNaN('true')); //true，字符串*均*不能转换成数值
alert(isNaN(NaN)); //true，NaN本身不是有用的数值

数值转换，有三个要领，Number()，parseInt()，parseFloat()

Number()的转换例子：

alert(Number(1)); //1
alert(Number(true)); //转换成1
alert(Number(false)); //转换成0
alert(Number(null)); //转换成0
alert(Number(undefined)); //NaN
alert(Number("")); //空字符串转换成0
alert(Number("12")); //转换成12
alert(Number("034")); //疏忽前导0，转换成34
alert(Number("12ab")); //NaN
alert(Number("0x11")); //有用的十六进制会转换成十进制的17

更常常使用的parseInt()与parseFloat()例子：

alert(parseInt(1)); //1
alert(parseInt(11.91)); //11
alert(parseInt(true)); //NaN
alert(parseInt(false)); //NaN
alert(parseInt(null)); //NaN
alert(parseInt(undefined)); //NaN
alert(parseInt("")); //NaN
alert(parseInt("12")); //12
alert(parseInt("034")); //34
alert(parseInt("12ab")); //疏忽数值后的无效字符，转换为12
alert(parseInt("ab12")); //NaN
alert(parseInt("0x11")); //17

//在转换八进制的字符串包括的数值中，ES3与ES5有时会存在不合：
alert(parseInt("067")); //ES3中会输出55
alert(parseInt("067")); //ES5中会疏忽前导0，并转换成10进制的67

基于上面的题目，作为最好实践，运用parseInt()一直应当到场第二个参数，即须要转换时须要运用的进制数：

alert(parseInt("076",8)); //62
alert(parseInt("076",10)); //76
alert(parseInt("0xAA",16)); //170
alert(parseInt("AA",16)); //170
alert(parseInt("AA")); //NaN

//parseFloat()只会剖析十进制数值，所以没有第二个参数
alert(parseFloat("1.2.3")); //只会剖析左起第一个小数点，所以该数值会被转换成1.2
alert(parseFloat("0xAA")); //十六进制数值一直会被转换成0
alert(parseFloat(11.1)); //11.1
alert(parseFloat("443abc")); //443，疏忽背面的无效字符
alert(parseFloat("443.3aa")); //443.3，疏忽背面的无效字符
alert(parseFloat("3.33e7")); //33300000
alert(parseFloat("0757.2768")); //疏忽前导0，757.2768

ES数据范例之 String 范例

即字符串，由0或多个16位Unicode字符构成的字符序列；

//能够由单引号或双引号包裹，且摆布引号必需婚配
var s1 = 'name1'; 
var s2 = "name2";

字符字面量

String数据范例包括一些特别的字符字面量，也叫转义序列，用于示意非打印字符，或许有其他用处的字符：

上述的字符字面量能够涌现在字符串的恣意位置，而且也会被作为字符来剖析：

var sign = "sign is : \u011f";
console.log(sign);  /*sign is : ğ*/
console.log(sign.length); //11，申明六个字符长的转义序列只会示意一个字符，占一个索引位置；

转换为字符串的要领toString():

var name = 'Jon';
alert(name.toString()); //"Jon"
var age = 25;
alert(age.toString()); //字符串"25"
var isMarried = false;
alert(isMarried.toString()); //字符串"false"

//null与undefined没有toString()要领
alert(null.toString()); //NaN
alert(undefined.toString()); //NaN

//转换数值的状况下，能够传入一个参数，即输出数值的基数
var num = 10;
alert(num.toString()); //默许十进制输出，10
alert(num.toString(2)); //二进制输出，1010
alert(num.toString(8)); //八进制输出，12
alert(num.toString(10)); //十进制输出，10
alert(num.toString(16)); //十六进制输出，A

在不晓得转换的值是不是为null或undefined的状况下，能够运用转型函数String()，该函数能把任何范例的值转为字符串：

• 假如传入的值有toString()要领，则挪用该要领并返回响应的效果；

• 假如传入的值是null，则返回”null”；

• 假如传入的值是undefined，则返回”undefined”；

var value1 = 10;
var value2 = true;
var value3 = null;
var value4;

alert(String(value1)); // "10"
alert(String(value2)); // "true"
alert(String(value3)); // "null"
alert(String(value4)); // "undefined"

ES数据范例之 Object 范例

ES中的Object（对象）就是一组数据和功用的鸠合。
Object范例是一切其他范例的基本，所以Object范例的所以属性和要领也会存在于其他详细的对象中。

var o1 = new Object(); //建立一个自定义对象

Object实例具有的属性和要领

操纵符

包括 一元操纵符，位操纵符，布尔操纵符，乘性操纵符，加性操纵符，关联操纵符，相称操纵符，前提操纵符，赋值操纵符，逗号操纵符。

一元操纵符

递增与递减操纵符（包括前置型与后置型）

//前置型操纵符
var n1 = 25;
++n1;
 
var n2 = 25;
--n2;

//前置型操纵符会在求值前被实行
var age = 25;
var anotherAge = --age + 2;

console.log(age); //24 (鄙人一句实行之前已实行了自减)
console.log(anotherAge); //26 （24+2）

//后置型操纵符
var n1 = 25;
n1++;

//后置型操纵符会在被求值以后才实行，注重以下题目
var n1 = 2;
var n2 = 20;
var n3 = n1-- + n2; 
console.log(n3); //盘算n3时运用了原始值盘算，所以输出22
var n4 = n1 + n2; 
console.log(n4); //盘算n4时，n1已被递减，所以输出21

上述的4个操纵符能够用于整数，浮点数，字符串，布尔值，对象运算；

var s1 = "2"; 
console.log(++s1);//转换为数值2再介入运算，输出3
var s2 = "a"; 
console.log(++s2);//值为NaN，没法介入运算
var s3 = false; 
console.log(++s3);//转换为数值0再介入运算，输出1， **true则转换为1**
var s4 = 2.1; 
console.log(--s4); //介入减一运算，注重浮点数舍入毛病题目，输出1.1
console.log(++s4); //介入加一运算，注重浮点数舍入毛病题目，输出2.1
var s5 = {
  valueOf: function(){
    return -1;
  }
};
console.log(++s5); //先挪用对象的valueOf()要领，获得一个可供操纵的值，然后把该值运用于前述划定规矩；假如效果是NaN，则挪用toString()要领后再运用前述划定规矩。对象变量变成数值变量，这里输出0
console.log(++s5); //输出1

一元加和减操纵符

即+和-；
对非数值运用一元加和减操纵符时，会像Number()转型函数一样对这个值实行转换

/*一元加操纵符*/
var s1 = "01";
var s2 = "1.1";
var s3 = "z";
var b = false;
var f = 1.1;
var o = {
    valueOf: function() {
        return -1;
    } 
};
s1 = +s1; //1
s2 = +s2; //1.1
s3 = +s3; //NaN
b= +b; //0
f= +f; //1.1
o= +o; //-1

/*一元减操纵符*/
//一元减操纵符重要用来示意负数
var n1 = 1;
n2 = -n1; //-1

位操纵符 （略）

布尔操纵符

非（NOT）,与（AND）,或（OR）

逻辑非!

返回一个布尔值, 然后再对其求反

alert(!false); //true
alert(!"blue"); //false
alert(!0); //true
alert(!NaN); //true
alert(!""); //true
alert(!12345); //false
alert(!undefined); //true
alert(!null); //true
var i = function(){};
alert(!i); //false

逻辑与&&

有两个操纵数, 只需两个操纵数都返回true时, 才返回true; 不然返回false

var i = function(){};
var j = function(){console.log("funciton j")};
alert(i && true); //true
alert(i && false); //false

alert(true && i); //function(){}
alert(false && i); //false
alert(i && j); //function(){console.log("funciton j")};
//假如有一个操纵数是null, NaN或undefined, 则返回该三者之一
alert(null && false); //null
alert(null && true); //null
alert(null && i); //null

/*逻辑与属于短路操纵, 即假如第一个操纵数能决议效果,就不会再对第二个操纵数求值*/
var f = true;
var r = (f && cc); //cc未声明 
alert(r); //这一句不会实行,由于上面的cc未声明. Uncaught ReferenceError: cc is not defined(…)

//假如f为false,则会实行并返回false, 由于第一个操纵数已是false, 所以就不会再对背面的操纵数求值了
var f = false;
var r = (f && cc); //cc未声明
alert(r); //false

逻辑或||

有两个操纵数, 只需有一个操纵数都返回true, 就会返回true;

var i = function(){};
var j = function(){console.log("funciton j")};
alert(i || true); //function(){};
alert(i || false); //function(){};
alert(i || j); //function(){};
alert(true || i); //true
alert(false || i); //function(){};
alert(null || false); //false
alert(null || true); //true
alert(null || i); //function(){};
//假如两个操纵数都是null, NaN, undefined, 则会返回一样的效果.

//逻辑或也属于短路操纵
var f = true;
var r = (f || cc); //cc未声明 
alert(r); //会实行true

var f = false;
var r = (f || cc); //cc未声明
alert(r); //这一句不会实行,由于上面的cc未声明. Uncaught ReferenceError: cc is not defined(…)

/*平常开辟中, 能够运用逻辑与来防止为变量赋null或undefined值*/
var o = preferredObject || backupObject;
//backupObject供应一个后备值, 假如preferredObject不包括希冀的有用值的状况下, backupObject会被赋值给o, 不然在常常状况下, preferredObject赋值给o.

乘性操纵符

*, 乘法,用于盘算两个值的乘积

alert(2 * 2); //4
alert(2 * -2); //-4
alert(NaN * 2); //NaN
alert(Infinity * 0); //NaN
alert(Infinity * 1); //Infinity
alert(Infinity * -1); //-Infinity
alert(Infinity * Infinity); //Infinity
//在操纵数不是数值的状况下, 背景会挪用Number()将其转换为数值,然后在举行运算

/, 除法,第二个操纵数除第一个操纵数

alert(2 / 2); //1
alert(2 / -2); //-1
alert(2 / NaN); //NaN
alert(Infinity / Infinity); //NaN
alert(0 / Infinity); //0
alert(Infinity / 0); //Infinity
alert(0 / 0); //NaN
alert(0 / 2); //0
alert(2 / 0); //Infinity
alert(-2 / 0); //-Infinity
//在操纵数不是数值的状况下, 背景会挪用Number()将其转换为数值,然后在举行运算

加性操纵符

+, 加法

alert(1 + 2); //3
alert(NaN + 1);//NaN
alert(Infinity + Infinity); //Infinity
alert(-Infinity + (-Infinity)); //-Infinity
alert(Infinity + (-Infinity)); //NaN
alert(0 + 0); //0
alert(-0 + (-0)); //0
alert(0 + (-0)); //0
alert(1+'2'); //12, 字符串拼接

//注重加法操纵中的数据范例毛病
var num1 = 5;
var num2 = 10;
var message = "The sum of 5 and 10 is " + num1 + num2;
alert(message);    // 获得的效果是 : "The sum of 5 and 10 is 510"

//应当像下面如许运用括号
var num1 = 5;
var num2 = 10;
var message = "The sum of 5 and 10 is " + (num1 + num2); 
alert(message); //"The sum of 5 and 10 is 15"

-, 减法

alert(2 - 1);
alert(NaN - 1); //NaN
alert(Infinity - Infinity); //NaN
alert(-Infinity -(-Infinity)); //NaN
alert(Infinity -(-Infinity)); //Infinity
alert(-Infinity - Infinity); //-Infinity
alert(0 - 0); //0
alert(0 - (-0)); //-0
alert(-0 -(-0)); //0
alert(5 - true); //4, ture to 1
alert(5 - ""); //5, "" to 0
alert(5 - "2"); //3, "2" to 2
alert(5 - null); //5, null to 0

关联操纵符

小于<, 大于>, 小于即是<=, 大于即是>=, 均返回一个布尔值

var r = 5 > 4; //true
var r = 5 < 4; //false

//在字符串的比较中, 决议效果的是字符串字母(大小写)的字符编码, 而不是字母的递次 : 
alert("app" > "back"); //false
alert("app" > "Back"); //true
alert("App" > "Back"); //false
//因字符编码的递次差别, 所以在举行比较时应当把字符串一致转换成大写或许小写再举行比较;
alert("App".toLowerCase() > "Back".toLowerCase()); //false

//一样的, 数字字符串也会比较的是字符编码 : 
alert("15" > "4"); //false
//把个中一个变成数值范例, 或许运用有用的转型函数转型成数值, 效果就平常了 :
alert("15" > 4); //true
alert(Number("15") > Number("4")); //true

//NaN跟任何数值比较均返回false
alert(NaN > 4); //false
alert(NaN < 4); //false

相称操纵符

相称==和不相称!=, 全等===和不全等!==
相称和不相称在比较前都邑先转换操纵数, 然后再举行比较

相称和不相称

//布尔值会被先转换成0和1
alert(1 == true); //true
alert(2 == true); //false
alert(0 == false); //true
alert("a" == 1); //false
var a = "jon";
var b = "percy";
var c = a;
alert(a == c); //true, 比较两个对象时, 假如两个对象指向的是同一个对象,则返回true, 不然返回false
alert(a == b); //false
alert(a == 1); //false
alert(null == undefined); //true
alert(undefined == 0); //false
alert(null == 0); //false
alert(5 == "5"); //true
alert("NaN" == NaN); //false
alert(5 == NaN); //false
alert(NaN == NaN); //false, NaN不即是本身

全等和不全等

全等和不全等不会像上面的相称和不相称一样举行数据范例转换, 而是直接举行比较 :

alert(55 == "55"); //相称比较下, 会举行数据转换, 所以返回true
alert(55 === "55"); //全等比较下, 不会举行数据转换, 所以这里返回false
/*注重null和undefined举行全等比较会返回false, 由于他们是相似的值(所以相称比较会返回true)然则属于差别范例的值*/
alert(null == undefined); //false

前提操纵符(三目运算符)

//对boolean_expression求值, 假如效果为true则返回true_value(给variable), 不然返回false_value(给variable)
variable = boolean_expression ? true_value : false_value;

var num1 = 4;
var num2 = 6;
var max = (num1 > num2) ? num1 : num2;
console.log(max); //6

赋值操纵符

• 简朴的赋值操纵符=

• 乘/赋值*=

• 除/赋值/=

• 模/赋值%=

• 加/赋值+=

• 减/赋值-=

• 左移/赋值<<=

• 有标记右移/赋值>>=

• 无标记右移/赋值>>>=

var n = 2;
n = n + 2; //4 

//能够简化成
n += 2;

//其他道理雷同

逗号操纵符

//可用于同时声明多个变量
var a, b, c;

语句

ES指流程掌握语句

if语句

if(condition){
    statement1
}else{
      statement2
}

var i = 20;
if(i > 25){
  console.log("i is greater than 25");
}else{
  console.log("i is less than or equal to 25");
}
//i is less than or equal to 25

if(condition1){
  statement1
}else if(condition2){
  statement2
}else{
  statement3
}

var i = 25;
if(i > 25){
  console.log("i is greater than 25");
}else if(i == 25){
  console.log("i is equal to 25");
}else{
  console.log("i is less than 25");
}
//i is equal to 25

do-while语句

do-while语句在对表达式求值之前, 轮回体内的代码会被起码实行一次

do{
  statement
}while(expression)

var i = 2;
do{
  i += 2;
  console.log(i);
}while(i < 7);
//之所以涌现8的原因是, 当i递增到6的时刻依旧少于7, 所以在推断while内里的前提之前依旧会被递增一次
//4, 6, 8

var i = 10;
do{
  i ++;
  console.log(i);
}while(i < 10);
//虽然while内里的前提已不满足,但do内里的语句照样会被实行一次, 输出11

while语句

与do-while语句相反, while语句会在轮回体(expression)内的代码被实行之前, 先对前提求值

while(expression){
  statement
}

var i = 10;
while(i < 20){
  i+=2;
  console.log(i);
  //12, 14, 16, 18, 20
}
console.log("the last i is : " + i); //20

for语句

for与while一样, 也是前测试轮回语句, 但它能够在实行轮回之前初始化变量和定义轮回后要实行的代码

for(initialization; expression; post-loop-expression){
  statement;
}

var c = 10;
for(var i = 1; i <= c; i+=2){
  console.log(i);
}
//1, 3, 5, 7, 9

//提早定义好变量, 就能够在for语句内里省略var关键字
var i, c = 10;
for(i = 1; i <= 10; i+=3){
  console.log(i);
  //1, 4, 7, 10
}
//注重ES内里没有块级作用域, 所以下面的语句能够平常输出
console.log("the last i is : " : i); //10

for-in语句

for-in是精准的迭代语句, 能够用来罗列对象的属性

for(property in expression){
  statement
}

var arr = ['Jon','Martin','Percy'];
for(var i in arr){
  console.log(arr[i]);
  //Jon, Martin, Percy
}
//注重for-in语句输出的效果递次是不可展望的
//作为最好实践, 运用for-in语句时, 应当确认该对象的值不是null或undefined

label语句

label语句能够在代码中增添标签, 以便在未来被break或continue援用

label : statement

first : for(var i = 0; i < 10; i+=2){
  console.log(i);
}
//first作为for轮回的标签

break与continue语句

break与continue语句用于在轮回中准确的掌握代码的实行;

break会马上退出轮回, 强迫实行背面的语句

continue也会马上退出轮回, 但退出后会从轮回的顶部继承实行

//break
var n = 0; //初始化盘算积累次数的变量
for(var i = 1; i < 10; i++){ //i从1递增到10
  if(i % 5 == 0){ //递增过程当中推断i是不是能被0整除
      break; //是的话马上退出轮回,这里在i=5的时刻退出了轮回
  }
  n++; //每轮回一次积累盘算次数
}
console.log(n); //退出轮回之前,轮回体实行了4次,所以输出4

//continue
var n = 0; //初始化盘算积累次数的变量
for(var i = 1; i < 10; i++){ //i从1递增到10
  if(i % 5 == 0){ //递增过程当中推断i是不是能被0整除
      continue; //是的话马上退出轮回,这里在i=5的时刻退出了轮回, 而且回到轮回顶部继承实行(在for轮回前提未满足之前继承实行)
  }
  n++; //每轮回一次积累盘算次数
}
console.log(n); //退出轮回之前(for轮回完毕之前),轮回体实行了8次(由于在5被整除的时刻退出了轮回,致使轮回体少实行了一次),所以终究输出8

与label标签合营运用

//break
var i, j, n = 0;
outerloop:
for(i = 0; i < 10; i++){
  for(j = 0; j < 10; j++){
    if(i == 5 && j ==5){
        break outerloop;
    }
    n++;
  }
}
//平常来讲, i每递增1次, j就会递增10次, 所以n终究值在不受滋扰的状况下回即是100
//这里推断假如i和j都即是5的状况下回马上退出轮回, 所以轮回体终究会退出内部和外部的for轮回(退回标签outerloop的位置), 所以终究n会输出55
console.log(n); //55

//continue
var i, j, n = 0;
outerloop:
for(i = 0; i < 10; i++){
  for(j = 0; j < 10; j++){
    if(i == 5 && j ==5){
        continue outerloop;
    }
    n++;
  }
}
//这里推断假如i和j都即是5的状况下回马上退出轮回, 但退回外部的for轮回(outerloop标签)的轮回以后会继承强迫实行外部轮回, 所以终究会获得95
console.log(n); //95

with语句

with语句作用是将代码的作用域设置到一个特定的对象中

with(expression){
  statement;
}

//定义with语句的目标重如果简化屡次编写同一个对象的事情
var qs = location.search.substring(1);
var hostName = location.hostname;
var url = location.href;

//运用with语句上面的代码能够改成
with(location){
  var qs = search.substring(1);
  var hostName = hostname;
  var url = href;
}
//严厉情势下不许可运用with, 不然会报错
//with会致使机能下落, 在大型项目中不发起运用

switch语句

switch(expression){
  //假如expression即是value, 则实行背面的statement, 并跳出当前轮回
  case value : statement
  break;
  case value : statement
  break;
  case value : statement
  break;
  case value : statement
  break;
  //假如expression不即是前面任何一个value, 则运用default内的statement代码
  default : statement
}

var i = 2;
switch(i){
    case 1 : 
    console.log("result is 1");
    break;
    
    case 2;
    console.log("result is 2");
    break;
    
    default : 
    console.log("what is the result?");
}

//能够兼并两种情况(cast)
switch(i){
  case 1 :
  case 2 :
  console.log("1 or 2");
  break;
  
  case N...
}

函数

函数能够封装恣意多条语句, 且能够在差别处所, 差别时候挪用实行.

运用关键字function声明,背面跟一组参数以及函数体

function functionName(arg0, arg1, arg2, ...argN){
  statements;
}

//实例
function sayHi(name, age){
  console.log("my name is " + name +", age is" + age + ".");
}
//挪用
sayHi("Jon",25);
//输出my name is Jon, age is 25.

//运用return语句背面跟要返回的值来完成返回值
function sum(n1, n2){
  return n1 + n2;
}
var r = sum(1 + 2);
alert(r); //3

//注重在return背面的语句永久不会实行
function sum(n1, n2){
  return n1 + n2;
  console.log("Hi!"); //永久不会实行
}

//一个函数中能够包括多个return语句
function diff(n1 ,n2){
  if(n1 < n2){
      return n2 - n1;
  }else{
    return n1 - n2;
  }
}

//return能够不带有任何返回值,平常用在须要提早实行函数实行有不须要返回值的状况下.
function sayHi(name, message){
  return;
  console.log("Hi! " + name + "," + message); //永久不会挪用
}
//引荐的做法是要么让函数一直返回一个值, 要么永久不会返回值

明白参数

• ES中的参数不限定数目和数据范例

• 假定被挪用的函数的参数定义了两个, 在挪用这个函数时也不强迫须要传入两个, 能够少传或多穿而不会报错, 定名的参数只是为了方便, 并非必需的

• ES函数的参数内部是一组类数组, 在函数体内能够经由过程arguments对象来接见这组数组的内容, 接见的时刻像接见数组一样, 运用方括号语法arguments[0], arguments[1], arguments[2], arguments[n] …

  //上面的sum函数例子能够写成
  function sum(n1, n2){
    //return n1 + n2;
    return arguments[0] + arguments[1];
  }
  sum(1 , 2); //3

//接见arguments的length属机能够晓得多少个参数通报给了函数
function howManyArgs(){
  console.log(arguments.length);
}
howManyArgs(); //0
howManyArgs(1); //1
howManyArgs(1,2); //2

//能够应用这一点让函数在吸收差别参数时实行差别的功用
function doAdd(n1, n2){
  if(arguments.length == 1){
    console.log(arguments[0] + 2);
  }else if(arguments.length == 2){
      console.log(arguments[0] + arguments[1]);
    //argument对象能够和定名参数夹杂运用
    //console.log(arguments[0] + n2); //没有题目!
  }
}
doAdd(1); //3
doAdd(2,3); //5

• arguments的值和对应的定名参数的值会坚持同步

  function doAdd(n1, n2){
    arguments[1] = 10;//注重严厉情势下会无效,n2依然即是undefined
    console.log(arguments[0] + n2); 
  }
  doAdd(12,1); //22, 而不是13
  //严厉情势下重写arguments的值会致使语法毛病, 代码不能实行

• ES中一切参数通报都是值, 不可能经由过程援用通报参数

​

没有重载

其他语言中能够为一个函数编写两个定义, 只需这两个定义的署名(吸收的参数范例和数目)差别即可

ES中的参数是由包括零个或多个值的数组来示意的, 而没有函数署名, 真正的重载是不可能的

假如定义了两个名字雷同的函数, 那末改名字只属于后定义的函数

function add(n){
  return n + 10;
}
function add(n){
  return n + 20;
}
add(1); //21

经由过程搜检传入函数中参数的范例和数目并作出差别的回响反映, 能够模仿要领的重载.