JavaScript学习笔记-函数实例

函数实例

var p = {
    a:15,
    b:'5',
    f1:function(){
        var self = this;
        console.log(self.a+self.b);
        f2();
        function f2(){
            console.log(self.a-self.b);
        }
        return self;  //返回this,方便对对象p进行链式调用
    },
    m1:function(n1,n2){
        this.a = n1>this.a?n1:this.a;
        this.b = n2>this.b?n2:this.b;
        return this;
    }
};
p.m1('23','r').f1();
//=======sum()可接收任意个数,任意类型参数,将有效数字求和,若为不可计算对象设为0==========
function sum(){
    var arg = arguments.length;
    var sum = 0;
    for(var i = 0;i<arg;i++){
        var s = Object.prototype.toString.call(arguments[i]).slice(8,-1);
        if(s === 'Number'||s ==='String'||s ==='Boolean'||s ==='Array'){
            arguments[i] =
                arguments[i] - 0 ||
                Array.prototype.reduce.call(
                    arguments[i],
                    function (x, y) {
                        x = x - 0 || 0;
                        y = y - 0 || 0;
                        return x + y;
                    }) ||
                0;
            sum += arguments[i];
        }
        else {
            sum += 0;
        }
    }
    return sum;
}

var a = 'b3c',b = 4,c = true,d=[,5,'q'];
var num1 = {a:1,b:2,c:3,d:'m'};
console.log('数字求和等于: '+sum(c,num1,a,b,d,/./));
console.log(a);
//====
function sum1(a){
    var total = 0;
    for(var i = 0;i<arguments.length;i++){
        var a = arguments[i],n;
        if(a==null) continue;
        if(Array.isArray(a)) n = sum1.apply(this,a);
        else if(typeof a === 'function') n = Number(a());
        else n = Number(a);
        total += n;
    }
    return total;
}
console.log(sum1([9,8,7,'6'],4));
//=====
var operators = {
    add:function(a,b){return a+b;},
    substract:function(a,b){return a-b;},
    multiply:function(a,b){return a*b;},
    divide:function(a,b){return a/b;},
    pow:Math.pow
};
function operate(operator,a,b){
    if(typeof operators[operator]==='function')
        return operators[operator](a,b);
    else throw new Error('unknown operator!');
}
console.log(operate('divide',20,4));
//=====
(function(){
    console.log('这里立即执行函数');
}());
//======特定场景下返回不同版本的extend或者extend2
var extend = (function(){
    for(var p in {toString:null}){
        return function extend(o){
            for(var i=1;i<arguments.length;i++){
                var source = arguments[i];
                for(var prop in source) o[prop] = source[prop];
            }
            return o;
        };
    }
    var protoprops = ['toString','valueOf','constructor','hasOwnProperty','isPropertyOf','propertyIsEnumerable','toLocaleString'];
    return function extend2(o){
        for(var i=1;i<arguments.length;i++){
            var source =arguments[i];
            for(var prop in source) o[prop] = source[prop];
            for(var j=0;j<protoprops.length;j++){
                prop = protoprops[j];
                if(source.hasOwnProperty(prop)) o[prop] = source[prop];
            }
        }
        return o;
    };
}());
var b1 = {a:1,b:2},b2 = {c:3,d:4};
console.log(extend); //[Function: extend]
console.log(extend(b1,b2)); //{ a: 1, b: 2, c: 3, d: 4 }
//=====
var uniq = (function(){
    var c = 0;
    return function(){return c++;};
}());
console.log(uniq());//0
console.log(uniq());//1
//=====无法从外部访问闭包内的局部变量,只有闭包内的方法可以访问
function couter(){
    var c=0;
    return {
        count: function() {return ++c;},
        reset: function() {return c=0;}
    };
}
var couter1 = couter() , couter2 = couter(); //创建不同的函数对象,他们互不干扰
console.log(couter1.count());//1
console.log(couter2.count());//1
console.log(couter1.reset());//0
console.log(couter1.count());//1
console.log(couter2.count());//2
//=========
function addPrivateProperty(o,name,predicate){
    var value;
    o['get'+name] = function(){return value;};
    o['set'+name] = function(v){
        if(predicate && !predicate(v)){
            throw Error('set'+name+':invalide value '+v);
        }else value = v;
    };
}
var o = {};
addPrivateProperty(o,'Name',function(x){return typeof x == 'string';});
o.setName('Frank');
console.log(o);
//=========面向对象的模块化编程(初探)======
var Module = (function(){
    var myModule = {};  //创建私有对象,被返回后变公共对象
    var _privateMethod = function(){return '_private';};  //私有方法
    myModule.publicMethod1 = function(){console.log('content a '+_privateMethod()+' and myself public_By_myModule');};
    var publicMethod2 = function(){console.log('public_By_return');};
    return{
        myModule:myModule,
        publicMethod2:publicMethod2,
        publicMethod3:function(){console.log('public');}
    }
})();
Module.myModule.publicMethod1();
Module.publicMethod2();
Module.publicMethod3();
//=============bind()
var sum3 = function(x,y){return x+y;};
var succ = sum3.bind(null,1); //x=1
succ(2);  //3,其中y=2
function f(x,y,z){return this.x+y+z;}
var g = f.bind({x:1},2); //x=1,y=2
g(3);  //6,z=3
f.bind({x:1},2,3)(); //6,立即执行函数
//======函数式编程:单独定义一些重复利用的基础功能函数并保存为变量,然后在实际应用中引用他们
var sum4 = function(x,y){return x+y;};
var square = function(x){return x*x;};
var data = [1,1,3,4,4];
var mean = data.reduce(sum4)/data.length;
var deviations = data.map(function(x){return x-mean;});
var stddev = Math.sqrt(deviations.map(square).reduce(sum4)/(data.length-1));
function compose(f1,f2){
    return function(){return f1.call(this,f2.apply(this,arguments));};
}
compose(square,sum4)(2,3); //25

//======

//=====不完全函数f的调用:
function array(a,n){return Array.prototype.slice.call(a,n||0);}
var f = function(x,y,z){return x*(y-z)};

function partialLeft(f /*,...*/){
    var args = arguments;
    return function(){
        var a = array(args,1);
        a = a.concat(array(arguments));
        return f.apply(this,a);
    };
}
console.log( partialLeft(f,2)(3,4) ); //-2, 其中a=[2,3,4]

function partialRight(f /*,...*/){
    var args = arguments;
    return function(){
        var a = array(arguments);
        a = a.concat(array(args,1));
        return f.apply(this,a);
    };
}
console.log( partialRight(f,2)(3,4) ); //6,其中a=[3,4,2]

function partial(f /*,...*/){
    var args = arguments;
    return function(){
        var a = array(args,1);
        var i = 0, j = 0;
        for(;i< a.length;i++){
            if(a[i] === undefined) a[i] = arguments[j++]; //每次循环后,若if条件为true,j也+1
        }
        a = a.concat(array(arguments,j));
        return f.apply(this,a);
    };
}
console.log(partial(f,2,undefined,3)(5,9));  //4,其中a=[2,5,3]

//======缓存技术的应用:检查要计算的参数,看是否在缓存内有用同样的参数计算过,若有则返回缓存的计算结果,避免重复计算
function memorize(){
    var cache = {}; //用来缓存的对象
    return function (f) {
            var args = Array.prototype.slice.call(arguments,1);
            var key = arguments.length-1 + ':' + f + args.join('-');
            if (key in cache) return cache[key];
            else {
                cache[key] = f.apply(this,args); //若缓存内不存在key,则创建这个key并赋值
                console.log(cache);
                return cache[key];
            }
    };
}
var add = function(x,y){return x+y;};
var divide = function(x,y){return x-y;};
var memo = memorize();
memo(add,4,5);
memo(Math.pow,4,5);
memo(divide,4,5);
//===
function memorize2(f){
    var cache2 = {};
    return {
        cheakMemo:function() {
            var key = arguments.length + ':(' + Array.prototype.join.call(arguments, ',') + ')';
            if (key in cache2) return cache2[key];
            else {
                cache2[key] = f.apply(this, arguments);
                console.log(cache2);
                return cache2[key];
            }
        },
        cache2:cache2
    };
}
var memo = memorize2(add);
memo.cheakMemo(4,5); //{ '2:(4,5)': 9 }
memo.cheakMemo(4,5); //直接取缓存的值,不计算
memo.cheakMemo(4,6); //{ '2:(4,5)': 9, '2:(4,6)': 10 }
memo.cheakMemo(4,7); //{ '2:(4,5)': 9, '2:(4,6)': 10, '2:(4,7)': 11 }