ES6学习————（三）

函数参数的默认值

  参数的默认值默认声明，不能用let或const声明和参数同名的变量或常量

		function fn(x = 520) {
  			let x = 20; 		// 报错
  			const x = 50; 		// 报错
		}

  定义了默认值的参数应该作为尾参数

		function fn(x = 1, y) {
 			 return [x, y];
		}
		fn() // [1, undefined]
		fn(2) // [2, undefined]
		fn(, 1) // 报错
		fn(undefined, 1) // [1, 1]


		function fn(x, y = 4, z) {
  			return [x, y, z];
		}
		fn() // [undefined, 4, undefined]
		fn(3) // [3, 4, undefined]
		fn(2, ,2) // 报错
		fn(5, undefined, 2) // [5, 4, 2]

  参数传入undefined将触发默认值，null则没有这个效果

		function fn(x = 6, y = 9) {
  			console.log(x, y);
		}
		fn(undefined, null)		// 6 null

  函数有一个length属性，返回没有设置默认值的参数的个数
  默认值的参数不是尾参数,则不计入后面的参数

		(function (x) {}).length // 1
		(function (y = 6) {}).length // 0
		(function (x, y, z = 6) {}).length // 2


		(function (xx = 2, yy, zz) {}).length // 0
		(function (xx, yy = 4, zz) {}).length // 1

rest参数

  rest参数只能放在最后面

        function f1(...a){
            console.log(arguments);			//类数组
            console.log(a);					//数组[1,21,13,4,5]
        }
        f1(1,21,13,4,5);

  rest参数让数组排列更简单

		// 从小到大排列
		function f1(b,...a){
			a = a.sort(function(x,y){
                return x-y
            })
            console.log(a);
            
        }
        f1(1,21,13,4,5);

  函数的length属性，不包括 rest 参数

		(function(...x) {}).length		// 0
		(function(y, ...z) {}).length	// 1

严格模式

  除了正常的运行模式之外，ES6添加了第二种运行模式：严格模式
  严格模式就是让JS代码在更严格的条件运行

  严格模式的作用

    	1.消除了js代码中一些不合理、不严谨之处，减少了一些怪异行为
   	 	2.消除了代码运行的一些不安全之处，保证代码的安全执行
    	3.提高编译效率，增加运行速度

  开启严格模式的方式

		第一种	在全局第一行
       		"use strict"

		第二种	在函数体的第一行
        	function f1(){
           		 "use strict"
        	}

  严格模式下常见的变化
    1. 严格模式禁止没有声明就赋值变量的情况

         a = 1;
         console.log(a);				//报错，a没有定义

    2. 严禁删除已声明的变量

        let b = 123;
        console.log(delete b);			//报错，在严格模式下删除非限定标识符

    3. 严格模式下，全局中普通函数的调用this指向undefined

        function f2(){
            console.log(this);			//undefined
        }
        f2();

    4. 构造函数只能使用new调用（普通调用this指向undefined）

        function f3(){
            this.name = "xiaoming";
            this.age = 18
        }

        let F = new f3();
        console.log(F);

        //f3();		//f3中this指向undefined

    5. 定时器中回调函数的this仍旧指向window

        setTimeout(function(){
            console.log(this);			//window{}
        },500);

    6. 严格模式下，函数中不允许有重名的参数

        function f4(a,a){
            console.log(a+a);			//报错，不允许重复参数名称
        }
        f4(1,2)

name属性

  函数中有一个默认属性name，保存的是函数名 是一个只读属性，修改无效

    	function foo(){
    	}
    	console.log(foo);				//foo(){}
    	foo.name = "fun";
    	console.log(foo.name);			//foo


    	let f1 = function (){}
    	console.log(f1.name);			//f1

箭头函数

  箭头函数的作用：简化代码
          回调函数大部分情况会选择使用箭头函数
 
  1. 箭头函数简写
     当有且只有一个参数，箭头函数的（）可省
     函数体内有且只有一句语句，{}可省 如果这个语句是返回语句 return可省

        let f2 = a =>console.log(111);

        //let f2 = (a)=>{return 111}
        let f2 = a => 111;
        
        // 如果返回值是一个对象
        // let f2 = a => {return {x:1}};
        let f2 = a => ({ x: 1 });

  2. 箭头函数中没有arguments,可以用rest参数替代arguments
 
  3. 关于箭头函数this的指向
    箭头函数内的this对象，就是定义时所在的对象，而不是使用时所在的对象。
    不可以当作构造函数使用new命令，会抛出一个错误。
    巧记：如果要找箭头函数中的this，找离它最近的function的this

递归

  递归：函数的内部自己调用自己
    递归很容易出现"栈溢出",所以递归必须加退出条件

        	let i = 0;
       		function f1(){
        		i++;
        		if(i==3){
            		return;
        		}
            	f1();
       		}
       		f1();

  求阶乘

			//  n*(n-1)*（n-2)*...*2*1
    		function fj(n){
        		if(n == 1){
            		return 1;
        		}
        		// 24
        		return n*fj(n-1);
    		}

    		console.log(fj(4));

  斐波那契数列

    		// 1、1、2、3、5、8、13、21、34
    		function ff(n){
        		if(n==1 || n == 2){
            		return 1;
        		}
        		return ff(n-1)+ff(n-2);
    		}
    		console.log(ff(3));