Skip to content
The Chat Archive
gemma-3-27b-it· Google LMArena Human Preference 140K

en javascript de object a map

  1. User

    en javascript de object a map

  2. Assistant
    /**
     * Converte um objeto JavaScript em um Map.
     *
     * @param {object} obj O objeto a ser convertido.
     * @returns {Map} Um novo Map criado a partir do objeto.
     * @throws {TypeError} Se o argumento não for um objeto.
     */
    function objectToMap(obj) {
      if (typeof obj !== 'object' || obj === null) {
        throw new TypeError('O argumento deve ser um objeto.');
      }
    
      const map = new Map();
    
      for (const key in obj) {
        if (obj.hasOwnProperty(key)) { // Garante que estamos iterando apenas sobre propriedades do próprio objeto, não herdadas.
          map.set(key, obj[key]);
        }
      }
    
      return map;
    }
    
    // Exemplos de uso:
    
    const meuObjeto = {
      nome: "João",
      idade: 30,
      cidade: "São Paulo"
    };
    
    const meuMap = objectToMap(meuObjeto);
    
    console.log(meuMap); // Output: Map(3) { 'nome' => 'João', 'idade' => 30, 'cidade' => 'São Paulo' }
    
    console.log(meuMap.get('nome')); // Output: João
    console.log(meuMap.has('idade')); // Output: true
    console.log(meuMap.size); // Output: 3
    
    // Exemplo com um objeto vazio:
    const objetoVazio = {};
    const mapVazio = objectToMap(objetoVazio);
    console.log(mapVazio); // Output: Map(0) {}
    
    // Tratamento de erro:
    try {
      const resultado = objectToMap(null);
    } catch (error) {
      console.error(error.message); // Output: O argumento deve ser um objeto.
    }
    
    try {
      const resultado = objectToMap("string");
    } catch (error) {
      console.error(error.message); // Output: O argumento deve ser um objeto.
    }
    

    Explicação:

    1. objectToMap(obj) Função:

      • Recebe um objeto obj como entrada.
      • Validação: Verifica se o argumento é realmente um objeto e não é null. Se não for, lança um TypeError para indicar um uso incorreto da função.
      • Criação do Map: Cria um novo Map vazio usando new Map().
      • Iteração sobre as propriedades do objeto:
        • Usa um loop for...in para iterar sobre as chaves (propriedades) do objeto.
        • hasOwnProperty(key): Esta é uma verificação crucial. hasOwnProperty(key) garante que estamos iterando apenas sobre as propriedades que pertencem diretamente ao objeto obj e não sobre propriedades herdadas do seu protótipo. Isso evita comportamentos inesperados.
        • map.set(key, obj[key]): Para cada chave key encontrada, usa o método set() do Map para adicionar um novo par chave-valor ao Map. A chave é key e o valor é obj[key] (o valor da propriedade correspondente no objeto).
      • Retorno do Map: Retorna o Map preenchido com os dados do objeto.
    2. Exemplos de Uso:

      • Demonstra como usar a função com um objeto de exemplo.
      • Mostra como acessar valores no Map usando get(), verificar se uma chave existe usando has(), e obter o tamanho do Map usando size.
      • Inclui um exemplo com um objeto vazio para mostrar que a função funciona corretamente nesse caso.
      • Apresenta exemplos de tratamento de erro para demonstrar como a função lida com entradas inválidas (como null ou uma string).

    Por que usar um Map em vez de um objeto?

    • Chaves de qualquer tipo: Um Map permite que você use qualquer tipo de dado como chave (objetos, funções, números, strings, etc.), enquanto que as chaves de um objeto JavaScript são sempre strings ou Symbols.
    • Ordem de inserção: Um Map preserva a ordem em que os pares chave-valor são inseridos. A ordem das propriedades em um objeto JavaScript não é garantida.
    • Tamanho: É fácil obter o tamanho de um Map usando a propriedade size. Para obter o número de propriedades de um objeto, você precisa usar Object.keys(obj).length.
    • Iteração: Map fornece métodos convenientes para iteração, como forEach(), keys(), values(), e entries().
    • Performance: Em alguns casos, Map pode ter melhor performance do que objetos para operações de adição e remoção de pares chave-valor, especialmente quando o número de pares é grande.

    Alternativas (mais concisas):

    Embora a função acima seja clara e explícita, você pode usar uma abordagem mais concisa com o operador spread (...) e o construtor Map:

    function objectToMapConcise(obj) {
      if (typeof obj !== 'object' || obj === null) {
        throw new TypeError('O argumento deve ser um objeto.');
      }
      return new Map(Object.entries(obj));
    }
    

    Explicação da alternativa concisa:

    • Object.entries(obj): Este método retorna um array de arrays, onde cada sub-array contém um par chave-valor do objeto. Por exemplo, Object.entries({ a: 1, b: 2 }) retorna [['a', 1], ['b', 2]].
    • new Map(...): O construtor Map pode receber um array de arrays como argumento, onde cada sub-array é interpretado como um par chave-valor para o Map.

    A alternativa concisa é mais curta, mas a primeira versão (com o loop for...in) pode ser mais fácil de entender para iniciantes. Ambas as versões são funcionalmente equivalentes. Escolha a que melhor se adapta ao seu estilo de codificação e às necessidades do seu projeto.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.