Arrays são uma estrutura de dados fundamental em ciência da computação. Todos os arrays armazenam coleções ordenadas de dados, mas dependendo do seu tipo, eles podem funcionar de maneira diferente nos bastidores. O comportamento subjacente deles pode ter um efeito importante na eficiência do programa, então vamos aprender sobre arrays dinâmicos e estáticos e suas diferenças, para que você possa escolher o mais eficiente para o seu programa. Começaremos com arrays estáticos. Arrays estáticos têm um tamanho fixo. Eles armazenam elementos em locais de memória adjacentes. O tamanho de um array estático é determinado quando o array é inicializado. Uma vez que aquele bloco específico de memória é alocado, ele é fixo e não pode ser alterado enquanto o programa está em execução. Esta é uma característica chave dos arrays estáticos. Armazenar elementos em locais de memória adjacentes torna o processo de recuperação de dados mais eficiente porque o programa pode armazenar a localização do primeiro elemento e então usar índices para fazer cálculos simples e encontrar os outros elementos na memória. Graças a isso, acessar os valores de um array estático leva tempo constante O(1), o que é muito eficiente. Você pode usar um array estático quando souber o número de elementos que serão armazenados com antecedência. Também é útil quando os valores serão acessados com muita frequência, já que a operação de acesso é muito eficiente. No entanto, essa estrutura de dados não pode crescer ou diminuir, então se o número de elementos que serão armazenados pode variar, você deve usar um array dinâmico em vez disso. Tentar aumentar o tamanho de um array estático envolveria criar um novo array e copiar todos os elementos do array antigo para um novo, o que é ineficiente. Nesse caso, um array dinâmico seria muito melhor porque ele lida com esse processo automaticamente. JavaScript não possui arrays estáticos tradicionais de baixo nível como C ou Java, mas você pode simular um array de tamanho fixo usando o Array embutido object:

let numbers = new Array(3); // fixed size of 3
numbers[0] = 10;
numbers[1] = 20;
numbers[2] = 30;

Embora o JavaScript permita redimensionamento, conceitualmente isso representa um array de comprimento fixo. Arrays em Javascript são dinâmicos por padrão, então vamos dar uma olhada neles. Arrays dinâmicos são mais flexíveis porque podem crescer ou encolher automaticamente enquanto o programa está em execução. Eles funcionam por meio de um mecanismo automático de redimensionamento que copia os elementos para um novo array quando o array original está cheio. O processo é feito de forma eficiente porque o tamanho do novo array é escolhido de uma maneira eficiente que torna essas operações computacionalmente caras menos frequentes. Acessar os elementos de um array dinâmico leva tempo constante O(1), então essa operação é muito eficiente. Inserir um elemento no meio do array leva tempo linear O(n) porque os elementos após ele precisam ser realocados. Inserir um elemento no final do array leva tempo constante O(1) se ainda houver espaço disponível no array dinâmico, mas se o array estiver cheio e precisar ser redimensionado, essa operação tem complexidade O(n). Você deve usar arrays dinâmicos quando você não souber antecipadamente o número de valores que precisará armazenar no array. Eles também são úteis quando você for inserir e deletar elementos com frequência. Para criar um array em Javascript, você escreve os elementos dentro de colchetes, separados por vírgulas:

let numbers = [3, 4, 5, 6];

Isto cria um array dinâmico com quatro elementos. Você pode acessar um elemento no array escrevendo o nome da variável, seguido por colchetes contendo o índice. Os índices começam em 0 para o primeiro elemento e aumentam em 1 para cada próximo elemento.

numbers[0]; // 3
numbers[1]; // 4
numbers[2]; // 5
numbers[3]; // 6

Para atualizar um valor, você só precisa reatribuí-lo:

numbers[2] = 16

Agora, o array se torna [3, 4, 16, 6]. Para adicionar um elemento ao final do array, use o método .push():

numbers.push(7)

Agora o array se torna [3, 4, 16, 6, 7]: Para inserir elementos em um índice específico, o Javascript não possui .insert() como o Python, mas você pode usar o método .splice(). A sintaxe é assim:

array.splice(index, deleteCount, newElement)

Aqui está um exemplo:

numbers.splice(3, 0, 15);

Este exemplo significa:

• Comece no index 3
• Remover 0 elementos
• Insira 15

Se o array era [3, 4, 16, 6, 7], agora se torna [3, 4, 16, 15, 6, 7]. Você pode remover um elemento em um índice específico com o mesmo método .splice:

numbers.splice(2, 1);

Isso significa começar no index 2 e remover 1 element. Para remover o último elemento, use o método .pop():

numbers.pop();

Existem muitos outros métodos de array embutidos que você pode consultar na documentação para trabalhar com arrays em Javascript. Esse é o poder dos arrays dinâmicos. Em geral, você deve usar arrays estáticos quando souber o número de elementos com antecedência e precisar acessá-los frequentemente e usar arrays dinâmicos quando o número de elementos for desconhecido ou variável ao longo do tempo. Você deve sempre considerar a troca entre a simplicidade dos arrays estáticos e a flexibilidade dos arrays dinâmicos. Eles são úteis para casos de uso e cenários específicos. Ser capaz de escolher o melhor para um dado problema faz parte das habilidades de resolução de problemas que você desenvolverá gradualmente com a prática.