1.函数声明和函数表达式有什么区别?
函数声明：function functionName(){}
函数表达式：var fn = function(){}
函数声明会提前，不论执行语句的位置在哪皆可调用该函数。函数表达式必须在表达式执行完后，函数才存在并可以被调用。
函数声明会提前，函数表达式可以省略标识符（函数名）。
2.什么是变量的声明前置？什么是函数的声明前置
在同一个作用域下，var 声明的变量和 function 声明的函数会前置，也就是不管这些声明在作用域的什么地方，JavaScript 的解析器先统一把它们全部按顺序放在执行上下文的最前面，先赋值为undefined，再按顺序执行语句然后才开始执行后面的语句。
函数声明前置：JS自动把function声明的函数提到前面，因此调用函数时不需要考虑函数调用与声明的位置关系
在 JavaScript 中，只有全局作用域和函数作用域，没有块作用域
在函数作用域中，var 声明的变量和 function 声明的函数也会前置，跟在全局作用域中的行为一致
- arguments 是什么
是一个类数组对象，它包含了函数的所有实参。
argument是类数组对象，每个函数中都存在argument对象，argument并不是一个真正的数组，所以不具备除length属性之外的属性，这个对象维护着所有传入该函数的参数列表，通过arguments[1、2、3]等...可以获取到相应的传入参数
function foo(a,b) {
console.log(a);
console.log(b);
console.log(arguments);
}
foo(1,2);
//1
//2
//[1, 2]
- 函数的"重载"怎样实现
重载是函数具有相同的名字，根据传入的参数不同，执行不同操作。在js中没有类似其他语言的重载，因为同名函数会被覆盖。但是js可以通过在函数内部对传入参数进行判断来达到重载的目的。
所谓重载，就是定义两个或多个同名的函数，分别设置不同的参数个数、类型。在调用函数时，通过检测传入参数的个数、类型，来执行不同的函数体语句，以达到一个函数名，多种用法的目的。
但是在 JavaScript 中，没有重载。同名函数，前面声明的会被后面声明的覆盖，不过可以在函数体内部，针对不同的参数调用，执行相应的逻辑（用 if 语句判断）。
function fn(name,age,sex) {
if (name) {
console.log(name);
}
if (age) {
console.log(age);
}
if (sex){
console.log(sex);
}
}
fn('luoqian');
fn('luoqian',21);
fn('luoqian',21,'female');
or
function doAdd() {
if(arguments.length == 1) {
alert(arguments[0] + 5);
} else if(arguments.length == 2) {
alert(arguments[0] + arguments[1]);
}
}
doAdd(10); //输出 "15"
doAdd(40, 20); //输出 "60"
立即执行函数表达式是什么？有什么作用？
立即执行函数表达式就是声明一个函数，同时马上调用它，把声明和调用合用写成一个语句。
它有多种写法：
(function() {})();
(function() {});
[function() {}];
1, function() {};
它的作用：隔离作用域，避免变量污染全局
- 求n!，用递归来实现
递归的思想：是指在函数在定义中自己调用自己
一个比喻帮助理解：我们查词典的过程就是递归，为了解释一个词，需要使用更多的词。当你查一个词，发现这个词的解释中某个词仍然不懂，于是你开始查这第二个词，可惜，第二个词里仍然有不懂的词，于是查第三个词，这样查下去，直到有一个词的解释是你完全能看懂的，那么递归走到了尽头，然后你开始后退，逐个明白之前查过的每一个词，最终，你明白了最开始那个词的意思。
类推：n的阶乘，就是n乘(n-1)的阶乘，一直顺推到1的阶乘是1，作为终止条件。再逆推2的阶乘是2x(1的阶乘)),3的阶乘是3x(2的阶乘)，4的阶乘是4x(3的阶乘)......
function factor(n){
if (n === 1) { return 1 }//终结点
return n * factor(n-1);
}
console.log(factor(4)); //输出24；
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: 男
["饥人谷", 2, "男"]
name valley
*/
getInfo('小谷', 3);
/* name: 小谷
age: 3
sex: undefined
["小谷", 3]
name valley
*/
getInfo('男');
/* name: 男
age: undefined
sex: undefined
["男"]
name valley
*/
8 . 写一个函数，返回参数的平方和？
function foo(){
var result = 0;
for(var i = 0; i < arguments.length;i++){
result +=arguments[i]*arguments[i]
}
return result
}
foo(3,4)//25
9.如下代码的输出？为什么
console.log(a); //声明提前，但是未赋值所以为undefined
var a = 1;
console.log(b); //会报错，b is not defined
10.如下代码的输出？为什么?
sayName('world'); //hello world,因为函数声明前置
sayAge(10); //sayAge is not a function函数表达式只将函数表达式里的sayAge前置，此时还未赋值，所以以函数的方式调用会报错
function sayName(name){
console.log('hello ', name);
}
var sayAge = function(age){
console.log(age);
};
- 如下代码输出什么? 写出作用域链查找过程伪代码
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
barContext = {
AO:{
x:30
},
Scope:bar.[[scope]]//globalContext.AO
}
fooContext = {
AO:{},
scope:foo.[[scope]] //globalContext.AO
}
以下代码会输出什么？
var x = 10;
bar()
function bar(){
var x = 30;
(function(){
console.log(x)
}())
}
globalContext ={
AO:{
x:10,
bar:function(){}
},
Scope:null
}
//函数声明时候就会得到下面
bar.[[scop]] = globaltext.AO
bartContext ={
AO:{
x:30,
},
Scope:bar.[[scop]] = globaltext.AO
}
function.[[scope]]=barCOntext
functionCOntext = {
AO:{}
scope:function.[[scope]]=barContext.AO
}
在匿名函数的AO中找不到x,于是从scope指向的barContext.AO上找找到x=30所以输出的是30
下面代码会输出什么
var a = 1;
function fn(){
console.log(a)//underfined
var a = 5
console.log(a)//5
a++
var a
fn3()
fn2()
console.log(a,'a')//20
function fn2(){
console.log(a)//6
a = 20
}
}
function fn3(){
console.log(a)//1
a = 200
}
fn()
console.log(a)//200
globalContext ={
AO:{
a:1=>200,
fn:function(){}
fn3:function(){}
},
Scope:null
}
fn.[[scope]]=globalContext.AO
fn3.[[scope]]=globalContext.AO
fnContext = {
AO:{
a:undefined =>5=>6=>20,
fn2:function(){}
},
Scope:fn.[[scope]]=globalContext.AO
}
fn2.[[scope]] =fnContext.AO
fn2Context ＝{
AO:{
},
Scope:fn2.[[scope]]=fnContext.AO
}
fn3Context = {
AO:{
},
Scope:fn3.[[scope]]=globalContext.AO
}
