函数声明和函数表达式有什么区别
- 函数声明在JavaScript解析时进行函数提升，因此在同一个作用域内，不管函数声明在哪里定义，该函数都可以进行调用。
- 函数表达式的值是在JavaScript运行时确定，并且在表达式赋值完成后，该函数才能调用。这个微小的区别，可能会导致JavaScript代码出现意想不到的bug,让你陷入莫名的陷阱中。
什么是变量的声明前置？什么是函数的声明前置
-
变量声明前置就是在一个作用域块中，所有的变量都被放在块的开始出声明。
console.log(i); var i =1; //打印出 undefined。而不是报错，是因为var i;已经前置。上面代码相当于：
var i; console.log(i); i = 1; -
JavaScript引擎将函数名视同变量名，所以采用function声明函数时，整个函数会像var声明变量一样，被提升到代码头部。
test(1); function test(i){ console.log(i); }; //打印值为 1. 因为整个函数都前置。上面代码相当于：
function test(i){ console.log(i) }; test(1); //输出值为1
arguments 是什么
-
arguments是一个类数组的本地对象，你可以使用arguments获取到该函数的所有传入参数。
function getInfo(name, age, sex){ console.log('name:',name); console.log('age:',age); console.log('sex:',sex); arguments[1]= 23; console.log('age:',age); } getInfo('bily', 22, 'man'); //输出： name：bily age：22 sex：man age: 23
函数的重载怎样实现
在 JavaScript 中没有重载! 同名函数会覆盖。但可以在函数体针对不同的参数调用执行相应的逻辑。
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');
立即执行函数表达式是什么？有什么作用
创建只使用一次的函数，并立即执行它。
创建闭包，保存状态，隔离作用域。
-
作为独立模块存在，防止命名冲突，命名空间注入。
写法1 // 推荐写法 (function() { console.log('hello','jijrengu'); } () ); 其他写法 (function() { console.log('hello','jijrengu'); } ) ();作用： 隔离作用域
求n!，用递归来实现
求 n 的阶乘 n!
function factor(n){
if(n === 0 || n === 1) {
return 1
}
return n * factor(n-1)
}
factor(5)
求 1+2+...+n 的值
function sum(n){
if(n === 1) {
return 1
}
return n + sum(n-1)
}
sum(10)
以下代码输出什么？
代码1.jpg
代码1答案.jpg
写一个函数，返回参数的平方和？
代码2.jpg
代码2答案.jpg
如下代码的输出？为什么
代码3.jpg
上面代码相当于：
var a; // 因为变量提升，var a；前置
console.log(a); // 输出undefined
a = 1; // a=1未前置
console.log(b); // 报错不存在， b 未声明未赋值（不存在），打印b就会报错
如下代码的输出？为什么
代码4.jpg
sayName('world');
sayAge(10);
function sayName(name){
console.log('hello ', name);
}
var sayAge = function(age){
console.log(age);
};
// "hello" "world" 因为函数声明提前，将整个函数前置，所以执行代码能正常输出。
// "sayAge is not a function" sayAge虽然因变量提升已经被声明，
但是sayAge（10） 是函数的调用方式，所以输出 is not a function
如下代码输出什么? 写出作用域链查找过程伪代码
代码5.jpg
globalContext = {
AO: {
x: 10,
foo: function,
bar: function;
}
}
foo.[[scope]] = globalContent.AO;
bar.[[scope]] = globalContext.AO;
barContext = {
AO: {
x: 30
},
scope: globalContext.AO;
}
fooContext = {
AO: {
}
scope: globalContext.AO;
}
// foo()输出： 10
如下代码输出什么? 写出作用域链查找过程伪代码
6.jpg
globalContext = {
AO: {
x: 10,
bar: function;
}
}
bar.[[scope]] = globalContext.AO;
barContext = {
AO: {
x: 30
foo: function
},
scope: globalContext.AO;
}
foo.[[scope]] = barContext.AO;
fooContext = {
AO: {
}
scope: barContext.AO;
}
// foo()输出30
以下代码输出什么? 写出作用域链的查找过程伪代码
代码7.jpg
globalContext = {
AO: {
x: 10
bar: function
},
Scope: null
}
bar.[[scope]] = globalContext.AO
barContext = {
AO: {
x: 30,
function
},
Scope: bar.[[scope]] //globalContext.AO
}
function.[[scope]] = barContext.AO
functionContext = {
AO: {
},
Scope: function.[[scope]] // barContext.AO
}
输出为30
以下代码输出什么？ 写出作用域链查找过程伪代码
代码8.jpg
globalContext = {
AO: {
a: 1
fn: function
fn3: function
},
Scope: null
}
fn.[[scope]] = globalContext.AO
fn3.[[scope]] = globalContext.AO
fnContext = {
AO: {
a: undefined,
fn2: function,
};
Scope: fn.[[scope]] //globalContext.AO
}
fn2.[[scope]] = fnContext.AO
fn3Context = {
AO:{
a: 200,
},
Scope:fn3.[[scope]]//globalContext.AO
}
fn2ConText = {
AO:{
a: 20,
},
Scope:fn2.[[scope]]//fnContext.AO
}