Javascript 两个版本的函数之间有什么区别

有人能解释一下这两个代码块之间的区别吗？为什么我们需要第一种类型而第二种更简洁呢

首先

第二：

var Utility;
(function (Utility) {
    Utility.Func = function (param1, param2) {
            var self = this;
            this.Owner = param2;
        }
})(Utility || (Utility = {}));

---

上下文：第一个版本是由typescript编译器生成的代码，我试图理解为什么它生成第一个版本而不是更简单的第二个版本。

从我看来，它们是相同的，在这两种情况下，您都定义了函数，并将其作为实用程序的一个成员，调用它。 再加上，没有范围差异，没有上下文差异，没有真正的差异。 我认为这只是一个偏好的问题

---

但是，我可以看到一个潜在的差异，如果最内部的一个是

异步

函数调用，那么可能会有差异，因为

实用程序.Func

将以

未定义

作为值结束，这是第一个函数的一个非常大的问题，但我怀疑编写它的人不会注意到。

从我的观点来看，它们是相同的，在这两种情况下，您都在定义函数并将其作为实用程序的一个成员，调用它。 再加上，没有范围差异，没有上下文差异，没有真正的差异。 我认为这只是一个偏好的问题

---

但是，我可以看到一个潜在的差异，如果最内部的一个是

异步

函数调用，那么可能会有差异，因为

实用程序.Func

将以

未定义

作为值结束，这是第一个函数的一个非常大的问题，但我怀疑编写它的人不会注意到。

从我的观点来看，它们是相同的，在这两种情况下，您都在定义函数并将其作为实用程序的一个成员，调用它。 再加上，没有范围差异，没有上下文差异，没有真正的差异。 我认为这只是一个偏好的问题

---

但是，我可以看到一个潜在的差异，如果最内部的一个是

异步

函数调用，那么可能会有差异，因为

实用程序.Func

将以

未定义

作为值结束，这是第一个函数的一个非常大的问题，但我怀疑编写它的人不会注意到。

从我的观点来看，它们是相同的，在这两种情况下，您都在定义函数并将其作为实用程序的一个成员，调用它。 再加上，没有范围差异，没有上下文差异，没有真正的差异。 我认为这只是一个偏好的问题

---

但是，我可以看到一个潜在的差异，如果最内部的一个是

异步

函数调用，那么可能会有差异，因为

实用程序.Func

将以

未定义

作为值结束，这是第一个函数的一个非常大的问题，但是我怀疑编写它的人不会注意到。

代码块之间的唯一区别是，第一个代码块在创建

Func

函数的代码周围有一个函数范围。这样做的唯一原因是创建一个作用域，您可以在其中声明在外部作用域中不可用的变量：

var Utility;
(function (Utility) {
    var Func = (function () {

        var x; // a variable in the inner scope

        function Func(param1, param2) {
            var self = this;
            this.Owner = param2;
        }
        return Func;
    })();

    // the variable x is not reachable from code here

    Utility.Func = Func;
})(Utility || (Utility = {}));

---

代码块之间的唯一区别在于，第一个块在创建

Func

函数的代码周围有一个函数范围。这样做的唯一原因是创建一个作用域，您可以在其中声明在外部作用域中不可用的变量：

var Utility;
(function (Utility) {
    var Func = (function () {

        var x; // a variable in the inner scope

        function Func(param1, param2) {
            var self = this;
            this.Owner = param2;
        }
        return Func;
    })();

    // the variable x is not reachable from code here

    Utility.Func = Func;
})(Utility || (Utility = {}));

---

代码块之间的唯一区别在于，第一个块在创建

Func

函数的代码周围有一个函数范围。这样做的唯一原因是创建一个作用域，您可以在其中声明在外部作用域中不可用的变量：

var Utility;
(function (Utility) {
    var Func = (function () {

        var x; // a variable in the inner scope

        function Func(param1, param2) {
            var self = this;
            this.Owner = param2;
        }
        return Func;
    })();

    // the variable x is not reachable from code here

    Utility.Func = Func;
})(Utility || (Utility = {}));

---

代码块之间的唯一区别在于，第一个块在创建

Func

函数的代码周围有一个函数范围。这样做的唯一原因是创建一个作用域，您可以在其中声明在外部作用域中不可用的变量：

var Utility;
(function (Utility) {
    var Func = (function () {

        var x; // a variable in the inner scope

        function Func(param1, param2) {
            var self = this;
            this.Owner = param2;
        }
        return Func;
    })();

    // the variable x is not reachable from code here

    Utility.Func = Func;
})(Utility || (Utility = {}));

---

就我个人而言，我不明白这两种方法的目的，因为您所展示的代码中的三个闭包中的任何一个都没有实际的好处，所以它们所做的只是增加了不必要的复杂性。这实现了同样的效果，而且简单得多：这是由typescript编译器生成的代码。第一个版本是生成的，我试图理解为什么它生成了第一个而不是一个更简单的第二个版本。下次在问题中加入额外的上下文，因为这就是你的问题。闭包越多意味着放置私有变量的位置就越多（即使在这些示例中没有使用任何闭包）。因此，也许TypeScript代码生成器在某些情况下会在这些闭包中使用一些私有变量，因此它会将它们放在一般情况下，以防需要使用它们。第一个只是有更多的地方放置私有变量。就我个人而言，我不明白这两个的目的，因为在您展示的代码中，三个闭包中的任何一个似乎都没有实际的好处，所以它们所做的只是增加不必要的复杂性。这实现了同样的效果，而且简单得多：这是由typescript编译器生成的代码。第一个版本是生成的，我试图理解为什么它生成了第一个而不是一个更简单的第二个版本。下次在问题中加入额外的上下文，因为这就是你的问题。闭包越多意味着放置私有变量的位置就越多（即使在这些示例中没有使用任何闭包）。因此，也许TypeScript代码生成器在某些情况下会在这些闭包中使用一些私有变量，因此它会将它们放在一般情况下，以防需要使用它们。第一个只是有更多的地方放置私有变量。就我个人而言，我不明白这两个的目的，因为在您展示的代码中，三个闭包中的任何一个似乎都没有实际的好处，所以它们所做的只是增加不必要的复杂性。这实现了同样的效果，而且简单得多：这是由typescript编译器生成的代码。第一个版本是生成的，我试图理解它为什么会生成