1.函数声明与函数表达式有什么区别
函数声明： function myFunction(){}
函数表达式：var myFunction = function(){}
函数声明会前置，函数调用可以放在函数声明之前。但是函数表达式不会前置，函数调用需放到函数表达式之后。
2.变量的声明前置与函数的声明前置
变量声明前置：变量声明前置就是在一个作用域块中，所有的变量都被放在块的开始作出声明
console.log(a) // Uncaught ReferenceError: a is not defined
console.log(a) // undefined 不再报错，因为变量声明前置了，
var a=1;
函数声明前置：JavaScript解释器允许在函数声明之前使用函数，此时不仅仅是函数名被前置了，整个函数定义也被前置了，所以就可以直接调用函数
myFunction(); //hello world
function myFunction(){
console.log("hello world");
}
3.什么是arguments
arguments可以用来获取函数所有传入的参数
function printPersonInfo(name, age, sex){
console.log(arguments);
}
printPersonInfo('cz', 24, 'male');
/*
0 : 'cz'
1 : 24
2 : 'male'
*/
4.函数的重载
在js中是没有函数的重载，同名函数只会覆盖，但可以在函数体针对不同的参数调用执行相应的逻辑
function printPeopleInfo(name, age, sex){
if(name){
console.log(name);
}
if(age){
console.log(age);
}
if(sex){
console.log(sex);
}
}
printPeopleInfo('Byron', 26); // Byron 26
printPeopleInfo('Byron', 26, 'male'); // Byron, 26, male
5.立即执行函数表达式是什么？有什么作用？
立即执行函数表达式：(function(){})() (function fn1(){}) 等
可以立即执行函数，同时也可以闭包，此中的变量外面不能访问，避免变量污染。
6.求n!,用递归的方式
function factorial(n){
if( n===0 || n===1 ){
return 1;
}
else if( n<0 ){
return "负数没有阶乘"；
}
else{
return n*factorial(n-1);
}
}
7.实例1（arguments）
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：男
['饥人谷',24,'男']
name valley
*/
getInfo('小谷', 3);
/*
name : 小谷
age：3
sex：undefined
['小谷',3]
name valley
*/
getInfo('男');
/*
name : 男
age：undefined
sex：undefined
['男']
name valley
*/
8.写一个函数返回参数的平方和
function sumOfSquares(){
var sum = 0;
for(var i=0; i9.实例2（变量声明前置）
console.log(a); // undefined 变量声明前置
var a = 1;
console.log(b); // Uncaught ReferenceError: a is not defined b未声明
10.实例3（函数声明前置与函数表达式）
sayName('world'); // hello world 函数声明前置，可以正常使用
sayAge(10); //error sayAge函数表达式只能在定义后使用，不能再前面使用
function sayName(name){
console.log('hello ', name);
}
var sayAge = function(age){
console.log(age);
};
11.实例4（作用域链）
var x = 10
bar() // 10
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
fooContext = {
AO:{},
Scope: globalContext.AO
}
barContext = {
AO:{
x:30
},
Scope: globalContext.AO
}
12.实例5（作用域链2）
var x = 10;
bar() // 30
function bar(){
var x = 30;
function foo(){
console.log(x)
}
foo();
}
其具体过程
globalContext = {
AO: {
x: 10
bar: function
},
Scope: null
}
bar.[[scope]] = globalContext.AO
barContext = {
AO:{
x:30
foo:function
},
Scope: globalContext.AO
}
foo.[[scope]] = barContext.AO
fooContext = {
AO:{},
Scope: barContext.AO
}
13.实例6（作用域链3）
var x = 10;
bar() // 30
function bar(){
var x = 30;
(function (){
console.log(x)
})()
}
此例中立即执行函数 (function(){})() 就相当于实例5中 先在函数bar中定义
foo函数，接着在写一行foo()来执行foo()函数过程是一样的，只不过立即执行函数
把函数的名字省略了。
14.实例7（作用域链4）
var a = 1;
function fn(){
console.log(a) // undefined
var a = 5
console.log(a) // 5
a++
var a
fn3() // 1
fn2() // 6
console.log(a) // 20
function fn2(){
console.log(a)
a = 20
}
}
function fn3(){
console.log(a)
a = 200
}
fn()
console.log(a) // 200
其作用域链查找过程伪代码
globalContext = {
AO : {
a : 1,
fn : function,
fn3 : function
}
Scope: null
}
fn.[[scope]] = globalContext.AO
fn3.[[scope]] = globalContext.AO
fnContext = {
AO: {
a : 5,
fn2 : function
}
Scope : globalContext.AO
}
fn2.[[scope]] = fnContext.AO
fn2Context = {
AO : {}
Scope : fnContext.AO
}
fn3Context = {
AO : {}
Scope : globalContext.AO
}