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运算符可以返回一个值的数据类型:
    • 原始类型:
      数值、字符串、布尔值分别返回numberstringboolean
      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

推荐阅读更多精彩内容