JavaScript Object Properties
Mastering JavaScript Object Properties: A Comprehensive Guide
Introduction:
Unlock the power of JavaScript object properties with our comprehensive guide. Dive into the intricacies of creating, modifying, and accessing properties within JavaScript objects. Whether you’re a beginner or an experienced developer, this resource will enhance your understanding of object-oriented programming in JavaScript.
In JavaScript, objects are fundamental data structures that allow you to store and organize data using key-value pairs. Objects can have properties, which are the individual key-value pairs associated with the object. Here’s an overview of working with object properties in JavaScript:
Creating Objects:
You can create an object using either the object literal syntax {}, the Object constructor, or by creating instances of custom constructor functions.
// Using object literal syntax
let person = {
name: 'John',
age: 30,
job: 'Developer'
};
// Using the Object constructor
let car = new Object();
car.make = 'Toyota';
car.model = 'Camry';
car.year = 2022;Accessing Properties:
You can access object properties using dot notation or square bracket notation.
console.log(person.name); // John console.log(car['make']); // Toyota
Modifying Properties:
You can modify the value of an existing property by assigning a new value.
person.age = 31; car['year'] = 2023;
Adding Properties:
You can add new properties to an existing object.
person.city = 'New York'; car.color = 'Blue';
Deleting Properties:
You can delete a property from an object using the delete keyword.
delete person.job; delete car['model'];
Object Methods:
Objects can also have methods, which are functions associated with the object.
let calculator = {
add: function(x, y) {
return x + y;
},
subtract: function(x, y) {
return x - y;
}
};
console.log(calculator.add(5, 3)); // 8
console.log(calculator.subtract(7, 2)); // 5Iterating Over Properties:
You can iterate over an object’s properties using for…in loop.
for (let key in person) {
console.log(`${key}: ${person[key]}`);
}Object Property Shorthand (ES6+):
In modern JavaScript, you can use property shorthand when the variable name and property name are the same.
let name = 'Alice';
let age = 25;
let = { name, age };
// Equivalent to: let = { name: name, age: age };These are some basics of working with JavaScript object properties. Objects are versatile and widely used in JavaScript for structuring and organizing data.
complete example in html with explanation step by step
Let’s create a simple HTML file with embedded JavaScript to demonstrate the creation, manipulation, and usage of objects and their properties. We’ll create a hypothetical scenario where we manage information about s.
index.html:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>JavaScript Object Example</title>
</head>
<body>
<h1>JavaScript Object Example</h1>
<script>
// Step 1: Creating an object using object literal syntax
let = {
firstName: 'John',
lastName: 'Doe',
age: 30,
email: 'john@example.com'
};
// Step 2: Accessing and displaying properties
document.write('<p>Name: ' + .firstName + ' ' + .lastName + '</p>');
document.write('<p>Age: ' + .age + '</p>');
document.write('<p>Email: ' + .email + '</p>');
// Step 3: Modifying a property
.age = 31;
// Step 4: Adding a new property
.city = 'New York';
// Step 5: Deleting a property
delete .email;
// Step 6: Displaying updated information
document.write('<h2>Updated Information</h2>');
document.write('<p>Name: ' + .firstName + ' ' + .lastName + '</p>');
document.write('<p>Age: ' + .age + '</p>');
document.write('<p>City: ' + .city + '</p>');
// Step 7: Object method
let calculator = {
add: function(x, y) {
return x + y;
},
subtract: function(x, y) {
return x - y;
}
};
document.write('<h2>Calculator</h2>');
document.write('<p>5 + 3 = ' + calculator.add(5, 3) + '</p>');
document.write('<p>7 - 2 = ' + calculator.subtract(7, 2) + '</p>');
</script>
</body>
</html>Explanation:
Creating an Object:
We create an object named using object literal syntax with properties like firstName, lastName, age, and email.
Accessing and Displaying Properties:
We use document.write to display information about the on the webpage.
Modifying a Property:
We update the age property of the object.
Adding a New Property:
We add a new property city to the object.
Deleting a Property:
We remove the email property from the object using the delete keyword.
Displaying Updated Information:
We display the updated information about the after modifications.
Object Method:
We create an object named calculator with methods add and subtract to perform basic arithmetic operations.
Displaying Calculator Results:
We use the calculator methods to perform calculations and display the results on the webpage.
Open this HTML file in a web browser to see the output.
The comments in the code explain each step of the process.
How to loop through the properties of an object?
In JavaScript, you can loop through the properties of an object using a for…in loop.
Here’s an example demonstrating how to iterate over the properties of an object:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Loop Through Object Properties</title>
</head>
<body>
<h1>Loop Through Object Properties</h1>
<script>
// Creating an object
let person = {
firstName: 'John',
lastName: 'Doe',
age: 30,
city: 'New York'
};
// Looping through object properties
document.write('<p>Object Properties:</p>');
for (let key in person) {
document.write(`<p>${key}: ${person[key]}</p>`);
}
</script>
</body>
</html>In this example:
- We create an object called person with properties like firstName, lastName, age, and city.
- We use a for…in loop to iterate over the properties of the person object.
- Inside the loop, key represents the current property name, and person[key] accesses the corresponding value.
- We use document.write to display each property and its value on the webpage.
When you open this HTML file in a web browser, you should see the properties of the person object displayed on the webpage. The loop dynamically handles any properties added to or removed from the object.
How to add New Properties to an object ?
You can add new properties to an object in JavaScript using either dot notation or square bracket notation.
Here’s an example that demonstrates both methods:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Add New Properties to an Object</title>
</head>
<body>
<h1>Add New Properties to an Object</h1>
<script>
// Creating an object
let person = {
firstName: 'John',
lastName: 'Doe',
age: 30,
city: 'New York'
};
// Displaying original object
document.write('<h2>Original Object</h2>');
displayObject(person);
// Adding new properties using dot notation
person.job = 'Developer';
// Adding new properties using square bracket notation
person['hobbies'] = ['Reading', 'Gardening'];
// Displaying updated object
document.write('<h2>Updated Object</h2>');
displayObject(person);
// Function to display object properties
function displayObject(obj) {
document.write('<p>Object Properties:</p>');
for (let key in obj) {
document.write(`<p>${key}: ${obj[key]}</p>`);
}
}
</script>
</body>
</html>
In this example:
- We create an object called person with initial properties like firstName, lastName, age, and city.
- We use the displayObject function to show the properties of an object.
- We add new properties to the person object using both dot notation (person.job) and square bracket notation (person[‘hobbies’]).
- We use document.write to display the original and updated objects.
When you open this HTML file in a web browser, you should see the original properties of the person object, and then the object updated with new properties.
How to Delete Properties of an object ?
You can delete properties from an object in JavaScript using the delete keyword.
Here’s an example that demonstrates how to delete properties from an object:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Delete Properties of an Object</title>
</head>
<body>
<h1>Delete Properties of an Object</h1>
<script>
// Creating an object
let person = {
firstName: 'John',
lastName: 'Doe',
age: 30,
city: 'New York'
};
// Displaying original object
document.write('<h2>Original Object</h2>');
displayObject(person);
// Deleting properties
delete person.age;
delete person['city'];
// Displaying updated object
document.write('<h2>Updated Object</h2>');
displayObject(person);
// Function to display object properties
function displayObject(obj) {
document.write('<p>Object Properties:</p>');
for (let key in obj) {
document.write(`<p>${key}: ${obj[key]}</p>`);
}
}
</script>
</body>
</html>In this example:
- We create an object called person with initial properties like firstName, lastName, age, and city.
- We use the displayObject function to show the properties of an object.
- We delete properties from the person object using both dot notation (delete person.age) and square bracket notation (delete person[‘city’]).
- We use document.write to display the original and updated objects.
When you open this HTML file in a web browser, you should see the original properties of the person object, and then the object updated with the specified properties deleted. Note that using delete will remove the property from the object. If you try to access the deleted property later, it will return undefined.
How to create Nested Objects?
In JavaScript, you can create nested objects by including objects as properties within other objects. This allows you to organize and structure your data hierarchically.
Here’s an example that demonstrates how to create nested objects:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Nested Objects Example</title>
</head>
<body>
<h1>Nested Objects Example</h1>
<script>
// Creating a nested object
let = {
personalInfo: {
firstName: 'John',
lastName: 'Doe',
age: 30
},
address: {
street: '123 Main St',
city: 'New York',
zipCode: '10001'
},
contact: {
email: 'john@example.com',
phone: '555-1234'
}
};
// Displaying nested object
displayNestedObject();
// Function to display nested object properties
function displayNestedObject(obj) {
document.write('<h2> Information</h2>');
document.write('<p>Personal Information:</p>');
document.write(`<p>First Name: ${obj.personalInfo.firstName}</p>`);
document.write(`<p>Last Name: ${obj.personalInfo.lastName}</p>`);
document.write(`<p>Age: ${obj.personalInfo.age}</p>`);
document.write('<p>Address Information:</p>');
document.write(`<p>Street: ${obj.address.street}</p>`);
document.write(`<p>City: ${obj.address.city}</p>`);
document.write(`<p>Zip Code: ${obj.address.zipCode}</p>`);
document.write('<p>Contact Information:</p>');
document.write(`<p>Email: ${obj.contact.email}</p>`);
document.write(`<p>Phone: ${obj.contact.phone}</p>`);
}
</script>
</body>
</html>In this example:
- We create an object named with nested objects for personalInfo, address, and contact.
- The nested objects contain properties such as firstName, lastName, age (under personalInfo), street, city, zipCode (under address), and email, phone (under contact).
- The displayNestedObject function is used to display the nested object properties on the webpage.
When you open this HTML file in a web browser, you should see the ‘s information organized into nested objects.
Creating nested objects is a powerful way to structure data, especially when dealing with complex data models or hierarchical relationships between different pieces of information.
Nested Arrays and Objects
In JavaScript, you can create complex data structures by combining nested arrays and objects. This allows you to represent hierarchical and structured information.
Here’s an example that demonstrates the use of nested arrays and objects:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Nested Arrays and Objects Example</title>
</head>
<body>
<h1>Nested Arrays and Objects Example</h1>
<script>
// Creating a nested structure with arrays and objects
let company = {
name: 'TechCo',
employees: [
{
name: 'Alice',
position: 'Software Engineer',
skills: ['JavaScript', 'React', 'Node.js']
},
{
name: 'Bob',
position: 'UX Designer',
skills: ['UI/UX Design', 'Adobe XD']
},
{
name: 'Charlie',
position: 'Data Scientist',
skills: ['Python', 'Machine Learning']
}
],
officeLocations: [
{
city: 'San Francisco',
address: '123 Tech St'
},
{
city: 'New York',
address: '456 Code Ave'
}
]
};
// Displaying nested structure
displayCompanyInfo(company);
// Function to display nested structure properties
function displayCompanyInfo(company) {
document.write('<h2>Company Information</h2>');
document.write(`<p>Company Name: ${company.name}</p>`);
document.write('<p>Employees:</p>');
company.employees.forEach(employee => {
document.write(`<p>Name: ${employee.name}, Position: ${employee.position}</p>`);
document.write('<p>Skills: ' + employee.skills.join(', ') + '</p>');
});
document.write('<p>Office Locations:</p>');
company.officeLocations.forEach(location => {
document.write(`<p>City: ${location.city}, Address: ${location.address}</p>`);
});
}
</script>
</body>
</html>In this example:
- We create an object named company that contains properties like name, employees, and officeLocations.
- The employees property is an array of objects, each representing an employee with properties like name, position, and skills (which is an array).
- The officeLocations property is an array of objects, each representing an office location with properties like city and address.
- The displayCompanyInfo function is used to display the nested structure on the webpage.
When you open this HTML file in a web browser, you should see the company information with nested arrays and objects organized into a structured format.
This example demonstrates how to use nested arrays and objects to represent more complex relationships and structures in your data.
Property Attributes
In JavaScript, object properties have attributes that define their behavior. These attributes control how a property can be accessed, modified, and iterated over. The main property attributes include:
Value: The value assigned to the property.
Writable: Specifies whether the property’s value can be changed. If set to false, any attempt to modify the value will be ignored.
Enumerable: Specifies whether the property will be returned in a for…in loop or by the Object.keys() method. If set to false, the property will be skipped during iteration.
Configurable: Specifies whether the property can be deleted and whether its attributes can be changed. If set to false, the property cannot be deleted, and its attributes cannot be modified.
Here’s an example demonstrating property attributes in JavaScript:
let person = {
firstName: 'John',
lastName: 'Doe',
age: 30
};
// Accessing property attributes
let propertyDescriptor = Object.getOwnPropertyDescriptor(person, 'firstName');
console.log(propertyDescriptor);
// Modifying property attributes
Object.defineProperty(person, 'age', {
writable: false,
enumerable: false
});
// Attempting to modify a non-writable property (will throw an error in strict mode)
// person.age = 31;
// Adding a new property with specific attributes
Object.defineProperty(person, 'gender', {
value: 'Male',
writable: false,
enumerable: true,
configurable: false
});
// Deleting a configurable property
delete person.lastName;
// Attempting to delete a non-configurable property (will throw an error)
// delete person.gender;
// Displaying updated object
console.log(person);In this example:
- We use Object.getOwnPropertyDescriptor to get the property descriptor of the firstName property.
- We use Object.defineProperty to modify the attributes of the age property, making it non-writable and non-enumerable.
- We add a new property gender with specific attributes.
- We attempt to delete the lastName property (configurable), and then we attempt to delete the gender property (non-configurable).
- Finally, we display the updated person object.
It’s important to note that the default attributes for properties are writable: true, enumerable: true, and configurable: true. Understanding and manipulating property attributes can be useful in certain advanced scenarios, but in typical usage, you may not need to explicitly set these attributes.
complete example in html step by step
Let’s create an HTML file with embedded JavaScript to demonstrate property attributes step by step.
This example will create an object representing a person and modify the attributes of its properties.
index.html:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Property Attributes Example</title>
</head>
<body>
<h1>Property Attributes Example</h1>
<script>
// Step 1: Creating an object representing a person
let person = {
firstName: 'John',
lastName: 'Doe',
age: 30
};
// Step 2: Accessing property attributes
let firstNameDescriptor = Object.getOwnPropertyDescriptor(person, 'firstName');
console.log('Step 2:', firstNameDescriptor);
// Step 3: Modifying property attributes (making 'age' non-writable and non-enumerable)
Object.defineProperty(person, 'age', {
writable: false,
enumerable: false
});
// Attempting to modify a non-writable property (will throw an error in strict mode)
// person.age = 31;
// Step 4: Adding a new property with specific attributes ('gender' is non-writable, enumerable, and non-configurable)
Object.defineProperty(person, 'gender', {
value: 'Male',
writable: false,
enumerable: true,
configurable: false
});
// Attempting to delete the 'lastName' property (configurable)
delete person.lastName;
// Attempting to delete the 'gender' property (non-configurable)
// delete person.gender;
// Displaying updated object
console.log('Step 5:', person);
</script>
</body>
</html>Explanation:
Creating an Object:
We start by creating an object named person representing an individual with properties like firstName, lastName, and age.
Accessing Property Attributes:
We use Object.getOwnPropertyDescriptor to get the property descriptor of the firstName property and log it to the console.
Modifying Property Attributes:
We use Object.defineProperty to modify the attributes of the age property, making it non-writable and non-enumerable.
Adding a New Property:
We use Object.defineProperty to add a new property gender with specific attributes like value, writable, enumerable, and configurable.
Attempting to Modify and Delete Properties:
We attempt to modify the age property (which is non-writable) and delete the lastName and gender properties.
Displaying Updated Object:
We log the updated person object to the console after making the modifications.
Open this HTML file in a web browser and check the browser’s console to see the output and understand how property attributes are applied and affect the behavior of object properties.
JavaScript objects inherit the properties of their prototype:
In JavaScript, objects inherit properties and methods from their prototype. Every object in JavaScript is linked to a prototype object from which it can inherit properties. This prototype object, often referred to as the “prototype chain,” creates a chain of objects linked together.
Here’s a brief explanation and example:
Prototype Chain:
Prototype Object:
Each object in JavaScript has a prototype object.
When you create an object, it inherits properties and methods from its prototype.
Prototype Inheritance:
If a property or method is not found in an object, JavaScript looks for it in the object’s prototype.
This process continues up the prototype chain until the property is found or the chain ends at the Object.prototype (the default prototype for objects).
Example:
// Step 1: Creating a simple object
let person = {
firstName: 'John',
lastName: 'Doe',
sayHello: function() {
console.log('Hello, ' + this.firstName + ' ' + this.lastName);
}
};
// Step 2: Creating another object linked to the person object as its prototype
let employee = Object.create(person);
// Adding additional properties to the employee object
employee.jobTitle = 'Developer';
// Accessing properties and methods
console.log('Step 3:', employee.firstName); // Inherits from the person object
console.log('Step 4:', employee.jobTitle); // Own property of the employee object
employee.sayHello(); // Inherits from the person object
// Checking the prototype of the employee object
console.log('Step 5:', Object.getPrototypeOf(employee) === person); // trueExplanation:
Creating a Simple Object:
We start by creating a person object with properties like firstName, lastName, and a method sayHello.
Creating Another Object with Prototype Link:
We create an employee object using Object.create(person). This links the employee object to the person object as its prototype.
Accessing Properties:
The employee object inherits properties like firstName from its prototype (person).
It has its own property jobTitle.
Accessing Methods:
The employee object can also access the sayHello method, which is inherited from its prototype (person).
Checking Prototype:
We use Object.getPrototypeOf(employee) to check if the prototype of the employee object is the person object.
In this example, person serves as the prototype for employee. If a property or method is not found in employee, JavaScript looks for it in the person object. This is the essence of prototype-based inheritance in JavaScript. The prototype chain can be extended further by linking objects together, creating a chain of prototypes.
complete example in html with explanation step by step
- Let’s create an HTML file with embedded JavaScript to illustrate prototype-based inheritance step by step.
- This example will involve creating a person object and then creating an employee object that inherits properties and methods from the person prototype.
index.html:
Explanation:
Creating a Person Object:
We create a person object with properties like firstName, lastName, and a sayHello method.
Creating an Employee Object with Prototype Link:
We create an employee object using Object.create(person). This establishes a prototype link where employee inherits from person.
Adding Additional Properties to Employee:
We add an additional property jobTitle to the employee object.
Accessing Properties and Methods:
We use document.write to display the inherited and own properties of the employee object. The sayHello method is also invoked.
Checking Prototype:
We use Object.getPrototypeOf(employee) to check if the prototype of the employee object is the person object.
Open this HTML file in a web browser, and you will see the output illustrating prototype-based inheritance. The employee object inherits properties and methods from the person object, forming a prototype chain.
An application about JavaScript Object Properties
We’ll create a webpage where s can input information, and the application will display and manipulate that information using JavaScript objects. Let’s build a simple address book application.
index.html:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Address Book</title>
<style>
label {
display: block;
margin-top: 10px;
}
</style>
</head>
<body>
<h1>Address Book</h1>
<!-- Form for input -->
<form id="addressForm">
<label for="firstName">First Name:</label>
<input type="text" id="firstName" required>
<label for="lastName">Last Name:</label>
<input type="text" id="lastName" required>
<label for="email">Email:</label>
<input type="email" id="email" required>
<button type="button" onclick="addContact()">Add Contact</button>
</form>
<!-- Displaying contacts -->
<div id="contactList">
<h2>Contact List</h2>
<ul id="list"></ul>
</div>
<script>
// Step 1: Creating an array to store contacts
let contacts = [];
// Step 2: Function to add a new contact
function addContact() {
let firstName = document.getElementById('firstName').value;
let lastName = document.getElementById('lastName').value;
let email = document.getElementById('email').value;
// Step 3: Creating an object for the new contact
let newContact = {
firstName: firstName,
lastName: lastName,
email: email
};
// Step 4: Adding the new contact to the array
contacts.push(newContact);
// Step 5: Displaying the updated contact list
displayContacts();
}
// Step 6: Function to display contacts
function displayContacts() {
let list = document.getElementById('list');
list.innerHTML = ''; // Clear the previous content
// Step 7: Looping through contacts and displaying them
contacts.forEach(function(contact) {
let listItem = document.createElement('li');
listItem.textContent = `${contact.firstName} ${contact.lastName} - ${contact.email}`;
list.appendChild(listItem);
});
}
</script>
</body>
</html>
Explanation:
Creating an Array to Store Contacts:
We start by creating an empty array contacts to store our contacts.
Function to Add a New Contact:
The addContact function is called when the clicks the “Add Contact” button.
It retrieves input values, creates a new contact object, and adds it to the contacts array.
Creating an Object for the New Contact:
We create a new object (newContact) with properties firstName, lastName, and email.
Adding the New Contact to the Array:
The new contact object is pushed into the contacts array.
Displaying the Updated Contact List:
The displayContacts function is called to update the displayed contact list.
Function to Display Contacts:
The displayContacts function clears the previous content and then loops through the contacts array to display each contact in an unordered list.
Looping Through Contacts and Displaying Them:
We use the forEach method to iterate through the contacts array and create list items to display each contact’s information.
Open this HTML file in a web browser, and you’ll have a simple address book application where you can add contacts and see them displayed on the webpage. This example helps illustrate how JavaScript objects and arrays can be used to manage and display information in a web application.
Quiz about JavaScript Object Properties
Question 1:
What is the syntax for creating an object in JavaScript?
- create object = {};
- let obj = new Object();
- const obj = {}
- object = () => {}
Explanation: The correct syntax for creating an object in JavaScript is option 3: const obj = {};
Question 2:
How do you access the value of a property named ‘age’ in an object called ‘person’?
- person[‘age’]
- person.age
- person.get(‘age’)
- person.age()
Explanation: You can access the value of a property named ‘age’ in an object using both dot notation and square bracket notation. The correct answers are 1: person[‘age’] and 2: person.age.
Question 3:
What happens if you attempt to access a property that doesn’t exist in an object?
- It returns null.
- It throws an error.
- It creates a new property with that name.
- It returns undefined.
Explanation: If you attempt to access a property that doesn’t exist in an object, it returns undefined.
Question 4:
What is the purpose of the Object.keys() method in JavaScript?
- To create a new object.
- To retrieve an array of an object’s own enumerable property names.
- To delete a property from an object.
- To check if an object has a specific property.
Explanation: The Object.keys() method is used to retrieve an array of an object’s own enumerable property names (option 2).
Question 5:
How can you prevent a property from being modified in an object in JavaScript?
- Set the property’s value to null.
- Use the frozen attribute.
- Set the writable attribute to false.
- Remove the property from the object.
Explanation: To prevent a property from being modified, you can set the writable attribute to false (option 3).
Question 6:
How can you check if an object has a specific property?
- object.containsProperty(‘propertyName’)
- object.hasProperty(‘propertyName’)
- ‘propertyName’ in object
- object.propertyExists(‘propertyName’)
Explanation: The correct way to check if an object has a specific property is by using the ‘in’ operator. The correct answer is 3: ‘propertyName’ in object.
Question 7:
What is the purpose of the Object.defineProperty() method in JavaScript?
- To define a new object.
- To add a property to an object.
- To configure the attributes of an object’s property.
- To remove a property from an object.
Explanation: The Object.defineProperty() method is used to configure the attributes of an object’s property. The correct answer is 3.
Question 8:
What is the default value of the writable attribute when creating a new property using Object.defineProperty()?
- true
- false
- undefined
- null
Explanation: The default value of the writable attribute is false when using Object.defineProperty().
Question 9:
In JavaScript, how can you remove a property from an object?
- delete object.propertyName;
- object.removeProperty(‘propertyName’)
- object.deleteProperty(‘propertyName’)
- object.remove(‘propertyName’)
Explanation: The correct way to remove a property from an object is by using the delete keyword. The correct answer is 1.
Question 10:
What is the purpose of the Object.values() method in JavaScript?
- To retrieve an array of an object’s own enumerable property values.
- To create a new object.
- To add values to an object.
- To concatenate the values of two objects.
Explanation: The Object.values() method is used to retrieve an array of an object’s own enumerable property values. The correct answer is 1.
Question 11:
What does the Object.freeze() method do in JavaScript?
- Prevents new properties from being added to an object.
- Prevents modifications to existing object properties.
- Converts an object into a frozen state.
- Deletes all properties of an object.
Explanation: The Object.freeze() method is used to prevent modifications to existing object properties. The correct answer is 2.
Question 12:
What is the purpose of the Object.entries() method in JavaScript?
- To retrieve an array of an object’s own enumerable property names.
- To retrieve an array of an object’s own enumerable property values.
- To retrieve an array of an object’s own enumerable property key-value pairs.
- To create a new object.
Explanation: The Object.entries() method is used to retrieve an array of an object’s own enumerable property key-value pairs. The correct answer is 3.
Question 13:
How can you iterate through the properties of an object in JavaScript?
- Using a for loop.
- Using the forEach method.
- Using the for…in loop.
- Both 1 and 2.
Explanation: You can iterate through the properties of an object using both a for…in loop (option 3) and the forEach method (option 2). The correct answer is 4.
Question 14:
What is the purpose of the Object.getOwnPropertyNames() method in JavaScript?
- To retrieve an array of an object’s own enumerable property names.
- To retrieve an array of an object’s own non-enumerable property names.
- To retrieve an array of an object’s own enumerable property values.
- To retrieve an array of an object’s prototype property names.
Explanation: The Object.getOwnPropertyNames() method is used to retrieve an array of an object’s own non-enumerable property names. The correct answer is 2.
Question 15:
What happens if you try to access a property on an object that is set to undefined?
- It throws an error.
- It returns null.
- It returns undefined.
- It creates a new property with that name.
Explanation: If you try to access a property on an object that is set to undefined, it returns undefined. The correct answer is 3.