Skip to content
Subscribe to RSS Find me on GitHub Follow me on Twitter

Finding Values in JavaScript Objects


In JavaScript, objects are a fundamental data structure used to store and organize related data. Being able to efficiently find values within these objects is crucial for working with data effectively. This article explores different techniques for finding values in JavaScript objects and highlights the benefits of understanding these techniques.

Understanding how to retrieve data from objects allows developers to access specific information they need for their programs. This knowledge enables them to manipulate and use data effectively, leading to more efficient and optimized code. By exploring various techniques for accessing object values, developers can choose the most appropriate method for their specific use case.

In this post, we will discuss two commonly used techniques for finding values in JavaScript objects: dot notation and bracket notation. We will also delve into object property traversal, which is essential for accessing nested values in objects. By the end, you will have a solid understanding of these techniques and their significance in JavaScript programming.

Dot Notation

Dot notation is one of the most commonly used techniques to access values in JavaScript objects. It involves using a dot (.) to access properties of an object. This notation is especially useful when working with simple objects or when you know the key name in advance.

To access a value using dot notation, you simply write the object name followed by a dot and the property name. For example:

const person = {
  name: "John",
  age: 30,
  address: {
    street: "123 Main St",
    city: "New York",

console.log(; // Output: John
console.log(; // Output: New York

In the above example, we use dot notation to access the name property of the person object and the city property of the address object nested within it.

Dot notation can also be used in real-world scenarios. For instance, when working with APIs, you may receive JSON data and access its properties using dot notation. Consider the following example:

const response = {
  status: "success",
  data: {
    id: 123,
    message: "Data retrieved successfully",

console.log(response.status); // Output: success
console.log(; // Output: Data retrieved successfully

In the above example, we use dot notation to access the status property of the response object and the message property of the data object within it.

Dot notation is a simple and straightforward way to access values in JavaScript objects. It is especially useful for accessing properties of simple objects or known properties in nested objects.

Bracket Notation

Bracket notation is another way to access values in JavaScript objects. It allows you to use a string or a variable as the key to access a specific property in an object.

The syntax for bracket notation is object[key], where object is the name of the object and key is the property name enclosed in square brackets. This notation is particularly useful when the property name contains special characters, spaces, or is stored in a variable.

Here is an example of using bracket notation with a string key:

const person = {
  name: "John",
  age: 30,
  "favorite color": "blue"

console.log(person["name"]); // Output: John
console.log(person["age"]); // Output: 30
console.log(person["favorite color"]); // Output: blue

In the example above, we use bracket notation to access the name, age, and "favorite color" properties of the person object. The property names with spaces are enclosed in quotes.

Bracket notation can also be used with variables:

const propertyName = "age";
console.log(person[propertyName]); // Output: 30

In this example, we store the property name "age" in the variable propertyName and use bracket notation to access the corresponding value in the person object.

When comparing dot notation and bracket notation for object traversal, dot notation is simpler and easier to read. However, bracket notation provides more flexibility, allowing you to access properties with dynamic or unconventional names. Bracket notation is also essential when working with objects that have properties containing spaces or special characters.

Overall, understanding and utilizing both dot notation and bracket notation will give you the necessary tools to effectively retrieve values from JavaScript objects.

Object Property Traversal

Object property traversal is a technique used to access and retrieve values from nested properties within JavaScript objects. In many cases, objects may have multiple layers of properties, making it necessary to traverse through these layers to find the desired value.

One common approach to object property traversal is using dot notation or bracket notation to access each level of the object. By chaining property names together with dots or using square brackets, we can navigate through the object's structure and access the desired value.

Here is an example of object property traversal using dot notation:

const person = {
  name: 'John',
  age: 30,
  address: {
    street: '123 Main St',
    city: 'New York',
    country: 'USA'

const cityName =;
console.log(cityName); // Output: New York

In this example, the person object has a nested address property. By using dot notation (, we can access the value of the city property within the address object.

Another technique for object property traversal is using a loop, such as a loop, to iterate through each property of the object. This can be useful when the depth of the object is unknown or when we need to perform some operations on each property.

const car = {
  make: 'Honda',
  model: 'Civic',
  year: 2022,
  features: ['Bluetooth', 'Backup camera', 'Keyless entry']

for (let key in car) {
  console.log(`${key}: ${car[key]}`);

In this example, the loop is used to iterate through each property in the car object. The loop iterates over each property key (key), and we can access the corresponding value using bracket notation (car[key]).

Object property traversal becomes particularly important when dealing with deeply nested objects. For example, consider an object representing a university, with properties for departments, courses, and students. By using object property traversal techniques, we can easily access and manipulate specific values within these nested structures.

In summary, object property traversal allows us to access nested values within JavaScript objects. By using dot notation, bracket notation, or loops, we can navigate through the object's structure and retrieve the desired data. This technique is essential for effectively working with complex objects and is a valuable tool in JavaScript programming.


In this article, we explored various techniques for finding values in JavaScript objects. We discussed the dot notation and bracket notation, which are the two main methods used to access values in objects. We also learned about object property traversal and how it can be used to retrieve data from nested properties.

Understanding these techniques is crucial for efficient JavaScript programming. By knowing how to access values in objects, we can easily retrieve and manipulate data stored within them. This knowledge allows us to build more robust and dynamic applications.

To further enhance your skills, I encourage you to practice and explore more advanced object traversal methods. JavaScript provides powerful methods like Object.keys(), Object.values(), and Object.entries() that can aid in object manipulation and data extraction. By becoming familiar with these techniques, you can take your JavaScript programming to the next level.

Remember, practice makes perfect. The more you work with JavaScript objects and practice retrieving values from them, the more comfortable and proficient you will become. So keep coding, keep exploring, and keep improving your JavaScript skills!