No JavaScript, os navegadores, especialmente os navegadores em dispositivos móveis, alocam memória muito limitada e como salvar a memória se tornou uma coisa muito significativa. Uma maneira eficaz de salvar a memória é reduzir o número de objetos.
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.
Existem duas maneiras de aplicar o modo de enciclopédia no JavaScript. O primeiro é aplicá -lo na camada de dados, principalmente a um grande número de objetos semelhantes na memória; O segundo é aplicá -lo na camada DOM, a enciclopédia pode ser usada no gerenciador de eventos central para evitar a adição de alças de eventos a cada elemento filho no contêiner pai.
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.
Podemos substituir todos os objetos pelo mesmo estado interno pelo mesmo objeto compartilhado e, para criar um objeto compartilhado, é necessário um método de fábrica singleton em vez de um construtor normal. Isso pode rastrear objetos individuais que foram instanciados, para que um novo objeto seja criado apenas se o estado interno do objeto necessário for diferente do objeto existente. O estado externo do objeto é salvo em um objeto de gerente. Ao chamar o método do objeto, o gerente passará por esses estados externos como parâmetros.
Salve os dados de um objeto em dois objetos diferentes (objeto compartilhado, objeto de gerente)
1. Objeto compartilhado (aproveite o objeto original)
2. Método da fábrica de singleton (crie um objeto compartilhado)
3. Objeto de gerente (gerenciar estado externo)
Por exemplo, um livro em uma biblioteca pode ser representado por um objeto, que possui muitos atributos.
var book = function (id, título, autor, gênero, pageCount, publisherID, ISBN, checkOutdate, CheckOutMember, duereTurnDate, disponibilidade) {... // código de inicialização} book.prototype = {gettitle: function () {return this.title; }, ... // Atualize o método de status de empréstimo UpdateCheckoutStatus: function (BookId, NewStatus, CheckOutdate, CheckoutMember, NewrenGurnDate) {...}, // RENEW ExtendCheckOutPeriod: function (BookId, NewrenDate) {...}, // se expira ISPastDue: function: function) {...},}, se expira »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. No mesmo livro, os dados relacionados a objetos de livro (título, autor, etc.) podem ser atribuídos a propriedades internas, enquanto (membro do checkout, 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:
// objeto compartilhado 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;};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:
/* Livro de fábrica singleton*/var bookFactory = (function () {var existingbooks = {}; return {createBook: function (title, autor, gênero, PageCount, publisherID, isbn) {/* encontre se deve criar antes*/var existingBooks existingings [isbn]; se (* if (* existingbook; Novo livro (título, autor, gênero, Pagecount, PublisherID, ISBN);O estado externo é relativamente simples. Exceto pelo livro que encapsulamos, todo o resto precisa ser gerenciado aqui:
/*BookRecordManager Singleton for Borrow Management*/var BookRecordManager = (function(){ var bookRecordDatabase = {}; return{ /*Add a borrowing record*/ addBookRecord: function(id, title, author, genre, pageCount, publisherID,ISBN, checkoutDate, checkoutMember, dueReturnDate, availability){ var book = bookfactory.createbook (título, autor, gênero, pageCount, publisherID, ISBN); CHECKOUTMEM, NEWRANCENTE) BookRecordDatabase [BookId] .DuereTurnDate = NewrenTurncate;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.
Pool de objetos
O pool de objetos é outra solução de otimização de desempenho, que possui algumas semelhanças com o modo Xiangyuan, mas não separa o estado interno e o estado externo.
Implementação geral de pool de objetos:
var objectPoolFactory = function (createObjfn) {var objectPool = []; // Pool de objetos retorna {create: function () {// recuperar var obj = objectpool.length === 0? createObjfn.Apply (this, argumentos): objectpool.shift (); retornar obj; }, recuperar: function (obj) {// recuperar objectpool.push (obj); }}};Agora use o ObjectPoolFactory para criar um pool de objetos que carregue alguns iframes:
var ifRameFactory = objectPoolFactory (function () {var ifRame = document.createElement ('iframe'); document.body.appendchild (iframe); iframe.onload = function () {ifRame.onload = null; // prevenir bugs de ifRame de carga ifRameFactory.ReCover.Oname (ifr); retornar iframe;}); // Call var iframe1 = ifRameFactory.create (); iframe1.src = 'http://www.qq.com';REFERÊNCIAS: "Javascript Pattern" "JavaScript Design Pattern and Development Practice"
O exposto acima é todo o conteúdo deste artigo. Espero que seja útil para o aprendizado de todos e espero que todos apoiem mais o wulin.com.