1、 函数声明和函数表达式有什么区别
ECMAScript规定了三种声明函数方式：构造函数、函数声明、和函数表达式。
函数声明: 函数声明通过关键字function来声明, 关键词后面是函数名, 名称后面有个小括号, 括号里面放的是函数的参数, 最后是一对花括号,包括函数的代码块
function sum(num1,num2) {
return num1+num2;
}
函数表达式：
var sum = function(num1, num2) {
return num1+num2;
};
定义变量sum并将一个匿名函数赋值给变量，这时这个匿名函数又称函数表达式(Function Expression)。function关键字后面没有函数名。
区别：
- 函数声明最后一般不写分号, 而函数表达式有分号
- 函数声明和变量声明都有声明提前的特点, 函数声明是函数名称和函数体均提前声明了, 可以在声明之前调用它;
- 函数表达式的规则与变量声明提前一样,只是函数声明变量提前了, 但是它的赋值仍在原来的位置, 不能在函数表达式之前调用。
2、什么是变量的声明前置？什么是函数的声明前置
变量的声明前置：
变量声明前置是指把变量的声明提前到当前作用域的最前面, 但变量的赋值仍然按照原来的顺序执行, 如果变量声明但未被赋值, 变量自动赋值为undefined。
函数的声明前置：
函数的声明前置有两种情况, 一个是使用函数声明, 则整个声明都前置, 另一个是使用函数表达式, 那么规则和变量的声明前置一样。
3、arguments 是什么
- arguments是一个类数组对象, 代表传给一个function的参数列表, 只在函数内部起作用; arguments的值与函数传入参数有关, 与定义参数无关。
- 可以使用arguments对象在函数中引用函数的参数。此对象包含传递给函数的每个参数的条目，第一个条目的索引从0开始。例如，如果一个函数传递了三个参数，你可以以如下方式引用他们：
arguments[0]
arguments[1]
arguments[2]
参数也可以被设置：
arguments[1] = 'new value';
- arguments对象不是一个 Array 。它类似于Array，但除了长度之外没有任何Array属性
-
属性
arguments.callee
指向当前执行的函数。
arguments.caller
指向调用当前函数的函数。
arguments.length
指向传递给当前函数的参数数量。
arguments[@@iterator]
返回一个新的Array迭代器对象，该对象包含参数中每个索引的值。
4、函数的"重载"怎样实现
- 重载是很多面向对象语言实现多态的手段之一, 相同名字的函数参数个数不同, 或者顺序不同, 都被认为是不同的函数.
- 如果定义了两个名字相同的函数，则该名字属于后定义的函数。
- ECMAscript函数不能像传统意义上的那样实现重载， ECMAscript函数没有签名，其参数是由包含零个或多个值的数组来表示的。而没有函数签名，真正的重载是不可能做到的。但可以在函数体针对不同的参数调用执行相应的逻辑
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');
也可以用arguments.length来实现重载。
5、立即执行函数表达式是什么？有什么作用
- 在JavaScript中, 一对圆括号()是一种运算符, 跟在函数明后, 表示调用该函数; 有时我们希望在定义函数之后, 立即调用该函数; 这时, 不能再函数的定义之后加圆括号, 会产生语法错误; 因为function这个关键字既可以当做语句, 也可当做表达式; 为了避免解析上的歧义, JavaScript引擎看到行首是function关键字之后, 认为这一段都是函数的定义 , 不应该以圆括号结尾, 所以报错;
- 解决方法就是不要让function出现在行首, 让引擎将其理解外一个表达式, 最简单的方式, 是将其放在圆括号内
(function(){
var a = 1;
})()
console.log(a); //undefined
其他写法
// 在数组初始化器内只能是表达式
[function fn2() {}]();
// 逗号也只能操作表达式
1, function fn3() {}();
作用：将全局变量与局部变量分隔开，保证全局变量不受污染。
6、求n!，用递归来实现
function factorial(num) {
if (num === 1 || num === 0) {
return 1;
}
else if (num < 0) {
return console.log("minus has no factorial");
}
return num*arguments.callee(num-1);
}
console.log(factorial(7));
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, '男');
/*name:饥人谷
age: 2
sex: 男
Arguments["饥人谷", 2, "男"]
name: valley
*/
getInfo('小谷', 3);
/*name: 小谷
age: 3
sex: undefined
Arguments["小骨", 3]
name: valley
*/
getInfo('男');
/*name: 男
age: undefined
sex: undefined
Arguments["男"]
name: valley
*/
8、写一个函数，返回参数的平方和？
function sumOfSquares() {
var sum=0;
for(var i=0; i<arguments.length; i++){
sum += arguments[i]*arguments[i];
}
return sum;
}
9. 如下代码的输出？为什么
console.log(a); //undefined, 变量声明会前置，并赋值undefined
var a = 1;
console.log(b); //报错, b未声明
10. 如下代码的输出？为什么
sayName('world');
sayAge(10);
function sayName(name){
console.log('hello ', name);
}
var sayAge = function(age){
console.log(age);
};
输出hello world，并报错:sayAge is not a function；
var sayAge = function(age){
console.log(age);
};
使用函数表达式声明函数，要先声明后使用。
11. 如下代码输出什么? 写出作用域链查找过程伪代码
var x = 10
bar()
function foo() {
console.log(x)
}
function bar(){
var x = 30
foo()
}
//输出10
globalContext = {
AO : {
x: 10
foo: function
bar: function
},
Scope: null
}
//声明 foo 时 得到下面
foo.[[scope]] = globalContext.AO
//声明 bar 时 得到下面
bar.[[scope]] = globalContext.AO
barContext = {
AO: {
x : 30
},
Scope = globalContext
}
fooContext = {
AO: {}
Scope = globalContext
}
//foo 函数是在全局作用域下定义的，执行console.log(x)时，函数内部没有定义变量x,向上寻找到函数定义时父对象定义有x = 10,故输出10
12.如下代码输出什么? 写出作用域链查找过程伪代码
var x = 10;
bar()
function bar(){
var x = 30;
function foo(){
console.log(x)
}
foo();
}
输出30，与11题的区别主要在于函数声明时的位置。
globalContext = {
AO: {
x: 10
bar: function
}
scope = null
}
bar.[[scope]] = globalContext.AO
barContext = {
AO: {
x: 30
foo: function
}
scope = globalContext.AO
}
foo.[[scope]] = barContext
fooContext = {
AO: {}
scope = barContext.AO
}
13. 以下代码输出什么? 写出作用域链的查找过程伪代码
var x = 10;
bar()
function bar(){
var x = 30;
(function (){
console.log(x)
})()
}
输出30
globalContext = {
AO: {
x: 10
bar:function
}
scope: null
}
bar.[[scope]] = globalContext.AO
barContext = {
AO: {
x: 30
function
}
scope = globalContext.AO
}
function.[[scope]] = barContext.AO
functionContext = {
AO: {}
scope = barContext.AO
}
14. 以下代码输出什么？ 写出作用域链查找过程伪代码
var a = 1;
function fn(){
console.log(a)//变量声明提升，此时a定义但未被赋值。故输出undefined
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)
输出：undefined 5 1 6 20 200
globalContext = {
AO: {
a: 200
fn: function
fn3: function
}
scope = null
}
fn.[[scope]] = globalContext.AO
fn3.[[scope]] = globalContext.AO
fnContext = {
AO: {
a: 20
fn2: function
}
scope = globalContext.AO
}
fn2.[[scope]] = fnContext.AO
fn3Context = {
AO: {}
scope = globalContext.AO
}
fn2Context = {
AO: {}
scope = fnContext.AO
}
