Tipos de Listas em JavaScript (Collections): Arrays, Sets, Maps, Weaks, Queues, Typed Arrays, Stacks e Linked Lists

Ao trabalhar com conjuntos de dados em JavaScript, é importante conhecer os diferentes tipos de listas ou coleções disponíveis. Neste tutorial, vamos explorar os principais tipos de listas em JavaScript: Arrays, Sets, Maps, WeakSets, WeakMaps, Typed Arrays, Queues, Stacks e Linked Lists. Com exemplos práticos, você aprenderá a utilizar cada um deles.

Arrays

O Array é uma lista ordenada de elementos, identificados por índices numéricos. Ele é ideal para armazenar e acessar elementos de forma eficiente. Vejamos um exemplo:

JavaScript

let frutas = ['maçã', 'banana', 'laranja'];

console.log(frutas[0]); // Saída: maçã
console.log(frutas.length); // Saída: 3

Os Arrays possuem uma variedade de métodos úteis para adicionar, remover e manipular elementos.

Sets

O Set é uma coleção de valores únicos, sem uma ordem específica. É útil quando você precisa armazenar elementos exclusivos. Veja um exemplo:

JavaScript

let conjunto = new Set();

conjunto.add(10);
conjunto.add('Olá');
conjunto.add(true);

console.log(conjunto.size); // Saída: 3
console.log(conjunto.has('Olá')); // Saída: true

Sets oferecem métodos para adicionar, remover e verificar a presença de elementos, além de operações como união e interseção.

Maps

O Map é uma coleção de pares chave-valor, permitindo que você associe valores a chaves exclusivas. Ele mantém a ordem de inserção dos elementos. Veja um exemplo:

JavaScript

let mapa = new Map();

mapa.set('nome', 'João');
mapa.set('idade', 25);
mapa.set('profissão', 'Programador');

console.log(mapa.get('nome')); // Saída: João
console.log(mapa.size); // Saída: 3

Maps fornecem métodos para adicionar, remover e percorrer os elementos, além de permitir a busca de valores por chaves.

WeakSets e WeakMaps

WeakSets e WeakMaps são variações dos Sets e Maps, respectivamente, que permitem apenas referências a objetos. Eles não impedem que objetos sejam coletados pelo garbage collector se não houver outras referências. Veja um exemplo de WeakMap:

JavaScript

let weakMapa = new WeakMap();
let objeto1 = {};
let objeto2 = {};

weakMapa.set(objeto1, 'Valor do objeto 1');
weakMapa.set(objeto2, 'Valor do objeto 2');

console.log(weakMapa.get(objeto1)); // Saída: Valor do objeto 1

Typed Arrays

Typed Arrays são arrays especiais que permitem armazenar elementos de um tipo específico, como inteiros ou floats, com uma representação de memória mais eficiente. Veja um exemplo de Typed Array:

JavaScript

let arrayInteiros = new Int32Array([10, 20, 30]);

console.log(arrayInteiros[0]); // Saída: 10
console.log(arrayInteiros.length); // Saída: 3

Queues

Queues são estruturas de dados que seguem a ordem FIFO (First-In-First-Out), onde o primeiro elemento adicionado é o primeiro a ser removido. Veja um exemplo de Queue:

JavaScript

class Queue {
  constructor() {
    this.elements = [];
  }

  enqueue(element) {
    this.elements.push(element);
  }

  dequeue() {
    return this.elements.shift();
  }

  isEmpty() {
    return this.elements.length === 0;
  }

  size() {
    return this.elements.length;
  }
}

let fila = new Queue();

fila.enqueue('elemento1');
fila.enqueue('elemento2');
fila.enqueue('elemento3');

console.log(fila.dequeue()); // Saída: elemento1
console.log(fila.size()); // Saída: 2

Stacks

Stacks são estruturas de dados que seguem a ordem LIFO (Last-In-First-Out), onde o último elemento adicionado é o primeiro a ser removido. Veja um exemplo de Stack:

JavaScript

class Stack {
  constructor() {
    this.elements = [];
  }

  push(element) {
    this.elements.push(element);
  }

  pop() {
    return this.elements.pop();
  }

  isEmpty() {
    return this.elements.length === 0;
  }

  size() {
    return this.elements.length;
  }
}

let pilha = new Stack();

pilha.push('elemento1');
pilha.push('elemento2');
pilha.push('elemento3');

console.log(pilha.pop()); // Saída: elemento3
console.log(pilha.size()); // Saída: 2

Linked Lists

Linked Lists são listas encadeadas compostas por nós, cada um contendo um valor e uma referência para o próximo nó. Essa estrutura de dados é flexível e permite manipulações eficientes. Veja um exemplo de Linked List:

JavaScript

class Node {
  constructor(value) {
    this.value = value;
    this.next = null;
  }
}

class LinkedList {
  constructor() {
    this.head = null;
    this.tail = null;
  }

  append(value) {
    const newNode = new Node(value);

    if (!this.head) {
      this.head = newNode;
      this.tail = newNode;
    } else {
      this.tail.next = newNode;
      this.tail = newNode;
    }
  }

  prepend(value) {
    const newNode = new Node(value);

    if (!this.head) {
      this.head = newNode;
      this.tail = newNode;
    } else {
      newNode.next = this.head;
      this.head = newNode;
    }
  }

  print() {
    let current = this.head;
    let elements = '';

    while (current) {
      elements += current.value + ' ';
      current = current.next;
    }

    console.log(elements.trim());
  }
}

let lista = new LinkedList();

lista.append('elemento1');
lista.append('elemento2');
lista.prepend('elemento3');

lista.print(); // Saída: elemento3 elemento1 elemento2

Agora que você conhece os diferentes tipos de listas em JavaScript, você pode escolher a estrutura de dados mais adequada para as necessidades do seu projeto. Experimente cada uma delas e descubra suas vantagens em diferentes cenários.

Espero que este tutorial tenha sido útil! Continue explorando e aprofundando seus conhecimentos em JavaScript.

Arrays

Sets

Maps

WeakSets e WeakMaps

Typed Arrays

Queues

Stacks

Linked Lists

Deixe um comentário Cancelar resposta