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

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

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

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

JavaScript的數(shù)值與大多數(shù)編程語言的數(shù)值一樣，不同于我們?nèi)粘Ｋ姷睦硐牖瘮?shù)值。首先，它們收到計算設(shè)備固定大小的物理元件的限制。因此，存在一個最大的數(shù)值（在JavaScript里這個值約為1.79e308）和一個最小的數(shù)值（-1.79e108）。任何計算得到超過最大數(shù)值或者小于最小數(shù)值，都會轉(zhuǎn)化為特殊值Infinity或者-Infinity。

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

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

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

涉及非常大的數(shù)值、非常小的數(shù)值或者非整數(shù)的計算，經(jīng)常會導(dǎo)致不準(zhǔn)確的結(jié)果。

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

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

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

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

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

Math.sqrt(x) 對x開方

Math.sqrt(100);       // 10

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

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

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

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

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

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

" 單引號

" 雙引號

xhh hh是兩位十六進(jìn)制值，相應(yīng)字符的碼點

、 、、f、 、v 換行符、制表符、退格符、進(jìn)紙符、回車符、制表符

反斜杠本身

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

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

substr(start，length)

start 必需。一個非負(fù)的整數(shù)，規(guī)定要提取的子串的第一個字符在 stringObject 中的位置。

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

slice(start，end)

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

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

substring(start，stop)

必需。一個非負(fù)的整數(shù)，規(guī)定要提取的子串的第一個字符在 stringObject 中的位置

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

indexOf(searchvalue,fromindex)

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

searchvalue 必需。規(guī)定需檢索的字符串值。

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

lastIndexOf(searchvalue,fromindex)

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

searchvalue 必需。規(guī)定需檢索的字符串值。

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

charCodeAt(index)

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

charAt(index)

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

index 必需。表示字符串中某個位置的數(shù)字，即字符在字符串中的下標(biāo)。

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

toLowerCase() and toUpperCase()

這個不解釋了

replace(regexp/substr,replacement)

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

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

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

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

這個方法可以搭配正則表達(dá)式使用，后續(xù)會繼續(xù)研究用法

注意幾點：

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

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

    var x = "Queen";

    x.substring(1,4);       // "uee"
    x.substring(-1,2);      // "Qu"    識別第二個參數(shù)，但是是從頭部開始兩個字母
    x.substring(-4,-1);     // ""    空字符，兩個參數(shù)都不接收負(fù)數(shù)
    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)        
    
    
    // 共同點！已表達(dá)式s.substring（x,y）或 s.slice    (x,y)為例
    // 都為正整數(shù)情況下，會得到字符串s中，從位置x開始直到（但不包含）位置y的所有字符。

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

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

使用了不能作為標(biāo)識符的屬性名的情況

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

將表達(dá)式的求值結(jié)果作為屬性名使用的情況


// 自行使用console.log()或者alert()調(diào)用試驗
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"];              // 屬性名含有空格必須用方括號
                            // 屬性名不能使用數(shù)字！
                            
test.foo-bar;               // 含有橫杠的屬性名點運算會引起錯誤，會解析為：obj.foo減去                bar，引發(fā)錯誤
test["foo-bar"];            // 5    

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


理解對象引用



基本類型值直接存儲在變量中，而對象不是。對象的值中存儲的是指向?qū)ο蟮囊?/strong>

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

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


對象原型

對象原型示意圖

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


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

自引用對象

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

自引用示意圖



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

數(shù)組引用示意圖
常用方法：

slice(start,end)略....


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

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

arrayX    必需。該參數(shù)可以是具體的值，也可以是數(shù)組對象?？梢允侨我舛鄠€。


    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() 方法用于把數(shù)組中的所有元素放入一個字符串。元素是通過指定的分隔符進(jìn)行分隔的。

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



        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() 方法用于把一個字符串分割成字符串?dāng)?shù)組。（接受一個字符串，返回的是把字符串分割后各元素組成的數(shù)組）

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


howmany    可選。該參數(shù)可指定返回的數(shù)組的最大長度。如果設(shè)置了該參數(shù)，返回的子串不會多于這個參數(shù)指定的數(shù)組。如果沒有設(shè)置該參數(shù)，整個字符串都會被分割，不考慮它的長度。
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參數(shù)注意是空格符(" "),還是默認(rèn)(""),具體情況具體分析





數(shù)組頭尾的增刪方法：


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


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

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



        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"
        
        // 添加若干元素，或者添加若干數(shù)組




末尾刪除：pop()

pop() 方法將刪除 arrayObject 的最后一個元素，把數(shù)組長度減 1，并且返回它刪除的元素的值。如果數(shù)組已經(jīng)為空，則 pop() 不改變數(shù)組，并返回 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() 方法將把它的參數(shù)插入 arrayObject 的頭部，并將已經(jīng)存在的元素順次地移到較高的下標(biāo)處，以便留出空間。該方法的第一個參數(shù)將成為數(shù)組的新元素 0，如果還有第二個參數(shù)，它將成為新的元素 1，以此類推。


newelement1    必需。向數(shù)組添加的第一個元素。

newelement2    可選。向數(shù)組添加的第二個元素。

newelementX    可選?？商砑尤舾蓚€元素。




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

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



頭部刪除：shift()

shift() 方法用于把數(shù)組的第一個元素從其中刪除，并返回第一個元素的值。如果數(shù)組是空的，那么 shift() 方法將不進(jìn)行任何操作，返回 undefined 值。請注意，該方法不創(chuàng)建新數(shù)組，而是直接修改原有的 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


類型轉(zhuǎn)換

弱類型

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

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

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





isNaN(x)

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


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






parseFloat(string)

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


如果參數(shù)字符串的第一個字符不能被解析成為數(shù)字，則 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

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






parseInt(string, radix)

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

開頭和結(jié)尾的空格是允許的。

提示：如果字符串的第一個字符不能被轉(zhuǎn)換為數(shù)字，那么 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可以轉(zhuǎn)換基數(shù)為2到36的任何數(shù)值，進(jìn)制轉(zhuǎn)換
    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


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


松散相等操作符
簡單歸納為：嚴(yán)格相等運算符===和!==不會進(jìn)行類型轉(zhuǎn)換，而相等運算==和!=會在判斷前進(jìn)行類型轉(zhuǎn)換

要確定x == y的結(jié)果，JavaScript會嘗試對它們進(jìn)行類型轉(zhuǎn)換，以便比較。

如果x和y中有一個字符串，有一個數(shù)值，JavaScript會把字符串轉(zhuǎn)換成數(shù)值

如果一個是布爾值，另一個不同，JavaScript會把布爾值轉(zhuǎn)換成數(shù)值。

如果是一個對象，另一個是字符串是或數(shù)值，JavaScript會把對象轉(zhuǎn)換成字符串或者數(shù)值。

最后，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


練習(xí)


1：設(shè)x = 10,y= 4,b = false,求下列表達(dá)式的值


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



加上括號就一目了然了，主要考察運算符優(yōu)先級和運算符的結(jié)合性






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

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

蠢方法排列組合出的4種情況，代入測試。但是不知道怎么從數(shù)學(xué)上證明，還沒發(fā)現(xiàn)兩者之間的聯(lián)系。有看到有想法的讀者忘告知！





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

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



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

這里涉及到了JS中位運算的相關(guān)知識，但是我還沒具體了解過，算是待完善的知識點。先送上兩篇大神文，之后會另外開設(shè)一篇來談?wù)勎业睦斫狻?/p>
十進(jìn)制負(fù)數(shù)轉(zhuǎn)換為二進(jìn)制、八進(jìn)制、十六進(jìn)制的知識分享

JavaScript位運算





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


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

變量fahrenheit里的運算會把字符串隱式轉(zhuǎn)換為數(shù)值，然后再進(jìn)行數(shù)學(xué)意義上的計算。但是如果輸入的是字符串的話，隱式轉(zhuǎn)換后是NaN，而NaN進(jìn)行任何計算結(jié)果都將是NaN。


2e600轉(zhuǎn)換為數(shù)值后顯然超過了JS可表示的數(shù)字，將會顯示Infinity，任何計算都將是Infinity。
            console.log(5/0);                    // Infinity 0作為被除數(shù)，結(jié)果為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：對下列表達(dá)式求值：
        "one two three".split(" ");
        // result:[one,two,three]
        "abracadabra".split("a");
        // result:[,br,c,d,br,]
       



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



8：畫出如下對象的示意圖，你認(rèn)為這個對象表示什么意思？
    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：求值下列表達(dá)式并解釋結(jié)果。

5 < 10 < 20

-20 < -10 < -5


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

更新：想來是我理解出現(xiàn)了錯誤，對于何時需要數(shù)值，何時需要布爾值不清楚?，F(xiàn)在明白了，如下代碼：
        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被轉(zhuǎn)換為了1？

在<、<=、>、>=、+、-、*、/、%是需要數(shù)值的，即可能會發(fā)生隱式轉(zhuǎn)換為數(shù)值這一行為。

解釋parseInt（"250",3）得到的結(jié)果。


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


合理的假設(shè)是，當(dāng)接受數(shù)值不符合進(jìn)制轉(zhuǎn)換要求，會盡可能將可轉(zhuǎn)換的數(shù)字（2）轉(zhuǎn)換。所以這次得出一個：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  
        



：）沒錯就是介樣兒！