Revisão de Objetos JavaScript

Noções Básicas de Objetos

Definição: Um objeto é uma estrutura de dados composta por propriedades. Uma propriedade consiste em uma chave e um valor. Para acessar dados de um objeto você pode usar a notação de ponto ou a notação de colchetes.

const person = {
  name: "Alice",
  age: 30,
  city: "New York"
};

console.log(person.name);  // Alice
console.log(person["name"]); // Alice

Para definir uma propriedade de um objeto existente você pode usar tanto a notação de ponto quanto a notação de colchetes junto com o operador de atribuição.

const person = {
  name: "Alice",
  age: 30
};

person.job = "Engineer"
person["hobby"] = "Knitting"
console.log(person);  // {name: 'Alice', age: 30, job: 'Engineer', hobby: 'Knitting'}

Removendo Propriedades de um Objeto

Operador delete: Este operador é usado para remover uma propriedade de um objeto.

const person = {
  name: "Alice",
  age: 30,
  job: "Engineer"
};

delete person.job;

console.log(person.job); // undefined

Verificando se um Objeto possui uma Propriedade

Método hasOwnProperty(): Este método retorna um booleano indicando se o objeto possui a propriedade especificada como sua própria propriedade.

const person = {
  name: "Alice",
  age: 30
};

console.log(person.hasOwnProperty("name")); // true
console.log(person.hasOwnProperty("job")); // false

Object.hasOwn() Method: Esta é a forma moderna e recomendada de verificar se um objeto possui uma propriedade como sua própria (não herdada). A sintaxe é Object.hasOwn(object, propertyName). Retorna true se a propriedade existir no objeto e false se não existir — independentemente do valor da propriedade. Isso o torna mais seguro que hasOwnProperty() e mais confiável que if (obj.prop) quando os valores podem ser 0, false, null ou undefined.

const person = {
  name: "Alice",
  age: 30
};

console.log(Object.hasOwn(person, "name")); // true
console.log(Object.hasOwn(person, "job")); // false

Aqui está um exemplo mais detalhado mostrando por que Object.hasOwn() é mais confiável do que verificar o valor diretamente:

const settings = {
  darkMode: false,
  fontSize: 0,
  language: null
};

// Object.hasOwn() correctly sees these properties exist
console.log(Object.hasOwn(settings, "darkMode")); // true (value is false, but exists)
console.log(Object.hasOwn(settings, "fontSize")); // true (value is 0, but exists)
console.log(Object.hasOwn(settings, "theme"));    // false (property was never added)

// Using if() directly is unsafe for falsy values!
if (settings.darkMode) {
  console.log("Dark mode on"); // Does NOT print — misleading!
}

// Object.hasOwn() is the safe way
if (Object.hasOwn(settings, "darkMode")) {
  console.log("darkMode exists, value is:", settings.darkMode); // darkMode exists, value is: false
}

Operador in: Este operador retornará true se a propriedade existir no objeto.

const person = {
  name: "Bob",
  age: 25
};

console.log("name" in person);  // true

Acessando Propriedades de Objetos Aninhados

Acessando Dados: Acessar propriedades de objetos aninhados envolve usar a notação de ponto ou a notação de colchetes, assim como acessar propriedades de objetos simples. No entanto, você precisará encadear esses acessadores para aprofundar na estrutura aninhada.

const person = {
  name: "Alice",
  age: 30,
  contact: {
    email: "alice@example.com",
    phone: {
      home: "123-456-7890",
      work: "098-765-4321"
    }
  }
};

console.log(person.contact.phone.work); // "098-765-4321"

Tipos de Dados Primitivos e Não Primitivos

Primitive Data Types: These data types include numbers, strings, booleans, null, undefined, and symbols. Esses tipos são chamados de "primitivos" porque representam valores únicos e não são objetos. Valores primitivos são imutáveis, o que significa que, uma vez criados, seu valor não pode ser alterado.
Tipos de Dados Não Primitivos: Em JavaScript, estes são objetos, que incluem objetos regulares, arrays e funções. Diferentemente dos primitivos, os tipos não primitivos podem conter múltiplos valores como propriedades ou elementos.

Métodos de Objeto

Definição: Métodos de objeto são funções que estão associadas a um objeto. Eles são definidos como propriedades de um objeto e podem acessar e manipular os dados do objeto. A palavra-chave this dentro do método refere-se ao próprio objeto, permitindo o acesso às suas propriedades.

const person = {
  name: "Bob",
  age: 30,
  sayHello: function() {
    return "Hello, my name is " + this.name;
  }
};

console.log(person.sayHello()); // "Hello, my name is Bob"

Construtor de Objeto

Definition: In JavaScript, a constructor is a special type of function used to create and initialize objects. Ele é invocado com a palavra-chave new e pode inicializar propriedades e métodos no objeto recém-criado. O construtor Object() cria um novo objeto vazio.

new Object()

Trabalhando com o Operador de Encadeamento Opcional (`?.`)

Definição: Este operador permite acessar propriedades de objetos ou chamar métodos com segurança sem se preocupar se eles existem.

const user = {
  name: "John",
  profile: {
    email: "john@example.com",
    address: {
      street: "123 Main St",
      city: "Somewhere"
    }
  }
};

console.log(user.profile?.address?.street); // "123 Main St"
console.log(user.profile?.phone?.number);   // undefined

Desestruturação de Objetos

Definição: A desestruturação de objetos permite extrair valores de objetos e atribuí-los a variáveis de uma forma mais concisa e legível.

const person = { name: "Alice", age: 30, city: "New York" };

const { name, age } = person;

console.log(name); // Alice
console.log(age);  // 30

Trabalhando com JSON

Definição: JSON significa JavaScript Object Notation. É um formato de dados leve, baseado em texto, que é comumente usado para trocar dados entre um servidor e uma aplicação web.

{
  "name": "Alice",
  "age": 30,
  "isStudent": false,
  "list of courses": ["Mathematics", "Physics", "Computer Science"]
}

JSON.stringify(): Este método é usado para converter um objeto JavaScript em uma string JSON. Isso é útil quando você quer armazenar ou transmitir dados em um formato que pode ser facilmente compartilhado ou transferido entre sistemas.

const user = {
  name: "John",
  age: 30,
  isAdmin: true
};

const jsonString = JSON.stringify(user);
console.log(jsonString); // '{"name":"John","age":30,"isAdmin":true}'

JSON.parse(): Este método converte uma string JSON de volta em um objeto JavaScript. Isso é útil quando você recupera dados JSON de um servidor web ou do localStorage e precisa manipular os dados na sua aplicação.

const jsonString = '{"name":"John","age":30,"isAdmin":true}';
const userObject = JSON.parse(jsonString);

// result: { name: 'John', age: 30, isAdmin: true }
console.log(userObject);