摘要：使用表明你的比較不會涉及任何的隱形的類型轉(zhuǎn)換。當(dāng)對不同類型的數(shù)據(jù)進(jìn)行比較的時候你要首先把它們進(jìn)行顯示的類型轉(zhuǎn)換。然后再進(jìn)行比較這樣會使你的程序更加清晰。

通過在程序最開始假如一個字符串字面量 use strict ，即可開啟嚴(yán)格模式

嚴(yán)格模式可以讓JS代碼擁有更好的兼容性，更強(qiáng)的健壯性

在嚴(yán)格模式下，重新聲明 arguments 會報錯，非嚴(yán)格模式則不會

"use strict";
function say() {
    var arguments = []; 
// Uncaught SyntaxError: Unexpected eval or arguments in strict mode
}

如果連接兩個不同模式的JavaScript文件的話，如果是嚴(yán)格模式的文件放在開始的話，那么整個文件都是處于嚴(yán)格模式

如果連接兩個不同模式的JavaScript文件的話，如果是非嚴(yán)格模式的文件放在開始的話，那么整個文件都是處于非嚴(yán)格模式

在文件中間使用use strict是沒有作用的

為了同時使用嚴(yán)格和非嚴(yán)格模式的文件，可以通過立即調(diào)用函數(shù)達(dá)到分離作用域的目的

(function() {
    // file1.js 使用了嚴(yán)格模式
    "use strict";
    function say() {

    }
})();

(function() {
    // file2.js 使用非嚴(yán)格模式
    function sayWithNoStrict() {
        var arguments = [];
    }
})();

JavaScript中的數(shù)字都是 Number 類型，即雙精度浮點(diǎn)數(shù)，JS中整數(shù)是雙精度浮點(diǎn)數(shù)的一個子集

JavaScript存在精度缺陷，如 0.1+0.2 ，應(yīng)該盡量通過單位轉(zhuǎn)換使用整數(shù)運(yùn)算 1+2

注意 toString() 和 parseInt() 方法的參數(shù)

console.log(typeof 36); // number
console.log(typeof 36.36); // number
console.log(typeof -36.36); // number

console.log(0.1 * 3.6); // 0.36000000000000004
console.log(1 * 36); // 36
console.log(1 - 0.6); // 0.4
console.log(25 / 5); // 5
console.log(2.5 / 5); // 0.5
console.log(25 % 4); // 1
console.log(25 % 0.4); // 0.19999999999999862
console.log(8 | 1); // 9

console.log((10).toString(7)); // 13 參數(shù)表示返回值的進(jìn)制數(shù)
console.log(parseInt("1010", 2)); // 10 第二個參數(shù)表示需要轉(zhuǎn)換的數(shù)據(jù)的進(jìn)制數(shù)，返回值為10進(jìn)制

console.log(0.1 + 0.2); // 0.30000000000000004
console.log(0.1 + (0.2 + 0.3)); // 0.6
console.log((0.1 + 0.2) + 0.3); // 0.6000000000000001
console.log(((1 + 2) + 3) / 10); // 0.6

console.log(10 + (20 + 30)); // 60
console.log((10 + 20) + 30); // 60

String + Number ，Number會被轉(zhuǎn)為String。

String * Number ，String會被轉(zhuǎn)為Number。

要當(dāng)心 NaN 和 isNaN 的判斷與使用

console.log(3 + true); // 4

console.log(1 + 1); // 2
console.log("hello" + " world"); // hello world

console.log(2 + "3"); // 23
console.log("2" + 3); // 23
console.log("2" + "3"); // 23

console.log(1 + "2" + 3); // 123

console.log(2 * "3"); // 6
console.log("8" | "1"); // 9

var x = NaN;
console.log(x === x); // false
var a = {};
console.log(a === a); // true
var b = null;
console.log(b === null); // true

console.log(isNaN(NaN)); // true;

console.log(isNaN({})); // true
console.log(isNaN(undefined)); //true
console.log(isNaN("foo")); // true 不能用isNaN來判斷字符串
console.log(isNaN(1)); // false
console.log(isNaN({valueOf: "foo"})); // true

console.log(isNaN({valueOf: function(){return 1}})); // false

console.log("J" + {toString: function(){return "S"}}); // JS
console.log(1 + {valueOf: function(){return 2}}); // 3

var obj = {
    toString: function() {
        return "obj";
    },
    valueOf: function() {
        return 1;
    }
};

console.log(1 + obj); // 2
console.log("1" + obj); // 11


// bad
function badPoint(x, y) {
    if(!x) {
        x = 1;
    }
    if(!y) {
        y = 1;
    }
    return {
        x: x,
        y: y
    }
}

// good
function point(x, y) {
    if(typeof x === undefined || y === undefined) {
        return {
            x: x || 1,
            y: y || 1
        }
    }
    return {
        x: x,
        y: y
    }
}

console.log(badPoint(0, 0)); // { x: 1, y: 1 }
console.log(point(0, 0)); // { x: 0, y: 0 }
console.log(point()); // { x: 1, y: 1 }

注意變量聲明，原始對象和封裝對象是不一樣的

var s = new String("hello");
console.log(s); // String {0: "h", 1: "e", 2: "l", 3: "l", 4: "o", length: 5, [[PrimitiveValue]]: "hello"}

var str = s + " world";
console.log(str); // hello world

console.log(str[4]); // o

console.log(typeof "hello"); // string
console.log(typeof s); // object

var s1 = new String("hello");
var s2 = new String("hello");
console.log(s1 === s2); // false
console.log(s1 == s2); // false

console.log(str.toUpperCase()); // HELLO WORLD

str.someProperty = "some";
console.log(str.someProperty); // undefined

s.someProperty = "some";
console.log(s.someProperty); // "some"

當(dāng)使用 == 操作符進(jìn)行相等的比較操作的時候,如果它的兩個參數(shù)的類型是不一樣的; 那么==會把它們先強(qiáng)制轉(zhuǎn)換為相同類型參數(shù),然后再進(jìn)行比較。

使用 === 表明你的比較不會涉及任何的隱形的類型轉(zhuǎn)換。

當(dāng)對不同類型的數(shù)據(jù)進(jìn)行比較的時候,你要首先把它們進(jìn)行顯示的類型轉(zhuǎn)換。 然后再進(jìn)行比較,這樣會使你的程序更加清晰。

編譯器僅在 { 標(biāo)記之前，一行的結(jié)束和程序的結(jié)束處推導(dǎo)分號

僅在緊接著的標(biāo)記不能被解析的時候推導(dǎo)分號

在以(,[,+,-或/字符開頭的語句前決不能省略分號

當(dāng)腳本連接的時候，應(yīng)在腳本之間顯式地插入分號

在return, throw, break, continue, ++ 或 -- 的參數(shù)之前決不能換行

var b = 12;
function f() {}

// 當(dāng)@1和@2連在一起不能夠解析的時候,分號才會自動插入
var a = b // @1
f() // @2

// 當(dāng)@3和@4連在一起能夠解析(雖然可能會解析失敗)的時候,分號就不會自動插入了
var c = b // @3
(f()) // @4

// 在以`[`,`(`,`+`,`-`,`/`開頭的語句前,永遠(yuǎn)不要省略分號
var d = 8;
var e = 3  //此處的分號絕不能省略
+d
console.log(e); // 11

// 當(dāng)連接不同的腳本的時候,要在不同的腳本之間插入分號。
(function() {
    console.log("hello")
})()
;(function() { //編寫庫函數(shù)的時候，常常在立即調(diào)用函數(shù)前添加分號，防止上一個文件最后一行無分號導(dǎo)致未知錯誤
    console.log("world")
})()

// 不然就會解析出錯
//(function() {
//    console.log("hello")
//})()(function() {
//    console.log("world")
//})()

// 參數(shù)之前含有`return`,`throw`,`break`,`continue`,`++`,`--`的,參數(shù)與它們之間不要換行，否則會變?yōu)?`return;` 
function demoFunc() {
    return
    1
}
console.log(demoFunc()) // undefined 沒有返回預(yù)期的結(jié)果

// 在循環(huán)語句的頭部,分號不是用來當(dāng)分隔符或者空語句使用的。
for(var i = 0; i < 3; i++) {
    console.log(i);
}

// 解析出錯
//for(var i = 0
//        i < 3
//        i++) {
//    console.log(i);
//}