JS数据类型、运算符、流程控制语句

JavaScript 定义了几种数据类型?哪些是原始类型?哪些是复杂类型?原始类型和复杂类型的区别是什么?

数据类型：
- 数值（number）：整数和浮点数（比如1和3.14）
- 字符串（string）：字符组成的文本（比如“Hello World”）
- 布尔值（boolean）：true（真）和false（假）两个特定值
- undefined：表示“未定义”或不存在，即由于目前没有定义，所以此处暂时没有任何值
- null：表示无值，即此处的值就是“无”的状态。
- 对象（object）：各种值组成的集合（又分为3个子类型）
  - 狭义的对象（object）
  - 数组（array）
  - 函数（function）
通常，我们将数值、字符串、布尔值称为原始类型（primitive type）的值，即它们是最基本的数据类型，不能再细分了。而将对象称为合成类型（complex type）的值，因为一个对象往往是多个原始类型的值的合成，可以看作是一个存放各种值的容器。至于undefined和null，一般将它们看成两个特殊值。

typeof 和 instanceof 的作用和区别?

typeof运算符可以返回一个值的数据类型:

原始类型:
数值、字符串、布尔值分别返回number、string、boolean
```
typeof 123 // "number"
typeof '123' // "string"
typeof false // "boolean"
```
函数
函数返回function
```
function f() {}
typeof f
// "function"
```
undefined
undefined返回undefined
```
typeof undefined
// "undefined"
```

其他
除此以外，其他情况都返回object。

typeof window // "object"
typeof {} // "object"
typeof [] // "object"
typeof null // "object"

instanceof 运算符
- 由于typeof对数组（array）和对象（object）的显示结果都是object，可以通过instanceof运算符做到区分
```
var o = {};
var a = [];
o instanceof Object // true
a instanceof Array // true
```
区别
- typeof是一元运算符，返回值为字符串，该字符串用来说明原数据的数据类型
- instanceof用于判断某个变量是否是某个对象的实例，返回值布尔类型.

如何判断一个变量是否是数字、字符串、布尔、函数

使用typeof运算符，详情请参考上面的题目；

NaN是什么? 有什么特别之处?

NaN 表示 Not-A-Number，是 number 类型，它不与任何数相等，包括它自己。

如何把非数值转化为数值

有三个函数可以将非数值转换为数值
```
Number()
parseInt()
parseFloat()
```

Number

原始类型值的转换规则
原始类型的值主要是字符串、布尔值、undefined 和 null，它们都能被 Number 转成数值或 NaN。

// 数值：转换后还是原来的值
Number(324) // 324

// 字符串：如果可以被解析为数值，则转换为相应的数值
Number('324') // 324

// 字符串：如果不可以被解析为数值，返回NaN
Number('324abc') // NaN

// 空字符串转为0
Number('') // 0

// 布尔值：true 转成1，false 转成0
Number(true) // 1
Number(false) // 0

// undefined：转成 NaN
Number(undefined) // NaN

// null：转成0
Number(null) // 0

对象的转换规则
简单的规则是，Number方法的参数是对象时，将返回NaN，除非是包含单个数值的数组。
```
Number({a: 1}) // NaN
Number([1, 2, 3]) // NaN
Number([5]) // 5
```

parseInt

基本用法

parseInt方法用于将字符串转为整数。
parseInt('123') // 123 

如果字符串头部有空格，空格会被自动去除。
parseInt('   81') // 81

如果parseInt的参数不是字符串，则会先转为字符串再转换。
parseInt(1.23) // 1
// 等同于
parseInt('1.23') // 1

字符串转为整数的时候，是一个个字符依次转换，如果遇到不能转为数字的字符，就不再进行下去，返回已经转好的部分。
parseInt('8a') // 8
parseInt('12**') // 12
parseInt('12.34') // 12
parseInt('15e2') // 15
parseInt('15px') // 15
上面代码中，parseInt的参数都是字符串，结果只返回字符串头部可以转为数字的部分。

如果字符串的第一个字符不能转化为数字（后面跟着数字的正负号除外），返回NaN。
parseInt('abc') // NaN
parseInt('.3') // NaN
parseInt('') // NaN
parseInt('+') // NaN
parseInt('+1') // 1
parseInt的返回值只有两种可能，不是一个十进制整数，就是NaN。

如果字符串以0x或0X开头，parseInt会将其按照十六进制数解析。
parseInt('0x10') // 16

如果字符串以0开头，将其按照10进制解析。
parseInt('011') // 11

对于那些会自动转为科学计数法的数字，parseInt会将科学计数法的表示方法视为字符串，因此导致一些奇怪的结果。
parseInt(1000000000000000000000.5) // 1
等同于 parseInt('1e+21') // 1
parseInt(0.0000008) // 8
// 等同于 parseInt('8e-7') // 8

进制转换

parseInt 方法还可以接受第二个参数（2到36之间），表示被解析的值的进制，返回该值对应的十进制数。默认情况下，parseInt 的第二个参数为10，即默认是十进制转十进制。
parseInt('1000') // 1000
// 等同于 parseInt('1000', 10) // 1000

下面是转换指定进制的数的例子。
parseInt('1000', 2) // 8
parseInt('1000', 6) // 216
parseInt('1000', 8) // 512
上面代码中，二进制、六进制、八进制的1000，分别等于十进制的8、216和512。这意味着，可以用parseInt方法进行进制的转换。

如果第二个参数不是数值，会被自动转为一个整数。这个整数只有在2到36之间，才能得到有意义的结果，超出这个范围，则返回NaN。如果第二个参数是0、undefined和null，则直接忽略。
parseInt('10', 37) // NaN
parseInt('10', 1) // NaN
parseInt('10', 0) // 10
parseInt('10', null) // 10
parseInt('10', undefined) // 10

如果字符串包含对于指定进制无意义的字符，则从最高位开始，只返回可以转换的数值。如果最高位无法转换，则直接返回NaN。
parseInt('1546', 2) // 1
parseInt('546', 2) // NaN
上面代码中，对于二进制来说，1是有意义的字符，5、4、6都是无意义的字符，所以第一行返回1，第二行返回NaN。

前面说过，如果parseInt的第一个参数不是字符串，会被先转为字符串。这会导致一些令人意外的结果。
parseInt(0x11, 36) // 43
// 等同于 parseInt(String(0x11), 36)
parseInt('17', 36)
上面代码中，十六进制的0x11会被先转为十进制的17，再转为字符串。然后，再用36进制解读字符串17，最后返回结果43。

这种处理方式，对于八进制的前缀0，尤其需要注意。
parseInt(011, 2) // NaN
// 等同于 parseInt(String(011), 2)
parseInt('011', 2) // 3
上面代码中，第一行的011会被先转为字符串9，因为9不是二进制的有效字符，所以返回NaN。第二行的字符串011，会被当作二进制处理，返回3。

ES5不再允许将带有前缀0的数字视为八进制数，而是要求忽略这个0。但是，为了保证兼容性，大部分浏览器并没有部署这一条规定。

parseFloat

parseFloat方法用于将一个字符串转为浮点数。
parseFloat('3.14') // 3.14

如果字符串符合科学计数法，则会进行相应的转换。
parseFloat('314e-2') // 3.14
parseFloat('0.0314E+2') // 3.14

如果字符串包含不能转为浮点数的字符，则不再进行往后转换，返回已经转好的部分。
parseFloat('3.14more non-digit characters') // 3.14

parseFloat方法会自动过滤字符串前导的空格。
parseFloat('\t\v\r12.34\n ') // 12.34

如果参数不是字符串，或者字符串的第一个字符不能转化为浮点数，则    返回NaN。
parseFloat([]) // NaN
parseFloat('FF2') // NaN
parseFloat('') // NaN
上面代码中，尤其值得注意，parseFloat会将空字符串转为NaN。

这些特点使得parseFloat的转换结果不同于Number函数。
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

==与===有什么区别

区别是相等运算符（==）比较两个值是否相等，严格相等运算符（===）比较它们是否为“同一个值”。如果两个值不是同一类型，严格相等运算符（===）直接返回false，而相等运算符（==）会将它们转化成同一个类型，再用严格相等运算符进行比较。

break与continue有什么区别

break语句和continue语句都具有跳转作用，可以让代码不按既有的顺序执行；
break语句用于跳出代码块或循环；
continue语句用于立即终止本轮循环，返回循环结构的头部，开始下一轮循环。

void 0 和 undefined在使用场景上有什么区别

void 会执行后面的表达式并返回 undefined，但是某些情境下undefined是可以被赋值的，比如在函数中，这样的话就不能用undefined来进行判断了。所以用void 0返回undefined来进行判断。既减少了在原形链上查找 window.undefined 的时间，也避免了误用被修改过的 undefined；
void 运算符通常只用于获取 undefined 的原始值，一般使用 void(0)（等同于 void 0）。在上述情况中，也可以使用全局变量undefined 来代替（假定其仍是默认值）。

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

console.log(1+1);    // 2 数字相加
console.log("2"+"4");   // 24 字符串拼接
console.log(2+"4");    // 24 将数字2转换成字符串后字符串拼接
console.log(+"4");    // 4 字符串变为数字

以下代码的输出结果是

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

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

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

结果是 4，由于自增运算符 ++ 优先级高于 + 运算符，所以 a 先参加运算后自增，即 a+b = 4

遍历数组，把数组里的打印数组每一项的平方

var arr = [3,4,5]

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

遍历 JSON, 打印里面的值

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

for (var prop in obj) {
  console.log (obj[prop])
}
hunger
male
28

以下代码输出结果是? 为什么（选做题目）

var a = 1, b = 2, c = 3;
var val = typeof a + b || c >0
console.log(val) 
// number2  || 运算符，当第一个运算子的布尔值为true，则返回第一个运算子的值

var d = 5;
var data = d == 5 && console.log('bb')
console.log(data)
// undefined  &&运算符，当第一个运算子当布尔值为true，则返回第二个运算子的值

var data2 = d = 0 || console.log('haha')
console.log(data2)
// undefined   0 为 false 直接返回第二个运算子的值

var x = !!"Hello" + (!"world", !!"from here!!");
console.log(x)
//  2    true 为1，两个 true 相加为 2