函数声明和函数表达式的区别

//函数声明

function wscat(type){
   return type="wscat";
}

//函数表达式

var oaoafly =function (type){
  return type="oaoafly";
}

区别

1. 函数声明不管在哪里定义，该函数都可以进行调用。而函数表达式的值必须是在函数表达式赋值完成后，该函数才能调用。
2. 对于函数声明，js解析器会优先读取，确保在所有 代码执行前声明已经被解析。而函数表达式，如同其他基本类型的变量一样，只在执行到某一句的时候也会对其进行解析。

声明前置

变量声明前置

变量声明前置就是在一个作用域块中，所有的变量都被放在块的开始声明。

var a=1;
function main(){
  console.log(a);
  var a=2;
}

main()//输出undefined;
为什么会输出undefined呢？是因为脚本在运行的时候会自动将变量声明前置解析如下：

var a=1;
function main(){
  var a;
  console.log(a);
  a=2;
}//所以，我们在写js的时候应该尽量将变量声明放在作用域的开始地方。

函数声明前置

使用function关键字就可以声明一个函数，它的特征是函数声明提升，执行代码前会先读取函数声明，即函数声明不必放在调用的前面。

var a=3;
console.log(a);
sayHello();
function sayHello (){
  console.log("hello");
}
解析为
var a;
function sayHello(){}
然后：conslole.log(a);
         a=3;
        sayHello();

对于函数表达式，和var一个变量没什么区别。

arguments

可以在函数体内读取所有的参数，这就是argunments对象的由来。

arguments对象的使用

• 通过方括号语法访问每一个元素

var fun=function(one){
  console.log(arguments[0]);
  console.log(arguments[1]);
  console.log(arguments[2]);
}
fun(1,2,3)
//1
//2
//3

• 通过length属性，查看到底要几个参数

function fun(){
  return argunments.length;
}
fun(1,2,3,)

• 参数赋值（严格模式下不容许）

var fun=function (a,b){
  argunments[1]=2;
  return a+b;
}
fun(1,1)//3

重载

js没有重载，但是可以在js中实现重载的功能，即传递不同的实参，可以自动调用匹配。

function print(name,age,sex){
  if(name){
    console.log(name);
}
  if(age){
  console.log(age);
}
  if(sex){
  console.log(sex);
}
}
print("byyu",26)

立即执行函数

最常用的两种写法：

(function (){/*code*/}());
(function (){/*code*/})();

为什么第一种执行而不报错呢?因为在js里，括号内部不能包含语句，当解析器对代码进行解析的时候，先碰到了()，然后碰到function关键字就会自动将()里面的代码识别为函数表达式而不是函数声明。

作用

模拟块作用域
js只有函数作用域，在同时调用多个库的情况下，很容易造成对象或者变量的覆盖。
liba.js

var num=1;

libb.js

var num=2;

如果在页面上同时引用liba,js和liba,js两个库。必然导致num的覆盖，为此：
liba.js

(function(){
  var num=1;
})();
libb,js

(function(){
  var num=2;
})();

经过改造之后，两个库的代码就完全独立，互不影响了。

用递归实现 n！

function factor(n){
  if (n==1){
  return 1
}
  return n*factor(n-1);
}
factor(100)

代码输出

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，undefined,['小谷，'3']，name:valley;
getInfo('男');name:男，undefined,undefined,['男']，name:valley；

写一个函数，返回参数的平方和

function sumOfSquares(){
  var result=0;
  for(i=0;i<arguments.length;i++){
  result=result+argument[i]+argument[i];
}
  return result;
}
var demo=sumOfSquares(1,3,4);
console.log(demo);

代码输出（变量提升）

console.log(a);
var a = 1;
console.log(b);

console.log(a)输出undefined;因为a变量提升,相当于

var a;
console.log(a);

只声明了没有赋值，为undefined。
console.log(b)会报错，因为既没有声明也没有赋值。

代码输出（函数声明前置）

       sayName('world');
    sayAge(10);
    function sayName(name){
        console.log('hello ', name);
    }
    var sayAge = function(age){
        console.log(age);
    };

sayName函数会输出'hello''world',sayAge会报错
原因：第一个是函数声明，会函数声明前置，所以函数声明不必放在调用的前面。而第二个是函数表达式，相当于普通变量，所以函数调用必须放在函数声明的后面，否则会报错。

作用域链（查找过程伪代码）

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.[[scope]]=globalcontext.Ao;
bar.[[scope]]=globalcontext.Ao;
barcontext={
  Ao{
  x:30;}
  scope:globalcontext.Ao;
}
foocontext={
  Ao{};
  scope:globalcontext.Ao;
}//调用foo时候会先从Ao里面找，Ao里面为空，会向globalcontext.Ao里面找，找到x=10,所以会打印出10。

作用域链（查找过程伪代码）

var x = 10;
bar()
function bar(){
var x = 30;
function foo(){
console.log(x)
}
foo();
}
过程：

1. globalcontext={
   Ao:{
    x:10;
    bar: function;
}
  scope:null;
}   
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.调用foo()的时候，会在foo的Ao中查找，可见里面没有。所以会在scope里面找，barcontext.Ao里面有x=30;所以输出的结果为30。

查找过程的伪代码（立即执行函数）

var x = 10;
bar() 
function bar(){
  var x = 30;
  (function (){
    console.log(x)
  })()//等价于function foo(){console.log(x);}
}

过程：

1. globalcontext={  
  Ao:{
  x:10;
  bar:function;
}
scope:null;
}
bar.[[scope]]=globalcontext.Ao;
2. barcontext={
  Ao:{
    x:30;
    foo:function;
}
scope:globalcontext.Ao;
}
foocontext.[[scope]]=barcontext.Ao;
3. foocontext={
    Ao:{};
    scope:barcontext.Ao;
}//调用foo()函数时，Ao中没有值。所以在scope:barcontext.Ao查找;其中中x=30,所以输出30

作用域链（查找过程伪代码）

var a = 1;

function fn(){
  console.log(a)//输出undefined;因为变量声明前置var a
  var a = 5
  console.log(a)输出5，因为a=5
  a++
  var a
  fn3()
  fn2()
  console.log(a)//输出6，因为a++,a为6

  function fn2(){
    console.log(a)//输出20，因为fn2.[[scope]]=fncontext.Ao;并且a=20,将
                             fncontext.Ao中的a=6改为20；
    a = 20
  }
}

function fn3(){
  console.log(a)//输出200，因为fn3中的AO为空，所以会在
                      globalcontext.Ao;中找，又因为a=200,将a=1改为200，所以a=200
  a = 200
}

fn()
console.log(a)

过程：

globalcontext={
  Ao:{
    a:1;
    fn3:function;
    fn:function;
}
scope:null;
}
fn3.[[scope]]=globalcontext.Ao;
fn.[[scope]]=globalcontext.Ao;
fncontext={
  Ao:{
    a:6;
    fn2:function;
  scope:globalcontext.Ao;
}
fn2.[[scope]]=fncontext.Ao;
}
fn3context={
    Ao:{};
    scope:globalcontext.Ao;
}
fn2context={
  Ao:{};
  scope:fncontext.Ao;
}