函数的参数和return

参数

参数是局部变量，优先级高于同名的全局变量
是为了解决函数的抽象化，多态化。具备模块化功能

js因为是弱引用语言，参数可以多样化改变，但也因此造成函数中需要对参数做大量的判断

function on(type,data,handler){
           if(data.constructor===Function){//函数
               handler=data;//数据
               data=null;
           }


        }

        on("click",function(){

        });
        on("click",{a:1,b:2},function(){

        })

参数也可以做为递归函数中初始设置变量

//递归
function fnc(num){
            if(num===undefined) num=0;
            num++;
            if(num<10) return fnc(num);
            return num;
        }

      var s=fnc();
      console.log(s);

在多函数中，参数可以被作为中介值来回传递，并且处理。减少全局变量

 
 //参数可以传递，达到代码分离效果
 
 function fn1(){
        var num=1;
        num=fn2(num);
        console.log(num);
      }

      function fn2(n){
         n++;
          return fn3(n);
      }
      function fn3(n){
         n*=n;
         return n;
      }

      fn1();

js中参数没有初始值（ES5），参数是没有类型区分（大量判断），参数的先后问题（必须参数在前，不必须参数在后），(ES5)参数没有若干(…arg)，但是有arguments

return

使用return跳出函数，条件作用时，使用return可以解决多分支解构
- return使用跳出时直接跳出循环或者条件，返回undefined
- 使用return可以在setInterval或者快速连续调用时用于防抖
- 使用return可以完成函数的开关操作

工厂模式

 function ce(type,style){
        var elem=document.createElement(type);
        Object.assign(elem.style,style);
        return elem;//每次返回一个新内容
    }

//给什么材料加工什么产品，每次创造出新产品，div1和div2引用不一样
    var div1=ce("div");
    var div2=ce("div");
    var p=ce("p");
    console.log(div1===div2);

 function createObj(){
         return{
             a:1,
             b:2
         }
     }
  var o=createObj();//执行一次产生一个对象

单例模式

完成功能：

//只创造一个
var elem;
     function createElem(){
         if(elem) return elem;
         elem=document.createElement("div");
         return elem;
     }
     
     同上
      function createElem(){
         if(!elem) elem=document.createElement("div");
         return elem;
     }
        var a=createElem();
        var b=createElem();
         console.log(a===b);

 class Box{
         static _instance
         constructor(){

         }
         static getInstance(){
             if(!Box._instance)Box._instance=new Box();
             return Box._instance;
         }

     }

   var a=Box.getInstance()
    var b=Box.getInstance();
    console.log(a===b);
    
    
    class Box{
        constructor(){

        }
        static get instance(){
            if(!Box._instance){
                Object.defineProperty(Box,"_instance",{
                //_instance不可枚举，不可修改，不可删除
                    value:new Box()
                })
            }
            return Box._instance;
        }

        play(){
            console.log("play");
        }
        run(){
            console.log("run");
        }
    }
      var a=Box.instance
      var b=Box.instance;
      console.log(a===b);
     
     Box.instance.play();
     Box.instance.run();//任何时候都可以调用，不需要实例化

返回参数对象

 function fn(obj){
        obj.a=10;
        return obj;
     }

    var obj=fn({b:1})
     var obj={b:1};
    obj=fn(obj);
     console.log(obj);

如果参数是函数，返回回调函数的结果

function fn1(fn){
            return fn(5,6);
        }

        function fn2(a,b){
            return a+b;
        }

       var sum=fn1(fn2);
       console.log(sum);

返回数组或者对象，用于返回多个元素

//返回数组
function fn(){
            var a=1;
            var b=2;
            var c=3;
            return [a,b,c];
        }


        let [a,b,c]=fn();
        
 //返回对象

 function fn(){
            return {
                a:1,b:2,c:3
            }
        }

        let {a,b,c}=fn();

返回函数体

function fn(){
            return function(){
                console.log("aaa");
            }
        }


        var f=fn();
        f();
        f();

函数的参数和return

函数的参数和return

参数

return

猜你喜欢