6.1 Criando objetos
Objetos são um dos principais tipos de dados no JavaScript e são amplamente usados para armazenar e gerenciar dados. Um objeto é uma coleção de propriedades, onde cada propriedade consiste em uma chave (nome) e um valor. Nesta aula, vamos explorar a criação de objetos, assim como o acesso às suas propriedades e métodos.
1. Literal de objeto
A forma mais comum de criar um objeto em JavaScript é usando o literal de objeto.
Neste exemplo, criamos um objeto person com quatro propriedades: name, age, isStudent e greet.
let person = {
name: 'John',
age: 30,
isStudent: false,
greet: function() {
return 'Hello!';
}
};
2. Construtor Object
Objetos também podem ser criados usando o construtor Object().
Este método é equivalente à criação de um objeto usando o literal de objeto, mas é mais verboso:
let person = new Object();
person.name = 'John';
person.age = 30;
person.isStudent = false;
person.greet = function() {
return 'Hello!';
};
3. Função Construtora
A função construtora permite criar múltiplas instâncias de objetos com mesmas propriedades e métodos.
Neste exemplo, a função construtora Person() é usada para criar os objetos john
e jane com mesmas propriedades e métodos:
function Person(name, age, isStudent) {
this.name = name;
this.age = age;
this.isStudent = isStudent;
this.greet = function() {
return 'Hello!';
};
}
let john = new Person('John', 30, false);
let jane = new Person('Jane', 25, true);
4. Método Object.create()
O método Object.create() cria um novo objeto com o protótipo e as propriedades especificados.
Neste exemplo, o objeto john é criado com base no protótipo personPrototype:
let personPrototype = {
greet: function() {
return 'Hello!';
}
};
let john = Object.create(personPrototype);
john.name = 'John';
john.age = 30;
john.isStudent = false;
6.2 Acesso às propriedades e métodos
1. Acesso com ponto
A forma mais comum de acessar propriedades e métodos de um objeto é através do ponto:
let person = {
name: 'John',
age: 30,
greet: function() {
return 'Hello!';
}
};
console.log(person.name); // Exibe: John
console.log(person.age); // Exibe: 30
console.log(person.greet()); // Exibe: Hello!
2. Acesso com colchetes
As propriedades de um objeto também podem ser acessadas usando colchetes. Este método é útil se o nome da propriedade é armazenado em uma variável ou contém espaços ou caracteres especiais:
let person = {
'first name': 'John',
age: 30,
greet: function() {
return 'Hello!';
}
};
console.log(person['first name']); // Exibe: John
console.log(person['age']); // Exibe: 30
let propertyName = 'greet';
console.log(person[propertyName]()); // Exibe: Hello!
3. Alteração e adição de propriedades
As propriedades de um objeto podem ser alteradas ou adicionadas a qualquer momento:
let person = {
name: 'John',
age: 30
};
// Alteração de uma propriedade existente
person.age = 31;
console.log(person.age); // Exibe: 31
// Adição de uma nova propriedade
person.isStudent = false;
console.log(person.isStudent); // Exibe: false
4. Exclusão de propriedades
As propriedades de um objeto podem ser excluídas usando o operador delete:
let person = {
name: 'John',
age: 30,
isStudent: false
};
delete person.isStudent;
console.log(person.isStudent); // Exibe: undefined
6.3 Iteração sobre as propriedades de um objeto
1. Loop for...in
O loop for...in permite iterar sobre todas as propriedades enumeráveis de um objeto:
let person = {
name: 'John',
age: 30,
isStudent: false
};
for (let key in person) {
console.log(`${key}: ${person[key]}`);
}
// Exibe:
// name: John
// age: 30
// isStudent: false
2. Método Object.keys()
O método Object.keys() retorna um array de todas as propriedades enumeráveis de um objeto:
let person = {
name: 'John',
age: 30,
isStudent: false
};
let keys = Object.keys(person);
console.log(keys); // Exibe: ['name', 'age', 'isStudent']
3. Método Object.values()
O método Object.values() retorna um array dos valores de todas as propriedades enumeráveis de um objeto:
let person = {
name: 'John',
age: 30,
isStudent: false
};
let values = Object.values(person);
console.log(values); // Exibe: ['John', 30, false]
4. Método Object.entries()
O método Object.entries() retorna um array de pares [chave, valor] para todas as propriedades enumeráveis de um objeto:
let person = {
name: 'John',
age: 30,
isStudent: false
};
let entries = Object.entries(person);
console.log(entries); // Exibe: [['name', 'John'], ['age', 30], ['isStudent', false]]
6.4 Verificação de existência de propriedades
1. Operador in
O operador in permite verificar a existência de uma propriedade em um objeto:
let person = {
name: 'John',
age: 30
};
console.log('name' in person); // Exibe: true
console.log('isStudent' in person); // Exibe: false
2. Método hasOwnProperty()
O método hasOwnProperty() verifica se um objeto possui uma propriedade especificada como sua própria (não herdada):
let person = {
name: 'John',
age: 30
};
console.log(person.hasOwnProperty('name')); // Exibe: true
console.log(person.hasOwnProperty('isStudent')); // Exibe: false
GO TO FULL VERSION