introduzir
O modo de peso mosca (peso mosca) executa a tecnologia de compartilhamento para suportar efetivamente um grande número de objetos de granulação fina, evitando a sobrecarga de um grande número de classes pequenas com o mesmo conteúdo (como consumo de memória) e permitindo que todos compartilhem uma classe (metaclasse).
O padrão de enciclopédia pode evitar uma grande quantidade de sobrecarga de classes muito semelhantes. Na programação, às vezes é necessário produzir um grande número de instâncias de classe de granulação fina para representar dados. Se você descobrir que essas instâncias têm basicamente a mesma sobrecarga, exceto por alguns parâmetros, você pode reduzir significativamente o número de classes que precisam ser instanciadas. Se esses parâmetros puderem ser movidos para fora da instância da classe e os passaram quando o método for chamado, o número de instâncias individuais poderá ser bastante reduzido pelo compartilhamento.
E daí se você aplicar o modo de enciclopédia em JavaScript? Existem duas maneiras. O primeiro é aplicá -lo à camada de dados, principalmente a um grande número de objetos semelhantes na memória; O segundo é aplicá -lo à camada DOM, que pode ser usada no Gerenciador de Eventos Central para evitar adicionar alças de evento a cada elemento filho no contêiner pai.
Aproveite a camada de dados
Existem dois conceitos importantes no peso da mosca - extrínseco intrínseco e externo do estado interno. O estado interno é gerenciado através de métodos internos no objeto e as informações externas podem ser excluídas ou salvas externamente.
Para ser franco, é primeiro prender um modelo original e depois produzir modelos específicos com características diferentes de acordo com diferentes ocasiões e ambientes. Obviamente, novos objetos diferentes precisam ser gerados aqui; portanto, o modo de fábrica geralmente aparece no modo de peso mosca. O estado interno do peso mosca é usado para compartilhar. A Flyweight Factory é responsável por manter um pool de peso mosca (pool de modo) para armazenar objetos com estado interno.
Use o modo de diversão
Vamos demonstrar que, se o sistema usa uma biblioteca de classes para gerenciar todos os livros, os metadados de cada livro serão provisoriamente definidos para o seguinte conteúdo:
A cópia do código é a seguinte:
EU IA
Título
Autor
Gênero
Contagem de páginas
ID do editor
ISBN
Também precisamos definir o tempo e o mutuário de cada livro, bem como a data de retorno e se está disponível:
A cópia do código é a seguinte:
CheckOutdate
CheckoutMember
duereTurnndate
disponibilidade
Como o objeto do livro está definido para o código a seguir, observe que o código ainda não foi otimizado:
A cópia do código é a seguinte:
var book = function (id, título, autor, gênero, pageCount, publisherID, ISBN, CheckOutdate, CheckoutMember, DuereTurnDate, Disponibilidade) {
this.id = id;
this.title = title;
this.author = autor;
this.genre = gênero;
this.pageCount = pageCount;
this.publisherID = PublisherID;
this.isbn = isbn;
this.checkOutdate = checkOutdate;
this.CheckOutMember = CheckOutMember;
this.DuereTurnDate = duereTurnndate;
this.Availability = Disponibilidade;
};
Book.prototype = {
gettitle: function () {
devolver este.title;
},
getAuthor: function () {
devolver isso. Autora;
},
getisbn: function () {
devolver este.isbn;
},
/*Outros métodos GET não serão exibidos aqui*/
// Atualize o status de empréstimo
UpdateCheckoutStatus: function (BookId, NewStatus, CheckOutdate, CheckoutMember, NewrenGurndate) {
this.id = bookId;
this.Availability = newstatus;
this.checkOutdate = checkOutdate;
this.CheckOutMember = CheckOutMember;
this.DuereTurnNdate = newReturnDate;
},
//renovar
ExtendCheckoutPeriod: function (bookId, newrenTurndate) {
this.id = bookId;
this.DuereTurnNdate = newReturnDate;
},
// está expirado
ISPASTDUE: function (bookId) {
var currentDate = new Date ();
retornar currentDate.getTime ()> date.parse (this.duereTurnDate);
}
};
O programa pode estar bem no início, mas com o passar do tempo, os livros podem aumentar em grandes quantidades e cada tipo de livro tem versões e quantidades diferentes, você descobrirá que o sistema está ficando mais lento. Milhares de objetos de livro podem ser imaginados na memória e precisamos usar o modo de enciclopédia para otimizar.
Podemos dividir os dados em dois tipos de dados internos e externos. Os dados relacionados a objetos de livro (título, autor, etc.) podem ser atribuídos a propriedades internas, enquanto (CheckoutMember, DuereTurnndate etc.) podem ser atribuídos a propriedades externas. Dessa forma, o código a seguir pode compartilhar o mesmo objeto no mesmo livro, porque não importa quem empreste o livro, desde que o livro seja o mesmo livro, as informações básicas são as mesmas:
A cópia do código é a seguinte:
/*Código de otimização do modo xienyuan*/
var book = function (título, autor, gênero, pageCount, publisherID, ISBN) {
this.title = title;
this.author = autor;
this.genre = gênero;
this.pageCount = pageCount;
this.publisherID = PublisherID;
this.isbn = isbn;
};
Definindo a fábrica de base
Vamos definir uma fábrica básica para verificar se o objeto do livro foi criado antes, retornar, se houver e recriar e armazená -lo para que ele possa continuar a acessar mais tarde, o que garante que criemos apenas um objeto para cada livro:
A cópia do código é a seguinte:
/* Livro de fábrica singleton*/
var bookfactory = (function () {
Var existingbooks = {};
retornar{
CreateBook: function (título, autor, gênero, PageCount, publisherID, ISBN) {
/*Pesquise se deve criar antes*/
Var existingbook = existingbooks [ISBN];
if (livro existente) {
retornar o livro existente;
}outro{
/ * Se não, crie um e salve */
Var Book = New Book (título, autor, gênero, PageCount, PublisherID, ISBN);
Livros existentes [ISBN] = livro;
livro de retorno;
}
}
}
});
Gerenciar status externo
O estado externo é relativamente simples. Exceto pelo livro que encapsulamos, todo o resto precisa ser gerenciado aqui:
A cópia do código é a seguinte:
/*BookRecordManager Singleton para emprestar gerenciamento*/
var bookRecordManager = (function () {
var bookRecordDatabase = {};
retornar{
/*Adicione um registro de empréstimo de livro*/
AddBookRecord: function (id, título, autor, gênero, pageCount, publisherID, ISBN, CheckOutdate, CheckoutMember, DuereTurnDate, Disponibilidade) {
var book = bookfactory.createbook (título, autor, gênero, pageCount, publisherID, ISBN);
bookRecordDatabase [id] = {
CheckoutMember: CheckOutMember,
CheckOutdate: CheckOutdate,
DuereTurnndate: DuereTurndate,
Disponibilidade: disponibilidade,
Livro: livro;
};
},
UpdateCheckoutStatus: function (BookId, NewStatus, CheckOutdate, CheckoutMember, NewrenGurndate) {
var registro = bookRecordDatabase [bookId];
registro.Availability = NewStatus;
registro.CheckOutdate = checkOutdate;
registro.CHECKOUTMEMBER = CHECKOUTMEMBER;
registro.DuereTurnDate = newReTurNndate;
},
ExtendCheckoutPeriod: function (bookId, newrenTurndate) {
bookRecordDatabase [bookId] .DuereTurnDate = newReturndate;
},
ISPASTDUE: function (bookId) {
var currentDate = new Date ();
retornar currentDate.getTime ()> date.parse (bookRecordDatabase [bookId] .DuereTurnDate);
}
};
});
Dessa forma, salvamos as mesmas informações do mesmo livro em um objeto BookManager e salvamos apenas uma cópia; Comparado com o código anterior, podemos descobrir que ele economiza muita memória.
Aproveite o modo Yuan e Dom
Não vou dizer muito sobre o incidente do DOM aqui. Eu acredito que todo mundo já sabe disso. Vamos dar dois exemplos.
Exemplo 1: Gerenciamento de eventos centralizado
Por exemplo, se precisarmos monitorar seu evento de cliques para muitos elementos ou estruturas semelhantes (como menus ou múltiplos LIS no UL), precisamos vincular eventos para cada elemento. Se houver muito, muitos elementos, o desempenho poderá ser imaginado. Combinado com o conhecimento das bolhas, se algum elemento filho for acionado, o evento borbulhará para o elemento anterior após o acionamento do gatilho. Portanto, usando esse recurso, podemos usar o modo de enciclopédia, podemos monitorar eventos de eventos nos elementos pais desses elementos semelhantes e, em seguida, julgar qual elemento filho tem um evento acionado e, em seguida, executar mais operações.
Aqui, combinamos o método de jQuery Bind/Unbind para dar um exemplo.
Html:
A cópia do código é a seguinte:
<div id = "contêiner">
<div href = "#"> mais informações (endereço)
<pan>
Aqui está mais informações
</span> </div>
<div href = "#"> mais informações (mapa)
<pan>
)
</span>
</div>
</div>
JavaScript:
A cópia do código é a seguinte:
Statemanager = {
fly: function () {
var self = this;
$ ('#contêiner'). Unbind (). bind ("clique", função (e) {
VAR Target = $ (E.originalTarget || e.srceLement);
// determinar qual elemento filho é
if (Target.is ("div.toggle")) {
self.Handleclick (Target);
}
});
},
handleclick: function (elem) {
elem.find ('span'). alternar ('lento');
}
});
Exemplo 2: Aplicação do modo de enciclopédia para melhorar o desempenho
Outro exemplo ainda está relacionado ao jQuery. Geralmente, usamos objetos de elemento na função de retorno de chamada do evento. Frequentemente usamos a forma de $ (isso). De fato, cria repetidamente um novo objeto porque isso na função de retorno de chamada já é o próprio elemento DOM. Devemos usar o seguinte código:
A cópia do código é a seguinte:
$ ('div'). bind ('click', function () {
console.log ('Você clicou:' + $ (this) .attr ('id'));
});
// O código acima deve ser evitado e evitar a geração de objetos jQuery no elemento DOM novamente, porque você pode usar diretamente o próprio elemento DOM.
$ ('div'). bind ('click', function () {
console.log ('Você clicou:' + this.id);
});
De fato, se tivermos que usar a forma de $ (isso), também podemos implementar nossa própria versão do padrão de instância única, por exemplo, podemos implementar uma função como jQuery.signle (this) para retornar o próprio elemento DOM:
A cópia do código é a seguinte:
jQuery.single = (function (o) {
var coleção = jQuery ([1]);
Função de retorno (elemento) {
// coloca elementos na coleção
coleção [0] = elemento;
// retorna à coleção
coleção de retorno;
};
});
Como usar:
A cópia do código é a seguinte:
$ ('div'). bind ('click', function () {
var html = jQuery.single (this) .next (). html ();
console.log (html);
});
Dessa forma, o próprio elemento DOM é retornado como é e o objeto jQuery não é criado.
Resumir
O modo de peso mosca é um modo que melhora a eficiência e o desempenho do programa, que acelerará bastante a velocidade de execução do programa. Existem muitos cenários de aplicativos: por exemplo, se você quiser ler uma série de strings de um banco de dados, muitas dessas strings são repetidas, então podemos armazenar essas strings no pool de peso mosca (piscina).
Se um aplicativo usar um grande número de objetos e esses grandes números de objetos causam excelente armazenamento, considere usar o modo de enciclopédia; e a maioria dos estados de objetos pode ser externa. Se o estado externo do objeto for excluído, muitos grupos de objetos poderão ser substituídos por relativamente poucos objetos compartilhados. No momento, você pode considerar o uso do modo de enciclopédia.