1.函数声明和函数表达式有什么区别
函数声明会提前，声明前置。声明不必放到调用的前面
函数表达式是将声明变量提升，是为了得到返回值，一定会返回一个值，声明必须放到调用的前面
//函数声明
function sayHello(){
console.log('hello')
}
//函数调用
sayHello()
//函数表达式
var sayHello = function(){
console.log('hello');
}
sayHello()
2.什么是变量的声明前置？什么是函数的声明前置
console.log(a);
var a = 1; // 虽然不会报错（存在变量提升） 但真实运行的是下面的代码
var a;
console.log(a);
a = 1; //这就是变量声明前置
函数的声明前置（JavaScript引擎将函数名视同变量名），但如果采用赋值语句定义函数，就会报错。
f(); //不会报错
function f() {}
3.arguments 是什么
arguments是一个类数组对象。代表传给一个function的参数列表。
// arguments对象
function args() { return arguments }
var arrayLike = args('a', 'b');
arrayLike[0] // 'a'
arrayLike.length // 2
arrayLike instanceof Array // false
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.立即执行函数表达式是什么？有什么作用
(function(){
var a = 1;
})()
作用：隔离作用域，避免变量污染全局。
6.求n!，用递归来实现
function factorial(n){
if(n === 1){
return 1;
}else {
return n * factorial(n-1)
}
}
factorial();
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,'sex'] name valley
getInfo('小谷', 3); // name:小谷、age:3、undefined、['小谷', 3]、name vally;
getInfo('男'); //name:男、undefined、undefined、['男']、name vally;
8.写一个函数，返回参数的平方和？
function sumOfSquares(){
}
var sum = 0;
for (var i = 0; i < arguments.length; i++) {
sum = 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);//underfined,因为声明变量前置
var a = 1;
console.log(b); //会报错，b is not defined 未声明变量b
10.如下代码的输出？为什么
sayName('world');
sayAge(10);
function sayName(name){
console.log('hello ', name); // hello world ,因为函数声明前置
}
var sayAge = function(age){
console.log(age); // 报错，函数表达式不会被前置 所以在声明前调用不起作用
};
11. 如下代码输出什么? 写出作用域链查找过程伪代码
var x = 10
bar()
function foo() {
console.log(x)
}
function bar(){
var x = 30
foo()
}
伪代码：
globalContext = {
AO:{
x:10
foo:function
bar:function
},
scope:null
}
//声明foo时，得到下面
foo.[ [scope] ] = globalContext.AO
//声明bar时，得到下面
bar.[ [scope] ] = globalContext.AO
//调用bar，bar执行上下文
barContext = {
AO:{
x:30
foo:function
},
scope:bar.[[scope]] = golobaContext.AO
}
fooContext = {
AO:{
}
scope:foo.[ [scope] ]= globalContext.AO
}//从scope中即globalContext.AO中可以找到x:10。
12.如下代码输出什么? 写出作用域链查找过程伪代码
var x = 10;
bar()
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
}
bar.[ [scope] ] = globalContext.AO
}
foo.[ [scope] ] = barContext.AO
fooContext = {
AO:{
}
foo.[ [scope] ] = barContext.AO
}
//调用foo时会在barContext.AO中找到x:30。
13.以下代码输出什么? 写出作用域链的查找过程伪代码
var x = 10;
bar()
function bar(){
var x = 30;
(function (){
console.log(x)
})()
}
伪代码：
globalContext={
AO:{
x:10
bar:function
},
scope:null
}
bar.[ [scope] ] = globalContext.AO
barContext={
AO{
x:30
function
},
function.[[scope]] = barContext.AO
}
x: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)
伪代码：
globalContext = {
AO:{
a:1
fn:function
fn3:function
},
scope:null
}
//声明fn时，得到下面
fn.[ [scope] ] = globalContext.AO
//声明fn3时，得到下面
fn3.[ [scope] ] = globalContext.AO
fnContext = {
AO:{
a:underfined
fn2:function
},
scope:fn2.[[scope]] = globalContext.AO
}
fn3Context = {
AO:{
a:200
},
scope:fn3.[ [scope] ] = globalContext.AO
}
fn2Context = {
AO:{
a:20
},
scope:fn2.[ [scope] ] = fnContext.AO
}
// underfined 5 1 6 20 200
【个人总结，如有错漏，欢迎指出】
：>
