问答题
1. 函数声明和函数表达式有什么区别
1.函数声明必须有标识符，也就是常说的函数名；函数表达式可以省略函数名。
函数声明（要带标识符）
function functionName(arg1, arg2, ...){
<!-- function body -->
}
函数表达式
- 省略标识符：
var variable=function(arg1, arg2, ...){
<!-- function body -->
}
- 带有标识符：
var variable=function functionName(arg1, arg2, ...){
<!-- function body -->
}
2.函数声明会提前
sayTruth();<!-- 函数声明 -->
function sayTruth(){
alert('myvin is handsome.');
}
sayTruth();<!-- 函数表达式 -->
var sayTruth=function(){
alert('myvin is handsome.');
}
即函数声明的话sayTruth()可以提前调用，而函数表达式是什么时候遇到什么时候执行。
3.ECMAScript规范中表示，函数声明语句可以出现在全局代码中，或者内嵌在其他函数中，但是不能出现在循环、条件判、或者try/finally以及with语句中；而函数表达式可以在任何地方声明.
2. 什么是变量的声明前置？什么是函数的声明前置
- 变量的声明前置
JavaScript引擎的工作方式是，先解析代码，获取所有被声明的变量，然后再一行一行地运行。这造成的结果，就是所有的变量的声明语句，都会被提升到代码的头部，这就叫做变量提升
console.log(xxx); // Uncaught ReferenceError: xxx is not defined
我们在使用一个变量之前必须声明变量，但是由于变量提升，我们如果声明了变量，即使在声明语句前使用也是可以的，只不过其值是初始值undefined
console.log(xxx); // undefined
var xxx = 2;
- 函数的声明前置
和变量的声明会前置一样，函数声明同样会前置，如果我们使用函数表达式那么规则和变量一样;
console.log(fn); //undefined
var fn = function(){}
如果我们使用函数声明的方式，那么即使函数写在最后也可以在前面语句调用，前提是函数声明部分已经被下载到本地
fn(); // "1"
function fn(){
console.log('1');
}
3.arguments 是什么
在函数内部,你可以使用arguments对象获取到该函数的所有传入参数
function printPersonInfo(name, age, sex){
console.log(name);
console.log(age);
console.log(sex);
console.log(arguments);
}
printPersonInfo("Bob", 22, "male");
//输出：
// Bob
// 22
// male
// ["Bob", 22, "male"]
4.函数的重载怎样实现
重载是很多面向对象语言实现多态的手段之一，在静态语言中确定一个函数的手段是靠方法签名——函数名+参数列表，也就是说相同名字的函数参数个数不同或者顺序不同都被认为是不同的函数，称为函数重载
在JavaScript中没有函数重载的概念，函数通过名字确定唯一性，参数不同也被认为是相同的函数，后面的覆盖前面的.
function sum(a,b){
var sum=0;
sum=a+b;
return sum;
}
function sum(a,b,c){
var sum=0;
sum=a+b+c;
return sum;
}
console.log(sum(1,2));//NaN
console.log(sum(1,2,3));//6
实现方法：
function sum(){
var sum=0;
for(var i=0;i<arguments.length;i++){
sum+=arguments[i];
}
return sum;
}
console.log(sum(1,2,3));//6
console.log(sum(1,2));//3
5. 立即执行函数表达式是什么？有什么作用
1.立即执行函数就是：
- 声明一个匿名函数
- 马上调用这个匿名函数
下面是一个典型的立即执行函数：
0_1481618156231_2509778-0a9edfdef63e74c7.png
注意要将匿名函数包起来，若直接写function(){console.log("我是一个匿名函数");则报错
function(){console.log("我是一个匿名函数");
//Uncaught SyntaxError: Unexpected token (
你必须让浏览器知道你声明的这个匿名函数是要用的才行，也就是当函数被理解成表达式时就会执行，比如下面几种写法：
(function(){alert('我是匿名函数')} ()) // 用括号把整个表达式包起来
(function(){alert('我是匿名函数')}) () // 用括号把函数包起来
!function(){alert('我是匿名函数')}() // 我们不在意值是多少，只想通过语法检查。
+function(){alert('我是匿名函数')}()
-function(){alert('我是匿名函数')}()
~function(){alert('我是匿名函数')}()
void function(){alert('我是匿名函数')}()
new function(){alert('我是匿名函数')}()
前面两种对整个表达式的值没有影响，其他的在使用时可以注意一下。
-
立即执行函数的作用
作用只有一个：创建一个独立的作用域。这个作用域里面的变量，外面访问不到（避免了变量污染）。
比如下面这个例子:不管单击哪个item，alert出来的总是6，而不是0、1、2、3、4、5。
因为i是贯穿整个作用域的（即window下的），而不是给每个div分配一个i。for循环执行完后i已经变成6了（注意不是5），然后用户一定是在for循环运行完之后才点击的，此时i的结果已经为6了.
<div class="wrap">
<div class="item">0</div>
<div class="item">1</div>
<div class="item">2</div>
<div class="item">3</div>
<div class="item">4</div>
<div class="item">5</div>
</div>
<script src="http://apps.bdimg.com/libs/jquery/1.9.1/jquery.js"></script>
<script>
var items = $(".item");
for(var i=0; i<items.length; i++){
items[i].onclick = function(){
alert(i);
}
}
</script>
- 那我们怎么解决这个问题呢？明显我们要给每个div创建一个独立的作用域，一种方法就是用立即执行函数。
var items = $(".item");
for(var i=0; i<items.length; i++){
(function(n){
items[n].onclick = function(){
alert(n);
}
})(i);
}
for循环每执行一次立即执行函数也跟着执行一次，并且保存在内存中。在立即执行函数执行的时候，i 的值被赋值给 n，此后 n 的值一直不变。
i 的值从 0 变化到 5，对应 6 个立即执行函数，这 6 个立即执行函数里面的 div分别是 0、1、2、3、4、5。
6.什么是函数的作用域链
在JavaScript中，函数也是对象，实际上，JavaScript里一切都是对象。函数对象和其它对象一样，拥有可以通过代码访问的属性和一系列仅供JavaScript引擎访问的内部属性。其中一个内部属性是[[Scope]]，由ECMA-262标准第三版定义，该内部属性包含了函数被创建的作用域中对象的集合，这个集合被称为函数的作用域链，它决定了哪些数据能被函数访问。
当一个函数创建后，它的作用域链会被创建此函数的作用域中可访问的数据对象填充。例如定义下面这样一个函数：
function add(num1,num2) {
var sum = num1 + num2;
return sum;
}
在函数add创建时，它的作用域链中会填入一个全局对象，该全局对象包含了所有全局变量，如下图所示（注意：图片只例举了全部变量中的一部分）：
函数add的作用域将会在执行时用到。例如执行如下代码：
var total = add(5,10);执行此函数时会创建一个称为“运行期上下文(execution context)”的内部对象，运行期上下文定义了函数执行时的环境。每个运行期上下文都有自己的作用域链，用于标识符解析，当运行期上下文被创建时，而它的作用域链初始化为当前运行函数的[[Scope]]所包含的对象。
这些值按照它们出现在函数中的顺序被复制到运行期上下文的作用域链中。它们共同组成了一个新的对象，叫“活动对象(activation object)”，该对象包含了函数的所有局部变量、命名参数、参数集合以及this，然后此对象会被推入作用域链的前端，当运行期上下文被销毁，活动对象也随之销毁。新的作用域链如下图所示：
在函数执行过程中，没遇到一个变量，都会经历一次标识符解析过程以决定从哪里获取和存储数据。该过程从作用域链头部，也就是从活动对象开始搜索，查找同名的标识符，如果找到了就使用这个标识符对应的变量，如果没找到继续搜索作用域链中的下一个对象，如果搜索完所有对象都未找到，则认为该标识符未定义。函数执行过程中，每个标识符都要经历这样的搜索过程。
简单总结: 以函数为例：函数定义时（或被声明时），此时会生成一个全局执行期上下文，函数每次执行都会产生一个自己唯一的执行期上下文，然后和之前函数定义产生的执行期上下文形成栈式作用域链，全局位于栈底，而刚生成上下文位于栈顶，访问时，优先访问栈顶执行期上下文，若没有目标，再往下寻找，依次规则，一般全局变量都是被最后访问的，所以尽量少定义全局变量。
代码题
1.以下代码输出什么？ （难度**）
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('hunger', 28, '男');
//name: hunger
//age: 28
//sex: 男
//["hunger", 28, "男"]
//name valley
getInfo('hunger', 28);
//name: hunger
//age: 28
//sex: undefined
//["hunger", 28]
//name valley
getInfo('男');
//name: 男
//age: undefined
//sex: undefined
//["男"]
//name valley
2. 写一个函数，返回参数的平方和？如 （难度**）
function sumOfSquares(){
var sum=0;
for(var i=0;i<arguments.length;i++){
sum+=arguments[i]*arguments[i];
}
return sum;
}
console.log(sumOfSquares(2,3,4)); // 29
console.log(sumOfSquares(1,3)); // 10
3. 如下代码的输出？为什么 （难度*）
console.log(a);//undefined
var a = 1;
console.log(b);// Uncaught ReferenceError: b is not defined(…)
变量提升，相当于：
var a；
console.log(a);
a = 1;
console.log(b);
4.如下代码的输出？为什么 （难度*）
sayName('world');//hello world
sayAge(10);//Uncaught TypeError: sayAge is not a function(…)
function sayName(name){
console.log('hello ', name);
}
var sayAge = function(age){
console.log(age);
};
相当于：
var sayAge;
function sayName(name){
console.log('hello ', name);
}
sayName('world');
sayAge(10);
sayAge = function(age){
console.log(age);
};
5.如下代码的输出？为什么 （难度**）
function fn(){}
var fn = 3;
console.log(fn);//3
相当于
var fn;
function fn(){}
fn = 3;
console.log(fn);//3
先函数的声明覆盖变量的声明，然后变量的赋值覆盖函数的声明。
6.如下代码的输出？为什么 （难度***）
function fn(fn2){
console.log(fn2);
var fn2 = 3;
console.log(fn2);
console.log(fn);
function fn2(){
console.log('fnnn2');
}
}
fn(10);
输出
function fn2(){
console.log('fnnn2');
}
3
function fn(fn2){
console.log(fn2);
var fn2 = 3;
console.log(fn2);
console.log(fn);
function fn2(){
console.log('fnnn2');
}
}
相当于
function fn(fn2){
var fn2
function fn2(){
console.log('fnnn2');
}
console.log(fn2);
fn2 = 3;
console.log(fn2);
console.log(fn);
}
fn(10);
7.如下代码的输出？为什么 （难度***）
var fn = 1;
function fn(fn){
console.log(fn);
}
console.log(fn(fn)); // Uncaught TypeError: fn is not a function(…)
相当于
var fn ;
function fn(fn){
console.log(fn);
}
fn = 1;
console.log(fn(fn)); //最后 fn=1，无法使用fn( )
8.如下代码的输出？为什么 （难度**）
//作用域
console.log(j); //undefined
console.log(i); //undefined
for(var i=0; i<10; i++){
var j = 100;
}
console.log(i); //10
console.log(j); //100
for循环不会建立局部变量，仍是全局变量，for循环结束后i=10，j=100
相当于
var i,j;
console.log(j); //undefined
console.log(i); //undefined
for(var i=0; i<10; i++){
var j = 100;
} //此时i=10，j=100
console.log(i); //10
console.log(j); //100
9.如下代码的输出？为什么 （难度****）
fn();
var i = 10;
var fn = 20;
console.log(i);
function fn(){
console.log(i);
var i = 99;
fn2();
console.log(i);
function fn2(){
i = 100;
}
}
输出：
undefined
100
10
相当于：
var i;
var fn ;
function fn(){
var i;
function fn2(){
i = 100;
}
console.log(i);//undefined
i = 99;
fn2(); //此时调用fn2( ) i=100
console.log(i);//100
}
fn();
i = 10;
fn = 20;
console.log(i);//10
10.如下代码的输出？为什么 （难度*****）
var say = 0;
(function say(n){
console.log(n);
if(n<3) return;
say(n-1);
}( 10 ));
console.log(say);
依次输出：10,9,8,7,6,5,4,3,2,0
括号内是一个立即执行函数，创建了一个独立的作用域，这个作用域里的变量，外面访问不到。第一次传入参数10，打印10，由于n=10不满足条件(n<3)，于是执行函数say(n-1)，打印9,接着是8,7......3,2，当n=2时，满足条件(n<3)，于是跳出函数，执行console.log(say);,打印0。
