函数声明和函数表达式有什么区别
函数声明：function functionname(){}
函数表达式：var fn = function(){};
函数声明会前置，因此，函数调用可以放在函数声明之前。函数表达式不会前置，函数调用需放到函数表达式之后。
什么是变量的声明前置？什么是函数的声明前置
在一个作用域下，var 声明的变量和function 声明的函数会前置
console.log(a); //undefined 声明前置，可以在a声明之前使用变量a，但由于a没有赋值，所以输出undefined
var a = 3;
console.log(a); //3
sayHello();//函数声明前置，所以可以在其之前使用
function sayHello(){
console.log('hello');
}
arguments 是什么
在函数内部,你可以使用arguments对象获取到该函数的所有传入参数
function printPersonInfo(name, age, sex){
console.log(name);
console.log(age);
console.log(sex);
console.log(arguments);
}
arguments对象不是一个 Array 。它类似于数组，但除了 长度之外没有任何数组属性。
函数的"重载"怎样实现
没有重载! 同名函数会覆盖。 但可以在函数体针对不同的参数调用执行相应的逻辑
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');
立即执行函数表达式是什么？有什么作用
(function(){})()
由于javascript没有块级作用域，所以我们可以利用函数来构造作用域。
求n!，用递归来实现
function factorial(n){
if(n==1)
return n;
else
return n*factorial(n-1);
}
console.log(factorial(4));
以下代码输出什么？
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: 男
[object Arguments] {
0: "饥人谷",
1: 2,
2: "男"
}
name: valley
getInfo('小谷', 3);
//name: 小谷 age: 3 sex: undefined
[object Arguments] {
0: "小谷",
1: 3,
}
name: valley
getInfo('男');
//name: 男 age: undefined sex: undefined
[object Arguments] {
0: "男",
}
name: valley
写一个函数，返回参数的平方和？
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
如下代码的输出？为什么
console.log(a); //undefined 变量声明前置，但没有赋值，所以是undefined
var a = 1;
console.log(b); //error 未定义b
如下代码的输出？为什么
//函数声明和函数表达式的区别
sayName('world'); // hello: world
sayAge(10); //error
function sayName(name){
console.log('hello ', name);
}
var sayAge = function(age){
console.log(age);
};
11. 如下代码输出什么? 写出作用域链查找过程伪代码
var x = 10
bar() //10
function foo() {
console.log(x)
}
function bar(){
var x = 30
foo()
}
globalContext = {
AO: {
x: 10
foo: function
bar: function
},
Scope: null
}
foo.[[scope]] = globalContext.AO
bar.[[scope]] = globalContext.AO
fooContext = {
AO:{},
Scope: foo.[[scope]]
}
barContext = {
AO:{
x:30
},
Scope: bar.[[scope]]
}
12. 如下代码输出什么? 写出作用域链查找过程伪代码
var x = 10;
bar() //30
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
foo: function
},
Scope: bar.[[scope]]
}
foo.[[scope]] = barContext.AO
fooContext = {
AO: {},
Scope: foo.[[scope]]
}
13. 以下代码输出什么? 写出作用域链的查找过程伪代码
var x = 10;
bar() //30
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
foo: function
},
Scope: bar.[[scope]]
}
function.[[scope]] = barContext.AO
functionContext = {
AO: {},
Scope: function.[[scope]]
}
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.[[scope]] = globalContext.AO
fnContext = {
AO: {
a: 5
fn2: function
},
Scope: fn.[[scope]]
}
fn2.[[scope]] = fnContext.AO
fn3Context = {
AO: {},
Scope: fn3.[[scope]]
}
fn2Context = {
AO: {},
Scope: fn2.[[scope]]
}
var a = 1; //我称global的a为ga fn中a为ia
function fn(){
console.log(a) // undefined ia声明了，但未赋值
var a = 5
console.log(a) // 5 ia
a++ // ia=6
var a
fn3() // 1 ga=200
fn2() // 6 ia=20
console.log(a) // 20 ia
function fn2(){
console.log(a)
a = 20
}
}
function fn3(){
console.log(a)
a = 200
}
fn()
console.log(a) //200 ga
