In this article, we’ll cover:

• What objects are and why we need them

• How to create objects

• Accessing and updating object properties

• Adding and deleting properties

• Looping through object keys

1. What Are Objects and Why We Need Them

An object is a collection of key-value pairs, where each key (also called a property) maps to a value.

Example: A person object

let person = {
  name: "Alice",
  age: 25,
  city: "New York"
};

Here:

• "name", "age", and "city" are keys

• "Alice", 25, "New York" are the values

Objects are useful because:

• They organize related data in one place

• They allow easy access and updates to values

• They are more flexible than arrays when working with named properties

Array vs Object:

• Array: Ordered list of values (["Alice", 25, "New York"])

• Object: Named collection of values ({name: "Alice", age: 25, city: "New York"})

2. Creating Objects

You can create objects in multiple ways:

Using object literal (most common):

let student = {
  name: "John",
  age: 20,
  course: "Web Development"
};

Using new Object() constructor:

let car = new Object();
car.brand = "Toyota";
car.model = "Corolla";

3. Accessing Properties

There are two ways to access object properties:

Dot notation:

console.log(student.name); // John
console.log(student.age);  // 20

Bracket notation:

console.log(student["course"]); // Web Development

Use dot notation when the key is a valid identifier. Use bracket notation when the key has spaces, special characters, or is stored in a variable.

4. Updating Object Properties

You can update existing properties easily:

student.age = 21;               // Using dot notation
student["course"] = "JavaScript"; // Using bracket notation
console.log(student);

5. Adding and Deleting Properties

Adding a property:

student.city = "San Francisco";

Deleting a property:

delete student.course;

After deletion, student no longer has the course property.

6. Looping Through Object Keys

You can use a for...in loop to iterate through all keys:

for (let key in student) {
  console.log(key, ":", student[key]);
}

Output:

name : John
age : 21
city : San Francisco

This method is useful when you want to access all keys and values dynamically.

7. Example Assignment: Student Object

Let’s create a practical example combining everything we learned:

// Create object
let student = {
  name: "Emma",
  age: 22,
  course: "Frontend Development"
};

// Update a property
student.age = 23;

// Add a new property
student.grade = "A";

// Loop through keys and values
for (let key in student) {
  console.log(key + ":", student[key]);
}

Output:

name: Emma
age: 23
course: Frontend Development
grade: A

Conclusion

JavaScript objects are a fundamental way to organize and manage data in your programs. By using key-value pairs, you can store related information in a structured and readable way. Understanding how to create objects, access and update properties, add or delete fields, and loop through keys gives you the tools to handle real-world data efficiently.

Mastering objects is essential for building dynamic applications, managing user data, and working with APIs. Start with simple examples, practice manipulating properties, and gradually you’ll find objects an intuitive and powerful part of JavaScript development.

1. Arithmetic Operators

Arithmetic operators perform basic math operations. Let’s see how they work:

let a = 10;
let b = 3;

console.log(a + b); // 13 (addition)
console.log(a - b); // 7  (subtraction)
console.log(a * b); // 30 (multiplication)
console.log(a / b); // 3.3333... (division)
console.log(a % b); // 1 (remainder)

Tip: Start with simple examples like adding two numbers to see results instantly.

2. Comparison Operators

Comparison operators help us check relationships between values.

let x = 5;
let y = "5";

console.log(x == y);  // true  (checks value only)
console.log(x === y); // false (checks value + type)
console.log(x != y);  // false (not equal in value)
console.log(x > 3);   // true
console.log(x < 10);  // true

🔹 Notice the difference between == and ===.

• == compares values only (type coercion may happen)

• === compares values and types (strict equality)

3. Logical Operators

Logical operators let us combine conditions:

let isLoggedIn = true;
let hasSubscription = false;

console.log(isLoggedIn && hasSubscription); // false (both must be true)
console.log(isLoggedIn || hasSubscription); // true  (either one is true)
console.log(!isLoggedIn);                  // false (negates the value)

Logical operators are great for building decision-making conditions in code.

4. Assignment Operators

Assignment operators are used to store values in variables, sometimes combined with arithmetic:

let num = 10;

num = num + 5;  // 15
num += 5;       // 20 (shortcut for addition)
num -= 2;       // 18 (shortcut for subtraction)

These operators make your code cleaner and more readable

5. Real-Life Example: Putting It All Together

Let’s combine arithmetic, comparison, and logical operators in a small practical example:

let a = 8;
let b = 3;

// Arithmetic operations
let sum = a + b;
let product = a * b;
console.log("Sum:", sum);
console.log("Product:", product);

// Comparison
console.log("Are a and b equal?", a == b);     // false
console.log("Are a and b strictly equal?", a === b); // false

// Logical conditions
let condition = (a > 5) && (b < 5);
console.log("Condition check:", condition); // true

// Assignment operators
let count = 0;
count += sum;   // count = 11
count *= 2;    // count = 22
console.log("Final count:", count);

This example shows how operators are used in everyday coding tasks: calculating numbers, comparing values, checking conditions, and updating variables.

Key Takeaways

• Operators are the building blocks of JavaScript.

• Start with arithmetic operators to perform calculations.

• Use comparison operators for checking conditions.

• Logical operators help combine conditions for more complex decisions.

• Assignment operators keep your code concise and readable.

By practicing these operators with small exercises, you’ll build a strong foundation for writing effective and scalable JavaScript code.

Pro Tip: Open your browser console and try these examples yourself — nothing teaches faster than experimenting in real time!

Conclusion

Understanding JavaScript operators is essential for writing clean, efficient, and maintainable code. Arithmetic operators help with calculations, comparison operators allow us to make decisions, logical operators combine conditions, and assignment operators keep our code concise.

By practicing these operators with small examples, you’ll gain confidence in handling everyday programming tasks and building more complex applications. Mastering them lays a strong foundation for becoming a proficient JavaScript developer.

Remember: start simple, experiment in the console, and gradually explore more complex use cases. The more you practice, the more intuitive these operators will become in your coding workflow.