1.函数声明和函数表达式有什么区别
- 用函数声明，函数名是必须的；用函数表达式，函数名可省略；
- 用函数声明，函数调用可以在声明之前；用函数表达式，调用必须在声明之后；
- 用函数声明，它们仅仅可以出现在全局中，或者嵌套在其他的函数中，但是它们不能出现在循环，条件或者try/catch/finally中；而函数表达式可以在任何地方声明；
2.什么是变量的声明前置？什么是函数的声明前置？
在一个作用域内，无论变量和函数的声明实际位置在哪，函数解析时，都会将这些声明置于作用域最前端；
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); //undefined
a = 3;
console.log(a); //3
sayHello();
3.arguments 是什么?
参数在内部使用一个数组来表示的，函数接收到的是这个数组。通过arguments这个对象可以访问这个数组，从而获取到里面的每一个参数，如
Paste_Image.png
4.函数的"重载"怎样实现？
javscript中没有重载，同名函数，后定义的会覆盖前面定义的。
但可以通过对参数的判断筛选，在函数内部实现不同的功能。
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(){
var a = 1;
})()
console.log(a);
6.求n!，用递归来实现
function factor(n){
if(0 === n) {
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 i,length,sum;
length = arguments.length;
sum = 0;
for(i=0;i<length;i++){
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);
先输出undefined，然后b没有定义；
因为声明前置，代码相当于先声明a，但是没有赋值，这时候输出就是undefined；输出b，b没有定义
10.如下代码的输出？为什么
sayName('world');
sayAge(10);
function sayName(name){
console.log('hello ', name);
}
var sayAge = function(age){
console.log(age);
};
仅能输出hello world，sayAge使用函数表达式声明的，调用必须在声明之后，所以调用Age时，函数未定义。
11.如下代码输出什么? 写出作用域链查找过程伪代码
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
}
bar.[[scope]] = globalContext.AO
foo.[[scope]] = globalContext.AO
barContext = {
AO: {
x: 30
},
Scope: bar.[[scope]]//globalContext.AO
}
fooContext = {
AO: {
},
Scope: foo.[[scope]]//globalContext.AO
}
结果：输出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.[[scope]] = globalContext.AO
barContext = {
AO:{
x:30;
foo:function
},
Scope: bar[[scope]]//globalContext.AO
}
foo.[[scope]] = barContext.AO
fooContext = {
AO:{
},
Scope: foo[[scope]]//barContext.AO
}
结果：输出30
13.以下代码输出什么? 写出作用域链的查找过程伪代码
var x = 10;
bar()
function bar(){
var x = 30;
(function (){
console.log(x)
})()
}
代码等价于：
var x；
function bar(){
var x = 30;
var fn = function (){console.log(x)};
fn();
}
x = 10;
bar()
globalContext{
AO:{
x:10
bar：funtion
}
Scope:null
}
bar.[[scope]] = globalContext.AO
barContext{
AO:{
x:30
fn：funtion
}
Scope:bar.[[scope]]//globalContext.AO
}
fn.[[scope]] = barContext.AO
fnContext{
AO:{
}
Scope:fn.[[scope]]//barContext.AO
}
结果：输出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:200
fn2：function
}
Scope:null
}
fn.[[scope]] = globalContext.AO
fn3.[[scope]] = globalContext.AO
fnContext{
AO:{
a:20
fn：funtion
}
Scope:fn.[[scope]]//globalContext.AO
}
fn2.[[scope]] = fnContext.AO
fn3Context{
AO:{
}
Scope:fn3.[[scope]]//globalContext.AO
}
fn2Context{
AO:{
}
Scope:fn3.[[scope]]//fnContext.AO
}
输出结果：
undefined 5 1 6 20 200
网友评论