1. 函数声明和函数表达式有什么区别
//函数声明
function fn() {
console.log('hello');
}
//函数表达式
var fn = function() {
console.log('hello');
}
对于函数声明来说， 声明不必放在调用之前。但是对于函数表达式来说，声明必须放在调用之前。
因为Javascript解释器中存在一种变量声明被提升的机制，也就是说函数声明会被提升到作用域的最前面，即使写代码的时候是写在最后的。用函数表达式创建的函数是在运行时赋值，并且要在等到表达式赋值完成之后才能调用。
总结：
函数声明在JS解析时进行函数提升，因此在同一个作用域内，不管函数声明在哪里定义，该函数都可以被调用；而
函数表达式的值是在运行时确定，并且在表达式赋值完成之后，该函数才能被调用。
2. 什么是变量的声明前置？什么是函数的声明前置
变量的声明前置指的是在一个作用域中，所有的变量声明都会被放在作用域的开头。如：
// var a 变量提升到开头 声明
console.log(a) //undefined
var a = 7;
console.log(a); // 7
函数的声明前置指的就是声明函数表达式，将函数作为一个变量来声明，调用必须在声明之后，否则会报错。
3. arguments 是什么
在函数的内部可以使用arguments对象获取到该函数的所有传入参数。arguments对象是所有函数都可以使用的局部变量。此对象包含传递给函数的每个参数的条目，第一个条目从索引0开始。arguments对象不是一个Array。但类似于Array,但除了长度以为没有任何Array属性。但可以转化成一个真正的Array
var args = Array.prototype.slice.call(arguments);
var args = [].slice.call(arguments);
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);
printPeopleInfo('Byron', 26, 'male');
5. 立即执行函数表达式是什么？有什么作用
立即执行表达式（IIFE）
//立即执行函数表达式，
(function(){
var a = 1;
})();
console.log(a); //undefined.使用立即执行函数表达式，可以隔离作用域
//其他写法
(function fn1() {});
// 在数组初始化器内只能是表达式
[function fn2() {}];
// 逗号也只能操作表达式
1, function fn3() {};
使用立即执行函数表达式的目的：
- 不必为函数命名，避免了污染全局变量
- IIFE内部形成了一个单独的作用域，可以封装一些外部无法读取的私有变量。
6. 求n!，用递归来实现
function factorial(n) {
if (n === 1) {
return 1
} 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:男 ;['饥人谷',2,'男'] ;name:valley
getInfo('小谷', 3);//name: 小谷; age: 3;sex:undefined;['小谷','3']；name:valley
getInfo('男'); //name: undefied;age:undefned;sex:男;['男']；name: valley
8. 写一个参数返回参数的平方和
function sumOfSquares(){
var arr = Array.prototype.slice.call(arguments);
var total = 0;
arr.map(function(value) {
total = total + value * value;
});
return total;
}
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); //error
//变量a声明提升,打印前没有赋值，所以undefined。变量b完全没有声明，所以报错。
10. 如下代码的输出？为什么？
sayName('world');
sayAge(10);
function sayName(name){
console.log('hello ', name);
}
var sayAge = function(age){
console.log(age);
};
//hello world
//error
//函数声明 ，调用的时候 可以不看位置。函数表达式声明，由于声明前置的问题，必须先声明，后调用。
11. 如下代码输出什么? 写出作用域链查找过程伪代码
var x = 10
bar()
function foo() {
console.log(x)
}
function bar(){
var x = 30
foo()
}
// 10
/*
globalContext = {
A0 = {
x: 10
foo: function
bar: function
},
Scope: null
}
foo.[[scope]] = globalContext.A0
bar.[[scope]] = globalContext.A0
barContext = {
A0 = {
x: 30
}
Scope: bar.[[scope]]
}
fooContext = {
A0 = {}
Scope: foo.[[scope]] //globalContext.A0
}
*/
12. 如下代码输出什么? 写出作用域链查找过程伪代码
var x = 10;
bar()
function bar(){
var x = 30;
function foo(){
console.log(x)
}
foo();
}
// 30
/*
globalContext = {
A0 = {
x: 10
bar: function
},
Scope: null
}
bar.[[scope]] = globalContext.A0
barContext = {
A0 = {
x: 30
foo: function
}
Scope: bar.[[scope]]
}
foo.[[scope]] = barContext.A0
fooContext = {
A0 = {
x: 30
}
Scope: foo.[[scope]] //barContext.A0
}
*/
13. 以下代码输出什么? 写出作用域链的查找过程伪代码
var x = 10;
bar()
function bar(){
var x = 30;
(function (){
console.log(x)
})()
}
// 30
/*
globalContext = {
A0 = {
x: 10
bar: function
},
Scope: null
}
bar.[[scope]] = globalContext.A0
barContext = {
A0 = {
x: 30
IIFE: function
}
Scope: bar.[[scope]]
}
IIFE.[[scope]] = barContext.A0
*/
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)
//undefined
//5
//1
//6
//20
//200
/*
globalContext = {
A0 = {
a: 1 -> 200
fn: function
fn3: function
},
Scope: null
}
fn.[[scope]] = globalContext.A0
fn3.[[scope]] = globalContext.A0
fnContext = {
A0 = {
a: 5 -> 6
f2: function
}
Scope: fnContext.A0
}
f2.[[scope]] = fnContext.A0
fn2context = {
A0 = {
a: 6 -> 20
}
}
*/
