第三章（基本概念）
第三章
1. 语法
1.1 区分大小写
+ 如，函数名不可以用 *typeof*但可以使用 *typeOf*。
1.2 标识符
+ 指的是变量、函数、属性的名字，或者函数的参数。
+ 第一个字符必须是一个字母、下划线、或者一个 *$* 符号
+ 其它字符可以是字母、下划线、*$* 、或数字。
+ 按照惯例，ECMAScript 标识符使用驼峰大小写格式。 例如：myCar
1.3 注释
+ ECMAScript 使用 C 风格的注释，包括单行注释和块级注释。单行注释以两个斜杠开头，如下所示：// 单行注释 + 块级注释以一个斜杠和一个星号（/*）开头，以一个星号和一个斜杠（*/）结尾，如下所示：/*
*这是一个多行
*（块级）注释
*/
?
+ 虽然上面注释中的第二和第三行都以一个星号开头，但这不是必需的。之所以添加那两个星号，纯粹是为了提高注释的可读性（这种格式在企业级应用程序中极其常见）。
1.4 严格模式
"use strict";
//例：
function doSomething() {
"use strict";
//函数体
}?
1.5 语句
// 尽量加上分号或者花括号等。if (test)
alert(test);
//有效但容易出错，不要使用if (test) {//推荐使用
alert(test);
}
2. 关键字和保留字 3. 变量 3.1 定义变量使用 var
var message;
//像这样未初始化的值，会保存一个特殊的值 ——undefined- 可以使用一条语句定义多个变量。
var message = 'hi', found = false, age = 18;
3.3 全局变量
- 若在函数中使用 var 定义一个变量，那么这个变量在函数执行完就会被销毁。但如果省略 var ，则会创建一个全局变量。
function test () {
message = "hi";
//全局变量
}4. 数据类型 4.1 基本数据类型（5种）：
- Undefined、Null、Boolean、Number 和 String。
4.2 复杂数据类型（1种）：
- Object，Object 本质上是由一组无序的名值对组成的。
4.3 typeof 操作符
// 检测给定变量的数据类型 // 对一个值使用 typeof 操作符可能返回下列某个字符串："unde“undefined·——如果这个值未定义;
“boolean“——如果这个值是布尔值;
“string“——如果这个值是字符串;
“number"—一如果这个值是数值;
“object“——如果这个值是对象或 nul1；
“function“——如果这个值是函数;
// typeof 对于未初始化和为声明的变量执行 typeof 操作符都返回 undefined 值。
var message;
alert(typeof message);
// "undefined"
alert(typeof message);
// "undefined"
4.4 Undefined 类型
- 只有一个值，即特殊的 undefined
var a; alert(a == undefined); //true
- 只有一个值，即特殊的 null 。从逻辑的角度来看 null 值表示一个空对象指针，所以使用 typeof 操作符检测 null 值时会返回 "object"
var car = null; alert(typeof car); // "object"
- 实际上，undefined 值是派生自 null 值的
alert(null = undefined); //true
- 只有两个字面值： true 和 false
- 将一个值转换为对应的 Boolean 值，用调用转型函数 Boolean( )
var message="Hello world!"; var messageAsBoolean=Boolean(message);
数据类型 转为 true 的值 转为 false 的值 Boolean true false String 任何非空字符串 ""(空字符串) Number 任何非零数字值(包括无限大) 0 和 NaN Object 任何对象 null undefined n/a (意思是 “不适用” ) undefined
var octalNuml=070；//八进制的56
var octalNum2=079；//无效的八进制数值——解析为79
var octalNum3=08；//无效的八进制数值——解析为8var hexNuml=0xA；//十六进制的10
var hexNum2=0x1f；//十六选制的31//在进行算数计算时，都最终被转换为十进制进行计算
- 浮点数值
- 所谓浮点数值，就是该数值中必须包含一个小数点，并小数点后至少有一位数字
var floatNuml=1.1； var floatNum2=0.1； var floatNum3=.1；//有效，但不推荐
- 所谓浮点数值，就是该数值中必须包含一个小数点，并小数点后至少有一位数字
- 如果小数点后没有数字或浮点数本身表示的就是一个证书，南无该值会被转换为整数
var floatNuml=1.；//小数点后面没有数字—一解析为1 var floatNum2=10.0；//整数一—解析为10
- 对于极大的数或极小的数用 e (科学计数法)
var floatNum = 3.125e7; //等于31250000
- 不要对浮点数进行相等判断
var a = 0.1, b = 0.2; if (a + b == 0.3) { //不要做这样的测试 alert('You got 0.3。') } // 0.1 + 0.2 的值是0.3000000000000004 //但对于其他值，如 0.15 + 0.25 就没有问题
- 数值范围
- 最大值： Number.MAX_VALUE
- 最小值： Number.MIN_VALUE
- 若一个值超出范围，则自动转换为特殊的 Infinity
- 若这个值为负数，则自动转换为 -Infinity
- 确定一个数值是不是有穷的
- NaN (Not a Number)
- 在 js 中，任何数值除以 0 会返回 NaN
- NaN 与任何值都不相等，包括 NaN 本身
- isNaN（）
- 任何不能被转换为数值的都会返回 true
alert（isNaN（NaN））；//true alert（isNaN（10））; //false（10是一个数值） alert（isNaN（“10“））；//false（可以被转换成数值l0） alert（isNaN（“blue“））；//true（不能转换成数值） alert（isNaN（true））；//false（可以被转换成数值1）
- 数值转换
- Number()
/* 如果是Boolean值，true和false将分别被转换为1和0。 如果是数字值，只是简单的传入和返回。 如果是nu11值，返回0。 如果是undefined，返回NaN。 如果是字符串，遵循下列规则： 如果字符串中只包含数字（包括前面带正号或负号的情况），则将其转换为十进制数值，即“1会变成1，·123“会变成123，而·011“会变成11（注意：前导的零被忽略了）；a如果字符串中包含有效的浮点格式，如1.1，则将其转换为对应的浮点数值（同样，也会忽略前导零）；如果字符串中包含有效的十六进制格式，例如“0x，则将其转换为相同大小的十进制整数值；a如果字符串是空的（不包含任何字符），则将其转换为0；如果字符串中包含除上述格式之外的字符，则将其转换为NaN。 如果是对象，则调用对象的valueof（）方法，然后依照前面的规则转换返回的值。如果转换的结果是NaN，则调用对象的tostring（）方法，然后再次依照前面的规则转换返回的字符串值。 */ var numl=Number("Hello world!"); //NaN var num2=Number(""); //0 var num3=Number("000011"); //11 var num4=Number(true); //1
- Number()
var numl=parseInt（“1234blue"）；//1234 var num2=parseInt（""）；//NaN var num3=parseInt（"0xA"）；//10（十六进制数） var num4=parseInt（22.5）；//22 var num5=parseInt（“070"）；//56（八进制数） var num6=parseInt（"70"）；//70（十进制数） var num7=parseInt（“OXf"）；//15（十六进制数）//第二个参数：指定进制 var num=parseInt("0XAF",16); //175 var numl=parseInt("AF",16); //175 var num2=parseInt("AF"); //NaN var numl= parseInt（“10"，2）；//2（按二进制解析） var num2=parseInt（“10“，8）；//8（按八进制解析） var num3=parseInt（“10”，10）；//10（按十进制解析） var num4=parseInt（“10"，16）；//16（按十六进制解析）
- parseFloat()
var numl=parseFloat（"1234blue"）；//1234（整数） var num2=parseFloat（"0xA"）；//0 十六进制始终会被转换为0 var num3=parseFloat（"22.5"）；//22.5 var numd=parseFloat（"22.34.5"）；//22.34 var num5=parseFloat（"0908.5"）；//908.5 var num6=parseFloat（"3.125e7"）；//31250000
- 单引号，双引号都可以
- 任何字符串的长度都可以通过其 length 属性取得
var text = "This is the letter sigma" alert(text.length); // 输出 24
- 字符串特点
- 字符串一旦创建，它们的值就不能改变。
- 转化为字符串
- toString()
var age=11； var ageAsString =age.tostring（）；//字符串”11“ var found=true； var foundAsString=found.tostring（）；//字符串“true”
- null 和 undefined 没有 toString() 方法
- toString() 可以传参数，可以输出任意有效进制格式表示的字符串值
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 值没有 toString() 方法
- null 和 undefined 没有 toString() 方法
- String()
- 可以将任何类型的值转换为字符串
//如果值有tostring（）方法，则调用该方法（没有参数）并返回相应的结果； //如果值是nu11，则返回“nu11”； //如果值是undefined，则返回“undefined"。var valuel=10; var value2=true; var value3=nul1; var value4; alert(String(valuel)); //"10* alert(String(value2)); //"true" alert(String(value3)); //"nul1" alert(String(value4)); //"undefined"
- 可以将任何类型的值转换为字符串
- toString()
- ECMAScript中的对象其实就是一组数据和功能的集合。
var o = new Object(); varo=new Object；//有效，但不推荐省哈圈括号
- Object的每个实例都具有下列属性和方法。
- Constructor：保存着用于创建当前对象的函数。
- hasOwnProperty（propertyName）：用于检查给定的属性在当前对象实例中（而不是在实例的原型中）是否存在。其中，作为参数的属性名（propertyName）必须以字符串形式指定例如：o.hasOwnProperty（"name"）
- isPrototypeOf（object）：用于检查传入的对象是否是另一个对象的原型
- propertyIsEnumerable（propertyName）：用于检查给定的属性是否能够使用for-in语句来枚举。与hasOwnProperty（）方法一样，作为参数的属性名必须以字符串形式指定。
- toLocaleString（）：返回对象的字符串表示，该字符串与执行环境的地区对应。
- toString（）：返画对象的字符串表示。
- valueof（）：返回对象的字符串、数值或布尔值表示。通常与tostring（）方法的返回值相同。
- ++ 和 -- 运算
- 运算符在前面，先自加(减)再进行运算
- 运算符在后面，先运算再进行自加(减)
var age = 29； var anotherAge = --age + 2； alert（age）；//输出28 alert（anotherAge）；//输出30var numl = 2； var num2 = 20； var num3 = --numl + num2；//等于21 var num4 = numl + num2；//等于21
- 这 4 个操作符对任何值都适用
- 在应用于一个包含有效数字字符的字符串时，先将其转换为数字值，再执行加减1的操作。字符串变量变成数值变量。
- 在应用于一个不包含有效数字字符的字符串时，将变量的值设置为NaN，字符串变量变成数值变量。
- 在应用于布尔值false时，先将其转换为0再执行加减1的操作。布尔值变量变成数值变量。
- 在应用于布尔值true时，先将其转换为1再执行加减1的操作。布尔值变量变成数值变量。
- 在应用于浮点数值时，执行加减1的操作。
- 在应用于对象时，先调用对象的 valueof（）方法，以取得一个可供操作的值。然后对该值应用前述规则。如果结果是NaN，则在调用 tostring（）方法后再应用前述规则。对象变量变成数值变量。
var s1 = "2"； var s2 = "z"； var b = false； var f = 1.1； var o = { valueof:function（）{ return -1； } }; s1++；//值变成数值3 s2++；//值变成NaN b++；//值变成数值1 f--；//值变成0.10000000000000009（由于浮点含入错误所致） O--；//债变成数值-2
- 在应用于一个包含有效数字字符的字符串时，先将其转换为数字值，再执行加减1的操作。字符串变量变成数值变量。
- 运算符在前面，先自加(减)再进行运算
- 一元加操作符：+
var num = 25； num = +num；//仍然是25//对于非数值应用时，该操作符会像 Number() 转型函数一样 var Sl = "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 num = 25； num = -num；//变成了-25//对于非数值应用时，该操作符会遵循一元加运算符同样的规则，然后再将数值转换为负数 var sl = "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 numl = 25; var num2 = -numl - 1; alert(num2); //"-26" //这也验证了按位非操作的本质：操作数的负值减1。
- 按位与（AND）用 & 表示
第一个数值的位 第二个数值的位 结果 1 1 1 1 0 0 0 1 0 0 0 0
var result = 25 & 3;
alert(result);
//1 25=00000000000000000000000000011001
3=00000000000000000000000000000011
---------------------------------------
AND=00000000000000000000000000000001
- 按位或（OR）：|
| 第一个数值的位 | 第二个数值的位 | 结果 |
| :------------: | :------------: | :--: |
| 1 | 1 | 1 |
| 1 | 0 | 1 |
| 0 | 1 | 1 |
| 0 | 0 | 0 |
var result = 25 | 3; alert(result); //2725=00000000000000000000000000011001 3=00000000000000000000000000000011 ------------------------------------- OR=00000000000000000000000000011011
- 按位异或（XOR）：^
第一个数值的位 第二个数值的位 结果 1 1 0 1 0 1 0 1 1 0 0 0 var result = 25 ^ 3; alert(result); //26 25=00000000000000000000000000011001 3=00000000000000000000000000000011 -------------------------------------- XOR=00000000000000000000000000011010
- 由 << 表示
var oldValue = https://www.it610.com/article/2；//等于二进制的10 var newValue = oldValue << 5；//等于二进制的1000000，十进制的64
- 有符号的右移，由 >> 表示
- 以符号位来填充空位
var oldValue = https://www.it610.com/article/64；//等于二进制的1000000 var newValue = oldValue>> 5；//等于二进制的10，即十进制的2
- 无符号的右移，用 >>> 表示
- 以 0 来填充空位
var oldValue = https://www.it610.com/article/-64；//等于二选制的11111111111111111111111111000000 var newValue = oldValue>>> 5；//等于十进制的134217726
- 以 0 来填充空位
- 逻辑非
- 由一个 ！ 表示
// 规则 // 如果操作数是一个对象，返回false； // 如果操作数是一个空字符串，返回true； // 如果操作数是一个非空字符串，返回false； // 如果操作数是数值0，返回true； // 如果操作数是任意非0数值（包括Infinity），返回false； // 如果操作数是nu11，返回true； // 如果操作数是NaN，返回true； // 如果操作数是undefined，返回true。alert(!false); //true alert(!"blue"); //false alert(!0); //true alert(!NaN); //true alert(!""); //true alert(!12345); //false
- 使用两个逻辑非就会模拟 Boolean（）转型函数的行为
alert(!!"blue"); //true alert(!!0); //false alert(!!NaN); //false alert(!!""); //false alert(!!12345); //true
- 由一个 ！ 表示
- 逻辑与
- 由 && 表示
- 真值表
第一个操作数 第一个操作数 结果 true true true true false false false true false false false false // 规则 // 如果第一个操作数是对象，则返回第二个操作数； // 如果第二个操作数是对象，则只有在第一个操作数的求值结果为true的情况下才会返回该对象； // 如果两个操作数都是对象，则返回第二个操作数； // 如果有一个操作数是nu11，则返回nu11； // 如果有一个操作数是NaN，则返回NaN； // 如果有一个操作数是undefined，则返回 undefined。
- 逻辑与操作属于短路操作，即如果第一个操作数能够决定结果，那么就不会再对第二个操作数求值。对于逻辑与操作而言，如果第一个操作数是false，则无论第二个操作数是什么值，结果都不再可能是true了。
- 由 && 表示
- 逻辑或
- 由 || 表示
- 真值表
第一个操作数 第一个操作数 结果 true true true true false true false true true false false false // 规则 // 如果第一个操作数是对象，则返回第一个操作数； // 如果第二个操作数的求值结果为 false ，则返回第二个操作数 // 如果两个操作数都是对象，则返回第一个操作数； // 如果有一个操作数是 nu11，则返回 nu11； // 如果有一个操作数是 NaN，则返回 NaN； // 如果有一个操作数是 undefined，则返回 undefined。
- 逻辑或操作属于短路操作，即如果第一个操作数为 true，那么就不会再对第二个操作数求值。
- 由 || 表示
- 乘法
- 由一个 * 表示，用于计算两个数值的乘积
// 规则 // 如果操作数都是数值，执行常规的乘法计算，即两个正数或两个负数相乘的结果还是正数，而如果只有一个操作数有符号，那么结果就是负数。 // 如果乘积超过了 ECMAScript 数值的表示范围，则返回 Infinity 或 -Infinity； // 如果有一个操作数是 NaN，则结果是 NaN； // 如果是 Infinity 与 0 相乘，则结果是 NaN； // 如果是 Infinity 与非 0 数值相乘，则结果是 Infinity 或 -Infinity，取决于有符号操作数的符号； // 如果是 Infinity 与 Infinity 相乘，则结果是 Infinity； // 如果有一个操作数不是数值，则在后台调用 Number（）将其转换为数值，然后再应用上面的规则。
- 由一个 * 表示，用于计算两个数值的乘积
- 除法
- 由一个 / 表示
// 规则 // 如果操作数都是数值，执行常规的除法计算，即两个正数或两个负数相除的结果还是正数，而如果只有一个操作数有符号，那么结果就是负数。 // 如果商超过了 ECMAScript 数值的表示范围，则返回 Infinity 或 -Infinity； // 如果有一个操作数是 NaN，则结果是 NaN； // 如果是 Infinity 被 Infinity 除，则结果是 NaN； // 如果是零被零除，则结果是 NaN； // 如果是非零的有限数被零除，则结果是 Infinity 或 -Infinity，取决于有符号操作数的符号； // 如果是 Infinity 被任何非零数值除，则结果是 Infinity 或 -Infinity，取决于有符号操作数的符号； // 如果有一个操作数不是数值，则在后台调用 Number（）将其转换为数值，然后再应用上面的规则。
- 由一个 / 表示
- 求余
- 【第三章（基本概念）】由 % 表示
// 规则 // 如果操作数都是数值，执行常规的除法计算，返回除得的余数； // 如果被除数是无穷大值而除数是有限大的数值，则结果是NaN； // 如果被除数是有限大的数值而除数是零，则结果是NaN； // 如果是Infinity被Infinity除，则结果是NaN； // 如果被除数是有限大的数值而除数是无穷大的数值，则结果是被除数； // 如果被除数是零，则结果是零； // 如果有一个操作数不是数值，则在后台调用Number（）将其转换为数值，然后再应用上面的规则。
- 【第三章（基本概念）】由 % 表示
- 加性操作符
- 加法
// 规则 // 如果有一个操作数是NaN，则结果是NaN； // 如果是Infinity加Infinity，则结果是Infinity； // 如果是-Infinity加-Infinity，则结果是-Infinity； // 如果是Infinity加-Infinity，则结果是NaN； // 如果是+0加+0，则结果是+0； // 如果是-0加-0，则结果是-0； // 如果是+0加-0，则结果是+0。// 如果有一个操作数是字符串，那么就要应用如下规则： // 如果两个操作数都是字符串，则将第二个操作数与第一个操作数拼接起来； // 如果只有一个操作数是字符串，则将另一个操作数转换为字符串，然后再将两个字符串拼接起来。 // 如果有一个操作数是对象、数值或布尔值，则调用它们的tostring（）方法取得相应的字符串值，然后再应用前面关于字符串的规则。对于undefined和nu11，则分别调用string（）函数并取得字符串“undefined“和“nul1"。var result1 = 5 + 5；//两个数值相加 alert{result1）；//10 var result2 = 5 + “5"；//一个数值和一个字符串相加 alert（result2）：//“55“
- 减法
// 规则 // 如果两个操作符都是数值，则执行常规的算术减法操作并返回结果； // 如果有一个操作数是NaN，则结果是NaN； // 如果是Infinity减Infinity，则结果是NaN； // 如果是-Infinity减-Infinity，则结果是NaN； // 如果是Infinity减-Infinity，则结果是Infinity； // 如果是-Infinity减Infinity，则结果是-Infinity； // 如果是+0减+0，则结果是+0；如果是+0减-0，则结果是-0； // 如果是-0减-0，则结果是+0； // 如果有一个操作数是字符串、布尔值、nu11或undefined，则先在后台调用Number（）函数将其转换为数值，然后再根据前面的规则执行减法计算。 // 如果转换的结果是NaN，则减法的结果就是NaN； // 如果有一个操作数是对象，则调用对象的valueof（）方法以取得表示该对象的数值。 // 如果得到的值是NaN，则减法的结果就是NaN。 // 如果对象没有valueof（）方法，则调用其tostring（）方法并将得到的字符串转换为数值。 var result1 = 5 - true；//4，因为true被转换成了1 var result2 = NaN - 1；//NaN var result3 = 5 - 3；//2 var result4 = 5 - “"；//5，因为“”被转换成了0 var result5 = 5 - “2"；//3，因为“2“被转换成了2 var result6 = 5 - nul1；//5，因为null被转换成了0
- 加法
- 小于（<）、大于（>）、小于等于（<=）和大于等于（>=），返回的都是布尔值
// 规则 // 如果两个操作数都是数值，则执行数值比较。 // 如果两个操作数都是字符串，则比较两个字符串对应的字符编码值。（实际比较的是两个字符串中对应位置的每个字符的字符编码值。） var result = "Brick" < "alphabet"; //true // 如果一个操作数是数值，则将另一个操作数转换为一个数值，然后执行数值比较。 // 如果一个操作数是对象，则调用这个对象的valueof（）方法，用得到的结果按照前面的规则执行比较。如果对象没有valueof（）方法，则调用tostring（）方法，并用得到的结果根据前面的规则执行比较。 // 如果一个操作数是布尔值，则先将其转换为数值，然后再执行比较。
- 相等和不相等
- 相等操作符由两个等于号（==）表示，相等则返回 true
- 不相等操作符由（！=）表示，不相等则返回 true
// 这两个操作符会先转换操作数（称为强制转型），遵循以下规则 // 如果有一个操作数是布尔值，则在比较相等性之前先将其转换为数值—— false 转换为 0，而 true 转换为 1； // 如果一个操作数是字符串，另一个操作数是数值，在比较相等性之前先将字符串转换为数值； // 如果一个操作数是对象，另一个操作数不是，则调用对象的valueof（）方法，用得到的基本类型值按照前面的规则进行比较；这两个操作符在进行比较时则要遵循下列规则。 // nu11 和 undefined 是相等的。 // 要比较相等性之前，不能将 nu11 和 undefined 转换成其他任何值。 // 如果有一个操作数是 NaN，则相等操作符返回 false，而不相等操作符返回 true。重要提示：即使两个操作数都是 NaN，相等操作符也返回 false；因为按照规则， NaN 不等于 NaN。 // 如果两个操作数都是对象，则比较它们是不是同一个对象。 // 如果两个操作数都指向同一个对象，则相等操作符返回 true；否则，返回 false。
表达式 值 表达式 值 null == undefined true true == 1 true "NaN" == NaN false true == 2 false 5 == NaN false undefined == 0 false NaN == NaN false null == 0 false NaN != NaN true "5" == 5 true false == 0 true
- 相等操作符由两个等于号（==）表示，相等则返回 true
- 全等和不全等
- 全等由 3 个等于号（===）表示
- 它只在两个操作数未经转换就相等的情况下返回 true
var result1 =（"55" == 55）；//true，因为转换后相等 var result2 =（"55" === 55）；//false，因为不同的数据类型不相等
- 它只在两个操作数未经转换就相等的情况下返回 true
- 不全等操作符由一个叹号后跟两个等于号（！==）表示
- 它在两个操作数未经转换就不相等的情况下返回 true
var result1=（“55" != 55）；//false，因为转换后相等var result2=（“55" !== 55）；//true，因为不同的数据类型不相等
- 它在两个操作数未经转换就不相等的情况下返回 true
- 全等由 3 个等于号（===）表示
var iable = boolean_expression ? true_value : false_value;
var max = (numl > num2) ? numl : num2;
5.11赋值运算符
- 简单的复制运算符：=
- 乘/赋值（*=）；
- 除/赋值（/=）；
- 模/赋值（%=）；
- 加/赋值（+=）；
- 减/赋值（-=）；
- 左移/赋值（<<=）；
- 有符号右移/赋值（>>=）；
- 无符号右移/赋值（>>>=）；
- 使用逗号操作符可以在一条语句中执行多个操作
var nunl=1, num2=2, num3=3; var nun=（5，1，4，8，0）；//num的值为0
if (i>25) (
alert("Greater than 25.");
) else if (i<0) {
alert("Less than 0.");
} else (
alert("Between 0 and 25, inclusive.")
};
6.2 do-while 语句
- 至少会执行一次
vari=0; do { i += 2; } while (i<10); alert(i);
var i = 0;
while (i < 10){
i += 2;
}
6.4 for 语句
var count = 10;
for (var i = 0;
i < count;
i++){
alert(i);
}
// for语句中的初始化表达式、控制表达式和循环后表达式都是可选的。将这两个表达式全部省略，就会创建一个无限循环，例如：
for（;
;
）{//无限循环
doSomething();
}
6.5 for-in语句
- 用来枚举对象的属性
for (var propName in window) { document. write(propName); }
start: for（var i=0；i< count；i++）{
alert（i）;
}
// 这个例子中定义的start标签可以在将来由break 或continue语句引用。加标签的语句一般都要与for 语句等循环语句配合使用。
// 未添加 Label
var num = 0;
for(var i = 0;
i < 10;
i++) {
for(var j = 0;
j < 10;
j++) {
if(i == 5 && j == 5) {
break;
}
num++;
}
}
alert(num);
//循环在 i= 5，j = 5 的时候跳出 j 循环，但会继续执行 i 循环，输出 95//添加 Label
var num = 0;
outPoint:
for(var i = 0;
i < 10;
i++) {
for(var j = 0;
j < 10;
j++) {
if(i == 5 && j == 5) {
break outPoint;
}
num++;
}
}
alert(num);
//循环在 i= 5，j = 5 的时候跳出双循环，输出 556.7 break 和 continue 语句
- break 会立即退出循环，强制执行循环后面的语句
- continue 会立即退出循环，然后回到循环的顶部继续执行
var num = 0; for(var i = 1; i < 10; i++){ if(i % 5 == 0) { break; } num++; } alert(num); //4var num = 0; for(var i = 1; i < 10; i++){ if(i % 5 == 0) { continue; } num++; } alert(num); //8var num = 0; outermost: for(var i = 0; i < 10; i++){ for(var j = 0; j < 10; j++){ if(i == 5 && j == 5) { break outermost: } num++; } }alert(num); //95
- 语法：with (expression) statement;
// 定义 with 语句的目的主要是为了简化多次编写同一个对象的工作 var gs = location.search.substring(1); var hostName = location.hostname; var url = location.href; // 上面几行代码都包含 location 对象。如果使用 with 语句 with(location) { var gs = search.substring(1); var hostName = hostname; var url = href; } // 会导致性能下降，不建议使用
switch (expression) {
case value:statement
break;
case value:statement
break;
case value:statement
break;
case value:statement
break;
default:statement
}
// 虽然ECMAScript中的switch 语句借鉴自其他语言，但这个语句也有自己的特色。首先，可以在switch语句中使用任何数据类型（在很多其他语言中只能使用数值），无论是字符串，还是对象都没有问题。其次，每个case的值不一定是常量，可以是变量，甚至是表达式。请看下面这个例子：
switch("hello world"){
case "hello"+"world":
alert("Greeting was found.");
break;
case "goodbye":
alert("Closing was found.");
break;
default:
alert("Unexpected message was found.");
}
7. 函数
- 通过 function 关键字来声明
function sayHi(name,message) { alert("Hello"+name+","+message); } sayHi("Nicholas","how are you today?");
- 没有重载
- ECMAScript 中的基本数据类型包括 Undefined、Null、Boolean、Number和string。
- 与其他语言不同，ECMScript 没有为整数和浮点数值分别定义不同的数据类型，Number 类型可用于表示所有数值。
- ECMAScript 中也有一种复杂的数据类型，即 object 类型，该类型是这门语言中所有对象的基础类型。
- 严格模式为这门语言中容易出错的地方施加了限制。
- ECMAScript 提供了很多与 C 及其他类 C 语言中相同的基本操作符，包括算术操作符、布尔操作符、关系操作符、相等操作符及赋值操作符等。
- ECMAScript 从其他语言中借鉴了很多流控制语句，例如 if 语句、for 语句和 switch 语句等。ECMAScript 中的函数与其他语言中的函数有诸多不同之处。
- 无须指定函数的返回值，因为任何 ECMAScript 函数都可以在任何时候返回任何值。
- 实际上，未指定返回值的函数返回的是一个特殊的 undefined 值。
- ECMAScript 中也没有函数签名的概念，因为其函数参数是以一个包含零或多个值的数组的形式传递的。
- 可以向 ECMAScript 函数传递任意数量的参数，并且可以通过 arguments 对象来访问这些参数。
- 由于不存在函数签名的特性，ECMAScript 函数不能重载。
推荐阅读
- HTML基础--基本概念--跟着李南江学编程
- 项目团队管理|项目团队管理 - 塔克曼阶梯理论
- 第三章你如果不能出众就可能出局（下）感悟
- 第三章|第三章 进校园重拾旧梦 登讲台初为人师第一节 接乱班面临考验 ，遇高师指点入门
- 一家三口齐穿越——第三章|一家三口齐穿越——第三章 竟然穿越了
- 2018-12-10《天生非此》第三章（你不是生来如此）
- QML基础信息
- 第三章|第三章 洞中洞
- 读书笔记（纪律的交易者（7））
- 父亲的队长生涯（3）