一个闭包和原型继承的例子

(function(window, jQuery, undefined) {

var HTMLS = {
    ovl: '<div class="J_WinpopMask winpop-mask" id="J_WinpopMask"></div>' + '<div class="J_WinpopBox winpop-box" id="J_WinpopBox">' + '<div class="J_WinpopMain winpop-main"></div>' + '<div class="J_WinpopBtns winpop-btns"></div>' + '</div>',
    alert: '<input type="button" class="J_AltBtn pop-btn alert-button" value="确定">',
    confirm: '<input type="button" class="J_CfmFalse pop-btn confirm-false" value="取消">' + '<input type="button" class="J_CfmTrue pop-btn confirm-true" value="确定">'
}

function Winpop() {
    var config = {};
    this.get = function(n) {
        return config[n];
    }

    this.set = function(n, v) {
        config[n] = v;
    }
    this.init();
}

Winpop.prototype = {
    init: function() {
        this.createDom();
        this.bindEvent();
    },
    createDom: function() {
        var body = jQuery("body"),
            ovl = jQuery("#J_WinpopBox");

        if (ovl.length === 0) {
            body.append(HTMLS.ovl);
        }

        this.set("ovl", jQuery("#J_WinpopBox"));
        this.set("mask", jQuery("#J_WinpopMask"));
    },
    bindEvent: function() {
        var _this = this,
            ovl = _this.get("ovl"),
            mask = _this.get("mask");
        ovl.on("click", ".J_AltBtn", function(e) {
            _this.hide();
        });
        ovl.on("click", ".J_CfmTrue", function(e) {
            var cb = _this.get("confirmBack");
            _this.hide();
            cb && cb(true);
        });
        ovl.on("click", ".J_CfmFalse", function(e) {
            var cb = _this.get("confirmBack");
            _this.hide();
            cb && cb(false);
        });
        mask.on("click", function(e) {
            _this.hide();
        });
        jQuery(document).on("keyup", function(e) {
            var kc = e.keyCode,
                cb = _this.get("confirmBack");;
            if (kc === 27) {
                _this.hide();
            } else if (kc === 13) {
                _this.hide();
                if (_this.get("type") === "confirm") {
                    cb && cb(true);
                }
            }
        });
    },
    alert: function(str, btnstr) {
        var str = typeof str === 'string' ? str : str.toString(),
            ovl = this.get("ovl");
        this.set("type", "alert");
        ovl.find(".J_WinpopMain").html(str);
        if (typeof btnstr == "undefined") {
            ovl.find(".J_WinpopBtns").html(HTMLS.alert);
        } else {
            ovl.find(".J_WinpopBtns").html(btnstr);
        }
        this.show();
    },
    confirm: function(str, callback) {
        var str = typeof str === 'string' ? str : str.toString(),
            ovl = this.get("ovl");
        this.set("type", "confirm");
        ovl.find(".J_WinpopMain").html(str);
        ovl.find(".J_WinpopBtns").html(HTMLS.confirm);
        this.set("confirmBack", (callback || function() {}));
        this.show();
    },
    show: function() {
        this.get("ovl").show();
        this.get("mask").show();
    },
    hide: function() {
        var ovl = this.get("ovl");
        ovl.find(".J_WinpopMain").html("");
        ovl.find(".J_WinpopBtns").html("");
        ovl.hide();
        this.get("mask").hide();
    },
    destory: function() {
        this.get("ovl").remove();
        this.get("mask").remove();
        delete window.alert;
        delete window.confirm;
    }
};

var obj = new Winpop();
window.alert = function(str) {
    obj.alert.call(obj, str);
};
window.confirm = function(str, cb) {
    obj.confirm.call(obj, str, cb);
};

})(window, jQuery);

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
闭包是指在一个函数内部定义的函数可以访问外部函数的变量和参数,即使外部函数已经执行结束。闭包形成一个封闭的作用域,保留了外部函数的变量和环境。这种特性使得闭包可以解决诸如变量私有化、保存变量状态等问题。 闭包的应用场景有很多,例如在异步编程中,可以使用闭包来保持状态,避免变量提升导致的错误;在模块化开发中,可以使用闭包来实现私有变量和方法的封装。但闭包也有一些注意事项,比如会占用内存,造成内存泄漏;还可能导致变量无法被垃圾回收,影响性能。 原型链是JavaScript中实现继承的机制。每个JavaScript对象都有一个内置的属性__proto__指向它的原型对象,原型对象又有自己的__proto__,形成了原型链。当访问对象的属性或方法时,会先在对象本身查找,如果找不到则沿着原型链向上查找,直到找到或者到达原型链的末尾(即null)。 原型链的好处是可以节省内存,将公共的属性和方法定义在原型对象中,所有实例对象共享这些属性和方法;还可以实现继承,子类对象的原型对象可以指向父类对象,从而共享父类的属性和方法。 原型链的缺点是只能继承父类的实例属性和方法,不能继承构造函数中的私有属性和方法;还有可能出现多个子类实例共享同一个父类实例的情况,导致数据共享的问题。 为了解决原型继承的缺点,ES6引入了class关键字,可以更方便地实现面向对象编程,并且支持super关键字调用父类的方法。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值