1.函数声明和函数表达式有什么区别
函数声明：function functionName(){}
函数表达式：var fn = function(){}
函数声明会提前，函数表达式可以省略函数名。
2.什么是变量的声明前置？什么是函数的声明前置
所谓的变量声明前置就是在一个作用域块中，所有的变量都被放在块的开始出声明。和变量声明前置一样，执行代码之前会先读取函数声明，只要函数在代码中进行了声明，无论它在哪个位置上进行声明，js引擎都会将它的声明放在范围作用域的顶部。
3.arguments 是什么
arguments是一个类数组对象，代表传给一个function的参数列表，可以在函数内部通过使用 arguments 对象来获取函数的所有参数。
4.函数的"重载"怎样实现
在JS中，没有重载。同名函数会覆盖。但可以在函数体针对不同的参数调用执行相应的逻辑。
5.立即执行函数表达式是什么？有什么作用
(function(){})()
// 作用是隔离作用域
6.求n!，用递归来实现
function recursive(n){
if (n === 1) {
return 1
}
return n*recursive(n-1)
}
console.log(recursive(4)); //24
7.以下代码输出什么？
function getInfo(name, age, sex){
console.log('name:',name); // name: 饥人谷/name: 小谷/name: 男
console.log('age:', age); // age: 2/age: 3/age: undefined
console.log('sex:', sex); // sex: 男/sex: undefined/sex: undefined
console.log(arguments); // ['饥人谷',2,'男']/['小谷',3]/['男']
arguments[0] = 'valley';
console.log('name', name); // name valley/name valley/name valley
}
getInfo('饥人谷', 2, '男');
getInfo('小谷', 3);
getInfo('男');
8.写一个函数，返回参数的平方和
function sumOfSquares(){
var sum = 0;
for (var i = 0; i < arguments.length; i++) {
sum += arguments[i]*arguments[i];
}
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); //undefined
var a = 1;
console.log(b); //报错:b is not defined
/* 由于声明前置，所以在输出a这条语句执行之前已经声明了a变量，而b变量并没有声明*/
10.如下代码的输出？为什么
sayName('world'); // hello world
sayAge(10); // 报错: sayAge is not a function
function sayName(name){
console.log('hello ', name);
}
var sayAge = function(age){
console.log(age);
};
/*由于sayName是用函数声明的方式，因此声明提前；而sayAge是采用函数表达式的方式*/
11.如下代码输出什么? 写出作用域链查找过程伪代码
var x = 10
bar()
function foo() {
console.log(x) // 10
}
function bar(){
var x = 30
foo()
}
/*
1. globalContext = {
Ao:{
x: 10,
foo: function(){},
bar: function(){}
},
Scope: null
}
//声明foo和bar时
foo.[[scope]] = globalContext.Ao
bar..[[scope]] = globalContext.Ao
2. barContext = {
Ao:{
x:30,
foo: function(){}
},
Scope: globalContext.Ao
}
3. fooContext = {
Ao:{
},
Scope: globalContext.Ao
}
*/
12.如下代码输出什么? 写出作用域链查找过程伪代码
var x = 10;
bar()
function bar(){
var x = 30;
function foo(){
console.log(x) // 30
}
foo();
}
/*
1. globalContext = {
Ao:{
x: 10,
bar: function(){}
},
Scope: null
}
//声明bar时
foo.[[scope]] = globalContext.Ao
2. barContext = {
Ao:{
x:30,
foo: function(){}
},
Scope: globalContext.Ao
}
//声明foo时
foo.[[scope]] = barContext.Ao
3. fooContext = {
Ao:{
},
Scope: barContext.Ao
}
*/
13.如下代码输出什么? 写出作用域链查找过程伪代码
var x = 10;
bar()
function bar(){
var x = 30;
(function (){
console.log(x) // 30
})()
}
/*
1. globalContext = {
Ao:{
x: 10,
bar: function(){}
},
Scope: null
}
//声明bar时
foo.[[scope]] = globalContext.Ao
2. barContext = {
Ao:{
x:30,
匿名函数:function(){}
},
Scope: globalContext.Ao
}
3. 匿名函数的Context = {
Ao:{
},
Scope: barContext.Ao
}
*/
14.如下代码输出什么? 写出作用域链查找过程伪代码
var a = 1;
function fn(){
console.log(a) //undefined
var a = 5
console.log(a) // 5
a++
var a
fn3()
fn2()
console.log(a) // 20
function fn2(){
console.log(a) // 6
a = 20
}
}
function fn3(){
console.log(a) // 1
a = 200
}
fn()
console.log(a) // 200
/*
1. globalContext = {
Ao:{
a: 200,
fn: function(){},
fn3: function(){}
},
Scope: null
}
声明fn/fn3时
fn.[[scope]] = globalContext.Ao
fn3.[[scope]] = globalContext.Ao
2. 执行fn
fnContext = {
Ao:{
a:20,
fn2:function(){}
},
Scope: globalContext.Ao
}
声明fn2时
fn2.[[scope]] = fnContext.Ao
3. 执行fn3
fn3Context = {
Ao:{
},
Scope: globalContext.Ao
}
4. 执行fn2
fn2Context = {
Ao:{
},
Scope: fnContext.Ao
}
*/
