1.函数声明和函数表达式有什么区别
函数声明
function functionName(){
statement;
}
函数声明不必放到调用之前
函数表达式
var printName = function(){
statement;
};
声明必须放到调用之前
2.什么是变量的声明前置？什么是函数的声明前置
变量的声明前置
在解析代码时，变量会被提到当前作用域开头来声明，然后运行到原来的位置时再赋值。在赋值之前的调用会返回undefined而不是出错。
函数的声明前置
函数声明也会被提到当前作用域开头来声明，这样可以在把声明放到调用之后。
3.arguments 是什么
在JavaScript中，arguments是对象的一个特殊属性。arguments对象就像数组，但是它却不是数组，而是一个Arguments对象。arguments有length属性。
function printPersonInfo(name, age, sex){
console.log(name);
console.log(age);
console.log(sex);
console.log(arguments[0]);
}
printPersonInfo("a","b","c");
a
b
c
a
4.函数的"重载"怎样实现
根据传入参数的不同执行不同的逻辑
5.立即执行函数表达式是什么？有什么作用
部分转自
立即执行函数能够立即执行，这样可以做到隔离作用域，避免变量污染全局。
var liList = ul.getElementsByTagName('li')
for(var i=0; i<6; i++){
liList[i].onclick = function(){
alert(i) // 6
}
}
为什么 alert 出来的总是 6，而不是 0、1、2、3、4、5因为 i 是贯穿整个作用域的，而不是给每个 li 分配了一个 i
image
那么怎么解决这个问题呢？用立即执行函数给每个 li 创造一个独立作用域即可（当然还有其他办法）：
var liList = ul.getElementsByTagName('li')
for(var i=0; i<6; i++){
!function(ii){
liList[ii].onclick = function(){
alert(ii) // 0、1、2、3、4、5
}
}(i)
}
在立即执行函数执行的时候，i 的值被赋值给 ii，此后 ii 的值一直不变。
i 的值从 0 变化到 5，对应 6 个立即执行函数，这 6 个立即执行函数里面的 ii 「分别」是 0、1、2、3、4、5。
6.求n!，用递归来实现
function fac(n){
if(n===1||n===0){
return 1;
}
return n*fac(n-1);
}
console.log(fac(10));
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('男');
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
8.写一个函数，返回参数的平方和？
function sumOfSquares(){
var sum = 0;
for(var i=0;i<arguments.length;i++){
sum += arguments[i]* arguments[i];
}
return sum;
}
console.log(sumOfSquares(2,5)); //29
9.如下代码的输出？为什么
console.log(a); //undefined 已经声明但是没有赋值
var a = 1;
console.log(b); // 报错 未声明b
10.如下代码的输出？为什么
sayName('world'); // hello world
sayAge(10); //报错 函数表达式必须在调用前声明
function sayName(name){
console.log('hello ', name);
}
var sayAge = function(age){
console.log(age);
};
11.如下代码输出什么? 写出作用域链查找过程伪代码
var x = 10
bar()
function foo() {
console.log(x)
}
function bar(){
var x = 30
foo()
}
//10
调用过程：
1. globalContext = {
AO: {
x: 10;
foo:function
bar:function
}
foo.[[scope]] = globalContext.AO
bar.[[scope]] = globalContext.AO
}
2.调用bar() barContext = {
AO:{
x:30;
}
scope:bar.[[scope]] = globalContext.AO
}
3.调用foo() fooContext = {
AO:{}
scope:foo.[[]scope] =globalContext.AO
}
12.如下代码输出什么? 写出作用域链查找过程伪代码
var x = 10;
bar()
function bar(){
var x = 30;
function foo(){
console.log(x)
}
foo();
}
// 30
调用过程:
1. globalContext = {
AO: {
x: 10；
bar:function
}
bar.[[scope]] = globalContext.AO
}
2.调用bar() barContext = {
AO:{
x:30;
foo:function
}
scope:bar.[[scope]] = globalContext.AO
scope:foo.[[scope]] = barContext.AO
}
3.调用foo() fooContext = {
AO:{}
scope:foo.[[]scope] =barContext.AO
}
13.以下代码输出什么? 写出作用域链的查找过程伪代码
var x = 10;
bar()
function bar(){
var x = 30;
(function (){
console.log(x)
})()
}
// 30
调用过程：
1. globalContext = {
AO: {
x: 10；
bar:function
}
bar.[[scope]] = globalContext.AO
}
2.调用bar() barContext = {
AO:{
x:30;
匿名:function
}
scope:bar.[[scope]] = globalContext.AO
scope:匿名.[[scope]] = barContext.AO
}
3.调用匿名函数() 匿名Context = {
AO:{}
scope:匿名函数.[[scope]] =barContext.AO
}
14.以下代码输出什么？ 写出作用域链查找过程伪代码
var a = 1;
function fn(){
console.log(a) //undefined
var a = 5
console.log(a) //5
a++
var a
fn3()
fn2()
console.log(a) //20
function fn2(){
console.log(a) // 6
a = 20
}
}
function fn3(){
console.log(a) //1
a = 200
}
fn()
console.log(a) // 200
调用过程：
1. globalContext {
AO: {
a: 200;
fn: function
fn3: function
}
Scope: null;
fn.[[scope]]=globalContext.AO
fn3.[[scope]]=globalContext.AO
}
2. 调用fn()
fnContext{
AO:{
a:20
fn2:function
}
fn.[[scope]]=globalContext.AO
fn2.[[scope]]=fnContext.AO
}
3. 调用fn3()
fn3Context{
AO:{}
fn3.[[scope]]=globalContext.AO
}
4. 调用fn2()
fn2Context{
AO:{}
fn2.[[scope]]=fnContext.AO
}