1. 函数声明和函数表达式有什么区别
区别在于声明是否必须放到调用之前
- 函数声明不必放到调用的前面。
- 函数表达式声明必须放到调用的前面。
2. 什么是变量的声明前置？什么是函数的声明前置？
- 变量声明前置就是在一个作用域块中，所有的变量都被放在块的开始被定义，但不赋值。
- 函数的声明前置就是在一个作用域块中，所有的函数都被放在块的开始被定义，但不执行语句。
var a = 1;
function(){
console.log()
};
相当于
var a;
function(){
};//前置声明部分
a = 1;
function(){
console.log()
}
3. arguments 是什么
arguments是一个特别的变量。这个变量维护着所有传递到这个函数中的参数列表。
arguments 变量不是一个数组（Array）。 尽管在语法上它有数组相关的属性 length，但它不从 Array.prototype 继承，实际上它是一个对象（Object）。
4. 函数的"重载"怎样实现
JS中要实现“重载”函数可以在函数体针对不同的参数调用执行相应的逻辑
例如在函数体中使用多个if构成选择输出。
function(a,b,c){
if(a){
return 1;
}
if(b){
return 2;
}if(c){
return 3;
}
}
5. 立即执行函数表达式是什么？有什么作用
立即执行函数表达式是不需要调用，会被即执行的函数表达式。
// 最常用的两种写法
(function(){ /* code */ }());
(function(){ /* code */ })();
// 括号和JS的一些操作符（如 = && || ,等）可以在函数表达式和函数声明上消除歧义
// 如下代码中，解析器已经知道一个是表达式了，于是也会把另一个默认为表达式
// 但是两者交换则会报错
var i = function(){ return 10; }();
true && function(){ /* code */ }();
0, function(){ /* code */ }();
// 也可以选择一元运算符
!function(){ /* code */ }();
~function(){ /* code */ }();
-function(){ /* code */ }();
+function(){ /* code */ }();
new function(){ /* code */ }
new function(){ /* code */ }() // 带参数
作用:立即执行函数处理模块化可以减少全局变量造成的空间污染，构造更多的私有变量。
6. 求n!，用递归来实现
function factorial(n){
if(n == 1){
return 1;
}
else if (n == 0){
return 0;
}
else{
return n * factorial(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, '男');
//name:饥人谷
//age:2
//sex:男
/*[object Arguments] {
0: "饥人谷",
1: 2,
2: "男"
}
*/
//name valley
getInfo('小谷', 3);
//name:小谷
//age:3
//sex:underfined
/*[object Arguments] {
0: "小谷",
1: 3,
}
*/
//name valley
getInfo('男');
//name:男
//age:underfined
//sex:underfined
/*[object Arguments] {
0: "男",
}
*/
//name valley
8. 写一个函数，返回参数的平方和？
function sumOfSquares(a,b,c){
var sum =0,temp;
for(var i = 0; i<arguments.length; i++){
temp = arguments[i]*arguments[i];
sum = sum+temp;
}
return sum;
}
var result = sumOfSquares(2,3,4)
var result2 = sumOfSquares(1,3)
console.log(result) //29
console.log(result2) //10
9. 如下代码的输出？为什么
console.log(a);
var a = 1;
console.log(b);
var a;//声明前置
console.log(a);//underfined，a未赋值
a = 1;
console.log(b);//报错，变量b未声明
10. 如下代码的输出？为什么
sayName('world');
sayAge(10);
function sayName(name){
console.log('hello ', name);
}
var sayAge = function(age){
console.log(age);
};
输出结果
//hello world
//报错
因为function sayName(name){}的声明类型是函数声明，函数的调用可以在声明前，而var sayAge = function(age){}的声明类型是函数表达式，相当于将函数的输出结果赋值结sayAge，调用不可以在声明前面。
11. 如下代码输出什么? 写出作用域链查找过程伪代码
var x = 10
bar()
function foo() {
console.log(x)
}
function bar(){
var x = 30
foo()
}
/*1.globalContext = {
AO:{
x: 10
bar: function
foo: function
},
scope: null
}
声明 bar 时 得到下面
bar.[[scope]] = globalContext.AO
声明 foo 时 得到下面
foo.[[scope]] = globalContext.AO
调用bar函数时进行bar的执行上下文
2.barContext = {
AO:{
x: 30
},
scope: bar.[[scope]] //globalContext.AO
}
调用foo函数时进行bar的执行上下文
3.fooContext = {
AO:{
},
scope: foo.[[scope]] //globalContext.AO
}
//foo函数的执行上下文没有x的值，因此foo函数会从foo.[[scope]]即全局执行上下文寻找x的值，所以输出结果是10*/
输出结果为
10
12. 如下代码输出什么? 写出作用域链查找过程伪代码
var x = 10;
bar()
function bar(){
var x = 30;
function foo(){
console.log(x)
}
foo();
}
/*1.globalContext = {
AO: {
x: 10
bar: function
}
scope: null
}
声明bar时，同时得出
bar.[[scope]] = globalContext.AO
调用bar函数时进入bar执行上下文
2.barContext = {
AO: {
x: 30
foo: function
},
scope: bar.[[scope]]//globalContext.AO
}
声明foo时，同时得出
foo.[[scope]] = barContext.AO
调用foo函数时，进入foo执行上下文
3.fooContext = {
AO: {
},
scope: foo.[[scope]]//barContext.AO
}
foo的执行上下文中没有x，函数在foo.[[scope]]即barContext中搜寻变量x，得出x30，所以输出结果为30*/
输出结果为
30
13. 以下代码输出什么? 写出作用域链的查找过程伪代码
var x = 10;
bar()
function bar(){
var x = 30;
(function (){
console.log(x)
})()
}
/*1.globalContext = {
AO: {
x: 10
bar: function
},
scope: null
}
声明bar函数，同时得
bar.[[scope]] = globalContext.AO
调用bar函数进入bar的执行上下文
barContext = {
AO: {
x: 30
},
scope: bar.[[scope]]t//globalContext.AO
(function (){
console.log(x)
})()
该函数表达式在barContext的中执行，故x=30，输出结果30*/
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.globalContext = {
AO: {
a: 1
fn: function
fn3: function
},
scope: null
}
fn.[[scope]] = globalContext.AO
fn3.[[scope]] = globalContext.AO
2.调用fn()
fnContext = {
AO: {
a: underfied//声明前置，未赋值时为underfied
fn2: function,//同时fn2.[[scope]] = fnContext.AO
},
scope: fn.[[scope]] //globalContext
}
3.调用fn2()
fn2Context = {
AO: {
},
scope: fn2.[[scope]] //fnContext
}
4.调用fn3()
fn3Context = {
AO: {
},
scope: fn3.[[scope]] //globalContext
}
*/
4.执行代码分析
//调用fn()时进入fnContext
function fn(){
console.log(a)// fnContext.AO中a的值为underfined，输出underfined
var a = 5 // a = 5 ， fnContext.AO
console.log(a) //输出5
a++ //a = 6， fnContext.AO
var a //a = 6，属于fnContext.AO
fn3()/*输出a，同时将a赋值为200，fn3Context.AO中没有a，从scope: fn3.[[scope]] //globalContext查找a，a的值为1，输出1；
同时使globalContext中的a = 200*/
fn2()/*输出a，同时将a赋值为20，fn2Context.AO中没有a，从scope: fn2.[[scope]] //fnContext查找a，a的值为6，输出6；
同时使fnContext中的a = 20*/
console.log(a)// 输出fnContext.AO中的a，即20
function fn2(){
console.log(a)
a = 20
}
}
所以fn()的输出结果是
fn()
underfined
5
1
6
20
最后
console.log(a)//输出globalContext.AO中的a，a = 200
200
