函数声明和函数表达式有什么区别？
函数声明和函数表达式是EMACScript规定的两种不同的声明函数的方法。
1.函数声明
//声明函数
function name() { //function+函数名+（参数）+{函数体}
console.log ('Jack')
}
//函数调用
name()
函数声明会在JavaScript代码开始时提到最前面进行定义，因此函数声明不必在调用之前定义。
2.函数表达式
var name = function () {
console.log ('Jack')
}
虽然变量声明会提到JavaScript代码开始前，但是赋值要运行到该行代码才执行，因此在调用用函数表达式声明的函数时，声明必须放到调用前。
总结区别：
1.函数声明会在代码开始前定义，函数表达式遇到时才会执行。
2.函数声明必须有函数名，函数表达式则可以省略。
什么是变量的声明前置？什么是函数的声明前置？
- 变量的声明前置：
在一个作用域块中，所有的变量声明都会被JS引擎放在作用域块范围的顶部进行声明；
- 函数的声明前置：
和变量声明前置一样，执行代码之前会先读取函数声明，只要函数在代码中进行了声明，无论它在作用域块的哪个位置上进行声明，JS引擎都会将它的声明放在作用域块范围的顶部进行声明；
arguments是什么?
在ECMAScript中，函数的参数在内部是用一个数组来表示的。在函数体内，可以用arguments来访问这个参数数组。arguments是一个类数组对象（不是Array的实例），因为可以使用方括号语法访问它的每一个元素，使用length属性来确定传递进来多少参数，示例：
function test () {
console.log (arguments.length); //参数的长度
console.log (arguments[0]); //第一个参数
console.log (arguments[1]); //第二个参数
}
test ('Jack',1,'888');
//输出结果为 3，'Jack'，1
JS函数的"重载"怎样实现？
重载，是函数或者方法有相同的名称，但是参数列表不相同的情形，这样的同名不同参数的函数或者方法之间，互相称之为重载函数或者方法。但是在JS，并没有重载这个概念，但我们可以用另外一种方法实现这个功能：
function test (num) {
if (num>=90) {
console.log ('优秀')
}
if (num>=60&&num<90) {
console.log ('及格')
}
if (num<60) {
console.log ('不及格')
}
}
test(95) //输出 '优秀'
test(77) //输出 '及格'
test(18) //输出 '不及格'
这样对于同一个函数，输入不同参数就会得到不同结果。
立即执行函数表达式是什么？有什么作用？
在JS中我们可以使用函数声明和函数表达式声明函数，再通过函数名进行调用：
function sayName (name) { //函数声明声明函数
console.log (name);
}
sayName ('Jack'); // 调用函数
var sayName = function () { //函数表达式声明函数
console.log (name);
}
sayName ('Jack') // 调用函数
因为在JS中圆括号()内是不能有语句的，括号内容会被当做表达式，因此上面例子可以进行改写：
(function (name) {
console.log (name);
})('Jack')
//或者
(function (name) {
console.log (name);
}('Jack')) // 输出都为Jack
当JS执行到该行代码时，函数会被定义且立即执行，叫做立即执行函数表达式。使用立即执行函数表达式可以创建一个独立的作用域，形成隔离，避免污染全局。
求n!，用递归来实现
ffunction multiply(n){
if(n===1){
return 1;
}
return n*multiply(n-1);
}
multiply(3);//6
以下代码输出什么？
function getInfo(name, age, sex){
console.log('name:',name);
console.log('age:', age);
console.log('sex:', sex);
console.log(arguments); //输出整组参数；
arguments[0] = 'valley'; //第一个参数赋值为‘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 sum = 0;
for(var i = 0;i < arguments.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(result) //10
解释下列代码的输出及原因
console.log(a); // 由于声明提前，此时a未赋值，输出undefined；
var a = 1; // a=1;
console.log(b); //报错，b未被声明;
sayName('world');
sayAge(10);
function sayName(name){
console.log('hello ', name);
}
var sayAge = function(age){
console.log(age);
};
//解释
function sayName(name){ //函数声明和变量声明提前；
console.log('hello ', name);
}
var sayAge;
sayName('world'); //调用函数，输出'hello，world';
sayAge(10); //undefined，因为sayAge未定义；
sayAge = function(age){
console.log(age);
};
//函数表达式需放到调用前！！
如下代码输出什么? 写出作用域链查找过程伪代码
var x = 10
bar()
function foo() {
console.log(x)
}
function bar(){
var x = 30
foo()
} // 输出 10；
/*作用域查找过程
goblecontext = {
AO: {
X=10
foo: function
bar: function
}
foo.[[scope]]: goblecontext.AO
bar.[[scope]]: goblecontext.AO
}
foocontext = {
AO: {}
scope: goblecontext.AO
}
barcontext = {
AO: {
x = 30
}
scope: goblecontext.AO
}*/
var x = 10;
bar()
function bar(){
var x = 30;
function foo(){
console.log(x)
}
foo();
} //输出30
/*作用域查找过程
goblecontext = {
AO: {
x=10
bar:function
}
bar.[[scopr]]=goblecontext.AO
}
barcontext = {
AO: {
x=30
foo:function
}
foo.[[scope]]=barcontext.AO
scope=goblecontext.AO
}
foocontext = {
AO: {}
scope=barcontext.AO
}*/
var x = 10;
bar()
function bar(){
var x = 30;
(function (){
console.log(x)
})()
} //输出30
/*作用域查找
goblecontext = {
AO: {
x=10
bar:function
}
bar.[[scope]]=goblecontext.AO
scope=null
}
barcontext = {
AO: {
x=30
f:function
}
f.[[scope]]=barcontext.AO
scope=goblecontext.AO
}
fcontext = {
AO: {}
scope=barcontext.AO
}*/
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() //输出：undefined，5，1，6，20，200；
console.log(a)
/*
goblecontext = {
AO: {
a: undefined
fn: function
fn3: function
}
scope = null
fn.[[scope]] = goblecontext.AO
fn3.[[scope]] = goblecontext.AO
}
fncontext = {
AO: {
a: undefinef
fn2: function
}
scope = goblecontext.AO
fn2.[[scope]] = fncontext.AO
}
fn2context = {
AO: {
a: 20
}
scope = fncontext.AO
}
fn3context = {
AO: {
a: 200
}
scope = goblecontext.AO
}*/
遇到fn(),开始执行：
console.log(a),，此时fncontextAO中a未被赋值，输出undefined；
a = 5;
console.log(a)，此时fncontextAO中a被赋值为5，输出5；
a++，fncontextAO中a变为6；
var a，因为a已经存在，故无意义；
fn3()，执行fn3()，进入fn3context；
console.log(a)，goblecontextAO中，a=1，故输出1；
a=200，goblecontextAO中a变为200；
fn2，执行fn2()，进入fn2context；
console.log(a)，fncontextAO中，a=6，故输出6；
a=20，fncontextAO中，a变为20；
console.log(a)，fncontextAO中，a为20，故输出20；
fn执行完毕；
console.log(a)，goblecontextAO中，a为200，故输出200；