函数面试题

第一题

var a = 1;
function b() {
     a = 10;
     return;  
     function a() {}
}
b();
console.log(a);

输出: 1

解析:输出的a是window下的

第二题

function foo(){
   function bar() {
       return 3;
   }
   return bar();
   function bar() {
       return 8;
   }
}
alert(foo());

输出: 8

解析: 涉及预编译问题,两个方法名同名,
后声明的覆盖之前的所以这里输出8

第三题

function parent() {
   var hoisted = "I'm a variable";
   function hoisted() {
       return "I'm a function";
   }
   return hoisted(); 
}
console.log(parent());

输出: “TypeError: hoisted is not a function”

解析:当变量名和函数名重名是,因为函数优先声明,所以变量名覆盖函数名,这里hoisted = “I’m a variable”,

第四题

alert(foo());
function foo() {
   var bar = function() {
      return 3;
   };
   return bar();
   var bar = function() {
      return 8;
   };
}

输出: 3

解析:预编译中变量名声明时赋值undefined,这里是变量的值是函数,它不是一个函数体,容易看错

第五题

var myVar = 'foo';
(function() {
    console.log('Original value was: ' + myVar);
    var myVar = 'bar';
    console.log('New value is: ' + myVar);
})();

输出: “Original value was: undefined”, “New value is: bar”

解析:第一个输出myVar为undefined:作用域中自身有声明时不会向上层查找,
本层有一个提前声明的myVar 赋值为undefined

第六题

console . log（to）　　　　//undefined
　　var   to=1；
　　function   fn（n1，n2）{
　　　　console . log（to）　　　//1
　　　　to=n1+n2；
　　　　console . log（to）　　　　//30
　　　}
　　fn（10，20）
　　console . log（to）　　　　//30

解析:
第一个输出:预编译变量声明提前
第二个输出:作用域,输出to为全局变量的值
第三个输出:作用域,输出to为全局变量的值修改n1+n2 = 30;
第四个输出:全局变量的值

第七题

function test（a，b）{
　　　　console . log（b）　　//function
　　　　console . log（a）　　//1
　　　　c=0；
　　　　a=3；
　　　　b=2；
　　　　console . log（b）；　　　　//2
　　　　function   b（）{ }
　　　　function   d（）{ }
　　　　console . log（b）　　　　//2
　　　}
　　test（1）

解析:预编译的过程

第八题

function foo() {
    console.log( this.a );
}

var obj1 = {
    a: 2,
    foo: foo
};

var obj2 = {
    a: 3,
    foo: foo
};

obj1.foo(); // 2
obj2.foo(); // 3

obj1.foo.call( obj2 ); // 3
obj2.foo.call( obj1 ); // 2

解析:改变this指向

第九题

var A = function( name ){ 
    this.name = name;
};
var B = function(){ 
    A.apply(this,arguments);
};
B.prototype.getName = function(){ 
    return this.name;
};
var b=new B('sven');
console.log( b.getName() ); // 输出:  'sven'

解析:原型链加改变this指向,
我们一步步看,输出的是b.getName(),b是B new出来的 ,所以b继承的是
B.prototype,那么getName() 执行的函数应该就是 function(){ return this.name;};这个函数体,函数体return this.name;,那么在原型链上寻找这个name,在变量A中发现这个name,我们还发现B的值函数体里面A改变了形参,
所以输出的应该是 ‘sven’

第十题

  //构造函数
  function Foo(name,age){
      this.name = name
  }
  Foo.prototype.alertName= function(){
      alert(this.name+"killua");
 }
 //创建示例
 var f = new Foo("L");
 f.lastName = function(){
     console.log(this.name)
 }
 f.lastName(); //"L",自身属性
f.alertName(); //"Lkillua"，原型属性
以上函数中，f共有3个属性，f自身的属性有2个(name属性和lastName属性),还有一个alertName是原型属性
 f.firstName();
 //这里f自身属性中没有firstName属性，它的原型Foo函数中也么有这个属性，所以要再往上一层Foo的原型上去找这个属性，这种有多层原型的函数就是原型链，直到null为止结束原型链