Como modelo de desenvolvimento de software, o padrão monolítico tem sido amplamente utilizado em muitos idiomas orientados a objetos. No JavaScript, o padrão monolítico também é amplamente utilizado. No entanto, como a linguagem JavaScript possui seu método exclusivo orientado a objetos, é consistente com alguns idiomas tradicionais orientados a objetos, mas ainda é diferente na implementação.
Primeiro, vamos dar uma olhada na definição de padrões de monômero em idiomas tradicionais orientados a objetos: os padrões de monômero são classes que só podem ser instanciadas uma vez e podem ser acessadas através de um ponto de acesso bem conhecido. Existem dois pontos nessa definição que destacam as características dos idiomas tradicionais orientados a objetos, a saber, classe e instanciação. Portanto, para as linguagens tradicionais orientadas a objetos, o padrão monolítico é baseado nas características naturais de sua classe e instanciação. Ou seja, use a classe de palavra -chave para definir uma classe, que pode ser instanciada através da nova palavra -chave, mas é preciso garantir que toda vez que ela for instanciada por nova, a mesma instância seja obtida ou que seu construtor só possa ser chamado uma vez por novo.
Vamos dar uma olhada na definição de padrão de monômero em JavaScript: o monômero é um objeto usado para dividir o espaço para nome e organizar um lote de métodos e atributos relacionados juntos. Se puder ser instanciado, só poderá ser instanciado uma vez. Comparando a definição acima, você descobrirá que a definição de monômero aqui define sua essência como um objeto, em vez de uma classe em uma linguagem tradicional orientada a objetos, que também mostra que o idioma do JavaScript é baseado em objetos. Ao mesmo tempo, foi apontado mais tarde que, se puder ser instanciado, isso mostra que deve haver várias maneiras de definir monômeros em JavaScript. Existem uma ou mais maneiras de instanciar que podem ser instanciadas, ou seja, use a nova palavra -chave para criar objetos de monômero. No entanto, esse método não é uma característica natural do próprio JavaScript, porque os objetos criados usando a nova palavra -chave são realmente simulados e definidos por meio de funções (embora o ES6 tenha começado a apoiar a palavra -chave da classe, ela ainda não foi amplamente suportada pelo navegador). Então, como usar os recursos naturais do JavaScript para implementar padrões de monômero?
var singleton = {atribui1: true, attribute2: 10, método1: function () {}, método2: function (arg) {}}Aqui está um objeto Singleton, que contém várias propriedades e métodos. Está incluído na página. Este objeto é criado quando o JS é carregado. É chamado usando singleton.method1 ao ligar. Sua instanciação é concluída durante a execução da página carregando a análise JS. Não usamos a nova palavra -chave para instanciar esse objeto. Essa também é uma grande diferença entre a implementação de padrões monolíticos em JavaScript e idiomas tradicionais orientados a objetos. Este método é mais simples e fácil de entender. No entanto, esse método tem várias desvantagens. Uma desvantagem óbvia é que ele não fornece um espaço para nome. Se outros programadores também definirem uma variável singleton na página, é fácil substituir e confundir o objeto monolítico. Então, para esse problema, é reescrito da seguinte maneira:
var myspace = {}; myspace.singleton = {attribute1: true, attribute2: 10, método1: function () {}, método2: function (arg) {}}Aqui, um namespace do MySpace é definido primeiro e, em seguida, o único objeto Singleton é montado abaixo desse objeto, o que reduz bastante a possibilidade de conflitos com outros programadores e mioperação. Mesmo que outros definam uma variável singleton no escopo global, ela não poluirá o objeto Singleton. Isso implementa a função de dividir o espaço para nome e organizar alguns atributos e métodos relacionados, conforme mencionado na definição anterior.
Este método ainda tem suas desvantagens. Todas as propriedades e métodos desse objeto monolítico são compartilhados e podem ser acessados e modificados a qualquer momento de fora. Portanto, os fechamentos são usados para simular propriedades e métodos privados, como segue:
mySpace.singleton = (function () {var privateTeattribute1 = false; var privateTtribute1 = [1,2,3]; função privatemethod1 () {} função privatemethod2 () {} return {publicattribute1: trueTtribute2: 10, publicmethod1: function () (); publicMethod2: function (arg) {privateattribute1 = [4,5,6];Aqui, atribuímos diretamente uma função auto-executiva anônima ao objeto Monolith. Nesta função, as palavras -chave VAR e da função são usadas para definir suas propriedades e métodos privados, respectivamente. Eles não podem ser acessados diretamente fora da função (fora do objeto monólito), porque uma vez que a função é executada, o espaço de seu escopo interno será reciclado, e é por isso que os fechamentos podem ser usados para simular propriedades e métodos privados. Nesta função (fechamento), um objeto é finalmente retornado, que contém alguns métodos e propriedades públicas, que podem ser chamadas diretamente para fora. Ao mesmo tempo, como esses métodos públicos são definidos dentro da função, eles podem chamar suas propriedades e métodos privados. No entanto, o mundo exterior só pode concluir determinadas operações através dos métodos e propriedades públicas retornadas e não pode chamar diretamente propriedades como singleton.privatemethod1. Isso faz com que o objeto monolítico não apenas isolou o mundo exterior para acessar diretamente suas propriedades e métodos privados, mas também fornece algumas propriedades e métodos comuns ao mundo exterior para concluir determinadas operações.
Esse padrão monolítico construído pela autoexecução de funções anônimas é amplamente utilizado em muitas bibliotecas JS, mas ainda há um problema. Se não precisarmos usar o objeto ao carregar a página, e a criação do objeto é mais cara (como muitos cálculos ou acesso múltiplo à árvore Dom e suas propriedades etc.), é razoável criá -lo quando necessário, em vez de criá -lo diretamente com a análise e a execução do JS. Este conceito é chamado de carregamento preguiçoso, então modifique o código acima da seguinte forma:
myspace.singleton = (function () {var uncelinstance; function construtor () {var privateTtribute1 = false; var privateTeattribute1 = [1,2,3]; função privatemethod1 () {} função privatemethod2 () {} return {publicattribute1: {} publicattTrtTr: PublictTr: 10) {Publicttion) {} PublicTr: Privateattribute1 = true;Aqui, uma variável privada exclusiva é definida na função anônima como um identificador para determinar se um objeto monolítico foi criado. Em seguida, todos os atributos e métodos definidos para o objeto monolítico foram colocados em uma função chamada construtor. Somente quando a função é chamada, o objeto monolítico pode ser criado, caso contrário, ele não será criado diretamente. Em seguida, retorne um objeto, que contém um método GetInstance, que é para chamadas externas. Ao chamar o método, primeiro determine se o objeto monolítico existe. Se existir, devolva diretamente. Caso contrário, chame a função do construtor para construir o objeto monolítico e devolvê -lo. Finalmente, se chamarmos um método do objeto monolítico, precisamos usar o myspace.singleton.getInstance (). PublicMethod1 (). Aqui, criaremos apenas esse objeto monolítico quando chamarmos dessa maneira, caso contrário, o objeto monolítico não será criado automaticamente, o que realmente implementa carregamento sob demanda ou carregamento preguiçoso.