1. JavaScript 定义了几种数据类型? 哪些是原始类型?哪些是复杂类型?原始类型和复杂类型的区别是什么?
最新的 ECMAScript 标准定义了 7 种数据类型: 6 种 原始类型: Boolean, Null, Undefined, Number, String, Symbol (ECMAScript 6 新定义) 和 Object

数值、字符串、布尔值称为原始类型（primitive type），是最基本的数据类型
Object称为复杂数据类型（complex type）的值，因为一个对象往往是多个原始数据类型的值的合成，可以看作是一个存放各种值的容器。
Undefined和null，是两个特殊的值。
2. typeof和instanceof的作用和区别?

• typeof一元运算符，用来返回操作数类型的字符串。
  typeof几乎不可能得到它们想要的结果。typeof只有一个实际应用场景，就是用来检测一个对象是否已经定义或者是否已经赋值。而这个应用却不是来检查对象的类型。
• instanceof 左操作数是一个类，右操作数是标识对象的类。如果左侧的对象是右侧类的实例，则返回true.而js中对象的类是通过初始化它们的构造函数来定义的。即instanceof的右操作数应当是一个函数。所有的对象都是object的实例。如果左操作数不是对象，则返回false,如果右操作数不是函数，则抛出typeError。instanceof 运算符是用来测试一个对象是否在其原型链原型构造函数的属性。instanceof 操作符用来比较两个操作数的构造函数。只有在比较自定义的对象时才有意义。 如果用来比较内置类型，将会和 typeof 操作符 一样用处不大。

分别是什么时候用？
对自定义类型使用instanceof：

var ClassFirst = function () {};
var ClassSecond = function () {};
var instance = new ClassFirst();
typeof instance; // object
typeof instance == 'ClassFirst'; //false
instance instanceof Object; //true
instance instanceof ClassFirst; //true
instance instanceof ClassSecond; //false

使用typeof为简单的内置类型：

'example string' instanceof String; // false
typeof 'example string' == 'string'; //true

'example string' instanceof Object; //false
typeof 'example string' == 'object'; //false

true instanceof Boolean; // false
typeof true == 'boolean'; //true

99.99 instanceof Number; // false
typeof 99.99 == 'number'; //true

function() {} instanceof Function; //true
typeof function() {} == 'function'; //true

对于复杂的内置类型使用instanceof:

/regularexpression/ instanceof RegExp; // true
typeof /regularexpression/; //object

[] instanceof Array; // true
typeof []; //object

{} instanceof Object; // true
typeof {}; //object

3. 如何判断一个变量是否是数字、字符串、布尔、函数
使用typeof即可

// Numbers
typeof 37 === 'number';
typeof 3.14 === 'number';
typeof Math.LN2 === 'number';
typeof Infinity === 'number';
typeof NaN === 'number'; // 尽管NaN是"Not-A-Number"的缩写
typeof Number(1) === 'number'; // 但不要使用这种形式!

// Strings
typeof "" === 'string';
typeof "bla" === 'string';
typeof (typeof 1) === 'string'; // typeof总是返回一个字符串
typeof String("abc") === 'string'; // 但不要使用这种形式!

// Booleans
typeof true === 'boolean';
typeof false === 'boolean';
typeof Boolean(true) === 'boolean'; // 但不要使用这种形式!

// Symbols
typeof Symbol() === 'symbol';
typeof Symbol('foo') === 'symbol';
typeof Symbol.iterator === 'symbol';

// Undefined
typeof undefined === 'undefined';
typeof declaredButUndefinedVariable === 'undefined';
typeof undeclaredVariable === 'undefined'; 

// Objects
typeof {a:1} === 'object';

// 使用Array.isArray 或者 Object.prototype.toString.call
// 区分数组,普通对象
typeof [1, 2, 4] === 'object';

typeof new Date() === 'object';

// 下面的容易令人迷惑，不要使用！
typeof new Boolean(true) === 'object';
typeof new Number(1) ==== 'object';
typeof new String("abc") === 'object';

// 函数
typeof function(){} === 'function';
typeof Math.sin === 'function';

4. NaN是什么? 有什么特别之处?
NaN 是一个全局对象的属性，表示非数字，NaN和任何值都不相等，包括自己。
NaN==NaN;//false
NaN 属性的初始值就是 NaN，和 Number.NaN 的值一样。在现代浏览器中（ES5中）， NaN 属性是一个不可配置（non-configurable），不可写（non-writable）的属性。但在ES3中，这个属性的值是可以被更改的，但是也应该避免覆盖。
5. 如何把非数值转化为数值?
Number() 、parselnt() 和 parseFloat()可以把非数值转换为数值。

Number():
var num1 = Number("Hello world!");  // NaN
var num2 = Number(" ");  // 0
var num3 = Numberl("000011");  // 11
var num4 = Number(true);  // 1

parseInt():
var num1 = parselnt ("1234blue") ;  // 1234
var num2 = parselnt (" ") ;   // NaN
var num3 = parselnt ("0xA") ;  // 10（十六进制数）
var num4 = parseInt(22.5);   // 22
var num5 = parselnt ("070") ;  // 56（八进制数）
var num6 = parselnt("70");  //70（十进制数）
var num7 = parselnt ("0xf") ;  // 15（十六进制数）
var num1 = parselnt ("10", 2);  // 2（按照二进制解析）
var num2 = parseInt("10", 8);  // 8（按照八进制解析）
var num3 = parselnt("10", 10);  // 10（按照十进制解析）
var num4 = parselnt("10", 16);  // 16（按照十六进制解析）

parseFloat():
var num1 = parseFloat ("1234blue") ;  // 1234（整数）
var num2 = parseFloat("0xA");   // 0
var num3 = parseFloat("22.5");  // 22.5
var num4 = parseFloat("22.34.5");  // 22.5
var num5 = parseFloat("0908.5");   // 908
var num6 = parseFloat("3.125e7");   // 31250000

6. ==与===有什么区别
绝大多数场合应该使用 === ，只有检测 null/undefined 的时候可以使用 x == null ，因为通常我们不区分 null 和 undefined ，即将 x == null 作为 x === null || x === undefined 的缩写。== 的比较看似会比较方便，比如 1 == '1' ，但是会埋下隐患，比如可能对类型做出错误的假设。例子：if (x == 10) x += 5如果传入的x是字符串'10'，x的结果会变成'105'。在后续运算中字符串'105'又可能被转型，从而引入隐蔽的错误。
1、对于string,number等基础类型，==和===是有区别的1）不同类型间比较，==之比较“转化成同一类型后的值”看“值”是否相等，===如果类型不同，其结果就是不等2）同类型比较，直接进行“值”比较，两者结果一样
2、对于Array,Object等高级类型，==和===是没有区别的进行“指针地址”比较
7. break与continue有什么区别
break用于强制退出循环体，执行循环后面的语句。
continue用于退出本次循环，执行下次循环。
8. void 0 和 undefined在使用场景上有什么区别
mdn上对void操作符的解释是
The void operator evaluates the given expression and then returns undefined.
意思是说 void 运算符能对给定的表达式进行求值，然后返回 undefined。也就是说，void 后面你随便跟上一个表达式，返回的都是 undefined，都能完美代替 undefined！那么，这其中最短的是什么呢？毫无疑问就是 void 0 了。其实用 void 1，void (1+1)，void (0) 或者 void “hello”，void (new Date()) 等等，都是一样的效果。更重要的前提是，void 是不能被重写的（cannot be overidden）。不使用undefined是因为undefined 并不是保留词（reserved word），它只是全局对象的一个属性，在低版本 IE 中能被重写
9. 以下代码的输出结果是?
console.log(1+1); console.log("2"+"4"); console.log(2+"4"); console.log(+"4");
2 “24” “24” 4
10. 以下代码的输出结果是?
var a = 1; a+++a; typeof a+2;
"number2"
11. 以下代码的输出结果是? 为什么
var a = 1; var b = 3; console.log( a+++b );
4， a+++b相当于(a++)+b，此时(a++)的值为1，b为3，相加就是4
12. 遍历数组，把数组里的打印数组每一项的平方
var arr = [3,4,5]

for (var i = 0; i < arr.length; i++) {
   console.log(arr[i] = arr[i] * arr[i])
}

13. 遍历 JSON, 打印里面的值
var obj = { name: 'hunger', sex: 'male', age: 28 }

for (var i in obj) {
  console.log(obj[i]);
}

14. 以下代码的输出结果是? 为什么

var a = 1, b = 2, c = 3;
var val = typeof a + b || c >0
console.log(val)   
//结果为number2，运算过程是(typeof a)+b,||是或运算符

var d = 5;
var data = d ==5 && console.log('bb')
console.log(data)  
//结果为undefined，"="的优先级最低，所以直接运行console.log('bb')。

var data2 = d = 0 || console.log('haha')
console.log(data2)
//结果为undefined，这里是或运算符||

var x = !!"Hello" + (!"world", !!"from here!!");
console.log(x)
//结果为2，!!是强制转换成布尔类型，!!"Hello" === true == 1，(!"world", !!"from here!!")运算的后的结果为(false,true)，所以就是(0,1)，返回结果为1，x这时就为1+1=2