基本概念

简介：第三章

---

语法

1. 区分大小写

2. 标识符
   概念：指变量、函数、属性的名字，或者函数的参数。
   推荐：ECMAScript 标识符采用驼峰大小写格式，也就是第一个字母小写，剩下的每个单词的首字母大写，eg: myCar

3. 注释

   // 单行注释
   
   /*
   * 这是一个多行
   * （块级）注释
   */

4. 严格模式 use strict
   在严格模式下，ECMAScript 3 中的一些不确定的行为将得到处理，而且对某些不安全的操作也会抛出错误。

5. 变量
   ECMAScript 的变量是松散类型的，所谓松散类型就是可以用来保存任何类型的数据。换句话说，每个变量仅仅是一个用于保存值的占位符而已。

数据类型

五种基本数据类型： Undefined，Null，Boolean，Number，String，Symbol (ES6新增)。
复杂数据类型：Object。

1. typeof操作符

鉴于 ECMAScript 是松散类型的，因此需要有一种手段来检测给定变量的数据类型，下面展示各种返回情况：

• “undefined”—— 如果这个值未定义；
• “boolean”—— 如果这个值是布尔值；
• “string”—— 如果这个值是字符串；
• “number”——如果这个值是数值；
• “object”——如果这个值是对象或 null；
• “function”——如果这个值是函数。

//typeof 是操作符，不是函数，所以可以省略括号
var message = "some string";
typeof message; // "string"
typeof(message); // "string"

2. Undefined类型

Undefined 类型只有一个值，即特殊的 undefined。
在使用 var 声明变量但未对其加以初始化时，这个变量的值就是 undefined

var message;
message === undefined; //true

//未定义的变量 age
console.log(age);   //error age is not defined

//typeof不区分
typeof age;  //'undefined'
typeof message; //'undefined'

3. Null类型

Null 类型只有一个值的数据类型，这个特殊的值是 null。
从逻辑角度来看，null 值表示一个空对象指针，所以 typeof null 值会返回”object”。
如果定义的变量准备在将来用于保存对象，那么将该变量初始化为 null。

var car = null;
typeof car; //'object'

只要意在保存对象的变量还没有真正保存对象，就应该明确地让该变量保存 null 值。

4. Boolean类型

类型只有两个字面值：true 和 false。
True 和 False（以及其他的混合大小写形式）都不是 Boolean 值，只是标识符。

var message = "Hello world!";
var messageAsBoolean = Boolean(message);  //将一个值转换为对应的布尔值

数据类型	转换为true的值	转换为false的值
Boolean	true	false
String	任何非空字符串	“”（空字符串）
Number	任何非零数字值（包括无穷大）	0和NaN
Object	任何对象	null
Undefined	不适用	undefined

5. Number类型

1. 浮点数值
   浮点数值需要的内存空间是保存整数值的两倍，因此 ECMAScript 会不失时机地将浮点数值转换为整数值。

   var floatNum = 3.125e7; // 等于 31250000; 3.125 乘以 10 的 7 次方

2. NaN
   非数值（Not a Number）是一个特殊的数值，这个数值用于表示一个本来要返回数值的操作数未返回数值的情况。

   NaN 与任何值都不相等，包括 NaN 本身。

   alert(NaN == NaN);  //false

   isNaN()：用于判断是否是函数。

   isNaN(NaN);  //true
   isNaN(10);   //false（10 是一个数值）
   isNaN("10"); //false（可以被转换成数值 10）
   isNaN("blue"); //true（不能转换成数值）
   isNaN(true);   //false（可以被转换成数值 1）

3. 数值转换
   把非数值转换为数值的方法： Number()、parseInt() 和 parseFloat()

   var num1 = Number("Hello world!"); //NaN
   var num2 = Number(""); //0
   var num3 = Number("000011"); //11
   var num4 = Number(true); //1 
   
   //为了避免错误的解析，我们建议无论在什么情况下都明确指定基数，默认十进制解析。
   var num1 = parseInt("1234blue"); // 1234
   var num2 = parseInt("");         // NaN
   var num4 = parseInt(22.5);       // 22
   var num1 = parseInt("10", 2);    // 2 （按二进制解析）
   var num2 = parseInt("10", 8);    // 8 （按八进制解析）
   var num3 = parseInt("10", 10);   // 10 （按十进制解析）
   var num4 = parseInt("10", 16);   // 16 （按十六进制解析）
   
   //parseFloat()只解析十进制值
   var num1 = parseFloat("1234blue");  // 1234 （整数）
   var num2 = parseFloat("0xA");       // 0
   var num3 = parseFloat("22.5");      // 22.5
   var num4 = parseFloat("22.34.5");   // 22.34
   var num5 = parseFloat("0908.5");    // 908.5
   var num6 = parseFloat("3.125e7");   // 31250000

4. 数值范围
   正无穷 : Infinity
   负无穷 : -Infinity

6. String类型

String 类型用于表示由零或多个 16 位 Unicode 字符组成的字符序列，即字符串。

length 属性

var text = "This is the letter sigma: \u03a3."; 
text.length; //28

toString() 方法：

var age = 11;
var ageAsString = age.toString(); // 字符串"11"
var found = true;
var foundAsString = found.toString(); // 字符串"true" 

//数值转换时，可以给 toString() 传一个基数作为参数，默认十进制
var num = 10;
num.toString();   // "10" 十进制
num.toString(2);  // "1010" 二进制
num.toString(8);  // "12" 八进制
num.toString(10); // "10" 十进制
num.toString(16); // "a"  十六进制

String() 方法：能够将任何类型的值转换为字符串，包括 null 和 undefined

var value1 = 10;
var value2 = true;
var value3 = null;  
var value4;
String(value1); // "10"
String(value2); // "true"
String(value3); // "null"
String(value4); // "undefined"
//因为 null 和 undefined 没有 toString()方法，所以 String()函数就返回了这两个值的字面量。

7. Object类型

Object 的每个实例都具有下列属性和方法。

var o = new Object();

Object 的每个实例都具有下列属性和方法。

• constructor：保存着用于创建当前对象的函数；
• hasOwnProperty(propertyName)：用于检查给定的属性在当前对象实例中（而不是在实例的原型中）是否存在。propertyName 为字符串形式；
• isPrototypeOf(object)：用于检查传入的对象是否是传入对象的原型；
• propertyIsEnumerable(propertyName)：用于检查给定的属性是否能够使用 for-in 语句来枚举。propertyName 为字符串形式；
• toLocaleString()：返回对象的字符串表示，该字符串与执行环境的地区对应；
• toString()：返回对象的字符串表示；
• valueOf()：返回对象的字符串、数值或布尔值表示。通常与 toString()方法的返回值相同；

操作符

1. 一元操作符

只能操作一个值的操作符叫做一元操作符。

1. 前置型：先递增或递减，然后执行语句进行求值。

   var age = 29;
   var anotherAge = --age + 2;
   
   alert(age); // 输出 28
   alert(anotherAge); // 输出 30

2. 后置型：先执行包含它们的语句，然后执行递增和递减

   var num1 = 2;
   var num2 = 20;
   var num3 = num1-- + num2; // 等于 22
   var num4 = num1 + num2; // 等于 21

3. 一元加和减操作符
   一元操作符在作用于非数值时，会像 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 
   
   s1 = -s1; // 值变成了数值-1
   s2 = -s2; // 值变成了数值-1.1
   s3 = -s3; // 值变成了 NaN
   b = -b; // 值变成了数值 0
   f = -f; // 变成了-1.1
   o = -o; // 值变成了数值 1

位操作符

1. 按位非（~）
   操作数的负值减 1

   var num1 = 25;     // 二进制 00000000000000000000000000011001
   var num2 = ~num1;  // 二进制 11111111111111111111111111100110
   console.log(num2); // -26 
   
   var num2 = -num1 - 1; //-26

2. 按位与（&）
   只在两个数值的对应位都是 1 时才返回 1，任何一位是 0，结果都是 0

   var result = 25 & 3;
   console.log(result); //1
   
   25  = 0000 0000 0000 0000 0000 0000 0001 1001
   3   = 0000 0000 0000 0000 0000 0000 0000 0011
   ---------------------------------------------
   AND = 0000 0000 0000 0000 0000 0000 0000 0001

3. 按位或（|）
   在两个数值对应位上只有一个 1 时才返回 1，如果对应的两位都是 1 或都是 0，则返回 0

   var result = 25 | 3;
   console.log(result); //27
   
   25  = 0000 0000 0000 0000 0000 0000 0001 1001
   3   = 0000 0000 0000 0000 0000 0000 0000 0011
   ---------------------------------------------
   AND = 0000 0000 0000 0000 0000 0000 0001 1010

4. 左移（<<）

   var oldValue = 2; // 等于二进制的 10
   var newValue = oldValue << 5; // 等于二进制的 1000000，十进制的 64

5. 右移（>>）

   var oldValue = 64; // 等于二进制的 1000000
   var newValue = oldValue >> 5; // 等于二进制的 10 ，即十进制的 2

6. 无符号右移（>>>）

布尔操作符

1. 逻辑非（！）
   先将操作数转换为布尔值，然后再对其求反。

   alert(!false);  // true
   alert(!"blue"); // false
   alert(!0);     // true
   alert(!NaN);   // true
   alert(!"");    // true
   alert(!12345); // false

2. 逻辑与（&&）
   类似于‘短路操作’，即如果第一个操作数能够决定结果，那么就不会再对第二个操作数求值。

• 如果第一个操作数是对象，则返回第二个操作数；
• 如果第二个操作数是对象，则只有在第一个操作数的求值结果为 true 的情况下才会返回该对象；
• 如果两个操作数都是对象，则返回第二个操作数；
• 如果有一个操作数是 null，则返回 null；
• 如果有一个操作数是 NaN，则返回 NaN；
• 如果有一个操作数是 undefined，则返回 undefined。

2. 逻辑或（||）
   逻辑或操作符也是短路操作符。也就是说，如果第一个操作数的求值结果为true，就不会对第二个操作数求值了

• 如果第一个操作数是对象，则返回第一个操作数；
• 如果第一个操作数的求值结果为 false，则返回第二个操作数；
• 如果两个操作数都是对象，则返回第一个操作数；
• 如果两个操作数都是 null，则返回 null；
• 如果两个操作数都是 NaN，则返回 NaN；
• 如果两个操作数都是 undefined，则返回 undefined。

相等操作符

相等和不相等(== / !=)：先转换再比较，全等和不全等
全等(=== / !==)：仅比较而不转换