Array

O que é

Array é uma estrutura de dados usada para guardar elementos em posições indexadas.

Em arrays mais tradicionais, a ideia mais comum é:

• cada elemento ocupa uma posição
• cada posição tem um índice
• o acesso é feito por esse índice

Imagine uma fileira de gavetas lado a lado:

[0][1][2][3]

Cada posição possui um índice, que funciona como o endereço lógico daquele elemento.

["a", "b", "c"]

0 -> "a"
1 -> "b"
2 -> "c"

Isso permite acessar elementos rapidamente pelo índice.

array[1]

Em arrays clássicos, esse acesso costuma ser:

O(1)

Ou seja: tempo constante.

Como arrays funcionam em muitas linguagens

Em linguagens como C, Java e em estruturas equivalentes de outras linguagens, arrays costumam ter estas características:

• posições indexadas
• elementos do mesmo tipo
• organização pensada para acesso rápido

Em arrays tradicionais, os elementos geralmente ficam em uma região contígua de memória.

Exemplo:

int[] numbers = new int[4];

Nesse caso:

• int define o tipo
• 4 define o tamanho

Esse tipo de array já nasce com tamanho fixo.

E quando o array precisa crescer?

Aqui vale separar duas coisas:

• array fixo
• estrutura dinâmica baseada em array

Um array fixo, como em muitos exemplos de C ou Java, não cresce sozinho.

Se você quiser crescimento automático, normalmente entra outra estrutura por cima, como:

• ArrayList no Java
• vector no C++

Essas estruturas costumam funcionar assim:

1. reservam um espaço interno
2. adicionam elementos enquanto houver capacidade
3. quando a capacidade acaba, criam um bloco maior
4. copiam os elementos antigos
5. passam a usar o novo bloco

Visualmente:

Antes:
[1][2][3]

Novo bloco:
[1][2][3][ ][ ][ ]

Esse processo pode custar:

O(n)

Porque precisa percorrer e copiar os elementos existentes.

JavaScript é diferente

No JavaScript, arrays são mais flexíveis do que arrays clássicos.

Você pode misturar tipos diferentes:

const items = [1, 'texto', true, { name: 'morango' }]

Isso já mostra que o comportamento deles não é exatamente igual ao de um array estático tradicional de baixo nível.

Arrays em JavaScript são objetos especiais, e os motores da linguagem fazem várias otimizações internas para tornar o uso comum eficiente.

O motor guarda tudo em memória contígua?

A resposta curta é:

não dá para tratar isso como uma regra fixa

O jeito mais seguro de pensar é:

• se o array estiver em um formato simples e previsível, o motor consegue otimizar bastante
• se ele ficar muito irregular, pode perder parte dessas otimizações

Exemplo de array simples:

const arr = [1, 2, 3]

Nesse tipo de cenário, o motor tende a usar representações internas mais eficientes.

Se depois você fizer:

arr.push(4)

isso normalmente continua sendo um caso amigável para otimização.

E quando o array fica “estranho”?

Quando o array deixa de ser previsível, o motor pode precisar mudar a forma como ele representa esse dado internamente.

Por exemplo:

• muitos buracos no meio
• índices muito distantes
• mistura de padrões pouco consistentes

Array denso

Um array denso é um array com índices sequenciais e sem grandes “buracos”.

;[1, 2, 3, 4]

Nesse cenário, o motor costuma conseguir otimizar melhor.

Array esparso

Um array esparso é um array com muitos espaços vazios entre índices.

const arr = []
arr[999999] = 'x'

Agora existem “buracos”.

Visualmente:

[empty, empty, empty, ..., "x"]

Nesse caso, o motor pode deixar de usar uma representação tão otimizada quanto a de um array denso.

Dependendo do engine, ele pode passar a tratar isso de uma forma mais parecida com mapeamento interno por chaves do que com um array sequencial super otimizado.

Então array em JavaScript é array “de verdade”?

Sim, mas com uma observação importante:

ele não deve ser entendido como uma cópia exata do array clássico de baixo nível.

No JavaScript, o array foi pensado para ser prático no uso do dia a dia, mesmo que por baixo dos panos o motor precise tomar decisões mais sofisticadas.

Por isso, a melhor intuição é:

• em teoria de estrutura de dados, array clássico costuma remeter a posições contíguas e acesso por índice
• em JavaScript, você continua tendo acesso por índice e comportamento de array
• mas o motor pode representar isso internamente de formas diferentes para otimizar o uso real

Resumindo

Se eu tivesse que resumir de um jeito simples:

• array clássico: mais rígido, previsível e próximo do modelo contíguo de memória
• estrutura dinâmica baseada em array: cresce copiando para um bloco maior quando necessário
• array no JavaScript: mais flexível, com otimizações internas que variam conforme o formato de uso

No fim, a ideia principal continua sendo a mesma:

array é excelente quando você quer acessar posições rapidamente por índice

E o detalhe mais importante de guardar é:

quanto mais previsível e sequencial o uso, mais fácil costuma ser para o motor otimizar.

Referências

• MDN Web Docs. Indexed collections
• MDN Web Docs. Array
• V8 Blog. Elements kinds in V8
• Oracle Java Docs. ArrayList
• Estrutura de Dados e Algoritmos. Augusto Galego