1.函数声明和函数表达式有什么区别
- 函数声明，使用Function关键字可以声明一个函数
function sayHello(){
console.log("hello")
}
sayHello()
- 函数表达式，使用var之类的关键字定义
var sayHello =function(){
console.log("hello")
}
sayHello()
区别：函数声明中，声明不必放在调用的前面；函数表达式中，声明必须放在调用的前面。
2.什么是变量的声明前置？什么是函数的声明前置
在一个作用域下，var 声明的变量和function 声明的函数会前置
console.log(a);
var a = "chen";
在这过程中，变量的声明会前置，变成
var a; // 结果undefined
console.log(a);
a = "chen";
这就是为什么单独输入console.log(a);会报错，但再后面加上var声明变量，可以显示结果。
test
function 声明的函数会前置，先声明后运算。
3.arguments 是什么？
在函数内部,你可以使用arguments对象获取到该函数的所有传入参数，也可以相应地选择一些参数。
test
4.函数的"重载"怎样实现？
- 针对其他强类型的语言，函数名虽然重复，但变量的类型是固定的，如数值类型对应int，字符串对应string。
-
对js来讲，没有重载! 同名函数会覆盖。 但可以在函数体针对不同的参数调用执行相应的逻辑
同名函数覆盖
5.立即执行函数表达式是什么？有什么作用？
一般的
function sayHello(name){
console.log("hello"+name)
}
sayHello("css")
立即执行函数表达式
(function sayHello(name){
console.log("hello"+name)
})("css")
作用：隔离作用域；省略函数名；包裹模块，避免污染全局变量
6.求n!，用递归来实现
function factor(n) {
if(n<=0){
return console.log('n不可小于或等于0')
}
if(n==1){
return n
}
return n*factor(n-1)
}
7
1.当执行getInfo('饥人谷', 2, '男');时
function getInfo(name, age, sex){
console.log('name:',name); // name:饥人谷
console.log('age:', age); // age:2
console.log('sex:', sex); // sex:男
console.log(arguments); // ['饥人谷', 2, '男']
arguments[0] = 'valley'; //（arguments[0] 值为 '饥人谷'， 将 'valley'值赋值给'饥人谷'）
console.log('name', name); // name，valley
}
2.当执行getInfo('小谷', 3);时
function getInfo(name, age, sex){
console.log('name:',name); // name:小谷
console.log('age:', age); // age:3
console.log('sex:', sex); // sex: undefined
console.log(arguments); // ['小谷', 3]
arguments[0] = 'valley';
console.log('name', name); // name，valley
}
3.当执行getInfo('男');时
function getInfo(name, age, sex){
console.log('name:',name); // name:男
console.log('age:', age); // age: undefined
console.log('sex:', sex); // sex: undefined
console.log(arguments); // ['男',undefined,undefined]
arguments[0] = 'valley';
console.log('name', name); // name，valley
}
8
function sumOfSquares(){
var sum=0;
for(var i=0;i<arguments.length;i++) {
sum+=arguments[i]*arguments[i];
}
return sum
}
sumOfSquares(2,3,4)
sumOfSquares(1,3)
9
console.log(a); //var=a，变量声明前置，但未赋值，结果显示为undefined。
var a = 1;
console.log(b); //出现报错，`b is not defined`
10
sayName('world');
sayAge(10);
function sayName(name){
console.log('hello ', name);
} //Function声明的函数前置，执行sayName('world')，结果：hello,world
var sayAge = function(age){
console.log(age);
}; //结果出现报错，原因：函数表达式必须放在声明的前面。
11
1.globalcontext={
AO:{
x:10
foo:function
bar:function
},
scope: null
}
声明foo时得到下面
foo.[[scope]]=globalcontext.AO
声明bar时得到下面
bar.[[scope]]=globalcontext.AO
2.执行bar时产生下面
barcontext={
AO:{
x:30
},
Scope: bar.[[scope]] =globalcontext.AO
}
3.执行foo时产生下面
foocontext={
AO:{}，
Scope: foo.[[scope]] = globalcontext.AO
}
**最终结果为`console.log(10)`，为10**
12
1.globalcontext={
AO:{
x:10
bar:function
},
Scope:null
}
声明bar时得到：bar.[[Scope]]=globalcontext
2.执行bar时产生下面
barcontext={
AO:{
x:30
foo:function
},
Scope:bar.[[Scope]]=globalcontext
}
Scope:foo.[[Scope]]=barcontext
3.执行foo时产生下面
foocontext={
AO:{},
Scope:foo.[[Scope]]=barcontext
}
console.log(10)结果为10
13
1.globalcontext={
AO:{
x:10
bar:function
}
}
声明bar时产生bar.[[Scope]]=globalcontext.AO
2.barcontext={
AO:{
x:30
(function)
}
}
Scope:(function).[[Scope]]=barcontext.A0
3.(function)context={
AO:{}
Scope:(function).[[Scope]]=barcontext.A0
}
4.最终结果console.log(30),结果为30
14
1.globalcontext={
AO:{
a:1
fn:function
fn3:function
},
}
fn.[[Scope]]=globalcontext.AO
fn3.[[Scope]]=globalcontext.AO
2.fncontext={
AO:{
声明前置var=a
console.log //undefined
a=5
console.log //5
a:6(a++后)
(fn3、fn2开始执行)
fn2：function
}
fn2.[[Scope]]=fncontext.AO
}
3.fn3context={
AO:{}
console.log //1(来着于globalcontent.AO)
}
a=200声明， //globalcontent.AO中的a为200
4.fn2context={
AO{}
console.log //6(来着于fncontext.AO)
}
a=20声明 //fncontext.AO中的a为20
执行console.log //20
}
5.fn运算结束，执行console.log，结果为200
运行fn2
6.结果依次为：undefined、5、1、6、20、200
