js面试题目

1 function test (x, y, z) {

console.log(test.length)
console.log(arguments.length)
console.log(arguments.callee === test)
console.log(arguments[2])

}
test(10,20)
答案：3 2 true undefined
解析：
test.length是返回的函数的形参个数，因此为3；

arguments.length返回的是函数调用时的实参个数，因此为2；

arguments.callee:初始值就是正被执行的 Function 对象,用于在函数内部调用自身，arguments对象自己是个由函数调用时传入的实参组成的伪数组，访问单个参数的方式与访问数组元素的方式相同。

只传入了两个参数，天然为undefined.
2 var a = 10
a.pro = 10
console.log(a.pro + a)

var s = 'hello'
s.pro='world'
console.log(s.pro+s)
答案：NaN undefinedhello
解析：JavaScript引擎内部在处理对某个基本类型 a进行形如a.pro的操做时，会在内部临时建立一个对应的包装类型(对数字类型来讲就是Number类型)的临时对象，并把对基本类型的操做代理到对这个临时对象身上，使得对基本类型的属性访问看起来像对象同样。可是在操做完成后，临时对象就销毁了，下次再访问时，会从新创建临时对象，固然就会返回undefined了
3

var f =1
if(!f) {
  var a =10
}
function fn() {
  var b =20
  c = 30
}
fn()
console.log(a)
console.log(c)
console.log(b)

答案：undefined 30 报错：b is not defined
解析：
一、没有用var声明的是全局变量，即使在函数内部；
二、只有在function内部新声明的才是局部变量，在if,while,for等声明的变量实际上是全局变量（除非自己在function内部）
三、由于变量提高，虽然if块的内容没执行，可是预解析阶段会执行var a，只是没有赋值而已，所以打印a是undefined而打印b会报错

4

var length = 10
function fn () {
    console.log(this.length)
}
var obj = {
    length: 5,
    method: function(fn) {
        fn()
        arguments[0]();
    }
}

obj.method(fn,1)
答案：10，2，第一次输出10应该没有什么异议，这里的this指向window，第二个调用arguments[0]()至关于执行arguments调用方法，this指向arguments，而这里传了两个参数，故输出arguments长度为2。

5 function fn(a) {
console.log(a)
var a = 2
function a() {}
console.log(a)
}
fn(1)
答案：f a() { } 2
解析：咱们知道预解析阶段，变量声明和函数声明会提早，且变量名和函数名同名时，函数优先级高于变量，会覆盖变量，所以第一个输出的是f a(){ }，继续执行，会执行a=2，再输出的时候就会输出2，不理解的同窗百度一下变量提高和函数提高
6 已知数组，编写一个程序将数组便情话而且去掉其中的重复数字，而后升序排列
[[11,22,22],[13,14,15,15],[16,17,18,19,[11,12,[12,13,[14]]]],12]
7 实现一个函数add,知足如下结果
add(1) // 1
add(1,2) // 3
add(1)(2) // 3
add(1,2)(3,4) // 10
add(1)(2)(3) //6

function add () {
        const arg = [...arguments]
        function sum () {
            arg.push(...arguments)
            return sum
        }
        sum.toString = function () {
            return arg.reduce((x, y) => {
                return x + y
            })
        }
        return sum
    }
    console.log(add(1))
    console.log(add(1, 2))
    console.log(add(1, 2)(3, 4)(5,6))

8 看代码

function Foo () {
        getName = function () {
          console.log(1)
        }
        return this
      }
      Foo.getName = function () {
        console.log(2)
      }
      Foo.prototype.getName = function () {
        console.log(3)
      }
      var getName = function () {
        console.log(4)
      }
      function getName () {
        console.log(5)
      }
      Foo.getName()
      getName()
      Foo().getName()
      getName()
      new Foo.getName()
      new Foo().getName()
      new new Foo().getName()

答案：2 4 1 1 2 3 3 1 访问的是Foo函数上存储的静态属性2 函数表达式覆盖函数声明，所以调用的是覆盖后的getName 3 先执行了Foo(),此时返回window，而且函数里getName没有var 因此覆盖了全局的 所以是14 等同于window.getName 45 点运算符优选与new， 执行为 new (Foo.getName)()6 执行顺序为 (new Foo()).getName() （new Foo()） 返回Foo一个实例7 执行顺序为 new ((new Foo()).getName)() 先初始化Foo实例 而后将其原型上的getName 做为构造函数再次new