DEV Community: Ana Clara

How to avoid requests to inaccessible resources

Ana Clara — Wed, 21 Aug 2024 13:35:40 +0000

The 404 Not Found error indicates that the server was unable to find the requested resource. For the browser, this means that the URL is not recognized.

404 requests cause frustration for the user and can lead to poor website performance. In addition, search engines crawl and index non-existent pages and, consequently, the website's ranking is negatively impacted. All in all, we can avoid searches for inaccessible requests by using a few methods.

1. Check links regularly
It may seem trivial, but the most common causes of 404 errors are pages that have been moved or deleted and incorrectly typed URLs. For this reason, you can use free tools such as Google Search Console and Screaming Frog SEO Spider to validate broken links and Soft 404s (non-existent resources that still return a success status of 200).

2. Validating URLs
Before making the request, validate that the URL is correct. Although this doesn't guarantee that the requested resource doesn't exist, it can prevent obvious errors. To validate a URL, there is Javascript's URL interface. Here you can validate the structure of the URL, the protocol, domain or extension of the requested file.

You can also check the existence of a resource before making a GET request using the HEAD method.

async function fileExists(url) {
  try {
    const response = await fetch(url, { method: 'HEAD' });
    return response.ok;
  } catch (error) {
    console.error('Error verifying the existence of the file:', error);
    return false;
  }
}

fileExists('https://example.com/file.jpg').then(exists => {
  if (exists) {
    console.log('File exists.');
  } else {
    console.log('File not found.');
  }
});

3. Evaluate the site's restrictions
Don't forget to check that HTML, CSS, JavaScript files and other resources have the correct read and execute permissions for users. Also check that there are no undue access restrictions in the web server settings that could prevent access to certain files or directories.

Settings such as AllowOverride and Require all granted can cause problems if they are not correctly configured.

4. Clear the cache

The cache stores copies of website resources so that when you visit the same site again, the browser can load these resources more quickly. However, if a website resource returns a 404 error, this response can also be stored in the cache. So, even if this resource is corrected on the server, the user may still receive the 404 error. To solve this problem, we can work on the configuration of the HTTP header.

You can set Cache-control: no-store to prevent a response from being stored, or Cache-Control: no-cache to force the browser to check with the server before using a cached version. You can also configure the Expires header with the time at which the response will expire.

5. If the resource is missing, deal with it gracefully

Instead of letting the user encounter a 404 error, set up redirects to alternative pages with the error and suggest other services. Also, if a service has been moved or renamed, set up a 301 (permanent) or 302 (temporary) redirect to the new URL.

Conclusion
404 errors negatively impact the user experience and the credibility of your application and SEO. As a dev, by handling 404 errors gracefully, you demonstrate a commitment to quality and usability, which strengthens customers' confidence in your work and the product you are developing.

Como evitar requisições a recursos inacessíveis

Ana Clara — Wed, 21 Aug 2024 12:29:38 +0000

O erro 404 Not Found indica que o servidor não conseguiu encontrar o recurso solicitado. Para o navegador, isso significa que a URL não é reconhecida.

Requisições 404 provocam frustração ao usuário e podem levar a mau desempenho do website. Além disso, as ferramentas de busca rastreiam e indexam páginas inexistentes e, consequentemente, o ranqueamento do website é impactado negativamente. Com tudo, podemos evitar buscas por requisições inacessíveis usando alguns métodos.

1. Verificar regularmente os links
Pode parecer trivial, mas as causas mais comuns para erros 404 são páginas que foram movidas ou deletadas e URLs digitadas incorretamente. Por isso, você pode utilizar ferramentas gratuitas como Google Search Console e Screaming Frog SEO Spider para validar links quebrados e Soft 404s (recursos não existentes que ainda sim retornam um status de sucesso 200).

2. Validar URLs
Antes de fazer a requisição, valide se a URL é correta. Mesmo que isso não garanta que o recurso solicitado não exista, pode prevenir erros óbvios. Para validar uma URL, existe a interface URL do Javascript. Nela é possível validar a estrutura da URL, o protocolo, domínio ou extensão do arquivo requisitado.

Ademais, pode ser feita a verificação da existência de um recurso antes de fazer uma requisição GET utilizando o método HEAD. Ele retorna apenas os cabeçalhos, sem o corpo da resposta, o que permite saber se o recurso existe sem o baixar.

async function fileExists(url) {
  try {
    const response = await fetch(url, { method: 'HEAD' });
    return response.ok;
  } catch (error) {
    console.error('Erro ao verificar a existência do arquivo:', error);
    return false;
  }
}

fileExists('https://example.com/file.jpg').then(exists => {
  if (exists) {
    console.log('Arquivo existe.');
  } else {
    console.log('Arquivo não encontrado.');
  }
});

3. Avalie as restrições do site
Não se esqueça de verificar se os arquivos HTML, CSS, JavaScript e outros recursos tenham permissões de leitura e execução corretas para os usuários. Também verifique se não há restrições de acesso indevidas nas configurações do servidor web que possam impedir o acesso a determinados arquivos ou diretórios.

Configurações como AllowOverride e Require all granted podem causar problemas se não estiverem corretamente configuradas.

4. Limpe o cache

O cache armazena cópias de recursos do site para que, ao visitar o mesmo site novamente, o navegador possa carregar esses recursos mais rapidamente. Entretanto, se o recurso de um site retorna o erro 404, essa resposta também pode ser armazenada no cache. Então, mesmo que esse recurso seja corrigido no servidor, o usuário ainda pode receber o erro 404. Para resolver esse problema, podemos trabalhar a configuração do cabeçalho HTTP.

Você pode definir Cache-control: no-store para impedir que uma resposta seja armazenada, ou Cache-Control: no-cache para forçar o navegador a verificar com o servidor antes de usar uma versão do cache. Você também pode configurar o cabeçalho Expires com o tempo na qual a resposta será expirada.

5. Se o recurso está ausente, lide com isso graciosamente

Ao invés de deixar o usuário encontrar um erro 404, configure redirecionamentos para páginas alternativas com o erro e sugira outros serviços. Além disso, caso um serviço tenha sido movido ou renomeado, configure um redirecionamento 301 (permanente) ou 302 (temporário) para a nova URL.

Conclusão
Erros 404 impactam negativamente a experiência do usuário e a credibilidade da sua aplicação e o SEO. Como dev, ao lidar graciosamente com erros 404, você demonstra compromisso com a qualidade e a usabilidade, o que fortalece a confiança dos clientes no seu trabalho e no produto que você está desenvolvendo.

5 principais estruturas de dados

Ana Clara — Fri, 16 Aug 2024 19:31:18 +0000

O que são estruturas de dados?

Uma estrutura de dados é uma solução para organizar informações, permitindo tanto o armazenamento quanto a recuperação de itens. Elas podem ser classificadas como abstratas ou concretas.

Estruturas de dados abstratas são conceitos ou modelos que descrevem como os dados podem ser organizados e manipulados.
Estruturas de dados concretas são as implementações reais dessas abstrações, que determinam a eficiência e a forma de armazenamento e manipulação dos dados.

Estruturas de dados básicas

Existem diversas estruturas de dados, cada uma com um propósito específico e ideal para diferentes cenários de implementação. Neste post, vou apresentar cinco delas: Arrays, Listas Encadeadas (Linked Lists), Filas, Pilhas e Tabelas Hash.

Arrays

Um array é uma estrutura de dados linear que armazena e organiza elementos em posições sequenciais. Ao declarar um array, é necessário especificar o número de elementos que ele armazenará, pois o array aloca um bloco contínuo de memória para armazenar esses dados.

Dessa forma, é possivel recuperar um elemento pelo seu índice numérico, que indica a posição do elemento dentro do array. Os índices geralmente começam em zero, o que significa que o primeiro elemento está no índice 0, o segundo no índice 1, e assim por diante.

Quando usar:

Se você precisa de acesso rápido aos elementos por índice (tempo constante O(1)).
Quando o tamanho dos dados é conhecido e fixo ou não mudará com frequência.
Para armazenar uma coleção de elementos homogêneos (como inteiros, strings).

Vantagens:

Acesso direto aos elementos e eficiente em termos de memória se o tamanho for fixo.

Desvantagens:

Redimensionar arrays dinâmicos pode ser custoso. Operações de inserção e remoção no início ou no meio do array são lentas (O(n)).

Aplique o seu conhecimento!

Listas Encadeadas (Linked Lists)

Uma lista encadeada armazena uma sequência de elementos, onde cada elemento é um nó que contém dois componentes principais: seu dado (informação que o nó armazena) e um ponteiro (referência ao próximo nó na lista. Se for o último nó, essa referência será nula, indicando o final da lista.).

O primeiro elemento da lista encadeada é chamado de cabeça e a lista é acessada começando por este nó.

Além do tipo de lista encadeada explicada acima, existe a lista duplamente encadeada, nela além da o ponteiro que aponta para o nó seguinte, existe também a referência ao nó anterior.

Quando usar:

Quando o tamanho dos dados é dinâmico e você precisa de uma estrutura que possa crescer ou diminuir com frequência.
Se as inserções e remoções no início ou no meio da lista são comuns.

Vantagens:

Inserção e remoção são eficientes (O(1)) nas extremidades.

Desvantagens:

Acesso aos elementos é mais lento (O(n)) em comparação com arrays, pois você precisa percorrer os nós.

Aplique o seu conhecimento!

Filas

A ideia dessa estrutura de dados é bem intuitiva. Ela segue o princípio FIFO (First In, First Out), ou seja, o primeiro elemento inserido na fila será o primeiro a ser removido, como em uma fila de supermercado.

Nela, o acesso aos elementos é restrito as duas extremidades, você só pode acessar o elemento da frente (a cabeça) para remoção ou no final (a cauda) para inserção.

Quando usar:

Quando você precisa processar os dados em ordem de chegada.
Ideal para sistemas de espera, processamento de tarefas assíncronas ou buffer de dados.

Vantagens:

Operações de inserção e remoção são rápidas (O(1)) nas extremidades.

Desvantagens:

Acesso direto aos elementos intermediários é raro e custoso (O(n)).

Aplique o seu conhecimento!

Pilhas

Uma pilha tem o comportamento semelhante a uma pilha de pratos: o último prato que você coloca no topo é o primeiro que você retira. Essa estrutura de dados linear pode seguir os princípios LIFO (Last In First Out) ou FILO (First In Last Out).

Nela o acesso aos dados também é restrito, você só pode acessar os elementos através de uma das duas extremidades (cabeça ou calda), a depender do princípio aplicado (LIFO ou FILO). Na pilha são executadas três operações básicas:

Push: Inserir um elemento no topo da pilha.
Pop: Remover e retornar o elemento do topo da pilha.
Peek (ou Top): Verificar o elemento no topo da pilha sem o remover.

Quando usar:

Para problemas onde a ordem inversa dos elementos importa.
Usado em algoritmos de recursão, backtracking, gerenciamento de chamadas de função (call stack).

Vantagens:

Inserções e remoções no topo da pilha são rápidas (O(1)).

Desvantagens:

Sem acesso direto a elementos que não estão no topo.

Aplique o seu conhecimento!

Tabelas Hash

Nessa estrutura de dados, para cada elemento é associado uma chave. Seu funcionamento se baseia em uma função hash, que é responsável por transformar uma chave em um índice, indicando a posição na tabela onde o valor associado àquela chave será armazenado. Entretanto, a função hash pode gerar o mesmo índice para diferentes chaves, causando uma colisão. É possível tratar essa situação com duas abordagens comuns, o encadeamento e o endereçamento aberto. No encadeamento, cada posição da tabela contém uma lista de pares chave-valor, e se uma colisão ocorrer, o novo par é adicionado a essa lista. No endereçamento aberto, a tabela procura a próxima posição livre para armazenar o novo par, seguindo uma sequência predefinida.

Quando usar:

Se você precisa de acesso rápido a elementos por chave (tempo médio O(1) para buscas, inserções e deleções).
Ideal para armazenamento de grandes conjuntos de dados quando o acesso por chave é frequente, como dicionários ou caches.

Vantagens:

Busca extremamente eficiente quando a função hash é bem definida.

Desvantagens:

Colisões na tabela hash podem aumentar o tempo de operação. - Pode consumir mais memória devido ao overhead de armazenamento da função hash.

Aplique o seu conhecimento!