面试题集

AdMaster笔试题

1. 变量作用域

var a = 'hello';
(function(){
  a = 'world';
})();
console.log(a);  // "world"


var a = 'hello';
(function(){
 var a = 'world';
})();
console.log(a);  // "hello"

2. 闭包

var foo = function(){
  var count = 0;
  return function(){
    return count+=1;
  }
};
var fn = foo();
console.log(fn());  // 1
console.log(fn());  // 2
console.log(fn(3));  // 3
console.log(fn(6));  // 4

3. this指向

var person = {
  age:18,
  say:function(){
    return this.age;
  }
};
var say = person.say;
console.log(person.say());  // 18

console.log(person.say(20));  // 18

console.log(person.say({age:20}));  // 18

console.log(say());  // undefined

console.log(say.call(person));  // 18

person.age += 1;
console.log(say.call(person));  // 19

console.log(say.apply(person,[32]));  // 19

这里基本功不扎实可能被参数迷惑，console.log(person.say({age:20}));我以为会自动调用setter方法，觉得有坑，写了20，实际上还是18。

云鸟科技

1. js执行顺序以及提升

function fn(a) {
    console.log(a);  
    a = 1;
    console.log(a);
    var a = function() { //函数1
        console.log(1);
    }
    console.log(a);

    function a() { //函数2
        console.log(2);
    }
    console.log(a);
}
fn(2);

输出结果：
[Function: a] //函数2
1
[Function: a] //函数1
[Function: a] //函数1
这里考察js的对象创建和执行顺序，执行上下文（EC）创建的过程是有先后顺序的：参数声明 > 函数声明 > 变量声明，函数的声明比变量优先级要高，并且定义过程不会被变量覆盖，除非是赋值，但函数声明会覆盖参数
这里有一篇文章解释的很明白：深入理解JavaScript执行上下文、函数堆栈、提升的概念

2. BFC理解及应用
   主要理解什么是BFC（块级格式化上下文），对于处理margin的重叠，清除浮动，以及双列伸缩布局的应用，可以自行百度了解。

必要商城

1. iframe的优缺点（seo?同域不同域修改dom？）
2. 描述一下HTML的语义化
3. jsonp的原理以及不足之处
4. 以下可以用来在浏览器和服务器之间传输的是？

• cookies
• localStorage
• sessionStorage
• session

5. DOCTYPE作用，包含哪几种类型？
6. 闭包是什么，有什么特性，对页面有什么影响？
7. 写出下列代码输出结果

function A(name){
    if(name)this.name = name;
};
function B(name){
    this.name = name;
};
function C(name){
    this.name = name||'test';
};
A.prototype.name = 'Tom';
B.prototype.name = 'Bob';
C.prototype.name = 'Alice';
console.log(new A().name+new B().name+ new C().name);
// Tomundefinedtest

易到用车

var num = 10;
var obj = {
    num :8,
    inner:{
        num:6,
        fn:function(){
            console.log(this.num);
        }
    }
};
num = 888;
obj.inner.fn();  //6
var foo = obj.inner.fn;
foo();  //888
(obj.inner.fn)();  //6
(obj.inner.fn = obj.inner.fn)(); //888

self

1. 事件循环执行顺序

console.log('start');
var promise = new Promise((reslove,reject) => {
    console.log('promise-define');
    
    reslove('promise-reslove');
});
function excuFn(callback) {
        callback();
}

var log = () => console.log('callback');
setTimeout(() => {
    console.log('timeout'); 
}, 0);

promise.then((data) => console.log(data),(err) => {console.log(err);
});
excuFn(log);
console.log('end');

结果：
start
promise-define
callback
end
promise-reslove
timeout
此处看callback是同步执行的（不考虑xhr和延时处理）。

原型链与构造函数

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();  //2
getName(); //4
Foo().getName(); //1
getName();  //1
new Foo.getName();  //2
new Foo().getName(); //3
new new Foo().getName(); //3