函数声明和函数表达式有什么区别
- 函数声明
function print(s) {
console.log(s);
}
函数声明命名了一个叫做print的函数，以后使用print()就可以调用这个函数。
- 函数表达式
var print = function(s) {
console.log(s);
};
函数的表达式需要在语句的结尾加上分号，表示语句结束。
- 区别
所以采用function命令声明函数时，整个函数声明会被提升到代码头部，因此函数调用在函数声明前面是允许的；
但是如果使用函数表达式则会报错，因为使用函数表达式相当于以下代码：
var f;
f();
f = function () {};
调用函数f时，f只是被声明了还没有被赋值，因此会报错
什么是变量的声明前置？什么是函数的声明前置
- 变量的声明前置：
JavaScript引擎的工作方式是，先解析代码，获取所有被声明的变量，然后再一行一行地运行。这造成的结果，就是所有的变量的声明语句，都会被提升到代码的头部，这就叫做变量提升（hoisting）。 - 函数的声明前置：
JavaScript引擎将函数名视同变量名，所以采用function命令声明函数时，整个函数会像变量声明一样，被提升到代码头部。
arguments 是什么
arguments对象是一个类数组对象，包含了函数运行时的所有参数，arguments[0]就是第一个参数，arguments[1]就是第二个参数，以此类推。这个对象只有在函数体内部，才可以使用。
函数的"重载"怎样实现
可以在一个函数里面使用条件分支来实现不同的函数功能
立即执行函数表达式是什么？有什么作用
JavaScript引擎规定，如果function关键字出现在行首，一律解释成语句。
若果不让function出现在行首，让引擎将其理解成一个表达式，就可以立即执行该函数。
如：
(function(){ /* code */ })();
作用：
- 使用匿名函数立即执行函数表达式，不必为函数命名，避免了污染全局变量；
- 是IIFE内部形成了一个单独的作用域，可以封装一些外部无法读取的私有变量。
求n!，用递归来实现
function f(n) {
if (n === 1) {
return n;
}
return n * f(n-1);
}
f(3);
以下代码输出什么？
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:男
['饥人谷', 2, '男']
name valley
*/
getInfo('小谷', 3);
/*
name:小谷
age:3
sex:undefined
['小谷', 3']
name valley
*/
getInfo('男');
/*
name:男
age:undefined
sex:undefined
['男']
name valley
*/
写一个函数，返回参数的平方和？
function sumOfSquares(){
var n = arguments.length;
var sum = 0;
var temp = 0;
for (var i=0; i<n; i++) {
temp = parseInt(arguments[i])
sum += temp * temp;
}
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
var a = 1;
console.log(b); // error
a变量提升，未赋值，为undefined
b变量为声明，报错
如下代码的输出？为什么
sayName('world');
sayAge(10);
function sayName(name){
console.log('hello ', name); // hello world
}
var sayAge = function(age){
console.log(age); // error
};
sayAge是函数表达式，不存在函数声明提升，所以调用sayAge时函数还未赋值，所以报错。
如下代码输出什么? 写出作用域链查找过程伪代码
1.
globalContext = {
AO: {
x: 10,
foo: function,
bar: function
}
}
foo.[[scope]] = globalContext.AO;
bar.[[scope]] = globalContext.AO;
2.
barContext = {
AO: {
x: 30,
},
scope: bar.[[scope]]
}
3.
fooContext = {
scope: foo.[[scope]]
}
输出10
以下代码输出什么? 写出作用域链的查找过程伪代码
1.
globalContext = {
AO: {
x: 10
bar: function
}
}
bar.[[scope]] = globalContext.AO
2.
barContext = {
AO: {
x: 30,
foo: function
},
Scope: bar.[[scope]] //globalContext.AO
}
foo.[[scope]] = barContext.AO
3.
fooContext = {
AO: {},
Scope: foo.[[scope]] // barContext.AO
}
输出30
以下代码输出什么？ 写出作用域链查找过程伪代码
1.
globalContext = {
AO: {
a: 200,
fn: function,
fn3: function
}
}
fn.[[scope]] = globalContext.AO;
fn3.[[scope]] = globalContext.AO;
2.
fnContext = {
AO: {
a: 20,
fn2: function
},
scope: fnContext.[[scope]]
}
fn2.[[scope]] = fnContext.AO;
3.
fn3Context = {
AO: {},
scope: fn3Context.[[scope]]
}
4.
fn2Context = {
AO: {},
scope: fn2Context.[[scope]]
}
输出 1 5 1 6 20 200
