1.函数声明和函数表达式有什么区别
函数声明使用function关键字可以声明一个函数
声明不必放到调用的前面(函数声明前置)
函数声明必须有函数名
//函数声明
function sayHello(){
console.log('hello')
}
//函数调用
sayHello()
函数表达式声明必须放到调用的前面
前后两个函数的名字可以相同也可以不相同
function 后面的这个名字(sayHello)是可以省略的
var sayHello = function sayHello(){
console.log('hello');
}
sayHello()
第三种声明函数方式，采用构建函数
var sayHello=new Function("console.log('hello world');")
2.什么是变量的声明前置？什么是函数的声明前置
变量的声明前置：在同一作用域下，先把所有的变量放在开头声明
函数的声明前置：与变量声明前置同义，只不过是在函数作用域下，在开头先把变量声明
3.arguments 是什么
在函数内部,可使用arguments对象获取到该函数的所有传入参数,需要注意定义了函数参数，但没有传进相应的参数值，则没有传递值的函数参数被自动赋予undefined值,例如
function printPersonInfo(name, age, sex){
console.log(name);
console.log(age);
console.log(sex);
console.log(arguments);
}
4.函数的"重载"怎样实现
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');
5.立即执行函数表达式是什么？有什么作用
立即执行函数就是声明一个匿名函数，定义函数后就立即执行的函数。它的作用是隔离作用域，不会产生任何全局变量，写法：
(function fn1() {})();
6.求n!，用递归来实现
function f(n){
if(n>1){
return n*f(n-1);}
else if(n==1){
return 1;}
else{
return 0;}
}
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 */
- 写一个函数，返回参数的平方和？
function sumOfSquares(){
var sum=0;
for(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);
var a = 1;
console.log(b);
/*
输出结果为：
undefined
Uncaught ReferenceError: b is not defined
将变量声明前置并重写
var a;
console.log(a);
a = 1;
console.log(b);//b没有声明及赋值，故报错
*/
- 如下代码的输出？为什么
sayName('world');
sayAge(10);
function sayName(name){
console.log('hello ', name);
}
var sayAge = function(age){
console.log(age);
};
/*输出结果
hello world
Uncaught TypeError: sayAge is not a function*/
function声明的函数，会前置，故该函数的调用可以放在函数声明前面，
var sayAge = function(age)是一个函数表达式，调用必须放在后面，故报错*/
- 如下代码输出什么? 写出作用域链查找过程伪代码
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
输出结果是：10 */
- 如下代码输出什么? 写出作用域链查找过程伪代码
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
barContext = {
AO: {
x: 30,
foo: function
},
Scope: bar.[[scope]] //globalContext.AO
}
在 bar 的执行上下文里声明 foo 时 得到下面
foo.[[scope]] = barContext.AO
最后输出结果是：30*/
- 以下代码输出什么? 写出作用域链的查找过程伪代码
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
barContext = {
AO: {
x: 30,
(function (){console.log(x)}): function
},
Scope: bar.[[scope]] //globalContext.AO
}
在 bar 的执行上下文里声明 foo 时 得到下面
(function (){console.log(x)}).[[scope]] = barContext.AO
最后输出结果是：30*/
- 以下代码输出什么？ 写出作用域链查找过程伪代码
var a = 1;
function fn(){
console.log(a) //undefiend
var a = 5
console.log(a) //5
a++
var a
fn3() //1
fn2() //6
console.log(a) //20
function fn2(){
console.log(a)
a = 20
}
}
function fn3(){
console.log(a)
a = 200
}
fn()
console.log(a) //200
/*globalContext = {
AO: {
a: 1
fn: function
fn3: function
},
Scope: null
}
声明 fn 时 得到下面
fn.[[scope]] = globalContext.AO
声明 fn3 时 得到下面
fn3.[[scope]] = globalContext.AO
fn.Context = {
AO: {
a: undefiend
fn2: function
},
Scope: fn.[[scope]] //globalContext.AO
}
在fn 的执行上下文里声明 fn2时 得到下面
fn2.[[scope]] = fnContext.AO*/
