<
Loading
/>
const app = () => {
} export default app;
logologo
  • Home
  • Tutorials
  • DSA
  • Interview
  • Exam Notes
  • Blogs
  • Support
logologo

Empowering learners worldwide with cutting-edge courses and resources for professional growth.

Instagram

Quick Links

  • Courses
  • Blog
  • About Us
  • Pricing

Resources

  • Tutorials
  • Documentation
  • Community
  • FAQ

Legal

  • Terms of Service
  • Privacy Policy
  • Refund Policy
  • Cookie Policy

Support

  • Contact Us
  • Help Center
  • Submit Ticket
  • System Status

© 2026 Coders Nexus. All rights reserved.

Built with ❤️ for learners worldwide

Complete JavaScript Tutorial for Beginners

beginner120
Progress0%
0/16 completed

What is JavaScript, and Why Should You Learn It?

5m

JavaScript Variables

20m

Conditional Statements of JavaScript

10m

JavaScript Strings

20m

JavaScript Loops

5m

Switch Statements

10m

New Topic

JavaScript Functions

5m

New Topic

Object Literals and Properties in JavaScript

5m

New Topic

Arrays Methods

5m

New Topic

Advanced Functions

5m

New Topic

JavaScript Arrays

5m

New Topic

Introduction to the DOM in JavaScript

5m

New Topic

Creating and Modifying Elements in JavaScript DOM

5m

New Topic

Form Handling in JavaScript

5m

New Topic

Working with Data in JavaScript

5m

New Topic

Debugging and Best Practices in JavaScript

5m

Object Literals and Properties in JavaScript

Learn JavaScript object literals and properties with this complete beginner-friendly guide. Understand what objects are, how to create object literals, define and use properties, and store different data types such as strings, numbers, arrays, and functions. This tutorial explains how to access, modify, add, and delete object properties using simple, real-world examples, helping beginners build a strong foundation in JavaScript objects.

What Is an Object in JavaScript?

In JavaScript, an object is a collection of related data and functionality, stored as key–value pairs. Objects help you group data that belongs together, making your code more organized and easier to understand.

  • A person has a name, age, and address
  • A car has a model, color, and speed
  • A user profile has a username, email, and password

All of these can be represented using JavaScript objects.

What Is an Object Literal?

An object literal is the simplest and most common way to create an object in JavaScript. It is created using curly braces {} with properties written inside.

Object Literals and Properties

Object literals provide the most straightforward syntax for creating objects in JavaScript. An object literal uses curly braces {} to define an object with its properties and values directly in the code. This declarative approach makes object creation intuitive and readable.

Basic Object Literal Syntax

<p>The fundamental structure of an object literal consists of comma-separated key-value pairs enclosed in curly braces. Each property has a name (key) followed by a colon and its corresponding value. </p>

Syntax of an Object Literal

javascript
const objectName = {
  key1: value1,
  key2: value2,
  key3: value3
};
  • Key → Property name
  • Value → Property value

Beginner Example: Object Literal

javascript
const student = {
  name: "Manjeet",
  age: 21,
  course: "BTech",
  isActive: true
};

Explanation:

  • student is the object
  • name, age, course, isActive are properties
  • "Manjeet", 21, "BTech", true are values

What Are Properties in an Object?

Properties are the data fields of an object. Each property has:

  • A key (name)
  • A value

Example

javascript
const car = {
  brand: "Toyota",
  model: "Fortuner",
  year: 2023
};

Here:

  • brand, model, year → properties
  • "Toyota", "Fortuner", 2023 → values

Types of Values Stored in Object Properties

An object property can store any JavaScript data type.

1. String

javascript
name: "Manjeet"

2. Number

javascript
age: 21

3. Boolean

javascript
isLoggedIn: true

4. Array

javascript
skills: ["HTML", "CSS", "JavaScript"]

5. Another Object (Nested Object)

javascript
address: {
  city: "Ranchi",
  state: "Jharkhand"
}

6. Function (Method)

javascript
greet: function () {
  return "Hello";
}

Accessing and Modifying Object Properties

JavaScript provides multiple ways to access and modify object properties, each with specific use cases and advantages. Understanding these different approaches helps you write more flexible and maintainable code.

Dot Notation

Dot notation is the most common and readable way to access object properties. You use a period (.) between the object name and the property name to retrieve or modify values.

Example - Dot Notation:

javascript
const car = {
  brand: 'Toyota',
  model: 'Camry',
  year: 2023,
  color: 'silver'
};

// Accessing properties
console.log(car.brand); // 'Toyota'
console.log(car.year); // 2023

// Modifying properties
car.color = 'blue';
car.year = 2024;

console.log(car.color); // 'blue'
console.log(car.year); // 2024

// Adding new properties
car.mileage = 15000;
console.log(car.mileage); // 15000

Bracket Notation

Bracket notation uses square brackets with a string or variable inside to access properties. This syntax is essential when property names contain special characters, spaces, start with numbers, or are stored in variables.

Example - Bracket Notation:

javascript
const student = {
  firstName: 'Alice',
  'last name': 'Johnson',
  'test-score': 95,
  1: 'freshman'
};

// Required for special characters and spaces
console.log(student['last name']); // 'Johnson'
console.log(student['test-score']); // 95
console.log(student[1]); // 'freshman'

// Using variables to access properties
const propertyToAccess = 'firstName';
console.log(student[propertyToAccess]); // 'Alice'

// Dynamic property access
const fields = ['firstName', 'last name', 'test-score'];
fields.forEach(field => {
  console.log(`${field}: ${student[field]}`);
});
// Output:
// firstName: Alice
// last name: Johnson
// test-score: 95

Nested Object Access

Objects often contain other objects as properties, creating nested structures. Accessing nested properties requires chaining dot or bracket notation, or using optional chaining for safer access.

Optional Chaining

Optional chaining (?.) is a modern JavaScript feature that allows you to safely access nested object properties. If any intermediate property is null or undefined, it prevents runtime errors and returns undefined instead.

Example - Optional Chaining:

javascript
const user = {
  name: 'Bob',
  address: {
    city: 'Seattle'
    // Note: no 'street' property
  }
};

// Without optional chaining - causes error
// console.log(user.address.street.number); // TypeError: Cannot read property 'number' of undefined

// With optional chaining - safe access
console.log(user.address?.street?.number); // undefined (no error)
console.log(user.profile?.age); // undefined (profile doesn't exist)

// Practical example with API data
const apiResponse = {
  data: {
    user: {
      name: 'Charlie'
      // email might be missing
    }
  }
};

const email = apiResponse.data?.user?.email ?? 'No email provided';
console.log(email); // 'No email provided'

// Using with methods
const result = user.getDetails?.(); // undefined if getDetails doesn't exist (no error)

Adding and Modifying Properties

JavaScript objects are mutable, meaning you can add new properties or modify existing ones after the object is created. This dynamic nature makes objects flexible for building applications.

Example - Adding and Updating Properties:

javascript
const book = {
  title: 'JavaScript Guide',
  author: 'Jane Smith'
};

console.log(book); // { title: 'JavaScript Guide', author: 'Jane Smith' }

// Adding new properties
book.pages = 350;
book.publisher = 'Tech Books Publishing';
book.isbn = '978-1234567890';

console.log(book);
// {
//   title: 'JavaScript Guide',
//   author: 'Jane Smith',
//   pages: 350,
//   publisher: 'Tech Books Publishing',
//   isbn: '978-1234567890'
// }

// Modifying existing properties
book.pages = 375;
book.author = 'Jane Smith PhD';

// Adding computed properties
const currentYear = 2024;
book[`edition_${currentYear}`] = '2nd Edition';

console.log(book.edition_2024); // '2nd Edition'

Deleting Properties

Example - Deleting Properties:

javascript
const profile = {
  username: 'developer123',
  email: 'dev@example.com',
  temporaryToken: 'abc123xyz',
  sessionId: '987654321'
};

console.log(profile.temporaryToken); // 'abc123xyz'

// Delete properties
delete profile.temporaryToken;
delete profile.sessionId;

console.log(profile.temporaryToken); // undefined
console.log(profile);
// {
//   username: 'developer123',
//   email: 'dev@example.com'
// }

// Checking if property exists
console.log('temporaryToken' in profile); // false
console.log('username' in profile); // true

Checking Property Existence

Before accessing properties, you might need to check if they exist to avoid unexpected undefined values or errors.

Example - Property Existence Checks:

javascript
const config = {
  theme: 'dark',
  fontSize: 16,
  notifications: true
};

// Using 'in' operator
console.log('theme' in config); // true
console.log('language' in config); // false

// Using hasOwnProperty
console.log(config.hasOwnProperty('fontSize')); // true
console.log(config.hasOwnProperty('backgroundColor')); // false

// Checking for undefined
if (config.theme !== undefined) {
  console.log('Theme is set to:', config.theme);
}

// Using optional chaining with nullish coalescing
const language = config.language ?? 'English';
console.log(language); // 'English'

Methods in Objects

Methods are functions stored as object properties. They define behaviors and actions that objects can perform, making objects more than just passive data containers.

Defining Methods

You can define methods using traditional function syntax or the more concise ES6 method syntax that omits the colon and function keyword.

Example - Method Definitions:

javascript
// Traditional function syntax
const calculator1 = {
  add: function(a, b) {
    return a + b;
  },
  subtract: function(a, b) {
    return a - b;
  }
};

// ES6 method syntax (recommended)
const calculator2 = {
  add(a, b) {
    return a + b;
  },
  subtract(a, b) {
    return a - b;
  },
  multiply(a, b) {
    return a * b;
  },
  divide(a, b) {
    if (b === 0) {
      return 'Cannot divide by zero';
    }
    return a / b;
  }
};

// Using methods
console.log(calculator2.add(5, 3)); // 8
console.log(calculator2.multiply(4, 7)); // 28
console.log(calculator2.divide(10, 2)); // 5
console.log(calculator2.divide(10, 0)); // 'Cannot divide by zero'

The 'this' Keyword

Inside object methods, the this keyword refers to the object itself, allowing methods to access and modify the object's own properties. This creates a connection between the method and its containing object.

Example - Using 'this' in Methods:

javascript
const bankAccount = {
  accountNumber: '123456789',
  balance: 1000,
  ownerName: 'Sarah Johnson',
  
  deposit(amount) {
    if (amount > 0) {
      this.balance += amount;
      return `Deposited $${amount}. New balance: $${this.balance}`;
    }
    return 'Invalid deposit amount';
  },
  
  withdraw(amount) {
    if (amount > this.balance) {
      return 'Insufficient funds';
    }
    if (amount > 0) {
      this.balance -= amount;
      return `Withdrew $${amount}. Remaining balance: $${this.balance}`;
    }
    return 'Invalid withdrawal amount';
  },
  
  getBalance() {
    return `Account ${this.accountNumber} balance: $${this.balance}`;
  },
  
  getAccountInfo() {
    return `Owner: ${this.ownerName}, Account: ${this.accountNumber}, Balance: $${this.balance}`;
  }
};

// Using methods that modify the object
console.log(bankAccount.getBalance()); // 'Account 123456789 balance: $1000'
console.log(bankAccount.deposit(500)); // 'Deposited $500. New balance: $1500'
console.log(bankAccount.withdraw(200)); // 'Withdrew $200. Remaining balance: $1300'
console.log(bankAccount.getAccountInfo()); 
// 'Owner: Sarah Johnson, Account: 123456789, Balance: $1300'

Arrow Functions in Methods

While arrow functions can be used in objects, they handle this differently. Arrow functions don't have their own this binding, which can cause issues when you need to reference the object itself.

Example - Arrow Functions vs Regular Functions:

javascript
const counter = {
  count: 0,
  
  // Regular method - 'this' refers to counter object
  incrementRegular() {
    this.count++;
    return this.count;
  },
  
  // Arrow function - 'this' doesn't refer to counter object
  incrementArrow: () => {
    // this.count++; // This would not work as expected!
    // 'this' refers to outer scope, not the object
  },
  
  // Using arrow functions inside regular methods works fine
  incrementMultiple(times) {
    // 'this' works here because we're in a regular method
    const numbers = Array.from({length: times}, (_, i) => i + 1);
    numbers.forEach(() => {
      this.count++; // Arrow function inherits 'this' from incrementMultiple
    });
    return this.count;
  }
};

console.log(counter.incrementRegular()); // 1
console.log(counter.incrementMultiple(5)); // 6
console.log(counter.count); // 6

Methods with Complex Logic

Methods can contain complex logic, call other methods, and interact with external functions or APIs.

Example - Shopping Cart Object:

javascript
// Shopping cart object (real-life example)
const cart = {
  // Array to store all items added to the cart
  items: [],

  // Tax rate (10%)
  taxRate: 0.1,

  // Method to add an item to the cart
  addItem(name, price) {
    // Add a new item object into the items array
    this.items.push({ name, price });

    // Display confirmation message
    console.log(`${name} added to cart`);
  },

  // Method to calculate total price including tax
  getTotal() {
    let total = 0; // Variable to store subtotal

    // Loop through each item in the cart
    for (let item of this.items) {
      // Add item price to total
      total += item.price;
    }

    // Calculate tax amount
    const tax = total * this.taxRate;

    // Return final total (subtotal + tax)
    return total + tax;
  }
};

Objects vs Arrays: When to Use Each

Understanding when to use objects versus arrays is crucial for writing efficient and maintainable JavaScript code. Both are reference types that store collections of data, but they serve different purposes and have distinct characteristics.

Key Differences

Objects and arrays have fundamental structural and functional differences that guide their appropriate usage.

Structural Differences:

Objects use named keys (strings or symbols) to access values, making them ideal for storing related data where each piece has a specific meaning.

Arrays use numeric indices (0, 1, 2, etc.) to access elements, making them perfect for ordered collections where the position of each item matters.

Example - Structure Comparison:

javascript
// Object - Named properties
const userObject = {
  id: 101,
  name: 'Emma Wilson',
  email: 'emma@example.com',
  age: 28
};

console.log(userObject.name); // Access by property name: 'Emma Wilson'

// Array - Indexed elements
const userArray = [101, 'Emma Wilson', 'emma@example.com', 28];

console.log(userArray[1]); // Access by index: 'Emma Wilson'
// Problem: What does index 1 represent? Not immediately clear!

When to Use Objects

Objects are the right choice when you need to represent a single entity with various attributes, when the order of properties doesn't matter, or when you need to access data by meaningful names rather than numeric positions.

Use Objects For:

  • Representing real-world entities with multiple properties
  • Unordered data where each piece has a specific meaning
  • Key–value pairs that need descriptive names
  • Configuration settings and options
  • Data where property names provide clear context

Example - Appropriate Object Usage:

javascript
// User profile - single entity with multiple attributes
const userProfile = {
  username: 'john_dev',
  email: 'john@example.com',
  role: 'developer',
  permissions: ['read', 'write', 'execute'],
  preferences: {
    theme: 'dark',
    language: 'en',
    notifications: true
  },
  lastLogin: new Date('2024-01-15')
};

// Product details - named properties provide clarity
const product = {
  sku: 'LAP-2024-001',
  name: 'Pro Laptop',
  price: 1299.99,
  category: 'Electronics',
  inStock: true,
  specifications: {
    processor: 'Intel i7',
    ram: '16GB',
    storage: '512GB SSD'
  }
};

// Application configuration
const appConfig = {
  apiBaseUrl: 'https://api.example.com',
  timeout: 5000,
  retryAttempts: 3,
  enableLogging: true,
  features: {
    darkMode: true,
    notifications: false,
    analytics: true
  }
};

// Database query result - single record
const blogPost = {
  id: 42,
  title: 'Understanding JavaScript Objects',
  author: 'Jane Smith',
  publishDate: '2024-01-10',
  content: 'Full article content here...',
  tags: ['javascript', 'programming', 'tutorial'],
  views: 1523,
  likes: 89
};

When to Use Arrays

Arrays excel when you need to store collections of similar items, maintain specific ordering, iterate through elements, or perform list operations like filtering and sorting.

Use Arrays For:

  • Lists of similar items (users, products, tasks)
  • Ordered sequences where position matters
  • Collections you will iterate through
  • Data you need to filter, sort, or transform
  • Cases where numeric indices make sense for the data

Example - Appropriate Array Usage:

javascript
// List of users - multiple similar entities
const users = [
  { id: 1, name: 'Alice', role: 'admin' },
  { id: 2, name: 'Bob', role: 'user' },
  { id: 3, name: 'Charlie', role: 'user' }
];

// Shopping list - ordered collection
const shoppingList = [
  'Milk',
  'Eggs',
  'Bread',
  'Butter',
  'Coffee'
];

// Scores - order matters (chronological or ranking)
const testScores = [95, 87, 92, 78, 88];

// Todo items - list that will be iterated
const todos = [
  { id: 1, task: 'Buy groceries', completed: false },
  { id: 2, task: 'Pay bills', completed: true },
  { id: 3, task: 'Call dentist', completed: false }
];

// Coordinates - ordered numeric data
const coordinates = [40.7128, -74.0060]; // [latitude, longitude]

// History or timeline - chronological order matters
const loginHistory = [
  { timestamp: '2024-01-15T10:30:00', ip: '192.168.1.1' },
  { timestamp: '2024-01-15T14:22:00', ip: '192.168.1.1' },
  { timestamp: '2024-01-16T09:15:00', ip: '10.0.0.5' }
];

Array Methods vs Object Operations

Arrays come with built-in methods optimized for working with lists, while objects require different approaches for iteration and manipulation.

Example - Array Methods:

javascript
const numbers = [1, 2, 3, 4, 5];

// Filter - get even numbers
const evenNumbers = numbers.filter(num => num % 2 === 0);
console.log(evenNumbers); // [2, 4]

// Map - double each number
const doubled = numbers.map(num => num * 2);
console.log(doubled); // [2, 4, 6, 8, 10]

// Reduce - sum all numbers
const sum = numbers.reduce((total, num) => total + num, 0);
console.log(sum); // 15

// Find - get first number greater than 3
const found = numbers.find(num => num > 3);
console.log(found); // 4

// Sort - arrange in descending order
const sorted = [...numbers].sort((a, b) => b - a);
console.log(sorted); // [5, 4, 3, 2, 1]

// ForEach - iterate through items
numbers.forEach((num, index) => {
  console.log(`Index ${index}: ${num}`);
});

Combining Objects and Arrays

Real-world applications often combine objects and arrays to create complex data structures that leverage the strengths of both.

Example - Combined Structures:

javascript
const students = [
  {
    id: 1,
    name: "Rahul",
    subject: "Math",
    marks: 85
  },
  {
    id: 2,
    name: "Priya",
    subject: "Science",
    marks: 92
  },
  {
    id: 3,
    name: "Aman",
    subject: "English",
    marks: 78
  }
];

// Accessing data
console.log(students[0].name);    // Rahul
console.log(students[1].marks);   // 92

Frequently Asked Questions

Properties are variables that belong to an object. Each property has a name (key) and a value. Properties define the data and characteristics of an object.

Yes. Objects can store arrays, other objects, and even functions as values. This makes them powerful for complex data structures.

Methods are functions stored inside an object. They define actions that the object can perform.

Objects store named properties, while arrays store ordered values accessed by index.

JavaScript returns undefined instead of throwing an error.