面试题集

AdMaster笔试题

变量作用域

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


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

闭包

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

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。

云鸟科技

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执行上下文、函数堆栈、提升的概念

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

必要商城

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

cookies
localStorage
sessionStorage
session

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

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

事件循环执行顺序

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

函数的定义和声明

var scareMe = function () {
    console.log("Boo!");
    scareMe = function () {
        console.log("Double boo!");
    };
};
// 1. adding a new property
scareMe.property = "properly";

// 2. assigning to a different name
var prank = scareMe;

// 3. using as a method
var spooky = {
    boo: scareMe
};

// calling with a new name
prank(); // "Boo!"
prank(); // "Boo!"
console.log(prank.property); // "properly"

// calling as a method
spooky.boo(); // "Boo!"
spooky.boo(); // "Boo!"
console.log(spooky.boo.property);// "properly"
// using the self-defined function
scareMe(); // Double boo!
scareMe(); // Double boo!
console.log(scareMe.property); // undefined

解释参考自定义函数

箭头函数的this

window.name = "window";
function fn(){
setTimeout(() => {
console.log("name：",this.name)},100)};
fn.call({name:"foo"})

结果：name:foo