javascript - 使用闭包来模拟封装是个坏主意吗？

Question

例如，看一下我对堆栈的简单实现:

var MyStack = (function() {
    var min;
    var head;

    // Constructor
    function MyStack() {
        this.size = 0;
    }

    MyStack.prototype.push = function(val) {
        var node = new Node(val);

        if (typeof min === 'undefined' || val < min) {
            min = val;
        }

        ++this.size;
        if (typeof head === 'undefined') {
            head = node;
        } else {
            node.next = head;
            head = node;
        }
    };

    MyStack.prototype.pop = function() {
        if (typeof head === 'undefined') {
            throw new Error('Empty stack');
        }

        --this.size;

        var data = head.data;
        head = head.next;

        return data;
    };

    MyStack.prototype.min = function() {
        if (typeof min === 'undefined') {
            throw new Error('Min not defined');
        }

        return min;
    };

    MyStack.prototype.peek = function() {
        if (typeof head === 'undefined') {
            throw new Error('Empty stack');
        }

        return head.data;
    };

    function Node(data) {
        this.data = data;
        this.next;
    }

    return MyStack;
})();

通过使用这种方法，我可以确保没有人能够(无意或有意)操纵“私有(private)”字段，例如 min 和 head。我还可以使用不需要公开的私有(private)函数，例如 Node()。

我读到这将使用更多内存，因为它必须为为 MyStack 创建的每个新对象维护一个额外的范围。它是否需要如此多的额外内存以至于这种方式不是一个好主意？

我确实尝试通过使用原型(prototype)而不是每次创建新对象时都创建函数来优化它。换句话说，我没有将这些函数包含在 MyStack 的构造函数中。

我的问题是，这是糟糕的设计吗？这种方法有什么重大缺陷吗？

Answer 1

Is using closures to emulate encapsulation a bad idea?

没有。虽然我不认为这是“模拟”，但闭包正在实现封装。

I did try to optimize it by making use of prototypes instead of creating functions every time a new object is created. In other words, I didn't include the functions as part of the constructor of MyStack.

My question is, is this poor design? Are there are any major downfalls to this methodology?

是的，这实际上是错误的。您的 min 和 head(以及 MyStack 和 Node)变量本质上是静态的。它们只定义一次，将被所有实例共享。您不能创建两个不同的堆栈，它们都将具有相同的 head 引用。

要封装每个实例的状态，您需要在构造函数中声明变量，以便在每个新对象中创建它们。为此，您还必须在构造函数范围内声明所有需要访问它们的方法(“特权”)。

var MyStack = (function() {
    function MyStack() {
        var size = 0;
        var head = undefined;

        function checkNonEmpty() {
            if (typeof head === 'undefined') {
                throw new Error('Empty stack');
            }
        }
        this.push = function(val) {
            size++;
            head = new Node(val, head);
        };
        this.pop = function() {
            checkNonEmpty();
            this.size--;
            var data = head.data;
            head = head.next;
            return data;
        };
        this.peek = function() {
            checkNonEmpty();
            return head.data;
        };
        this.getSize = function() {
            return size;
        };
    }

    function Node(data, next) {
        this.data = data;
        this.next = next;
    }

    return MyStack;
})();

如果您想将这些方法放在原型(prototype)上，您需要将 head 和 size 值作为实例的属性提供。