整理下Javascript的函数

函数的声明方法

1.函数声明

function f(){}

函数声明优先级大于变量提升

function a(){
   return b;
   b=10;
   function b(){}
   var b=＂11＂
}

console.log(typeof a())

答案:ｆｕｎｃｔｉｏｎ
解析:考察［函数提升］优先级＞［变量提升］
return后面的不执行

function a(){
　　function b(){}
   return b;
   b=10;
   var b=＂11＂
}

2.函数表达式
创建了一个匿名函数,没有函数提升,但得注意变量提升

var f = function (){}

注意：函数表达式定义的函数，函数名外部无法引用，如下：

  1.  var fn = function f(){};
      console.log(typeof f);  //打印undefined，函数表达式的函数名f在外部是访问不到的
   2. if(function f(){}){
        console.log(typeof f);  //同理，打印undefined，if语句中的函数解析为函数表达式，函数名f在外部是访问不到的
      }

作者：zh2443
链接：https://www.jianshu.com/p/5304f4196d2c
来源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

3.构造函数

function Person( name){
       this.name =name;
     }
      var Fsskay=new Person('Fss');
      console.log(Fsskay.name) //Fss

构造函数的this指向window

函数的作用域

函数内部可以读取外部变量(作用域链由内往外)[例子f3],外部不能读取函数内的局部变量[例子f1]
函数内部声明var会变量提升[例子f1],函数内部的函数声明会函数提升
函数内部声明变量不用var,会修改外部变量[例子f3]

var v = 1;

function f1(){
	console.log(v,'v1')//undefined,因为内部变量提升var a
  	var v = 2;
  	console.log(v,'v2');//2
}
console.log(v)//1

function f2(){
	console.log(v,'v3') //1 读取的全局变量
}
分割线------------------------------------------------------------------
function f3(){
	v=3
};
f3()  //执行下f3
console.log(v,'全局的那个v')//3

函数本身也是一个值，也有自己的作用域。它的作用域与变量一样，就是其声明时所在的作用域，与其运行时所在的作用域无关。
例子

var a = 1;
var x = function () {
  console.log(a);
};
function f() {
  var a = 2;
  x();
}
f() // 1

考题:

  var a =3;
  var b={
   a:2,
   b:{
     a:1,
     c:function(){ 
           return this.a
        }
      }
    }
var test = b.b.c;

console.log(test())
console.log(b.b.c())
答案://3
     //1
解析:考察浅拷贝与this的指向,考察 函数作用域是在声明时候的作用域
test=b.b.c ,test=f(){ return this.a},test()所在的作用域是全局window,window下的a=3,所以第一个是3
b.b.c()的this就是c所在的对象b下的a,所以this.a是a=1

函数的闭包

什么是闭包? 让外部读取函数内部变量
怎么做? 函数1内再给一个函数2,返回这个函数2的结果

 function f1(){
	var n=1
	function f2(){
	console.log(n)
	}
	return  f2()
}

// 1

有什么用?
1.外部函数访问内部函数作用域,减少使用全局变量
2.内部变量不垃圾回收,占内存

立即执行函数(自执行函数)

是什么?函数创建后立即执行,本质上是函数表达式(具名或匿名的)
怎么做?

(function(){})
(function(){})();
!function(){}();
+function(){}();
-function(){}();
~function(){}();

有什么用?
1.封装私有变量,外部读取不到内部函数
2.一种函数的调用方式,调用后垃圾回收,不占内存
3.只有表达式才能被执行,只执行一遍就自动销毁

递归

简单来说就是自己调用自己，递归需要设置结束条件

function f(n){
    if(n === 1){
        return 1
    }
    return n * f(n-1)
}
f(3)  //6

继承

细看可以看https://www.cnblogs.com/humin/p/4556820.html
大概记一下就是原型链继承prototype,构造函数继承,ES6 extends继承.

调用(call,apply,bind)

fn.call(this,参数列表) 立即调用
fn.apply(this.参数数组) 立即调用
fn.bind(this,参数列表) 之后调用
bind 方法返回值是函数以及 bind 接收的参数列表的使用。
bind 方法不会立即执行，而是返回一个改变了上下文 this 后的函数。

参数的使用
function fn(a, b, c){
console.log(a, b, c);
}

var fn1 = fn.bind(null, '123');
fn('A', 'B', 'C');       // A B C
fn1('A', 'B', 'C');     // 123 A B
fn1('B', 'C');           // 123 B C
fn.call(null, '123');   // 123 undefined undefined    call 是把第二个及以后的参数作为 fn 方法的实参传进去，而 fn1 方法的实参则是在 bind 中参数中的基础上再往后排