1.函数声明和函数表达式有什么区别
函数声明可以看作是函数的初始化，我们将给函数传参并建立函数体的表达式，当我门建立完成后，就可以进行函数的表达式了，做法如下:function foo(){}, foo();
函数表达式其实就是创建一个匿名的函数声明并赋值给一个变量,如var foo = function () {}。
区别是函数声明会提升，可以在任意位置调用，而函数表达式赋值给变量后，变量提升但此时是undefined,不能在函数表达式前调用函数。
2.什么是变量的声明前置？什么是函数的声明前置？
变量提升：当一个变量被定义时，在代码执行前会先将变量进行初始化再执行语句。
函数的声明前置：当一个函数以函数声明的方式声明时，代码执行前会首先生成该函数，然后再执行语句
3.arguments 是什么
argument是类数组对象，每个函数中都存在argument对象，argument并不是一个真正的数组
，所以不具备除length属性之外的属性，这个对象维护这所有传入该函数的参数列表。
通过以下语句可将arguments转化为数组对象
var args=Array.prototype.slice.call(arguments)
4.函数的"重载"怎样实现
通过判断参数是否存在来实现
function fn(name,age,sex) {
if (name) {
console.log(name);
}
if (age) {
console.log(age);
}
if (sex){
console.log(sex);
}
}
fn('gaojin');
fn('gaojin',24);
fn('gaojin',24,'male');
通过判断参数列表的个数来实现，即判断arguments.length来实现
function fn(name,age,sex){
if (arguments.length===1) {
console.log(name);
}
if (arguments.length===2) {
console.log(age);
}
if (arguments.length===3) {
console.log(sex);
}
}
5.立即执行函数表达式是什么？有什么作用
立即执行函数能够立即执行，这样可以做到隔离作用域，避免变量污染全局。
function(){ /* code */ }();// SyntaxError: Unexpected token
一般情况下，也许有人认为立即执行函数可能会是这个样子的，但其实为了避免解析上的歧义，JavaScript引擎规定，如果function关键字出现在行首，一律解释成语句。因此，JavaScript引擎看到行首是function关键字之后，认为这一段都是函数的定义，不应该以圆括号结尾，所以就报错了。
所以一般情况下要写成
(function(){ /* code */ }());//常用
或者
(function(){ /* code */ })();
上面两种写法都是以圆括号开头，引擎就会认为后面跟的是一个表示式，而不是函数定义语句，所以就避免了错误。这就叫做“立即调用的函数表达式”（Immediately-Invoked Function Expression），简称IIFE。
注意，上面两种写法最后的分号都是必须的。如果省略分号，遇到连着两个IIFE，可能就会报错。
推而广之，任何让解释器以表达式来处理函数定义的方法，都能产生同样的效果，比如下面三种写法。
var i = function(){ return 10; }();
true && function(){ /* code */ }();
0, function(){ /* code */ }();
6.求n!，用递归来实现
function factorial(i){
if (i===1) {
return 1;
}
else
return i*factorial(i-1);
}
console.log(factorial(5));
输出120
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 age:undefined ["小谷",3] name valley
getInfo("男");
输出 name:男 age:undefined sex:undefined [“男”] name valley
8.写一个函数，返回参数的平方和？
function sumOfSquares(){
var total=0;
if (arguments.length!==0){
for(var i=0;i<arguments.length;i++){
total+=Math.pow(arguments[i],2);
}
return total;
}
else return "输入有误";
}
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 ReferenceError: b is not defined
10. 如下代码的输出？为什么
sayName('world');
sayAge(10);
function sayName(name){
console.log('hello ', name);
}
var sayAge = function(age){
console.log(age);
};
hello world
TypeError: sayAge is not a function
原因：在代码开始解析前会进行变量提升和函数声明提升，而用函数声明方式的函数在哪里都可以被执行，所以返回hello world，而以函数表达式方式的，只有变量sayAge提升，函数表达式还留在原地，在此之前调用函数都会报错。
- 如下代码输出什么? 写出作用域链查找过程伪代码
var x = 10
bar()
function foo() {
console.log(x)
}
function bar(){
var x = 30
foo()
}
输出结果 10
globalContent={
AO:{
x:10
foo:function
bar:function
},
scope:globalContent.AO
}
barContent={
AO:{
x:30
},
scope：bar.[[scope]]=globalContent.AO
}
fooContent={
AO:{}
scope:foo.[[scope]]=globalContent.AO
}
- 如下代码输出什么? 写出作用域链查找过程伪代码
var x = 10;
bar()
function bar(){
var x = 30;
function foo(){
console.log(x)
}
foo();
}
输出结果 30,查找过程
globalContext={
AO:{
x:10
bar:function
},
scope:globalContext.AO
}
barContext={
AO{
x:30
foo:function
}，
scope:bar.[[scope]]=globalcontext.AO
}
fooContext={
AO{},
scope:foo.[[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:globalContext.AO
}
barContext={
AO:{
x:30
function
},
scope：bar.[[scope]]=globalContext.AO
}
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)
undefined,5,1,6,20,200
globalContext={
AO:{
a:1/200
fn:function
fn3:function
},
scope:globalContext.AO
}
fnContext={
AO:{
a:undefined/5/6/20
fn2:function
},
scope：bar.[[scope]]=globalContext.AO
}
fn3Context={
AO:{}
scope:fn3.[[scope]]=globalContext.AO
}
}
fn2Context={
AO:{}
scope：fn2.[[scope]]=fnContext.AO
}
