函数声明和函数表达式有什么区别？
1.函数声明
function foo() {}
2.函数表达式
var bar=function(){}；
1.声明的函数foo将会在执行前提升，因此foo在函数上下文都是可以被调用的，即使是在函数声明之前调用也不会报错。但是函数表达式bar，如果还没声明就调用，就会报错, 如下面代码写的，把函数表达式当做一个变量来看，调用bar的时候，bar只是被声明了，还没有被赋值，只有函数变量声明提前了，但是bar的初始化代码仍然在原来的位置,函数要等到表达式赋值完成后才能调用，所以这里会提示bar 不是一个函数。
var bar;
bar();
bar=function(){}
2.函数表达式与函数声明的最主要区别是函数名称，在函数表达式中可忽略它，从而创建匿名函数。
3.函数表达式可以作为其他函数的参数。
什么是变量的声明前置？什么是函数的声明前置
声明前置，也就是常说的提升，是一种将变量和函数的声明移到函数作用域最顶部的机制。一个变量应该包含三个阶段：
第一：声明一个变量，如 var a;
第二：给变量赋值，如var a=2；
第三：使用这个变量，console.log(a);
我们在编程的时候应该使用这种模式，但是javascript并没有遵循这个顺序，javascript的解析引擎，在执行代码之前也就是预处理阶段，创建执法环境，然后扫描js的全局代码，扫描出来之后就把用声明方式创建的函数名，和用var 定义的变量名加入到创建执法环境中（也就是作用域的顶部），这就是声明前置。
变量的声明前置：
在函数作用域内声明一个变量时，声明的变量会被提升到所在函数作用域的顶部，如果在声明之前使用这个变量，它的值就是undefined，如：
执法环境
{
a:undefined，
}
var a=5;
函数的声明前置：
只有以声明方式创建的函数才会声明前置，函数声明前置允许在所属作用域内任何地方使用该函数，即使是在声明之前也不会报错。如：
执法环境
{
f: 对函数的一个引用
}
function f(){
console.log("f")；
}
arguments 是什么？
arguments对象是所有函数中可用的局部变量,就是变量arguments是指向实参对象的引用，arguments对象是一个类数组对象（也就是说它不能能像数组一样pop,push），所以可以通过数字下标访问传入函数的实参的值，而不用通过参数名得到实参。一个函数， function f(x){},它只有一个形参，但是调用时传入了两个实参，f(1,2),第一实参可以通过x名得到，也可以通过arguments[0]得到，但是第二个实参只能通过arguments[1]得到。arguments和真正的数组一样，也有length属性，表示的是传入的实参的个数。如下
function f() {
return arguments.length;
}
f(1, 2, 3) // 3
f(1) // 1
arguments 对象仅在函数内部有效，当调用的函数的参数数量比它显式声明的参数数量多的时候，就可以使用 arguments 对象。
函数的"重载"怎样实现？
在其他面向对象的语言中，重载函数是一个共有的特性，重载是指：传给函数不同数目的参数或者不同类型的参数时，函数将执行不同的操作。
在javascript中，先定义的函数，可以被后定义的同名函数覆盖，js函数的参数可以是不定的个数，任何不确定的值都是默认为undifined，因此Javascript不可以直接使用函数的重载，但是可以通过别的方式实现：
1.arguments参数
//一个简单的发送消息的函数
function sendMessage(msg,obj){
//如果同时提供一个消息和一个对象
if(arguments.length==2){
//就把消息发送给对象
obj.handleMsg(msg);
}else {
//只显示该消息
alert(msg);
}
}
参考《面向对象编程》
2.使用if(我感觉是同一个意思),在函数体内，根据不同的参数，调用执行不同的逻辑。
function f(a,b,c){
if(a){
console.log(a);
}
if(b){
console.log(b);
}
if(c){
console.log(c);
}
}
立即执行函数表达式是什么？有什么作用？
立即执行函数是一个即使调用的函数表达式（Immediately-Invoked Function Expression），简称IIFE。可以使用立即调用的函数表达式来避免块内的变量提升 ，防止污染全局环境 。
求n!，用递归来实现
function num(n){
if(n<=1){
return 1;
}
else {
return n*num(n-1);
}
}
console.log(num(5))/120
以下代码输出什么？
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) //因为传入了三个实参
name:valley //因为把第一个参数的值改了
getInfo('小谷', 3);
name:小谷,
age:3,
sex:undefined //被省略的参数的值就变为undefined
Arguments(2) //因为传入了2个实参
name:valley //因为把第一个参数的值改了
getInfo('男');
name:男, //保留前面的参数，省略后面的参数
age:undefined,//被省略的参数的值就变为undefined
sex:undefined //被省略的参数的值就变为undefined
Arguments(1) //因为传入了1个实参
name:valley //因为把第一个参数的值改了
写一个函数，返回参数的平方和？
function sumOfSquares(){
var s1=0;
for(var i=0;i<arguments.length;i++){
s1=s1+arguments[i]*arguments[i];
}
return s1;
}
var result = sumOfSquares(2,3,4);
var result2 = sumOfSquares(1,3)
console.log(result) //29
console.log(result2) //10
如下代码的输出？为什么
console.log(a);// undefined,a声明提前了，但是赋值还在原来的位置，所以值是undefined
var a = 1;
console.log(b);//b is not defined ，b没有声明也没赋值。
如下代码的输出？为什么
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);
};
声明方式创建的函数会声明前置，函数声明前置允许在所属作用域内任何地方使用该函数，因为sayName函数以声明方式创建的，声明前置，所以可以在声明之前调用，而sayAge是以表达式的方式创建的，当变量sayAge声明提前的时候，sayAge只是被声明了，并没有初始化，所以调用函数的时候，会提示sayAge is not a function。
如下代码输出什么? 写出作用域链查找过程伪代码
var x = 10
bar()
function foo() {
console.log(x) //10
}
function bar(){
var x = 30
foo()
}
globalContext={
AO:{
x:10,
foo:function
bar:function
},
scope:null
}
fooContext={
AO：{
}
Scope:foo.[[scope]]=globalContext.AO
}
barContext={
AO:{
x:30
foo:function
},
Scope:bar.[[scope]]=globalContext.AO
}
注：在当前的执行上下文内声明的函数，该函数的[[scope]]就是当前执行上下文的AO。
所以：
foo.[[scope]]=globalContext.AO (全局上下文的活动对象)
bar.[[scope]]=globalContext.AO (全局上下文的活动对象)
代码从上到下执行，调用bar的时候，进入到bar函数内，bar内声明了局部变量x,调用了foo,程序进入foo,foo的AO为空没有声明变量x，又因为foo是在全局作用域中声明的，所以foo.[[scope]]=globalContext.AO,所以在globalContext.AO找到了变量x，console.log(x),所以x为10。
12. 如下代码输出什么? 写出作用域链查找过程伪代码
var x = 10;
bar()
function bar(){
var x = 30;
function foo(){
console.log(x) //30
}
foo();
}
globalContext={
AO:{
x:10
bar:function
}
Scope:null
}
barContext={
AO:{
x:30
foo:function
}
Scope:bar.[[scope]]=globalContext.AO
}
fooContext={
AO:{
null
}
Scope:foo.[[scope]]=barContext.AO
}
调用bar函数，在bar里声明了foo函数并调用，在调用foo函数的时候foo的AO对象是空的，所以从父级作用域链也就是barContext.AO找，在bar的AO里找到了x=30，所以最后结果是30.
13. 以下代码输出什么? 写出作用域链的查找过程伪代码
var x = 10;
bar()
function bar(){
var x = 30;
(function (){
console.log(x) //30
})()
}
globalContext={
AO:{
x:10
bar:function
}
Scope:null
}
barContext={
AO:{
x:30
function
}
Scope:bar.[[scope]]=globalContext.AO
}
function={
AO:{null}
Scope:barContext
}
}
程序进入到bar函数里的时候，bar里声明了变量x,和一个立即执行函数 ，所以执行到立即执行函数的时候，先检查函数里的活动对象有没有x,没有x,又继续沿着作用域链一层一层的往上找，所以找到了bar函数的AO中的x,
最后输出30.
以下代码输出什么？ 写出作用域链查找过程伪代码
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() //输出 undefined 5 1 6 20
console.log(a) //200
globalContext={
AO:{
a:1-->a:200
fn:function
fn3:function
}
}
进入fn(){},先扫描所有声明的变量和声明的函数，并声明前置
fnContext={
AO:{
a:undefined -->a:5--->a:(a++)=6-->var a 时 a已经存在，不变,a=6-->a=20
fn2:function
}
Scope:fn.[[scope]]=globalContext.AO
}
调用fn3(),进入fn3函数,里面没有声明a,所以在globalContext.AO中找到a=1，输出1。继续往下执行，a=200，因为fn3里没有声明a,所以把a=200赋值给globalContext.AO中的a,a=1变成a=200。
fn3Context={
AO:{}
Scope:fn3.[[scope]]=globalContext.AO
}
接着调用fn2(),进入fn2,fn2里也没有声明a,所以到fnContext.AO中找a，a=6,输出6，继续往下执行，a=20，因为fn2里没有声明a,所以把a=20赋值给fnContext.AO中的a,a=6变成a=20。再console.log(a)时，输出20，
fn2Context={
AO:{}
Scope:fn2.[[scope]]=fnContext.AO
}
最后console.log(a)，此时globalContext.AO中的a变成200。
