摘要：如果參數不在與之間，該方法將返回一個空字符串這個不解釋了方法用于在字符串中用一些字符替換另一些字符，或替換一個與正則表達式匹配的子串。

x && y 只有在x和y都為真的情況下為真。即真真為真，短路：因比較運算為左結合運算，若x為假，&&后面表達式不執行

x || y y或x有一個為真的情況下即為真。即一真為真，短路：若x為真，則短路跳出，||后面表達式不執行

!x 只有在x非真情況下為真

JavaScript的數值與大多數編程語言的數值一樣，不同于我們日常所見的理想化數值。首先，它們收到計算設備固定大小的物理元件的限制。因此，存在一個最大的數值（在JavaScript里這個值約為1.79e308）和一個最小的數值（-1.79e108）。任何計算得到超過最大數值或者小于最小數值，都會轉化為特殊值Infinity或者-Infinity。

精度不夠的問題注意以下幾點：

可表示的數值密集度集中在0左右，事實上有一多半都介于1和-1之間；離0越遠，就越稀疏。

所有介于正負9e15之間的數都可以精確表示，在這個范圍之外，只有部分整數可以表示。

涉及非常大的數值、非常小的數值或者非整數的計算，經常會導致不準確的結果。

1. `NaN`這個特殊值代表的是**“Not a Number”,**他會在數學計算**得到了非數學意義上的結果**時出現
2. **NaN不等于任何值，也不等于NaN！**
3. **檢測一個值是否為數值**，可用 `isNaN()` 方法。
4. 如果**想用十六進制表示整數，在數值前面加上**`0x`

Math.floor(x) 取得小于等于x的最大正整數

Math.floor(2.99);     // 2
Math.floor(-2.99);    // -3

Math.ceil(x) 取得大于等于x的最小整數

Math.ceil(3.99);      // 4
Math.ceil(-3.99);     // -3

Math.sqrt(x) 對x開方

Math.sqrt(100);       // 10

Math.random(x) 得到一個大于等于0，小于1的數

Math.random();        // x大于等于0，小于10

Math.pow(x,y) 得到的是x的y次方

Math.pow(2,4);        // 16

字符集由一組特定的字符組成，其中每個字符都有唯一的編號，叫碼點（codepoint）。與大多數語言一樣，JavaScript使用unicode字符集。unicode字符集一般用十六進制為每個字符編碼。
要了解全部碼點，可訪問Unicode碼點。

反斜杠不僅用于通過碼點來表示字符，而且也用于與后續字符組織成所謂的轉義序列

" 單引號

" 雙引號

xhh hh是兩位十六進制值，相應字符的碼點

、 、、f、 、v 換行符、制表符、退格符、進紙符、回車符、制表符

反斜杠本身

u加碼點的方式只在JavaScript代碼中有效。如果想在HTML文檔顯示字符，則需要在碼點前加上&#x;

大型頁面中，所有樣式規則也應該保存在一個多帶帶的文件匯總。這樣，文檔的結構、樣式、行為才能各安其位，相互分離。在軟件工程中，關注點分離是一個非常重要的思想。

substr(start，length)

start 必需。一個非負的整數，規定要提取的子串的第一個字符在 stringObject 中的位置。

length 可選。子串中的字符數。必須是數值。如果省略了該參數，那么返回從 stringObject 的開始位置到結尾的字串

slice(start，end)

要抽取的片斷的起始下標。如果是負數，則該參數規定的是從字符串的尾部開始算起的位置。也就是說，-1 指字符串的最后一個字符，-2 指倒數第二個字符，以此類推

緊接著要抽取的片段的結尾的下標。若未指定此參數，則要提取的子串包括 start 到原字符串結尾的字符串。如果該參數是負數，那么它規定的是從字符串的尾部開始算起的位置

substring(start，stop)

必需。一個非負的整數，規定要提取的子串的第一個字符在 stringObject 中的位置

可選。一個非負的整數，比要提取的子串的最后一個字符在 stringObject 中的位置多 1。如果省略該參數，那么返回的子串會一直到字符串的結尾

indexOf(searchvalue,fromindex)

方法可返回某個指定的字符串值在字符串中首次出現的位置。

searchvalue 必需。規定需檢索的字符串值。

fromindex 可選的整數參數。規定在字符串中開始檢索的位置。它的合法取值是 0 到 stringObject.length - 1。如省略該參數，則將從字符串的首字符開始檢索。

lastIndexOf(searchvalue,fromindex)

lastIndexOf() 方法可返回一個指定的字符串值最后出現的位置，在一個字符串中的指定位置從后向前搜索。

searchvalue 必需。規定需檢索的字符串值。

fromindex 可選的整數參數。規定在字符串中開始檢索的位置。它的合法取值是 0 到 stringObject.length - 1。如省略該參數，則將從字符串的最后一個字符處開始檢索。

charCodeAt(index)

charCodeAt() 方法可返回指定位置的字符的 Unicode 編碼。這個返回值是 0 - 65535 之間的整數。
方法 charCodeAt() 與 charAt() 方法執行的操作相似，只不過前者返回的是位于指定位置的字符的編碼，而后者返回的是字符子串。

charAt(index)

charAt() 方法可返回指定位置的字符。

index 必需。表示字符串中某個位置的數字，即字符在字符串中的下標。

如果參數 index 不在 0 與 string.length-1 之間，該方法將返回一個空字符串

toLowerCase() and toUpperCase()

這個不解釋了

replace(regexp/substr,replacement)

replace() 方法用于在字符串中用一些字符替換另一些字符，或替換一個與正則表達式匹配的子串。

regexp/substr 必需。規定子字符串或要替換的模式的 RegExp 對象。請注意，如果該值是一個字符串，則將它作為要檢索的直接量文本模式，而不是首先被轉換為 RegExp 對象。

regexp/substr 必需。規定子字符串或要替換的模式的 RegExp 對象。請注意，如果該值是一個字符串，則將它作為要檢索的直接量文本模式，而不是首先被轉換為 RegExp 對象。

console.log("Hello,there".replace("ello","i"));      // Hi,there

這個方法可以搭配正則表達式使用，后續會繼續研究用法

注意幾點：

slice()和substring()有一點共同的注意點：

兩個參數都為正整數情況下，最后返回的字符串中不包括最后一個被索引的字符！！！

    var x = "Queen";

    x.substring(1,4);       // "uee"
    x.substring(-1,2);      // "Qu"    識別第二個參數，但是是從頭部開始兩個字母
    x.substring(-4,-1);     // ""    空字符，兩個參數都不接收負數
    x.substring(-3);        // "Queen" 直接返回整個字符串
    // substring(strat,stop)    
    
    x.slice(1,4);           // "uee"
    x.slice(-1,2);          // ""
    x.slice(-4,-2);         // "ue"
    x.slice(0,-2);          // "Que"
    x.slice(-4);            // "ueen"
    // slice(start,end)        
    
    
    // 共同點！已表達式s.substring（x,y）或 s.slice    (x,y)為例
    // 都為正整數情況下，會得到字符串s中，從位置x開始直到（但不包含）位置y的所有字符。

        var x = "abcdefg";
        //    排列組合所有情況 (+)(-) and (a,b)
        // (+,+) a>b or ab 
        // (-,-) a>b or aa，按照正常邏輯返回字符串，當b
對象
分清理解點運算符和方括號運算符，并靈活運用

什么情況下必須使用方括號表訪問對象的屬性？

使用了不能作為標識符的屬性名的情況

將變量的值作為屬性名使用的情況

將表達式的求值結果作為屬性名使用的情況


// 自行使用console.log()或者alert()調用試驗
var test = {
    1:"one",
    name:"name",
    var:"var",
    "2 333":2333,
    "foo-bar":5,
    x:"x"
};

test["1"];                  // "one"    
test.1;                     // Unexpected number錯誤
test[1];                    // Unexpected number錯誤

test["name"];               // "name"
test.name;                  // "name"

test.var;                   // "var"
test["var"];                // "var"

test["2 333"];              // 屬性名含有空格必須用方括號
                            // 屬性名不能使用數字！
                            
test.foo-bar;               // 含有橫杠的屬性名點運算會引起錯誤，會解析為：obj.foo減去                bar，引發錯誤
test["foo-bar"];            // 5    

// 下面展示將變量的值作為屬性名使用的情況
var key = "name";
test[key];                  // "name"    方括號內的變量存儲的值依舊是引號包裹的字符串，方括號正常訪問


理解對象引用



基本類型值直接存儲在變量中，而對象不是。對象的值中存儲的是指向對象的引用

由于對象的值其實是引用，所以把一個對象賦值給一個變量，實際上會產生該對象引用的一個副本，而不會賦值對象本身。換句話說，對象賦值不會產生新對象。想想看，對象的賦值與基本類型值賦值過程并沒有不同。變量間的賦值就是把保存一個盒子里的東西賦值一份再保存到另一個盒子中，而該盒子中存儲的可能是數值，也可能是一個引用。

對象與其他類型值的第二個重要的區別是：對同一個對象字面量的每次求值，都會產生一個新對象。


對象原型

對象原型示意圖

每個JavaScript對象都有一個暗藏的鏈接指向自己的原型對象（prototype），如果你讀取的的屬性不在對象本身上，那么JavaScript就會進一步查詢這個對象的原型對象。如果在這個原型對象上也沒找到，還會進一步查詢原型對象的原型對象，以此類推。這個原型鏈最后一個對象的暗藏鏈接，應該指向null值。如果整個原型鏈都沒有你想讀取的屬性，那么你會看到一個錯誤。


自有屬性和繼承屬性:
字面意思先簡單理解，自有屬性在自身，直接訪問，不需通過原型鏈。繼承屬性繼承自原型，通過_proto_向上查詢

自引用對象

對象的屬性可以引用自身，兩個對象也可以通過屬性相互作用。但這種情況下，光靠對象字面量無法描述：先使用對象字面量創建對象的部分屬性，然后在通過賦值方式定義其他屬性。當然也可以為彼此賦值。

自引用示意圖



數組
概念：數組是一種特殊的對象,它的屬性是從0開始的連續非負整數，而且有一個名為length的對應屬性。

數組引用示意圖
常用方法：

slice(start,end)略....


concat(arrayX,arrayX,......,arrayX)

concat() 方法用于連接兩個或多個數組。該方法不會改變現有的數組，而僅僅會返回被連接數組的一個副本。

arrayX    必需。該參數可以是具體的值，也可以是數組對象。可以是任意多個。


    var a = [1,2,3];
    var b = ["one","two","three"];
    var c = a.concat(b);
    console.log(c.length)                    // 6
    console.log(a.length+" | "+b.length)     // 3 | 3 



join(separator)

join() 方法用于把數組中的所有元素放入一個字符串。元素是通過指定的分隔符進行分隔的。

separator 可選。指定要使用的分隔符。如果省略該參數，則使用逗號作為分隔符。



        var arr = [1,2,3,4,5,6];
        console.log(arr.join())               // "1,2,3,4,5,6"
        console.log(arr.join("|"))            // "1|2|3|4|5|6"


split(separator,howmany)

split() 方法用于把一個字符串分割成字符串數組。（接受一個字符串，返回的是把字符串分割后各元素組成的數組）

separator    必需。字符串或正則表達式，從該參數指定的地方分割 stringObject。


howmany    可選。該參數可指定返回的數組的最大長度。如果設置了該參數，返回的子串不會多于這個參數指定的數組。如果沒有設置該參數，整個字符串都會被分割，不考慮它的長度。
var os = "Windows Macos Unix Linux android、ios、WP ...";
    os.split(" ")         // "Windows,Macos,Unix,Linux,android、ios、WP,..."
    os.split("、")        // "Windows Macos Unix Linux android,ios,WP ..."
    
    "hello world!".split("")            // "h,e,l,l,o, ,w,o,r,l,d,!"
    "how,are,you,?".split(",",2)        // "how,are"
    "1|2|3|4|5".split("|",4)            // "1,2,3,4"
    
    // separator參數注意是空格符(" "),還是默認(""),具體情況具體分析





數組頭尾的增刪方法：


末尾添加：push(newelement1,newelement2,....,newelementX)


push() 方法可向數組的末尾添加一個或多個元素，并返回新的長度。

push() 方法可把它的參數順序添加到 arrayObject 的尾部。它直接修改 arrayObject，而不是創建一個新的數組。push() 方法和 pop() 方法使用數組提供的先進后出棧的功能。



        var arr = [1,2,3];
        arr.push(4,5,6);
        arr.push(["one","two","three"],["a","b","c"])
        
        console.log(arr[4])                     // "5"
        console.log(arr[6]+" | "+arr[7])        //  "one,two,three | a,b,c"
        
        // 添加若干元素，或者添加若干數組




末尾刪除：pop()

pop() 方法將刪除 arrayObject 的最后一個元素，把數組長度減 1，并且返回它刪除的元素的值。如果數組已經為空，則 pop() 不改變數組，并返回 undefined 值。


        var arr = [1,2,3];
        arr.push(4,5,6);
        arr.push(["one","two","three"],["a","b","c"])
        
        console.log(arr[4])                        // "5"
        console.log(arr[6]+" | "+arr[7])           //  "one,two,three | a,b,c"
        
        console.log(arr.pop())                     // "a,b,c"
        console.log(arr.pop())                     // "one,two,three"
        console.log(arr.length)                    // 6



頭部添加：unshift(newelement1,newelement2,....,newelementX)


unshift() 方法將把它的參數插入 arrayObject 的頭部，并將已經存在的元素順次地移到較高的下標處，以便留出空間。該方法的第一個參數將成為數組的新元素 0，如果還有第二個參數，它將成為新的元素 1，以此類推。


newelement1    必需。向數組添加的第一個元素。

newelement2    可選。向數組添加的第二個元素。

newelementX    可選。可添加若干個元素。




        var arr = [1,2,3];
        arr.unshift(0,[-1,-2,-3],{x:"x",y:"y"})

        arr[0]                // 0    傳入的第一個參數索引值為0
        arr[1]                // "-1,-2,-3"    
        arr[2]                // "object"



頭部刪除：shift()

shift() 方法用于把數組的第一個元素從其中刪除，并返回第一個元素的值。如果數組是空的，那么 shift() 方法將不進行任何操作，返回 undefined 值。請注意，該方法不創建新數組，而是直接修改原有的 arrayObject。


        var arr = [1,2,3];
        arr.unshift(0,[-1,-2,-3],{x:"x",y:"y"})
        
        console.log(arr.shift())        // "0"
        console.log(arr.shift())        // "-1,-2,-3"
        console.log(arr.shift())        // "[object Object]"
        
        console.log(arr.length)         // 3


類型轉換

弱類型

轉換為數值：false被轉換為0，true被轉換為1，字符串為轉換成可能的值,null被轉換成0；如果無法把字符轉換成數值，則轉換成NaN。對象x會調用x.valueOf()；

轉換為布爾值：除了0、空字符串（""）、null、undefined、NaN。其他值都被轉換成true。false一般稱為假值，true則為真值；

轉換為字符串：JavaScript會按常理處理，如例子所示。只是對象x會調用x.toString()，具體后面會討論。關于valueOf和toString的詳細解釋，&&與||其實他們并不是真的需要比較布爾值，后續繼續討論。





isNaN(x)

isNaN() 函數可用于判斷其參數是否是 NaN，該值表示一個非法的數字（比如被 0 除后得到的結果）。
把 NaN 與任何值（包括其自身）相比得到的結果均是 false，所以要判斷某個值是否是 NaN，不能使用 == 或 === 運算符。正因為如此，isNaN() 函數是必需的。


isNaN() 函數通常用于檢測 parseFloat() 和 parseInt() 的結果，以判斷它們表示的是否是合法的數字。當然也可以用 isNaN() 函數來檢測算數錯誤，比如用 0 作除數的情況。
isNaN(true);            // false,因為true轉換成了1
isNaN(null);            // false,因為null轉換成了0
isNaN("water");         // true,很明顯
isNaN("100");           // false,因為"100"轉換成了100






parseFloat(string)

parseFloat 將它的字符串參數解析成為浮點數并返回。如果在解析過程中遇到了正負號（+ 或 -）、數字 (0-9)、小數點，或者科學記數法中的指數（e 或 E）以外的字符，則它會忽略該字符以及之后的所有字符，返回當前已經解析到的浮點數。同時參數字符串首位的空白符會被忽略。


如果參數字符串的第一個字符不能被解析成為數字，則 parseFloat 返回 NaN。
console.log(parseFloat("23.9"));            // 23.9
console.log(parseFloat("5.663E2"));         // 566.3
console.log(parseFloat("     8.11 "));      // 8.11
console.log(parseFloat("52.3xyz"));         // 52.3
console.log(parseFloat("xyz52.3"));         // NaN
console.log(parseFloat("3 .5 .6"));         // 3
console.log(parseFloat("123456 454"));      // 123456

// 首尾空格忽略
// 除了+、-、數字、小數點、科學計數法(E或e)這些符號,其他的字符本身以及后面的所有字符都會被忽略
// 如果參數字符串第一個字符串不能被解析為數字，會直接返回NaN   






parseInt(string, radix)

只有字符串中的第一個數字會被返回。

開頭和結尾的空格是允許的。

提示：如果字符串的第一個字符不能被轉換為數字，那么 parseFloat() 會返回 NaN。


    console.log(parseInt("23.9"));                // 23
    console.log(parseInt("5.663E2"));             // 5
    console.log(parseInt("    8.11 "));           // 5        
    console.log(parseInt("52.3xyz"));             // 52
    console.log(parseInt("xyz52.3"));             // NaN
    // 使用parseInt可以轉換基數為2到36的任何數值，進制轉換
    console.log(parseInt("75EF2",16));            // 483058
    console.log(parseInt("50",8));                // 40
    console.log(parseInt("110101",2));            // 53        
    console.log(parseInt("hello",30));            // 14167554
    console.log(parseInt("36",2));                // NaN


顯式轉換
        // 慣用的數據類型轉換方法（最簡短的寫法）
        
        // 從數值轉換為字符串值
        var n = 3;
        String(n);            // 正式寫法
        n+"";                 // 將數值3轉換為字符串值"3"（利用字符串連接符）
        
        // 從字符串值轉換為數值
        var s = "3";        
        Number(s);            // 正式寫法
        +s;                   // 將字符串值"3"轉換為了數值3（利用了正號運算）


松散相等操作符
簡單歸納為：嚴格相等運算符===和!==不會進行類型轉換，而相等運算==和!=會在判斷前進行類型轉換

要確定x == y的結果，JavaScript會嘗試對它們進行類型轉換，以便比較。

如果x和y中有一個字符串，有一個數值，JavaScript會把字符串轉換成數值

如果一個是布爾值，另一個不同，JavaScript會把布爾值轉換成數值。

如果是一個對象，另一個是字符串是或數值，JavaScript會把對象轉換成字符串或者數值。

最后，undefined == null，null == undefined。待尋找原因。






typeof操作符
typeof 101.3;            // number
typeof false;            // boolean
typeof "dog";            // string
typeof {x:1,y:2};        // object
typeof undefined;        // undefined
typeof null;             // object
typeof [1,2,3];          // object
typeof alert;            // function

typeof (typeof 1);       // string
 
typeof Infinity);        // number
typeof NaN);             // number


練習


1：設x = 10,y= 4,b = false,求下列表達式的值


x > y >25 && !b || y % -3 !== 22

 （（（（ x > y ） >25） && !b） || （（y % -3） !== 22 ））

true




y * 4 === 2 || (b !== true)

（（（y * 4） === 2） || （b !== true））

true



加上括號就一目了然了，主要考察運算符優先級和運算符的結合性






2：證明a和b均為布爾值，則!a && !b || a && b與a === b的結果一樣。

可以把一式簡化成：!(a && b) || a && b

蠢方法排列組合出的4種情況，代入測試。但是不知道怎么從數學上證明，還沒發現兩者之間的聯系。有看到有想法的讀者忘告知！





3：在本章中，我們看到Math.sqrt(100)等于10。點號的使用以為著Math是一個對象，sqrt是它的一個屬性。可以試試在編輯器里計算Math["sqrt"](100),看結果是否支持是對象的推斷。
        console.log(Math["sqrt"](100));        // 10
        
        var mi = "pow";
        console.log(Math[mi](2,3));            // 8

        // 可以看出，Math的確是一個對象，并且是一個全局對象，其中包含了如sqrt、pow在內的運算屬性（方法）。



4：使用命令行界面計算~22、~105、~(-28)和其他一些對整個數值應用~的表達式。然后嘗試總結這個操作有什么作用。

這里涉及到了JS中位運算的相關知識，但是我還沒具體了解過，算是待完善的知識點。先送上兩篇大神文，之后會另外開設一篇來談談我的理解。

十進制負數轉換為二進制、八進制、十六進制的知識分享

JavaScript位運算





5：運行下列腳本：輸入0、37、-40和100.然后再次輸入dog、2e600、3ffc和Infinity。 每次運行后，說出觀察到的結果是否有意義，如果沒有，請解釋為什么結果與預期的不符。
var celsius = prompt("Enter a temperature in u00b0C");
var fahrenheit = 1.8*celsius+32;
alert(celsius+"u00b0C= "+fahrenheit+"u00b0F")
// f=1.8*celsius+32


語句意義：獲取用戶輸入的值，將值進行運算處理，彈出值。需要注意的是，prompt()方法會把輸入的值全部轉換為string型。

變量fahrenheit里的運算會把字符串隱式轉換為數值，然后再進行數學意義上的計算。但是如果輸入的是字符串的話，隱式轉換后是NaN，而NaN進行任何計算結果都將是NaN。


2e600轉換為數值后顯然超過了JS可表示的數字，將會顯示Infinity，任何計算都將是Infinity。
            console.log(5/0);                    // Infinity 0作為被除數，結果為Infinity
            console.log(0/0);                    // NaN        
            console.log(Infinity+Infinity);        // Infinity 
            console.log(Infinity-Infinity);        // NaN
            console.log(Infinity*Infinity);        // Infinity
            console.log(Infinity/Infinity);        // NaN
            console.log(Math.sqrt(Infinity));    // Infinity






6：對下列表達式求值：
        "one two three".split(" ");
        // result:[one,two,three]
        "abracadabra".split("a");
        // result:[,br,c,d,br,]
       



7：編寫一個表達式，該表達式在字符串s包含逗號時返回true，否認返回false。
    var s = prompt("enter a something").indexOf(",")
        if (s!==-1) {
            return true;
        } else {
            return false;
        };    



8：畫出如下對象的示意圖，你認為這個對象表示什么意思？
    var obj = {op:"+",l:{op:"*",l:{op:"-",l:3,r:9},r:7},r:{op:"/",l:9,r:{op:"+",l:8,r:2}}};                           
    // 可以變形后如下，其實就是對象的嵌套
    var obj1 = {
        op:"+",
        l:{
            op:"*",
            l:{
                op:"-",
                l:3,
                r:9
            },
            r:7,
        },
        r:{
            op:"/",
            l:9,
            r:{
                op:"+",
                l:8,
                r:2
            }
        }
    };





9：求值下列表達式并解釋結果。

5 < 10 < 20

-20 < -10 < -5


第二題我很費解，我的理解是， 按運算符優先級，結合性和隱式轉換方面考慮這兩道題，可問題是對于第二題的結果卻是false！？小于號左結合，于是相當于（-20<-10）< -5,很明顯括號內運算結果為true，但問題來了。true<-5不應該把-5隱式轉換為true嗎？這類比較符號返回值永遠是布爾值，但是卻得到了一個false?。

更新：想來是我理解出現了錯誤，對于何時需要數值，何時需要布爾值不清楚。現在明白了，如下代碼：
        console.log(-20<-10<-5)            // false
        
        console.log(-20<-10)            // true
        
        // 問題如下
        console.log(true<-5)            // false
        console.log(true<5)                // true
        
        // 可能？
        console.log(1<5)                // true被轉換為了1？

在<、<=、>、>=、+、-、*、/、%是需要數值的，即可能會發生隱式轉換為數值這一行為。

解釋parseInt（"250",3）得到的結果。


先上結果：
   console.log(parseInt("250",3))            // 2


合理的假設是，當接受數值不符合進制轉換要求，會盡可能將可轉換的數字（2）轉換。所以這次得出一個：2
        console.log(parseInt("115",2))            // (11)2 : 3
        console.log(parseInt("129",8))            // (12)8 : 10
        console.log(parseInt("FZ",16))            // (F)16 : 15  
        



：）沒錯就是介樣兒！