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

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;
})();

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

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

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

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

Answer 1

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

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

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

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

是的，这实际上是错误的。您的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;
})();

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

Answer 2

考虑到封装是面向对象编程的原则之一，我不认为这是一种不好的编码习惯。 JavaScript 中的闭包是封装变量和限制对应用程序其他部分的访问的方法。

在很多方面，JavaScript 中没有什么是真正安全的。即使使用闭包，您希望保持私有的那些变量也可以在不同的浏览器中通过不同的方式访问。例如，在 Google Chrome 中，您可以在调试器中设置断点并访问活动外壳中的任何变量。尽管我们可以在浏览器中做很多事情来确保安全性，但我们仍然在处理一种在运行代码的机器上编译的解释性语言。

考虑到你的例子： var MyStack = (function(){...})(); 如果您曾经使用过 typescript 或任何快速开发框架，您会看到这是在框架编译/转译时用于命名对象的输出编码方法。