1.JavaScript 定義了幾種數據類型? 哪些是原始類型?哪些是復雜類型?原始類型和復雜類型的區別是什么?

JS語言中定義了6種數據類型：

• number：整數和小數(例如1，3.14等)
• string：字符組成的文本，("hello,world")
• boolean： true和false兩個特定值
• undefined： 表示“未定義”或者不存在，即目前此處沒有任何值
• null： 表示“空缺”，即此處本來應該有值，但是目前為空。
• object：對象，即表示各種值組成的集合。

其中，number,string,boolean為原始類型(primitive type)，不可以再細分了。
object對象類型為復雜類型(complex type)，一個對象往往是多個原始類型的值的合成，可以看做是一個存放各種值的容器。
另外，undefined和null一般視為兩個特殊值。

對象的細分，對象又可以分為三個子類型：

• 狹義的對象(object)
• 數組(array)
• 函數(function)
• 正則表達式(regexp)

對于null和undefined的區別
對于null和undefined：null表示空值，即該處現在的值為空，一般用法為：

• 作為函數的參數，表示該函數的參數是一個沒有任何內容的對象
• 作為對象原型鏈的終點

undefined表示的是不存在值，就是此處目前不存在任何值，一般用法：

• 變量聲明了，但是沒有賦值，為undefined
• 調用函數時，應該提供的參數沒有提供，該參數等于undefined
• 對象沒有賦值的屬性，該屬性的值默認為undefined
• 函數沒有返回值時，默認返回undefined
  舉例說明：

    var i;  // i聲明了但是沒有賦值 為undefined

    function f(x) {
        console.log(x)
    }
    f(); // 運行f()后，函數return的就是undefined，因為默認沒有提供參數

    var obj = new Object();
    console.log(obj.p); // 調用一個對象不存在的屬性，該屬性的值默認是undefined

    var x = f();
    console.log(x); // 函數沒有返回值的時候，默認返回的也是undefined

另外關于null和undefined還有：

    console.log( undefined == null); //true
    console.log( undefined === null); //false

    console.log(typeof undefined); //undefined
    console.log(typeof null)//object

Boolean
布爾值代表真假兩個狀態，只有true和false兩個值
下列運算符會返回布爾值：

• 兩元邏輯運算符： &&(and), ||(or)
• 前置邏輯元素符： !(not)
• 相等運算符： ===，!==, ==,!=
• 比較運算符： >, >=,<,<=

可以轉換為false的類型
如果JS某個位置上應該是布爾值，會將現有的值轉換成布爾值，除了下列的6個值，其他值都被轉換為true，轉換為false的值有：

• undefined
• null
• false
• 0
• NaN
• ""（空字符串）
  只有空字符串為false，但是空數組，空對象對應的布爾值都是true

2.typeof和instanceof的作用和區別?

JS有三種方法可以確定一個值到底是什么類型：

• typeof運算符
• instanceof 運算符
• Object.prototype.toString 方法

typeof運算符可以返回一個值的數據類型

• 對于原始類型返回number， string或者boolean
• 對于函數返回function
• 對于數組，狹義對象，正則表達式都返回object
• 對于undefined返回undefined
• 對于null返回object

instanceof運算符是判斷某個對象是不是某個構造函數創建的實例，在上面的例子中，除了原始類型，函數和undefined，其他的通過typeof運算符都返回object，所以需要instaceof來區分

    var arr = [];
    var obj = {};
    console.log( arr instanceof  Array); //true
    console.log( obj instanceof Array); //false

• typeof undefined使用范例
  typeof可以用來檢查一個沒有聲明的變量，而不報錯，實際應用中通常可以用在if判斷語句條件中。

    if (typeof a === "undefined") {console.log('deejay');} //deejay
    if (a) {console.log*('deejay');}  //Uncaught ReferenceError: a is not defined

所示代碼中，正確的寫法為上面的。

3.如何判斷一個變量是否是數字、字符串、布爾、函數

number,string,boolean都是原始類型，可以通過typeof運算符判斷，typeof運算符判斷函數時也會返回function，所以可以通過typeof運算符進行判斷

    var num = 100;
    console.log(typeof num); //number
    var str = 'hello,deejay';
    console.log(typeof str); //string
    var bool = false;
    console.log(typeof bool); //boolean
    var a = function () {
        console.log("hello,deejay");
    }
    console.log(typeof a); //function

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

NaN即Not a Number,表示非數字，NaN和任何值都不相等，包括NaN
console.log(NaN == NaN); //false

5.如何把非數值轉化為數值?

JS的數字類型沒有整型和浮點數的區別，統一都是number類型，可以表示十進制，八進制，十六進制

  var a = 10; //十進制
  var b = 073 //八進制
  var c = 0xf3 //十六進制

浮點數:
浮點數是指數字包含小數點并且至少有以為數字的例如： var a =.57;
浮點數的精度不如整數，所以在進行小數運算的時候不要直接判斷相等，盡量換成整數來進行判斷

Infinity
也是number類型，代表無窮數

數值的轉換：
有三個函數可以把非數值轉換為數值：

• Number()
• parseInt()
• parseFloat()
  一般使用parseInt()和parseFloat(),具體用法舉例：

   parseInt('0'); // 0 字符串為數字，直接轉換為數字
   parseInt('0x11'); // 17 十六進制轉換為十進制 1+1*16 = 17
   parseInt('0abc');//0
   parseInt('a234abc'); // 234 上述兩種情況，以數字開頭的截止到不是數字的那一位，轉換成數字
   //其余情況轉換結果全為NaN
   parseInt('010'); //10

但是有parseInt('3.4')//轉換為3的情況，所以對于浮點數，要通過parseFloat()來進行轉換。

    parseFloat('3.4') //3.4
    parseFloat('3.4abc') //3.4

在轉換的過程中，開頭0會被當成八進制，開頭0x會被當成十六進制來轉換。對于開頭是0的情況，如果要按照十進制轉換，可以使用第二個參數來指定。

6.==與===有什么區別

==為近似相等,===為嚴格相等。
在使用==的時候，JS會做類型轉換，有可能出現一些意料之外的效果。具體類型轉換的規則為：

• 如果兩個值的類型相同，那么執行嚴格意義上的相等
• 如果兩個值的類型不同：

1. 一個是null一個是undefined，那么相等
2. 一個數字，一個字符串，將字符串轉換為數字，然后比較
3. 如果一個值為true/false，轉換為1/0比較
4. 如果一個值是對象，一個是數字或者字符串，則調用valueOf和toString進行轉換然后比較
5. 其他情況皆不相等。

    console.log(NaN == NaN);  //false
    console.log(NaN === NaN);  //false
    console.log(null == undefined); //true
    console.log(2 == '2'); // true

7.break與continue有什么區別

• break用于強制退出循環體，執行整個循環體后面的語句；
• continue 用于退出當前的這次循環，執行下次循環。

舉例說明區別：

      for (var i = 1; i < 10; i ++) {
        if (i % 4 === 0) {
            break; // 當i循環到4時，直接break跳出整個循環體，執行整個for循環體后面的代碼，不會繼續輸出
        }
        console.log(i); //所以結果為： 1，2,3   循環到4時，跳出整個for循環，所以沒有console.log(4)
    }



    for (var j = 1; j < 10; j ++) {
        if (j % 4 === 0) {
            continue;  // 當j循環到4時， continue跳出本次的for循環， 進行下一次for循環，所以當j=4,j=8時，跳出了for循環不會輸出
        }
        console.log(j);  // 所以輸出結果為1,2,3,5,6,7,9
    }

8.void 0 和 undefined在使用場景上有什么區別

void運算符的作用是 執行一個表達式，然后返回undefined。
在某些場景下(出現函數等)，undefined是可以被賦值的，舉例說明：

      function fn () {
        var undefined = 3;
        var a;
        if (a === undefined) {
            console.log("a === undefined");
        }
        else {
            console.log('a !== undefined');
        }
    }
    fn(); // a !== undefined  說明這個undefined是可以被賦值的。

而對于 void 0來說，返回的始終是真實的undefined，不存在上述的這個問題，所以可以重寫上述例子的函數為：

      function fn () {
        var undefined = 3;
        var a;
        if (a === void 0) {  //void 0 返回的永遠都是真實的undefined
            console.log("a === undefined");
        }
        else {
            console.log('a !== undefined');
        }
    }
    fn(); // a === undefined

9.以下代碼的輸出結果是?為什么?

console.log(1+1);    
console.log("2"+"4");  
console.log(2+"4"); 
console.log(+"4");

+操作符對不同的數據類型有不同的含義，例如:

• 兩個操作數都是數字，做加法運算
• 都是字符串或者有一個是字符串，會將另一個不是字符串的轉換為字符串然后進行拼接
• 有對象的時候會調用valueOf或者toString
• 只有一個字符串的時候會嘗試進行數值轉換，轉換為數字
• 只有一個數字的時候會返回其正數值
  另外，特別地，有true+true == 2;false+false ==0;

所以上述代碼的運行結果為

    console.log(1+1); //2
    console.log("2" + "4") // 24 轉換為字符串 '24'
    console.log(2 + '4'); // 24 轉換為字符串 '24'
    console.log(+ '4'); // 4 轉換為數值4

10.以下代碼的輸出結果是?

var a = 1;  
a+++a;  
typeof a+2;

• 對于自增自減運算符(++和--)，舉例說明：
  自增在前面，意味著先進行自增，再進行賦值;自增在后面，意味著先進行賦值語句，然后再執行自增運算

    var a = 100;
    var b = a ++; // 此時b的值為100，先執行賦值之后再進行自增。
    console.log(a,b); //101，100  自增在后面，意味著先進行賦值語句，然后再執行自增運算


    var c = 100;
    var d = ++c; //此時先進行c的自增，然后再進行賦值，所以d也為101
    console.log(c,d); // 101,101  自增在前面，意味著先進行自增，再進行賦值

• 在本例中，還涉及到自增運算符和加號運算符的權重問題，自增的權重是大于+的。

    //自增的權重是大于+的，所以有a+++b時，等價于(a++) + b；

• typeof的優先級，typeof的優先級相當高，比加減乘除的優先級要高，所以有：

    typeof 2*3; // NaN
    //由于typeof的優先級較高，等價于 (typeof 2) * 3;而(typeof 2)的結果是一個字符串'number',字符串'number'和3相乘，結果自然為NaN

    typeof (2*3); // 'number'
    // 同理 這下先計算2 *3 ，等價于 typeof 6; 運行結果為字符串'number'

    typeof 2+3;//   'number3'
    // 同理，這下等價于 (typeof 2) + 3,(typeof 2)的運行結果為字符串的'number',在通過+運算符，將字符串連接，結果為'number3'

    typeof 'abc' + 'def'; // 'stringdef
    // 同理，等價于 (typeof 'abc') + 'def'; 而 (typeof 'abc')的結果為字符串的'string',在和字符串'def'用+運算符進行連接，結果為字符串的'stringdef'

總結：typeof的優先級較高，另外運行結果為字符串形式的數據類型。
進行代碼的分析

    var a = 1;
    a+++a;   //等價于 (a++) + a 即1 + 1 =2，運行完成后a的值變為2
    typeof a+2; //此時a為2， 等價于 (typeof 2) + 2，運行結果為字符串的'number' + 2,結果為字符串的 'number2'

11.以下代碼的輸出結果是? 為什么

 var a = 1;
 var b = 3;
 console.log( a+++b );

運行結果為：

    var a = 1;
    var b = 3;
    console.log(a+++b);  //自增權重大于加號運算符，所以a+++b等價于 (a++) + b ,即1 + 3 = 4，運行完成后，a的值變為2，輸出結果為4

12.遍歷數組，把數組里的打印數組每一項的平方

 var arr = [3,4,5]

解決方法為：

    var arr =[3,4,5];
    for (var i = 0; i < arr.length; i ++) {
        console.log(Math.pow(arr[i],2));
    }
  //輸出結果為9,16,25

13.遍歷 JSON, 打印里面的值

var obj = {
 name: 'hunger', 
 sex: 'male', 
 age: 28 
}

解決方法為：

      var obj = {
        name: 'deejay',
        age: 21,
        sex: 'male'
    }

    for (var deejay_value in obj) {
        console.log(obj[deejay_value]);
    }
//輸出結果為 deejay 21 male

14.以下代碼輸出結果是? 為什么 ?

var a = 1, b = 2, c = 3;
var val = typeof a + b || c >0
console.log(val) 

var d = 5;
var data = d ==5 && console.log('bb')
console.log(data)

var data2 = d = 0 || console.log('haha')
console.log(data2)
 
var x = !!"Hello" + (!"world", !!"from here!!");
console.log(x)

代碼分析：

  var a = 1, b = 2, c = 3;
  var val = typeof a + b || c >0
  console.log(val) ; // 輸出結果為 'number2'
  
  
  var d = 5;
  var data = d ==5 && console.log('bb')
  console.log(data) ; // bb          (d == 5) && 'bb'  --->'bb'  data的值為undefined


  var data2 = d = 0 || console.log('haha')
  console.log(data2);   // haha  data2的值為undefined

  var x = !!"Hello" + (!"world", !!"from here!!");
  console.log(x); // !!'hello' + (false,true)  ---->  !!'hello' + true    ----> true + true ----> 2