Carregamento lento - Lazy loading
O carregamento lento (também conhecido como carregamento assíncrono ) é um padrão de design comumente usado em programação de computador e principalmente em web design e desenvolvimento para adiar a inicialização de um objeto até o ponto em que é necessário. Pode contribuir para a eficiência na operação do programa se usado de forma adequada e adequada. Isso o torna ideal em casos de uso em que o conteúdo da rede é acessado e os tempos de inicialização devem ser mantidos no mínimo, como no caso de páginas da web . Por exemplo, adiar o carregamento de imagens em uma página da web até que sejam necessárias pode tornar a exibição inicial da página mais rápida. O oposto do carregamento lento é o carregamento antecipado .
Frameworks que usam carregamento lento
Um framework bem famoso que usa carregamento lento é o Angular . Houve algumas discussões se o carregamento lento realmente ajuda, pois aumenta a comunicação do servidor. Essencialmente, o carregamento lento ajuda os desenvolvedores do Angular a decidir quais módulos carregar na inicialização ou quando uma função é chamada. Alega-se que oferece suporte a pequenos dispositivos e internet com baixa capacidade.
Abaixo está um exemplo de carregamento lento sendo usado em Angular, programado usando TypeScript da Farata Systems
@NgModule({
imports: [ BrowserModule,
RouterModule.forRoot([
{path: '', component: HomeComponent},
{path: 'product', component: ProductDetailComponent},
{path: 'luxury', loadChildren: () => import('./luxury.module').then(m => m.LuxuryModule), data: {preloadme:true} } ]
// , {preloadingStrategy: CustomPreloadingStrategy}
)
],
declarations: [ AppComponent, HomeComponent, ProductDetailComponent],
providers:[{provide: LocationStrategy, useClass: HashLocationStrategy}, CustomPreloadingStrategy],
bootstrap: [ AppComponent ]
})
Implementações
Existem quatro maneiras comuns de implementar o padrão de design de carregamento lento : inicialização lenta ; um proxy virtual ; um fantasma e um detentor de valor . Cada um tem suas próprias vantagens e desvantagens.
Inicialização lenta
Com a inicialização lenta, o objeto a ser carregado lentamente é originalmente definido como nulo, e cada solicitação para o objeto verifica se há nulo e o cria "em tempo real" antes de retorná-lo primeiro, como neste exemplo C #:
private int myWidgetID;
private Widget myWidget = null;
public Widget MyWidget
{
get
{
if (myWidget == null)
{
myWidget = Widget.Load(myWidgetID);
}
return myWidget;
}
}
Ou com o operador de coalescência nula '??'
private int myWidgetID;
private Widget myWidget = null;
public Widget MyWidget
{
get { return myWidget = myWidget ?? Widget.Load(myWidgetID); }
}
Este método é o mais simples de implementar, embora se null for um valor de retorno legítimo, pode ser necessário usar um objeto de espaço reservado para sinalizar que ele não foi inicializado. Se este método for usado em um aplicativo multithread , a sincronização deve ser usada para evitar condições de corrida .
Proxy virtual
Um proxy virtual é um objeto com a mesma interface do objeto real. Na primeira vez que um de seus métodos é chamado, ele carrega o objeto real e então delega.
Fantasma
Um "fantasma" é o objeto que deve ser carregado em um estado parcial. Ele pode conter apenas o identificador do objeto, mas carrega seus próprios dados na primeira vez que uma de suas propriedades é acessada. Por exemplo, considere que um usuário está prestes a solicitar conteúdo por meio de um formulário online. No momento da criação, tudo o que sabemos é que o conteúdo será acessado, mas que ação ou conteúdo é desconhecido.
Exemplo de PHP:
$userData = array (
"UID" = > uniqid(),
"requestTime" => microtime(true),
"dataType" => "",
"request" => ""
);
if (isset($_POST['data']) && $userData) {
// ...
}
Detentor de valor
Um portador de valor é um objeto genérico que lida com o comportamento de carregamento lento e aparece no lugar dos campos de dados do objeto:
private ValueHolder<Widget> valueHolder;
public Widget MyWidget => valueHolder.GetValue();
Implementação Web
Habilitar o navegador para servir e exibir páginas no mínimo de tempo é uma necessidade crítica do mundo moderno de hoje. O método mais simples para implementar o carregamento lento é o seguinte
<img src="image.jpg" alt="..." loading="lazy">
<iframe src="video-player.html" title="..." loading="lazy"></iframe>
O atributo de carregamento suporta dois valores, preguiçoso e ansioso . O Eager carregará a imagem em prioridade, enquanto o lazy a buscará somente quando for necessário ou a imagem estiver na janela de visualização.
Veja também
Referências
links externos