1、JavaScript 定義了幾種數(shù)據(jù)類型? 哪些是原始類型?哪些是復(fù)雜類型?原始類型（或基本數(shù)據(jù)類型）和復(fù)雜類型的區(qū)別是什么?

最新的 ECMAScript 標(biāo)準(zhǔn)定義了 7 種數(shù)據(jù)類型:

• 6種原始類型（也稱基本數(shù)據(jù)類型）：
  • Number：整數(shù)和浮點(diǎn)數(shù)值（所謂浮點(diǎn)數(shù)值，就是該數(shù)值中必須包含一個(gè)小數(shù)點(diǎn)，并且小數(shù)點(diǎn)后面必須至少有一位數(shù)字）。
  • String：String類型用于表示由零或多個(gè)16位Unicode字符組成的字符序列，即字符串。字符串可以由雙引號(hào)或單引號(hào)表示。
  • Boolean：Boolean類型只有兩個(gè)字面值：true和false。
  • Undefined：Undefined類型只有一個(gè)值，即特殊的undefined。在使用var聲明變量但未對(duì)其初值化時(shí)，這個(gè)變量的值就是undefined。對(duì)未聲明的變量執(zhí)行typeof操作符同樣也會(huì)返回undefined值。
  • Null：Null類型是第二個(gè)只有一個(gè)值的數(shù)據(jù)類型，這個(gè)特殊的值
    是null。null值表示通常有意地指向不存在或無(wú)效的對(duì)象或地址的引用，從邏輯角度看，null值表示一個(gè)空對(duì)象指針，而這也正是使用typeof操作符檢測(cè)null值時(shí)會(huì)返回“object”的原因。如果定義的變量準(zhǔn)備在將來(lái)用于保存對(duì)象，那么最好將該變量初始化為null而不是其他值。
  • Symbol ：(ECMAScript 6 新定義)
• 1種復(fù)雜數(shù)據(jù)類型：
  • Object：ECMAScript中的對(duì)象其實(shí)就是一組數(shù)據(jù)功能的集合。對(duì)象可以通過(guò)執(zhí)行new操作符后跟要?jiǎng)?chuàng)建的對(duì)象類型的名稱來(lái)創(chuàng)建。Object有三個(gè)子類型狹義的對(duì)象- 正則表達(dá)式（regexp），數(shù)組（array），函數(shù)（function）。

原始類型（或基本數(shù)據(jù)類型）和復(fù)雜類型的區(qū)別：

1. 在內(nèi)存中的存儲(chǔ)方式：
   基本數(shù)據(jù)類型把數(shù)據(jù)名和值直接存儲(chǔ)在棧當(dāng)中。
   復(fù)雜數(shù)據(jù)類型在棧中存儲(chǔ)數(shù)據(jù)名和一個(gè)堆的地址，在堆中存儲(chǔ)屬性及值。訪問(wèn)時(shí)先從棧獲取地址，再到堆中拿出相應(yīng)的值。

2. 不同數(shù)據(jù)類型作為參數(shù)時(shí)，函數(shù)內(nèi)部對(duì)參數(shù)的修改是否改變外部變量的值
   （1）基本數(shù)據(jù)類型作為參數(shù)時(shí)，函數(shù)內(nèi)部對(duì)參數(shù)值的修改不會(huì)改變外部變量的值

function a(s){//定義以s為參數(shù)的函數(shù)，返回s的值


    s=100;


    return s;


    }


    var y=1;


    a(y);//y作為參數(shù)調(diào)用函數(shù)a


    console.log(y);//y還是為1

結(jié)果還是1因?yàn)榘褃的值給s時(shí)是簡(jiǎn)單的復(fù)制了一份，y和s可以單獨(dú)操作不相互影響

（2）復(fù)雜數(shù)據(jù)類型作為參數(shù)時(shí)，函數(shù)內(nèi)部對(duì)參數(shù)值的修改會(huì)改變外部變量的值

因?yàn)閺?fù)雜數(shù)據(jù)類型賦值是把棧中對(duì)象的地址賦給變量，函數(shù)內(nèi)外兩個(gè)變量指向同一個(gè)對(duì)象，所以只要對(duì)象的屬性值改變，兩個(gè)變量值都會(huì)改變

function student(age,name,agrde){


    this.age=age;


    this.name=name;


    this.score=agrde;


    }




    var s1=new student(18,"wjq",2);//創(chuàng)建一個(gè)student對(duì)象

    function a(s){


    s.name=”xxx”;


    }


    a(s1)//把s1賦給s


    console.log(s1.name);//輸出xxx

原始類型和對(duì)象的區(qū)別主要還是在內(nèi)存中的保存形式，要弄懂js中簡(jiǎn)單數(shù)據(jù)類型和復(fù)雜數(shù)據(jù)類型的區(qū)別，關(guān)鍵還要搞懂兩個(gè)在內(nèi)存中的存儲(chǔ)過(guò)程。

2.typeof和instanceof的作用和區(qū)別?

JavaScript有三種方法，可以確定一個(gè)值到底是什么類型。

• typeof 運(yùn)算符
• instanceof 運(yùn)算符
• Object.prototype.toString.call() 方法

typeof 運(yùn)算符

最常用的是 typeof 運(yùn)算符，返回一個(gè)值的數(shù)據(jù)類型有以下幾種結(jié)果：

• "undefined" : 如果一個(gè)變量沒(méi)有聲明，或聲明了而沒(méi)有初始化；

// 變量聲明了，但沒(méi)有賦值
var i;
i // undefined

// 調(diào)用函數(shù)時(shí)，應(yīng)該提供的參數(shù)沒(méi)有提供，該參數(shù)等于undefined
function f(x) {
  return x;
}
f() // undefined

// 對(duì)象沒(méi)有賦值的屬性
var  o = new Object();
o.p // undefined

// 函數(shù)沒(méi)有返回值時(shí)，默認(rèn)返回undefined
function f() {}
f() // undefined

• "boolean" : 如果這個(gè)值是布爾值；

typeof false // "boolean"
typeof true // "boolean"

• "string" ： 如果這個(gè)值是字符串；

typeof '345' // "string"

• "number" ： 如果這個(gè)值是數(shù)值；

typeof 345 // "number"

• "object" ： 如果這個(gè)值是對(duì)象(包括數(shù)組、正則表達(dá)式)或null；

var s1=new Object();
typeof s1 //"object"

var arr1=[1,2,3];
typeof arr1 //"object"

var pattern= /at/g;
typeof pattern //"object"

typeof null // "object"

• "function" ： 如果這個(gè)值是函數(shù)。

var f= function() {};
typeof f //"function"

注意：

• null的返回值是object，這是由于歷史原因造成的，1995年JavaScript語(yǔ)言的第一版，所有值都設(shè)計(jì)成32位，其中最低的3位用來(lái)表述數(shù)據(jù)類型，object對(duì)應(yīng)的值是000。當(dāng)時(shí)，只設(shè)計(jì)了五種數(shù)據(jù)類型（對(duì)象、整數(shù)、浮點(diǎn)數(shù)、字符串和布爾值），完全沒(méi)考慮null，只把它當(dāng)作object的一種特殊值，32位全部為0。這是typeof null返回object的根本原因。
  為了兼容以前的代碼，后來(lái)就沒(méi)法修改了。這并不是說(shuō)null就屬于對(duì)象，本質(zhì)上null是一個(gè)類似于undefined的特殊值。

instanceof 運(yùn)算符

instanceof是判斷指定對(duì)象是否為某個(gè)構(gòu)造函數(shù)的實(shí)例，返回值是true或false。

var v = new Object();
v instanceof Object // true

上面代碼中，對(duì)象v是構(gòu)造函數(shù)Object的實(shí)例，所以返回true。

instanceof運(yùn)算符的左邊是實(shí)例對(duì)象，右邊是構(gòu)造函數(shù)。它會(huì)檢查右邊構(gòu)建函數(shù)的原型對(duì)象，是否在左邊對(duì)象的原型鏈上。因此，下面兩種寫法是等價(jià)的。

v instanceof Object
// 等同于
Object.prototype.isPrototypeOf(v)

由于instanceof對(duì)整個(gè)原型鏈上的對(duì)象都有效，因此同一個(gè)實(shí)例對(duì)象，可能會(huì)對(duì)多個(gè)構(gòu)造函數(shù)都返回true。

var d = new Date();
d instanceof Date // true
d instanceof Object // true

上面代碼中，d同時(shí)是Date和Object的實(shí)例，因此對(duì)這兩個(gè)構(gòu)造函數(shù)都返回true。
instanceof的原理是檢查原型鏈，對(duì)于那些不存在原型鏈的對(duì)象，就無(wú)法判斷。

null instanceof Object // false

由于null 沒(méi)有 prototype，即不存在原型，因此instanceof就認(rèn)為該對(duì)象不是Object的實(shí)例。

JavaScript 之中，只要是對(duì)象，就有對(duì)應(yīng)的構(gòu)造函數(shù)。因此，instanceof運(yùn)算符的一個(gè)用處，是判斷值的類型。

var x = [1, 2, 3];
var y = {};
x instanceof Array // true
y instanceof Object // true

上面代碼中，instanceof運(yùn)算符判斷，變量x是數(shù)組，變量y是對(duì)象。

注意，instanceof運(yùn)算符只能用于對(duì)象，不適用原始類型的值。

var s = 'hello';
s instanceof String // false

上面代碼中，字符串不是String對(duì)象的實(shí)例（因?yàn)樽址皇菍?duì)象），所以返回false。

此外，對(duì)于undefined和null，instanceOf運(yùn)算符總是返回false。

undefined instanceof Object // false
null instanceof Object // false

用法上的區(qū)別：

typeof 對(duì)數(shù)組 [] 和對(duì)象 {} 的返回值都是Object，無(wú)法區(qū)分?jǐn)?shù)組和對(duì)象，但是instanceof可以區(qū)分。

var a = {};
var b=[];
typeof a // "object"
typeof b // "object"
a instanceof Array // false
a instanceof Object // true
b instanceof Array // true
b instanceof Object // true

3、如何判斷一個(gè)變量是否是數(shù)字、字符串、布爾、函數(shù)

使用typeof 運(yùn)算符可以判斷一個(gè)變量是否是數(shù)字、字符串、布爾、函數(shù)。

數(shù)字

var a=1;
typeof a // 'number'

字符串

var b="string";
typeof b // "string"

布爾

var c=true;
typeof c //true

函數(shù)

var f=function() {};
typeof f // "function"

4.NaN是什么? 有什么特別之處?

（1）含義

NaN是 JavaScript 的特殊值，表示“非數(shù)字”（Not a Number），主要出現(xiàn)在將字符串解析成數(shù)字出錯(cuò)的場(chǎng)合。

100 - 'a' // NaN

上面代碼運(yùn)行時(shí)，會(huì)自動(dòng)將字符串a(chǎn)轉(zhuǎn)為數(shù)值，但是由于a不是數(shù)值，所以最后得到結(jié)果為NaN，表示它是“非數(shù)字”（NaN）。

需要注意的是，NaN不是一種獨(dú)立的數(shù)據(jù)類型，而是一種特殊數(shù)值，它的數(shù)據(jù)類型依然屬于Number，使用typeof運(yùn)算符可以判斷出來(lái)。

typeof NaN // 'number'

（2）特別之處

NaN不等于任何值，包括它本身。

NaN === NaN // false

由于數(shù)組的indexOf方法，內(nèi)部使用的是嚴(yán)格相等運(yùn)算符，所以該方法對(duì)NaN不成立。

[NaN].indexOf(NaN) // -1

NaN在布爾運(yùn)算時(shí)被當(dāng)作false。

Boolean(NaN) // false

NaN與任何數(shù)（包括它自己）的運(yùn)算，得到的都是NaN。

NaN + 12 // NaN
NaN - 12 // NaN
NaN * 12 // NaN
NaN / 12 // NaN

（3）判斷NaN的方法

isNaN方法可以用來(lái)判斷一個(gè)值是否為NaN。isNaN()函數(shù)接受一個(gè)參數(shù)，該參數(shù)可以是任何類型，而函數(shù)會(huì)判斷這個(gè)參數(shù)是否"不是數(shù)值"。isNaN()在接收到一個(gè)值之后，會(huì)嘗試將這個(gè)值轉(zhuǎn)換為數(shù)值。某些不是數(shù)值的值會(huì)直接轉(zhuǎn)換為數(shù)值，例如"10"和"Boolean"。而任何不能被轉(zhuǎn)換為數(shù)值的值都會(huì)導(dǎo)致這個(gè)函數(shù)返回true。

isNaN(NaN) // true
isNaN(123) // false
isNaN("123") // false
isNaN("123string") // true

isNaN只對(duì)數(shù)值有效，如果傳入其他值，會(huì)被先轉(zhuǎn)成數(shù)值。

出于同樣的原因，對(duì)于對(duì)象和數(shù)組，isNaN也返回true。

isNaN({}) // true
// 等同于
isNaN(Number({})) // true

isNaN(['xzy']) // true
// 等同于
isNaN(Number(['xzy'])) // true

但是，對(duì)于空數(shù)組和只有一個(gè)數(shù)值成員的數(shù)組，isNaN返回false。

isNaN([]) // false
isNaN([123]) // false
isNaN([123,567]) // true
isNaN(['123']) // false

上面代碼之所以返回false，原因是這些數(shù)組能被Number函數(shù)轉(zhuǎn)成數(shù)值。

判斷NaN更可靠的方法是，利用NaN是JavaScript之中唯一不等于自身的值這個(gè)特點(diǎn)，進(jìn)行判斷。

function IsNaN(value) {
  return value !== value;
}

5.如何把非數(shù)值轉(zhuǎn)化為數(shù)值?

有三個(gè)函數(shù)可以把非數(shù)值轉(zhuǎn)換為數(shù)值：

• Number()
• parseInt()
• parseFloat()

Number()

轉(zhuǎn)型函數(shù)Number()可以用于任何數(shù)據(jù)類型，而另外兩個(gè)函數(shù)則專門用于把字符串轉(zhuǎn)換成數(shù)值。

Number函數(shù)的轉(zhuǎn)換規(guī)則：

1. 如果是Boolean值，true 返回 1，false 返回 0 。

Number(true)    //1
Number(false)   //0

2. 如果是數(shù)字值，就是原樣。

Number(3.14)    //3.14

3. 如果是null值，返回0。

Number(null) // 0

4. 如果是undefined，返回NaN。

Number(undefined) // 0

5.如果是字符串，遵循下列規(guī)則：

• 如果是字符串中只包含數(shù)字（包括前面帶正號(hào)或負(fù)號(hào)的情況），則將其轉(zhuǎn)化成十進(jìn)制數(shù)值。

Number ('23')    // 23
Number ('+23')   // 23 
Number ('-23')   // -23
Number ('011')   // 11  前面的0會(huì)忽略

• 如果字符串中包含的有效的浮點(diǎn)數(shù)，就會(huì)轉(zhuǎn)化成對(duì)應(yīng)的浮點(diǎn)數(shù)，前面的0會(huì)忽略。

Number ('3.14')    //3.14
Number ('03.14')   //3.14

• 如果字符串中包含有效的十六進(jìn)制格式，前兩位為"0x..."的格式，會(huì)自動(dòng)轉(zhuǎn)化成相同大小的十進(jìn)制數(shù)。

Number ('0x10')  // 16

• 如果字符串是空字符串，則返回 0。

Number ('')  // 0

• 如果字符串中包含除上述格式外的其他字符，則轉(zhuǎn)化成NaN。

Number("123blue")  // NaN
Number(message)  // NaN,變量message未聲明

• 如果是對(duì)象，則調(diào)用對(duì)象的valueOf()方法，然后依照前面的規(guī)則轉(zhuǎn)換返回的值。如果轉(zhuǎn)換的結(jié)果是NaN，則調(diào)用對(duì)象的toString()方法，然后再依照前面的規(guī)則轉(zhuǎn)換字符串返回的字符串值。

parseInt()

• parseInt方法用于將字符串轉(zhuǎn)為整數(shù)。返回值只有兩種可能，不是一個(gè)十進(jìn)制整數(shù)，就是NaN。

parseInt ('120')       //120   整數(shù)轉(zhuǎn)化成整數(shù)
parseInt ('3.14')    //3     浮點(diǎn)數(shù)轉(zhuǎn)化前面的整數(shù)部分
parseInt ('    10')    //10    前面的空格會(huì)忽略
parseInt ('000010')    //10    前面的0會(huì)忽略

• 如果parseInt的參數(shù)不是字符串，則會(huì)先轉(zhuǎn)為字符串再轉(zhuǎn)換。

parseInt(1.23) // 1
// 等同于
parseInt('1.23') // 1

• 字符串轉(zhuǎn)為整數(shù)的時(shí)候，是一個(gè)個(gè)字符依次轉(zhuǎn)換，如果遇到不能轉(zhuǎn)為數(shù)字的字符，就不再進(jìn)行下去，返回已經(jīng)轉(zhuǎn)好的部分。

parseInt('8a') // 8
parseInt('12**') // 12
parseInt('12.34') // 12
parseInt('15e2') // 15
parseInt('15px') // 15
//上面代碼中，parseInt的參數(shù)都是字符串，結(jié)果只返回字符串頭部可以轉(zhuǎn)為數(shù)字的部分。

• 如果字符串的第一個(gè)字符不能轉(zhuǎn)化為數(shù)字（后面跟著數(shù)字的正負(fù)號(hào)除外），返回NaN。

parseInt('abc')   // NaN
parseInt('.3')    // NaN
parseInt('')      // NaN
parseInt('+')     // NaN
parseInt('+1')    // 1

• parseInt方法還可以接受第二個(gè)參數(shù)（2到36之間），表示被解析的值的進(jìn)制，返回該值對(duì)應(yīng)的十進(jìn)制數(shù)。默認(rèn)情況下，parseInt的第二個(gè)參數(shù)為10，即默認(rèn)是十進(jìn)制轉(zhuǎn)十進(jìn)制。

parseInt('1000', 10)    // 1000  以十進(jìn)制解讀（默認(rèn)）
parseInt('1000', 2)     // 8    以二進(jìn)制解讀
parseInt('1000', 6)     // 216   以六進(jìn)制解讀
parseInt('1000', 8)     // 512   以八進(jìn)制解讀
parseInt('10', 37) // NaN   進(jìn)制超出范圍，就返回 NaN
parseInt('10', 1) // NaN  進(jìn)制超出范圍，就返回 NaN
parseInt('10', 0) // 10
parseInt('10', null) // 10
parseInt('10', undefined) // 10  第二個(gè)參數(shù)是0、null、undefined 則直接忽略

parseFloat ()

• parseFloat用于將一個(gè)字符串轉(zhuǎn)為浮點(diǎn)數(shù)。

parseFloat('3.14')         // 3.14  浮點(diǎn)數(shù)轉(zhuǎn)浮點(diǎn)數(shù)
parseFloat('314e-2')       // 3.14  
parseFloat('0.0314E+2')    // 3.14  如果字符串符合科學(xué)計(jì)數(shù)法，則進(jìn)行相應(yīng)轉(zhuǎn)換
parseFloat ('3.14abc')     // 3.14  如果字符串包含不能轉(zhuǎn)換為浮點(diǎn)數(shù)的字符，則不再往后轉(zhuǎn)換，返回已經(jīng)轉(zhuǎn)好的部分。
parseFloat ('    3.14')    // 3.14
parseFloat ('00003.14')    // 3.14  parseFloat方法會(huì)自動(dòng)過(guò)濾字符串前面的空格

• 如果參數(shù)不是字符串，或者字符串的第一個(gè)字符不能轉(zhuǎn)換為浮點(diǎn)數(shù)，則返回NaN。

parseFloat([])     // NaN  空數(shù)組返回 NaN
parseFloat('FF2')  // NaN  第一個(gè)字符不能轉(zhuǎn)化浮點(diǎn)數(shù)
parseFloat('')     // NaN  空字符串轉(zhuǎn)化為 NaN

parseFloat () 和 Number () 的區(qū)別

parseFloat(true)       // NaN
Number(true)           // 1

parseFloat(null)       // NaN
Number(null)           // 0

parseFloat('')         // NaN
Number('')             // 0

parseFloat('123.45#')  // 123.45
Number('123.45#')      // NaN

parseInt()與parseFloat()的區(qū)別

區(qū)別（1）：parseFloat（）轉(zhuǎn)換時(shí)，第一個(gè)小數(shù)點(diǎn)有效,小數(shù)點(diǎn)對(duì)parseInt()無(wú)效

parseFloat("22.34.5") //22.34
parseInt("22.34.5") //22

區(qū)別（2）：parseFloat()始終會(huì)忽略前導(dǎo)的0

parseFloat()可以識(shí)別前面討論過(guò)的所有浮點(diǎn)數(shù)值格式，也包括十進(jìn)制整數(shù)格式。但十六進(jìn)制格式的字符串則始終會(huì)被轉(zhuǎn)換成0。由于parseFloat()直解析十進(jìn)制值，因此它沒(méi)有用第二個(gè)參數(shù)指定基數(shù)的用法。最后還要注意一點(diǎn)，如果字符串包含的是一個(gè)可解析為整數(shù)的數(shù)（沒(méi)有小數(shù)點(diǎn)，或者小數(shù)點(diǎn)后都是0），parseFloat()會(huì)返回整數(shù)。

parseFloat("1234blue") //1234
parseFloat("0xA") //0
parseFloat("22.5") //22.5
parseFloat(22.34.5) //22.34
parseFloat("0908.5") //908.5
parseFloat("3.125e7") //31250000
parseFloat("4.0000") //4

6.==與===有什么區(qū)別

歷史背景

確定兩個(gè)變量是否相等是編程中的一個(gè)非常重要的操作。在比較字符串、數(shù)值和布爾值的相等性時(shí)，問(wèn)題還比較簡(jiǎn)單。但在涉及到對(duì)象的比較時(shí)，問(wèn)題就變得復(fù)雜了。最早的ECMAScript中的相等和不等操作符會(huì)在執(zhí)行比較之前，先將對(duì)象轉(zhuǎn)換成相似的類型。后來(lái),有人提出了這種轉(zhuǎn)換到底是否合理的質(zhì)疑。最后，ECMAScript的解決方案就是提供兩組操作數(shù)：相等和不相等——先轉(zhuǎn)換在比較，全等和不全等——僅比較而不轉(zhuǎn)換。

1.相等和不相等

這兩個(gè)操作符都會(huì)先轉(zhuǎn)換操作數(shù)，然后再比較它們的相等性。

在轉(zhuǎn)換不同的數(shù)據(jù)類型時(shí)，相等和不相等操作符遵循下列基本規(guī)則：

• 如果有一個(gè)操作數(shù)是布爾值，則在比較相等性之前先將其轉(zhuǎn)換為數(shù)值——false轉(zhuǎn)換為0，而true轉(zhuǎn)換為1；

false == 1 //false
false == 0 //true
true ==1 //true
true == 0 //false

• 如果一個(gè)操作數(shù)是字符串，另一個(gè)操作數(shù)是數(shù)值，在比較相等性之前先將字符串轉(zhuǎn)換為數(shù)值；

"123" == 123 //true

• 如果一個(gè)操作數(shù)是對(duì)象，另一個(gè)操作數(shù)不是，則調(diào)用對(duì)象的valueof()方法，用得到的基本類型值按照前面的規(guī)則進(jìn)行比較；

這兩個(gè)操作符在進(jìn)行比較時(shí)則要遵循下列規(guī)則。

• null和undefined是相等的。

null == undefined //true

• 要比較相等性之前，不能將null和undefined轉(zhuǎn)換成其他任何值。

null +1 //1
undefined +1 //NaN
null == 0 //false
undefined == 0 //false

• 如果有一個(gè)操作數(shù)是NaN，則相等操作符返回false，而不相等操作符返回true。

"NaN" == NaN //false
NaN == NaN //false
NaN != NaN //true

• 如果兩個(gè)操作數(shù)都是對(duì)象，則比較它們是不是同一個(gè)對(duì)象。如果兩個(gè)操作數(shù)都指向同一個(gè)對(duì)象，則相等操作符返回true；否則返回false。

2.全等和不全等

全等操作符只在兩個(gè)操作數(shù)未經(jīng)轉(zhuǎn)換就相等的情況下返回true。

除了在比較之前不轉(zhuǎn)換操作數(shù)之外，全等和不全等操作符與相等和不相等操作符沒(méi)有什么區(qū)別。

"55" == 55 //true，因?yàn)檗D(zhuǎn)換后相等
"55" === 55 //false，因?yàn)樵诓晦D(zhuǎn)換的情況下，字符串不等于數(shù)值
null ==undefined //true
null === undefined //false

記住，null ==undefined會(huì)返回true，因?yàn)樗鼈兪穷愃频闹担坏玭ull === undefined會(huì)返回false，因?yàn)樗鼈兪遣煌愋偷闹怠?/strong>

var num = 0;
for (var i=1; i<10; i++) {
    if (i % 5 == 0) {
      break;
  }
  num++;
}
alert(num); //4

var num = 0;
for (var i=1; i<10; i++) {
    if (i % 5 == 0) {
      continue;
  }
  num++;
}
alert(num); //8

var num = 0;
outermost :
for (var i=0; i<10; i++) {
    for (var j=0; j<10; j++) {
        if (i ==5 && j == 5) {
            break outermost;
        }
        num++;
    }
}
alert(num);  //55

var num = 0;
outermost :
for (var i=0; i<10; i++) {
    for (var j=0; j<10; j++) {
        if (i ==5 && j == 5) {
            break;
        }
        num++;
    }
}
alert(num);  //95

var num = 0;
outermost :
for (var i=0; i<10; i++) {
    for (var j=0; j<10; j++) {
        if (i ==5 && j == 5) {
            continue outermost;
        }
        num++;
    }
}
alert(num);  //95

var num = 0;
outermost :
for (var i=0; i<10; i++) {
    for (var j=0; j<10; j++) {
        if (i ==5 && j == 5) {
            continue; 
        }
        num++;
    }
}
alert(num);  //99

var undefined = 10;
 
// undefined -- chrome
// 彈出10 -- IE 8，低版本IE中
alert(undefined);

(function() {

  //局部作用域
  var undefined = 10;
 
  //彈出 10 -- chrome
  alert(undefined);
})();
 
(function() {

  //全局變量并賦值，因?yàn)樵谌肿饔糜騯ndefiend不能被重寫，所以賦值無(wú)效
  undefined = 10;
 
  // 彈出undefined -- chrome
  alert(undefined);
})();

console.log(1+1);//輸出2，兩個(gè)數(shù)字加法運(yùn)算
console.log("2"+"4");//輸出'24'，兩個(gè)字符串類型的做字符串拼接
console.log(2+"4");//輸出'24'，一個(gè)是數(shù)字一個(gè)是字符串，數(shù)字轉(zhuǎn)化為字符串后拼接
console.log(+"4");//輸出4，只有一個(gè)字符串會(huì)轉(zhuǎn)換成數(shù)字輸出

var a = 1;  
a+++a;  
// 3     等同于 (a++)+a,這里前面的(a++)為1，后面的a為2，++優(yōu)先級(jí)高于+
typeof a+2;  
// 'number2'   等同于(typeof a)+2，前面為字符串‘number’，后面數(shù)值，拼接成字符串，typeof 優(yōu)先級(jí)高于+

 var a = 1;
 var b = 3;
 console.log( a+++b );  
 // 4  括號(hào)里面等同于(a++)+b，前面的(a++)表達(dá)式值為1，先用a的值，用完后再給a自加1

var arr = [3,4,5]

for (var i=0;i<3;i++){
  console.log(arr[i]*arr[i])
}
// 9  16  25

var obj = {
 name: 'hunger', 
 sex: 'male', 
 age: 28 
}
for(a in obj){
console.log(a+":"+obj[a])
}
// name:hunger sex:male age:28

var a = 1, b = 2, c = 3;
var val = typeof a + b ||  c >0    //  優(yōu)先級(jí)順序typeof   +  >   ||
console.log(val)    //  'number2' || true
// 輸出‘number2’

var d = 5;
var data = d ==5 && console.log('bb')  
// console.log('bb') 輸出了字符串bb，但它的返回值是undefined
console.log(data)  // data = true && undefined
//輸出 undefined

var data2 = d = 0 || console.log('haha')  
    // console.log('haha') 輸出了字符串haha，但它的返回值是undefined
console.log(data2)  // data2 = d = 0 || undefined
    //輸出 undefined

var x = !!"Hello" + (!"world", !!"from here!!");  
    // true+(false, true)，即true+true
console.log(x)  //  console.log (true+true)
    // 輸出 2

'a', 'b' //返回"b"

var x = 0;
var y = (x++, 10);
x //1
y  //10