函数与作用域
1. 函数声明和函数表达式有什么区别？
-
函数声明：
形式上 function fuctionName(){//statement};声明了一个名字为functionName的函数，浏览器解析的时候，先要做函数声明前置，在globlecontext的AO中，声明此函数，此时，你在全球作用域下（包括函数声明之前的位置）调用，都可以找到这个函数。 -
函数表达式：
形式上 var someThing=fuction (){//statement};虽然这也是声明了一个函数（匿名的），但实际上浏览器解析的时候，先做的是变量提升，在globlecontext的AO中，声明的是一个变量，假如，在函数声明之前调用该函数，是不能够找到这个函数的，因为调用的时候必然要调用的someThing这个变量，但是变量值在提升变量的时候未给出。
2.什么是变量的声明前置？什么是函数的声明前置
-
变量的声明前置:
变量的声明前置就是在函数内部，首先要做的事也是类似于浏览器做变量提升，先在当前上下文的AO中声明这个变量。 -
函数的声明前置：
函数的声明前置是，当我们用函数声明来声明一个函数时，函数就会在至当前上下文的AO中声明这个这个函数，同时，在函数内部的上下文的scope中，给声明的函数开辟一个空间，并指向父元素的AO.
3.arguments是什么？
- arguments是一个伪类数组，目前仅仅知道，他是一个函数内部自带的一个类似于数组的参数，我们可以调用arguments[],来获取传入函数内部的参数，并且支持索引，支持length属性。
4.函数的"重载"怎样实现？
- 首先，JS中不同于其他语言，没有重载，例如其他语言中，我们可以设定。但是我们可以控制函数体内部的逻辑语句来实现重载。
例如：
<script language="JavaScript">
function f(length)
{
alert("高为："+length);
}
function f(length,width)
{
alert("高为："+length+"，宽为："+width);
}
</srcipt>
/* 上面这个段代码行不通，第一个函数会被第二个覆盖，不能实现 f(10)想要的效果。*/
但是我们可以这么做
<script language="JavaScript">
function f(length)
{
var len= arguments.length;
if(1 == len)
{
var width = arguments[1];
alert("高为："+length+"，宽为："+width);
}
else
{
alert("高为："+length);
}
}
</srcipt>
5.立即执行函数表达式是什么？有什么作用？
- 立即执行表达式是什么?
（function (){})();
(function(){}());
上面就是两个常见的立即执行表达式，当我们建立一个匿名函数时，并希望他执行时，我们想到可以这样 function (){}(); 但是实际上，语法上不对，因为浏览器读到这里时，会认为这是一个函数声明，但是没有给出函数名字，所以会报错。但是我们在 function (){}加上括号，意义就不一样了，因为JS中小括号内部是一个表达式，表达式后面加括号，函数可以立即执行的， 和函数表达式声明一样
var something= functiong (){
console.log ( "hello")
}();
所以，我们只需要让浏览器明白，我们前面function (){} 是一个函数表达式就可以了，类似的方法有许多，而已加上各种运算符，让浏览器知道，我们这是一个函数表达式，这就可以了。类似的有很多。
-
为什么要用立即执行函数表达式？
因为JS并没有块级作用域的概念，你在全局或者局部声明的变量 极有可能会被自己或者他人覆盖掉，为了保护这些的变量，我们可以给他加上一层外壳，封装起来，这样，外部变量就不会对内部的变量造成影响了。
求n!，用递归来实现
function doRecursion(n){
if(n<0){
console.log('You input a wrong number');
}
else if(n===0||n===1){
return 1;
}
else if(n>0){
return n*multiply(n-1);
}
}
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, '男');
getInfo('小谷', 3);
getInfo('男');
// 倒数第三行调用函数 ，输出 name: 饥人谷,age:2,sex：男；['饥人谷'，2,'男‘],name:valley
// 倒数第二行调用函数，输出 name:小谷，age:3;sex:undefined;['小谷',3,]；name:valley;
//最后一行调用函数，输出name:男，age:undefined;sex:undefined;['男'];
name:valley;
8.写一个函数，返回参数的平方和？
function sumOfSquares(){
var sum=0;
for (var i=0;i<arguments.length;i++){
sum=sum+arguments[i]*arguments[i];
}
return sum;
}
var result = sumOfSquares(2,3,4);
var result2 = sumOfSquares(1,3);
console.log(result) ;
console.log(result2) ;
9.如下代码的输出？为什么
console.log(a); //undefined,变量提升，有变量a，但是没有值。
var a = 1;
console.log(b);//error ,没有定义这个变量。
10.如下代码的输出？为什么
sayName('world'); //hello,world.
sayAge(10);//报错 。
function sayName(name){
console.log('hello ', name);
}
var sayAge = function(age){
console.log(age);
};
第一个函数能输出是因为，函数声明前置，可以找到globleContext的OA中有这个函数，然后就可以去执行这个函数的上下文。
第二个变量提升，浏览器不知道sayAge(10)是什么意思，如果放在函数表达式后面，浏览器就知道原来这个sayAge()是一个函数表达式，就会执行了。
11.如下代码输出什么? 写出作用域链查找过程伪代码
var x = 10
bar()
function foo() {
console.log(x)
}
function bar(){
var x = 30
foo()
}
第一步：
globleContext{
A0:{
x:10,
function foo(),
bar(),
}
scope:null;
}
foo().[[scope]]=globleContext.AO
bar().[[scope]]=globleContext.AO
第二步：
执行bar();
在globloContext.AO中找到了 bar();
调用bar();进入bar()函数的barContext
barContext：{
AO:{
x:30,
}
scope:globleContext.AO
}
barContext.AO中没有找到 foo();然后去scope中找，scope指向globleContext.AO， 找到右foo();调用foo();
fooContext:{
AO:{
x:undefined,
}
scope:globleContext.AO
}
执行console.log(x);
但是在AO中没有找到，去scope中找到指向globleContext.AO,找到x的值为10，所以，最终结果就是10。
12.如下代码输出什么? 写出作用域链查找过程伪代码
var x = 10;
bar()
function bar(){
var x = 30;
function foo(){
console.log(x)
}
foo();
}
globleContext: {
AO:{
x:10,
function bar(),
}
scope:null
}
bar.[[scope]]=globleContext.AO;
//第二部；
执行bar(); 在globleContext中找到。
进入bar();
barContext:{
AO:{
x=30;
function foo();
}
scope:globleContext.AO
}
foo.[[scope]]=barContext.AO；
执行 foo();
foo()中没有找到x.去barContext.AO找到了。所以console.log(x);
结果是10。
13. 以下代码输出什么? 写出作用域链的查找过程伪代码
var x = 10;
bar()
function bar(){
var x = 30;
(function (){
console.log(x)
})()
}
1、执行bar(),globleContext中有bar()
2 、进入bar()的上下文；
3、执行立即执行函数表达式，但是函数表达式AO中没有找到X,
4、去scope中找，找到的是barContext.AO中，有x的值，得到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)
1、执行fn() 在globleContext中找到了，所以，进入fn()的上下文。
2、console.log(a),当前函数的作用域中有a变量，此时没有赋值//输出 **undefined**
3、再次执行console.log(a),上一行，a已经赋值，所以//输出 **5**
4、a++ ; a=6,不用输出。
5、var a, a仍然等于6.
6、执行fn3() ,当前函数的AO中没有，找到globleContext.AO,有fn3(),进入fn3()的上下文中。
7、console.log(a),当前的AO还没有a，所以，去找到上一级的AO,找到globleContext.AO,然后，得到结果// **1**,顺便，修改了globleContext.AO中的a=200;
8、回到fn(),运行fn2(),找到了fn2(),进入fn2(), console.log(a), 当前AO中没有a,找到上一级也就是fn的AO中，a=6 ,所以输出 ** 6 ** ，顺便修改了fnContext中的AO,是20 。
9、执行fn()中的console.log(a)，此时受到第8步骤的影响，所以，输出是**20.**
10 、fn()运行结束，此时，再次运行console.log，受到第7 的影响，a变为了200.所以输出**200**
