1.函数声明和函数表达式有什么区别?
函数声明必须有标识符，也就是常说的函数名；函数表达式可以省略函数名.函数声明会提前；对于函数表达式，函数调用只有在函数表达式声明后调用；
2.什么是变量的声明前置？什么是函数的声明前置?
变量的声明前置是指执行代码之前会先读取变量的声明，在执行的过程中进行赋值， var a=2;一般分为两步 var a 声明一个变量 a 会放在最前面，然后在进行赋值 a=2；
函数的声明前置意思是在执行代码之前会先读取函数声明。这就意味着可以把函数声明放在调用它的语句后面。
3.arguments 是什么?
在函数内部,你可以使用arguments对象获取到该函数的所有传入参数，是我们传入函数内的实参；所有的函数都有属于自己的一个arguments对象，它包括了函所要调用的参数。他不是一个数组，如果用typeof arguments，返回的是’object’。虽然我们可以用调用数据的方法来调用arguments。比如length,还有index方法。但是数组的push和pop对象是不适用的。
4.函数的"重载"怎样实现
js中是没有重载的；如果想实现类似函数重载，我们可以判断传入函数内部的参数的类型和数目来执行函数。注：js判断传入参数数量可以用arguments.length这个属性来判断；判断类型：
1.用 typeof 语句判断变量类型，typeof语句返回类型对应的字符串。
2.用 instanceof 语句判断变量类型，instanceof语句返回true/false。
3.用 constructor 属性判断变量类型，这个属性返回用来构造该变量的构造函数引用。
5.立即执行函数表达式是什么？有什么作用
立即执行函数模式是一种语法，可以让你的函数在定义后立即被执行；这种模式本质上就是函数表达式，在创建后立即执行。因为函数的声明是不可以跟圆括号的，但是函数的表达式可以；要将函数声明转换成函数表达式，就可以在声明外面加一对括号。在javascript里，括号内部不能包含语句，当解析器对代码进行解释的时候，先碰到了()，然后碰到function关键字就会自动将()里面的代码识别为函数表达式而不是函数声明。
//最常用的模式
(function () {
alert('hello world!');
})();
//第二种模式
(function () {
alert('watch out!');
}());
//还有许多模式
作用：临时需要变量的时候，可以创建私有作用域，这样不会污染到全局，避免了全局变量过多，防止命名冲突；同时匿名函数执行完毕后，会立即销毁函数内部变量，而匿名函数又是一个闭包，可以访问自身作用域链中的所有变量。这种做法可以减少闭包占用的内存问题，因为没有指向匿名函数的引用。只要函数执行完毕，就可以立即销毁其作用域链了。
6.求n!，用递归来实现
function factorial(n){
if(n<=1){
return 1;
}else{
return n*f(n-1);
}
}
factorial(n);
7.以下代码输出什么？
function getInfo(name, age, sex){
console.log('name:',name);
console.log('age:', age);
console.log('sex:', sex);
console.log(arguments);
arguments[0] = 'valley';
console.log('name', name);
}
getInfo('饥人谷', 2, '男'); // 输出 name:饥人谷；age: 2；sex: 男 ；Arguments(3) { " valley",2," 男 " }；name valley
getInfo('小谷', 3);// 输出 name:小谷；age: 3；sex: undefined ；Arguments(2) { " valley",3}；name valley
getInfo('男');// 输出 name:男；age: undefined ；sex: undefined ；Arguments(1) { " valley"}；name valley
8. 写一个函数，返回参数的平方和？
function sumOfSquares(){
var result = 0;
for(var i =0;i<arguments.length;i++){
result+=Math.pow(arguments[i],2);
}
return result;
}
var result = sumOfSquares(2,3,4)
var result2 = sumOfSquares(1,3)
console.log(result) //29
console.log(result2) //10
9. 如下代码的输出？为什么
console.log(a); //undefined 变量声明提升，但赋值在后 所以为undefined
var a = 1;
console.log(b);//报错 b is not defined
10. 如下代码的输出？为什么
sayName('world'); // hello world; 函数声明提升
sayAge(10); //sayAge is not a function; 函数表达式只把变量的声明提升了。赋值在后面
function sayName(name){
console.log('hello ', name);
}
var sayAge = function(age){
console.log(age);
};
11. 如下代码输出什么? 写出作用域链查找过程伪代码
var x = 10;
bar() ;
function foo() {
console.log(x);
}
function bar(){
var x = 30;
foo();
}
//分析
globalContext = {
//全局执行上下文
AO:{
x:10,
foo:function(){},
bar:function(){}
},
Scope = null;
};
foo.[[Scope]] = globalContext.AO;
bar.[[Scope]] = globalContext.AO;
bar执行的时候进入bar的执行上下文：
barContext = {
//bar的执行上下文
AO:{
x:30
},
Scope:bar.[[Scope]]
}
fooContext = {
//foo的执行上下文
AO:{
},
Scope:foo.[[Scope]]
}
分析：首先将变量声明 函数声明提升；执行bar函数进入bar函数的执行上下文；bar函数执行过程中执行foo函数，会先在bar的AO中寻找foo函数，没有再进入bar.[[Scope]]寻找。执行foo函数进入foo函数的执行上下文，执行console.log(x)；首先在foo自己的AO中找x，没有就进入foo.[[Scope]]中寻找所以console.log(x)打印出来的值为10；
12. 如下代码输出什么? 写出作用域链查找过程伪代码
var x = 10;
bar();
function bar(){
var x = 30;
function foo(){
console.log(x);
}
foo();
}
//全局执行上下文：
globalContext = {
AO:{
x:10,
bar:function(){}
}
Scope:null
}
bar.[[Scope]] = globalContext.AO;
//bar的执行上下文
barContext = {
AO:{
x:30,
foo:function(){}
},
Scope: bar.[[Scope]]
}
foo.[[Scope]] = barContext.AO;
//foo的执行上下文
fooContext = {
AO:{
},
Scope:foo.[[Scope]]
}
分析：先进行全局和函数内部的变量声明提升 函数声明提升，执行bar函数先在globalContext.AO中寻找函数bar，执行bar函数进入bar函数的执行上下文；bar函数内部执行foo函数先在barContext.AO 中寻找foo函数找到后执行console.log(x)；x先在fooContext.AO中寻找，没有进入foo.[[Scope]]寻找也就是 barContext.AO中寻找x=30，所以打印结果为30.
13.如下代码输出什么? 写出作用域链查找过程伪代码
var x = 10;
bar();
function bar(){
var x = 30;
(function (){
console.log(x);
})();
}
分析：同上因为立即执行函数可以看做一个函数表达式类似于var fn = function(){}; 然后立即执行fn();匿名函数执行上下文的Scope属性为barContext.AO，找到x为30；打印结果为30.
14.如下代码输出什么? 写出作用域链查找过程伪代码
var a = 1;
function fn(){
console.log(a);
var a = 5;
console.log(a);
a++;
var a;
fn3();
fn2();
console.log(a);
function fn2(){
console.log(a);
a = 20;
}
}
function fn3(){
console.log(a);
a = 200;
}
fn();
console.log(a);
分析过程：
首先在全局和函数内部进行变量声明提升和函数声明提升；
//全局执行上下文：
globalContext = {
AO:{
a:1,//变化顺序1;200
fn:function(){},
fn3:function(){}
},
Scope:null
}
fn.[[Scope]] = globalContext.AO;
fn3.[[Scope]] = globalContext.AO;
//fn函数执行上下文:
fnContext = {
AO:{
a:,//执行过程a值得变化 undefined;5;6;20
fn2:function(){}
},
Scope:fn.[[Scope]]
}
fn2.[[Scope]] = fnContext.AO;
//fn2的执行上下文
fn2Context = {
AO:{
},
Scope:fn2.[[Scope]]
}
//fn3的执行上下文
fn3Context = {
AO:{
},
Scope:fn3.[[Scope]]
}
执行程序分析：全局环境下执行fn,在globalContext.AO中找到fn函数执行fn,第一次console.log(a),在fnContext.AO找到a只声明未赋值为undefined,对a赋值5,第二次console.log(a)结果为5,a++ a为6,var a重新声明a不会对a值产生影响,执行fn3函数进入fn3函数的执行上下文,console.log(a),先在fn3Context.AO中寻找a,全局声明的a找不到,在fn3.[[Scope]]中找到全局的var a = 1;console.log(a)即为1;随后全局的a被赋值为200,继续往下执行fn2进入fn2的执行上下文,首先在fn2Context.AO中寻找a,没有进入fn2.[[Scope]]寻找此时a为a++后的6,打印出6;随后a = 20修改了fn执行上下文的a为20;再在fn内部console.log(a),得到20;最后在全局console.log(a),此时全局的a为200;最后打印结果为undefined 5 1 6 20 200
