摘要：如在上列中結(jié)果實(shí)際上是給定數(shù)字的字符串形式無效語法有效語法在上列中結(jié)果是因?yàn)榈谝粋€被視為的一部分，第二個是屬性訪問運(yùn)算符。用于檢查傳入的對象是否是傳入對象的原型第章將討論原型。返回對象的字符串表示。

只挑本人重要的寫(有夾雜其他補(bǔ)充)

 單行注釋以兩個斜杠開頭，如下所示：
    // 單行注釋
 塊級注釋以一個斜杠和一個星號（ /* ）開頭，
    以一個星號和一個斜杠（ */ ）結(jié)尾，如下所示：
    /*
    * 這是一個多行
    * （塊級）注釋
    */

嚴(yán)格模式(一些不確定的行為將得到處理，而且對某些不安全的操作也會拋出錯誤)

 要在整個腳本中啟用嚴(yán)格模式可以在頂部添加如下代碼：
   "use strict";
   在函數(shù)內(nèi)部的上方包含這條編譯指示，也可以指定函在嚴(yán)格模式下執(zhí)行：
   function doSomething(){
   "use strict";
   //函數(shù)體
   }

語句
ECMAScript 中的語句以一個分號結(jié)尾；如果省略分號，則由解析器確定語句的結(jié)尾

描述： ECMAScript 的變量是松散類型的，所謂松散類型就是可以用來保存任何類型的數(shù)據(jù)。 
簡單來說，每個變量僅僅是一個用于保存值的占位符而已。

注意
用 var 操作符定義的變量將成為定義該變量的作用域中的局部變量。簡單來說，如果在函數(shù)中使用 var 定義一個變量，那么這個變量在函數(shù)退出后就會被銷毀

 function test(){
    var message = "hi"; // 局部變量
  }
  test();
  alert(message); // 錯誤
  

可能會返回以下結(jié)果字符串:

"undefined"——如果這個值未定義;
 "boolean"——如果這個值是布爾值；
 "string"——如果這個值是字符串；
 "number"——如果這個值是數(shù)值；
 "object"——如果這個值是對象或null；
 "function"——如果這個值是函數(shù)。
注意： 
 a.對null返回是"object"。
     typeof null // object;
 b.不能區(qū)分對象、數(shù)組、正則，對它們操作都返回"object"。
     typeof Number()// object;
 c.對NaN返回是"number"    
     typeof parseInt("你") === "number" //true              

描述：聲明變量但未對其加以初始化時，這個變量的值就是 undefined。

 下面幾種情況會出現(xiàn)undefined：
     訪問數(shù)組或?qū)ο蟛淮嬖诘某蓡T
     定義的變量未賦值。
     函數(shù)沒有返回值，或return后沒有數(shù)據(jù)。
 注意：
     var a; // undefined
     b      // ReferenceErroe:b is not defined;
     typeof a; // undefined;
     typeof b; // undefined;          

描述：          表示一個空對象指針；   var car = null;   alert(typeof car); //
"object"   如果定義的變量準(zhǔn)備在將來用于保存對象，那么最好將該變量初始化為 null 而不是其他值。

注意：
     console.log(null == undefined) // true;
     console.log(null === undefined) //false
判斷值是否為null：
    var a = null;
    (!a && typeof a === "object");// true;   

可轉(zhuǎn)轉(zhuǎn)化布爾類型：

  a.假值
     undefined、null、false、+0、-0、NaN、"";
  b、假值對象
     var a = new Boolean(false);
     var b = new Number(0);
     var c = new String("");
     var d = Boolean(a && b && c );
     d // true;
     var e = a && b && c;
     e // String {length: 0[[PrimitiveValue]]: ""};
 

描述: 表示整數(shù)和浮點(diǎn)數(shù)值(雙精度64位二進(jìn)制); 整數(shù)就是沒有小數(shù)的十進(jìn)制數(shù)。所以42.0即等于“整數(shù)”42。

數(shù)字語法

a.十進(jìn)制：

var a = 42; 
var b = 42.3;

b.前面的0可以省略：

var a = 0.42;
var b = .42;

c.小數(shù)點(diǎn)部分最后的0也可以省略

var a = 42.0;
var b = 42.;

d.默認(rèn)情況下大部分?jǐn)?shù)字都以十進(jìn)制顯示，小數(shù)部分最后的0被省略

var a = 42.3000 // 42.3
var b = 42.0 // 42     

e.特別大與特別小的數(shù)字默認(rèn)用指數(shù)顯示

var a = 5E10;
a; // 50000000000
a.toExponential(); // "5e+10"
 
var b = a * a;
b; // 2.5e+21
 
var c = 1/a;
c; // 2e-11        

f.由于數(shù)字可以使用Number對象進(jìn)行封裝，可以調(diào)用Number.prototype方法。如：

var a = 42.59;
a.toFixed(0); // "43"
a.toFixed(1); // "42.6";
a.toFixed(3); // "42.590"
在上列中結(jié)果實(shí)際上是給定數(shù)字的字符串形式    
// 無效語法
42.toFixed(3); // SyntaxError
//有效語法
(42).toFixed(3);
0.42.toFixed(3);
42..toFixed(3);
在上列中結(jié)果是因?yàn)榈谝粋€.被視為number的一部分，第二個.是屬性訪問運(yùn)算符。      

較小的數(shù)值：(這是二進(jìn)制浮點(diǎn)數(shù)最大的問題)

0.1 + 0.2 === 0.3; // false

解決方法(判斷兩數(shù)是否相等):
function numbersCloseEnoughToEqual(n1,n2) {
    return Math.abs(n1 - n2 ) < Math.pow(2,-52);
}

整數(shù)的安全范圍：

  Number.MAX_SAFE_INTEGER = 2^53 -1;
  Number.MIN_SAFE_INTEGER = -(2^53 -1);
  如數(shù)據(jù)庫中的64位ID等，由于JavaScript的數(shù)值類型無法精確呈現(xiàn)64位數(shù)值，所以必須將它保存為字符串。     

整數(shù)檢測:

 Number.isInteger = function(num) {
     return typeof num === "number" && num % 1 === 0;
 }   

- 檢測是否是安全整數(shù)：

Number.isSafeInteger = function(num) {
    return Number.isInteger(num) && Math.abs(num) <= Number.MAX_SAFE_INTEGER;
}

特殊的數(shù)字：

描述：數(shù)學(xué)運(yùn)算的操作數(shù)不是數(shù)字類型，無法返回一個有效的數(shù)字，會返回NaN。

a.不是數(shù)字的數(shù)字

var a = 2/"foo"; // NaN
typeof a === "number"; // true
不是數(shù)字的數(shù)字是數(shù)字類型。
注意：
    NaN是一個特殊值，他和自身不相等；
    NaN != NaN; // true
    
可用isNaN()來判斷(但有個bug)：
var a = 2 / "foo"
isNaN(a); // true                      
var b = "foo";
isNaN(b); // true
isNaN()檢查參數(shù)是否不是NaN，也不是數(shù)字。
解決：
Number.isNaN = function(n){
    return (typeof n === "number" && window.isNaN(n))
}          

b.無窮數(shù)

 var a = 1 /0; // Infinity
 var b = -1/0; // -Infinity
 Infinity/Infinity; // NaN
 1/Infinity; // 0
 -1/Infinity; // -0                       

c.零值

var a = 0/ -3; //-0
var b = 0 * -3; // -0

a.toString(); // "0"
a + ""; // "0"
String(a); // "0"
JSON.stringfy(a); // "0"

+"-0"; // -0
Number("-0"); // -0
JSON.parse("-0"); // -0

-0 == 0; // true
-0 === 0; // true
0 > -0; // false

區(qū)分 -0 和 0：
   function isNegZero(n) {
       var n = Number(n);
       return (n === 0) && (1/n === -Infinity);
   }                                          

特點(diǎn)： 字符串是不可變的，也就是說，字符串一旦建， 它們的值就不能改變。
要改變某個變量保存的字符串，首先要銷毀原來的字符串，然后再用另一個包含新值的字符串填充該變量

轉(zhuǎn)換字符串：

基本類型值的轉(zhuǎn)化規(guī)則為：
null轉(zhuǎn)化為"null"，
undefined轉(zhuǎn)化為"undefined"，
true轉(zhuǎn)化為"true",
數(shù)字的字符串化則遵循通用規(guī)則，
數(shù)組的默認(rèn)toString(),將所有單元字符串化后再用"，"鏈接起來。

JSON字符串化

注意：
a.JSON字符串化并非嚴(yán)格意義上的強(qiáng)制類型轉(zhuǎn)換。
    序列化的結(jié)果總是字符串 
    JSON.stringify("42"); // ""42""
    JSON.stringify()在對象遇到undefined、function 和 symbol 時會自動將其忽略，在數(shù)組中返回null(以保證單元位置不變)                       
    JSON.stringify(undefined);// undefined
    JSON.stringify([1,undefined,function(){},4]); // "[1,null,null,4]"
    JSON.stringify({a:2,b:function(){}}) // "{"a":2}"
  
b.如果傳遞給JSON.stringify()的對象定義了toJSON()方法，該方法會在字符串前調(diào)用，以便將對象轉(zhuǎn)換為安全的JSON值。
             

Object 的每個實(shí)例都具有下列屬性和方法：

constructor ：保存著用于創(chuàng)建當(dāng)前對象的函數(shù)。
hasOwnProperty(propertyName) ：用于檢查給定的屬性在當(dāng)前對象實(shí)例中（而不是在實(shí)例的原型中）是否存在。其中，作為參數(shù)的屬性名（ propertyName ）必須以字符串形式指定（例如： o.hasOwnProperty("name") ）。
isPrototypeOf(object) ：用于檢查傳入的對象是否是傳入對象的原型（第 5 章將討論原型）。
propertyIsEnumerable(propertyName) ：用于檢查給定的屬性是否能夠使用 for-in 語句來枚舉。與 hasOwnProperty() 方法一樣，作為參數(shù)的屬性名必須以字符串形式指定。
toLocaleString() ：返回對象的字符串表示，該字符串與執(zhí)行環(huán)境的地區(qū)對應(yīng)。
toString() ：返回對象的字符串表示。
valueOf() ：返回對象的字符串、數(shù)值或布值表示。通常與 toString() 方法的返回值相同。