1.函数声明和函数表达式有什么区别
- 函数声明
使用function关键字可以声明一个函数
//函数声明
function sayHello(){
console.log('hello')
}
//函数调用
sayHello()
声明不必放到调用的前面；
- 函数表达式
var sayHello = function(){
console.log('hello');
}
sayHello()
声明必须放到调用的前面。
2.什么是变量的声明前置？什么是函数的声明前置
var 和 function 的声明前置
在一个作用域下，var 声明的变量和function 声明的函数会前置
例如：
console.log(a); //undefined
var a = 3;
console.log(a); //3
sayHello();
function sayHello(){
console.log('hello');
}
执行的实际情况为：
var a; // 变量声明前置
function sayHello() { // 函数声明前置
console.log('hello');
}
console.log(a);
a = 3;
console.log(a);
sayHello();
3.arguments 是什么
在函数内部,你可以使用arguments对象获取到该函数的所有传入参数，
arguments 是一个对应于传递给函数的参数的类数组对象。
function printPersonInfo() {
console.log(arguments[0]);
console.log(arguments[1]);
console.log(arguments[2]);
}
printPersonInfo('zz',15 , 'boy')；
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(){/* code */})()
(function(){/* code */}())
- 作用: 隔离作用域，执行一段代码，代码中的变量不被外部作用域影响，也不给外部作用域造成任何影响。
6.求n!，用递归来实现
function factor(n){
if(n === 0 ||n === 1) {
return 1;
}
return n * factor(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, '男');
getInfo('小谷', 3);
getInfo('男');
输出结果：
name:饥人谷
age:2
sex:男
["饥人谷", 2, "男"]
name:valley
name:小谷
age:3
sex:undefined
[“小谷”, “3”]
name:valley
name:男
age:undefined
sex:undefined
["男"]
name:valley
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);
var a = 1;
console.log(b);
声明前置实际为：
var a;
console.log(a); //undefined
a = 1;
console.log(b); //Uncaught ReferenceError: b is not defined
console.log(a); 这个时候a还没有赋值; b变量没有声明和定义, 所以报错.
10.如下代码的输出？为什么
sayName('world');
sayAge(10);
function sayName(name){
console.log('hello ', name);
}
var sayAge = function(age){
console.log(age);
};
声明前置实际为：
function sayName(name){
console.log('hello', name);
}
var sayAge
sayName('world'); //hello world
sayAge(10); // Uncaught TypeError: sayAge is not a function
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: funtion
bar: funtion
}，
Scope: null
}
//声明 foo 时 得到下面
foo.[[scope]] = globalContext.AO
//声明 bar 时 得到下面
bar.[[scope]] = globalContext.AO
当调用 bar() 时， 进入 bar 的执行上下文
barContext = {
AO: {
x: 30
},
Scope: bar.[[scope]] //globalContext.AO
}
当调用 foo() 时，先从 bar 执行上下文中的 AO里找，找不到再从 bar 的 [[scope]]里找到后即调用
当调用 foo() 时，进入 foo 的执行上下文
fooContext = {
AO: {},
Scope: foo.[[scope]] // globalContext.AO
}
所以 console.log(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 时 得到下面
bar.[[scope]] = globalContext.AO
当调用 bar() 时， 进入 bar 的执行上下文
barContext = {
AO: {
x: 30,
foo: function
},
Scope: bar.[[scope]] //globalContext.AO
}
//在 bar 的执行上下文里声明 foo 时 得到下面
foo.[[scope]] = barContext.AO
当调用 foo() 时，先从 bar 执行上下文中的 AO里找，找到后即调用
当调用 foo() 时，进入 foo 的执行上下文
fooContext = {
AO: {},
Scope: foo.[[scope]] // barContext.AO
}
所以 console.log(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时
bar.[[scope]] = globalContext.AO
//调用bar时，进入bar的执行上下文
barContext = {
AO: {
x: 30,
function//立即执行函数表达式
},
Scope: bar.[[scope]] // globalContext.AO
//执行立即执行函数
functionContext = {
AO:{ }
},
Scope: function.[[scope]] //barContext.AO
所以console.log(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
调用fn，进入fn的执行上下文
fnContext = {
AO: {
a: 5
fn2: function
},
Scope: fn.[[scope]] //globalContext.AO
}
//调用fn3，此时在fn的执行上下文的AO中找不到fn3，于是在fn的scope里找，找到后即调用
fn3Context = {
AO: {
a: 200
},
Scope: fn3.[[scope]] //globalContext.AO
}
//调用fn2，在bar的执行上下文AO中可以找到fn2，直接调用
fn2Context = {
AO: {
a: 20
},
Scope: fn2.[[scope]] //fnContext.AO
}
//输出结果如下：
//调用fn
console.log(a) // a的值在fnContext.AO中，此时a变量声明了但未定义，所以输出undefined。
var a = 5 // a被赋值为5
console.log(a) // 输出5
a++ // fnContext.AO中a的值变为6
//调用fn3
fn3() //此时a的值为globalContext.AO里的a，即console.log(a) 输出1
a = 200 // globalContext.AO里的a值变为200
//调用fn2
fn2() //此时a的值为fnContext.AO里的a，即console.log(a) 输出6
a = 20 // fnContext.AO里的a变为20
console.log(a) //输出20
//fn调用结束，此时 globalContext.AO里的a值为200
console.log(a) // 输出200
// 输出顺序为：undefined, 5, 1, 6, 20, 200
