容易混淆的基础面试题

typeof 的返回值有哪些

• number
• undefined
• string
• object
• function
• symbol
• boolean

NaN 代表的是一个特殊非数字，本身就是一个数字类型 typeof NaN 结果为 number

注意浏览器与node环境下得差别

以下表达式正确的是

A. Number('a') == Number('a')   // 两个结果都为NaN  NaN != NaN
B.console,log(NaN === NaN)
C.3 + '2' === 5  // 在浏览器中数字与字符串的  +   代表拼接   === '32'
D. ![] == '' //正确  false == false

如何把7.25 四舍五入为最接近的整数

A.Math.round(7.25) //7
B.Math.ceil(7.25) //8
C.round(7.25) //报错
D.Math.rnd(7.25) // 报错

Math.round() 返回一个数字 四舍五入后最接近的整数

Math.round(20.49)  // 20 
Math.round(20.5)  // 21
Math.round(-20.5)  // -20
Math.round(-20.51)  // -21 

负数的小数部分正好等于0.5的情况下会舍去，返回最接近当前数字正数(>0)的最小整数

Math.ceil() 向上取整

Math.ceil(1.01)  // 2
Math.ceil(-1.99) // -1

String对象的哪个方法可以寻找子字符串并返回改子字符串的位置

A.match()  // 根据正则，返回字符串
B.indexOf() //  找到，返回字符串所在的位置，没找到返回 -1
C.search() // 找到，返回字符串所在的位置，没找到返回 null
D.concat() // 字符串拼接，返回一个新的字符串

下面分别使用 JSON.stringify 方法，返回值 res 分别是

const fn = function(){}
const res = JSON.stringify(fn)  // 序列化一个函数，返回值是undefined
const num = 123
const res = JSON.stringify(num)
const res = JSON.stringify(NaN) // 序列化NaN,返回值是null
const b = true
const res = JSON.stringify(b)
​
A. 'function'、'123'、'NaN'、'true'
B. undefined、'123'、undefined、'true'
C. undefined、'123'、'null'、'true'
D. undefined、'123'、'null'、undefined
//C

下列哪种数组的方法不会修改数组本身

A. slice // 浅拷贝一个数组，返回一个新数组，不会改变原数组
B. splice //删除，添加，修改数组中的一个元素
C. sort // 用原地算法进行排列
D. unshift // 向数组最前面插入一个元素
//A

拓展：

• splice（处理数据，把数据处理成固定的多少条一组）

  let arr = ['假如有一万条数据']
  let newArr = []
  while(arr.length !=0) {
      newArr.push(arr.splice(0,10))
  }
  newArr = [['10条数据'],['十条数据']，......]    //直到arr.length = 0
  

• sort （原地算法进行排序）

  arr = [1,2,3,4,5]
  arr.sort((a,b) => b -a)
  //arr = [5,4,3,2,1] 
  

对于一个数字组成的数组 nums，现在需要执行在不改动 nums 的基础上去重操作，返回一个新的无重复元素的数组，以下几段代码能完成这一操作的是()

// (1)
const newNums = Array.from(new Set(nums))
​
// (2)
const newNums = nums.filter((n, i) => {
    return nums.indexOf(n) === i
})
​
// (3)
const newNums = nums.forEach((n, i) => {
    return nums.indexOf(n) === i
}) // 返回值为undefined
​
// (4)
const newNums = nums.reduce((acc, n, i) => {
    return [].concat(acc, nums.indexOf(n) === i ? n : []
)
})
​
A. (1)、(2)、(3)、(4)
B. (1)、(3)、(4)
C. (1)、(2)、(4)
D. (1)、(4)
//C