相关疑难解决方法(0)

在Java中实现单例模式的有效方法是什么？

是否可以在ES6类中创建私有属性？

这是一个例子.我怎样才能阻止访问instance.property？

class Something {
  constructor(){
    this.property = "test";
  }
}

var instance = new Something();
console.log(instance.property); //=> "test"

可能重复:
在JavaScript中实现单例的最简单/最简洁的方法？

我将这种模式用于单身人士,在单例中,单身人士是PlanetEarth:

var NAMESPACE = function () {

    var privateFunction1 = function () {
        privateFunction2();
    };

    var privateFunction2 = function () {
        alert('I\'m private!');
    };

    var Constructors = {};

    Constructors.PlanetEarth = function () {
        privateFunction1();
        privateFunction2();
    };

    Constructors.PlanetEarth.prototype = {
        someMethod: function () {
            if (console && console.log) {
                console.log('some method');             
            }
        }
    };

    Constructors.Person = function (name, address) {
        this.name = name;
        this.address = address;
    };

    Constructors.Person.prototype = {
        walk: function () {
            alert('STOMP!');
        }
    };

    return { …

您在应用程序的javascript中使用了哪些面向对象的设计模式,为什么？

即使没有附加正式的设计模式,也可以随意发布代码.

我已经写了很多javascript,但是我没有将很多面向对象的模式应用到我正在做的事情上,而且我确信我错过了很多.

在JavaScript中声明本地(内部)函数时,有两个选项:

使用var关键字声明,分配给变量:

(function() {
    var innerFunction1 = function() { ... };
    innerFunction1();
}());

仅使用function关键字声明,而不指定给变量:

(function() {
    function innerFunction2() { ... };
    innerFunction2();
}());

我可以看到第二个的一个优点:函数可以在调用它的代码下面声明,因此更容易将私有函数与实际执行的代码分开.

哪个更好,为什么？

我正在开发一个需要在客户端和服务器端工作的JS应用程序(在浏览器和Node.js中的Javascript中),我希望能够重用代码的各个部分.用于双方.

我发现这window是一个只能在浏览器和global节点上访问的变量,所以我可以检测代码在哪个环境中执行(假设没有脚本声明window变量)

他们是两个问题.

1. 我应该如何检测代码在哪个浏览器中运行.例如,这段代码是否正常.(此代码是内联的,意味着它被一些全局代码包围,可以在两种环境中重用)

   if window?
       totalPath= "../examples/#{path}"
   else
       totalPath= "../../examples/#{path}"
   

   Run Code Online (Sandbox Code Playgroud)

2. 如何在两种环境中使用全局变量？现在,我正在做以下事情,但这确实感觉不对.

   if window?
       window.DocUtils = {}
       window.docX = []
       window.docXData= []
   else
       global.DocUtils= {}
       global.docX = []
       global.docXData = []
   

   Run Code Online (Sandbox Code Playgroud)

基于javascript原型的面向对象编程风格很有趣,但是在很多情况下你需要能够从类创建对象.

例如,在矢量绘图应用程序中,工作空间通常在绘图开始时为空:我无法从现有工作空间创建新的"行".更一般地说,动态创建对象的每种情况都需要使用类.

我已经阅读了很多教程和书"Javascript:好的部分",但在我看来,没有办法定义尊重1)封装的类和2)有效的成员方法声明(我的意思是:成员)正在定义的方法,并在每个类实例之间共享).

要定义私有变量,正在使用闭包:

function ClassA()
{
    var value = 1;
    this.getValue = function()
    {
        return value;
    }
}

这里的问题是"ClassA"的每个实例都有自己的成员函数"getValue"的副本,这是无效的.

要有效地定义成员函数,正在使用原型:

function ClassB()
{
    this.value = 1;
}

ClassB.prototype.getValue = function()
{
    return this.value;
}

这里的问题是成员变量"value"是公共的.

我不认为这个问题可以轻易解决,因为在创建对象期间需要定义"私有"变量(以便对象可以访问其创建的上下文,而不暴露those值)而基于原型的成员函数定义必须在对象创建后完成,因此原型有意义("this.prototype"不存在,我已经检查过).

或者我错过了什么？

编辑:

首先,感谢您的有趣答案.

我只想为我的初始消息添加一点精度:

我真正想做的是拥有1)私有变量(封装是好的,因为人们只能访问他们需要的东西)和2)有效的成员方法声明(避免拷贝).

似乎简单的私有变量声明只能通过javascript中的闭包来实现,这就是为什么我专注于基于类的方法.如果有一种方法可以用基于原型的方法实现简单的私有变量声明,那对我来说没问题,我不是一个激烈的基于类的方法proponnent.

在阅读答案后,似乎简单的解决方案是忘记私有,并使用特殊的编码约定来阻止其他程序员直接访问"私有"变量...

我同意,我的标题/第一句话对于我想在这里讨论的问题有误导性.

在ES6中我们可以做匿名类:

var entity = class {
}

但我们也可以实例化它:

var entity = new class {
    constructor(name) { this.name = name; }
    getName() { return this.name; }
}('Foo');
console.log(entity.getName()); // Foo

背后做了什么,它带来了什么好处以及它带来了什么警告？

建立:

• BabelJS(es2015,反应,阶段-1)
• 的WebPack
• React/redux

CommonJS和ES6的新功能.我知道对象实例和方法的静态容器之间的区别,但我不确定它们在分离到模块时的行为方式.所以我想知道返回一个实例之间的区别是什么(这个模式是否有效？):

// StateParser.js

class StateParser {
    constructor() {
     }

     method1() {
        ...
     }

}

export default new StateParser()

并导出const方法:

// StateParser.js

let state = {
}

export const method1 = () => { ... }

1. 方法A:每次导入时都会有新的实例吗？

2. 方法B:使用对象解构的能力之一是:

   import { method1 } from '../utils/StateParser.js';
   

   Run Code Online (Sandbox Code Playgroud)

   然后使用method1,就好像它存在于本地？

3. 方法A:在构造函数中初始化状态的能力有哪些好处？

所以基本上我不确定何时使用哪个实用程序类,并希望您的输入.

我已经看到在某些项目中,Module Pattern使用而不是Singleton Pattern反之亦然.

我想确切地知道,Module Pattern和之间有什么不同Singleton Pattern？