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

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

1. 数据类型：

   • 数值（number）：整数和浮点数（比如1和3.14）
   • 字符串（string）：字符组成的文本（比如“Hello World”）
   • 布尔值（boolean）：true（真）和false（假）两个特定值
   • undefined：表示“未定义”或不存在，即由于目前没有定义，所以此处暂时没有任何值
   • null：表示无值，即此处的值就是“无”的状态。
   • 对象（object）：各种值组成的集合（又分为3个子类型）
     • 狭义的对象（object）
     • 数组（array）
     • 函数（function）

2. 通常，我们将数值、字符串、布尔值称为原始类型（primitive type）的值，即它们是最基本的数据类型，不能再细分了。而将对象称为合成类型（complex type）的值，因为一个对象往往是多个原始类型的值的合成，可以看作是一个存放各种值的容器。至于undefined和null，一般将它们看成两个特殊值。

typeof 和 instanceof 的作用和区别?

1. 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"
     

2. instanceof 运算符
   • 由于typeof对数组（array）和对象（object）的显示结果都是object，可以通过instanceof运算符做到区分

     var o = {};
     var a = [];
     o instanceof Object // true
     a instanceof Array // true
     

3. 区别
   • 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