How to Get an Object Value By Key in TypeScript

In TypeScript, we can get an object value by key by accessing the specific properties within the objects of the dynamic type. This can be done using Dot Notation, Bracket Notation, and Optional Chaining. In this article, we will explore all these approaches along with their implementation in terms of examples and outputs.

Using Dot Notation

Dot notation is used in TypeScript to directly access the value associated with the "name" key within the object obj. The result is stored in the variable res, which consists of the value "GeeksforGeeks," and is then printed to the console.

Syntax:

let value = obj.key

Example: The below example uses Dot Notation to Get an Object Value By Key in TypeScript.

const obj: { [key: string]: string } = {
    name: "GeeksforGeeks",
    category: "Programming",
    language: "TypeScript",
};
const res: string = obj.name;
console.log(res);

Output:

"GeeksforGeeks" 

Using Bracket Notation

In this approach, we are using bracket notation ([]) in TypeScript to access the value associated with the "category" key within the object obj. The result is stored in the variable res, which consists of the value "Programming," and is then printed to the console.

Syntax:

let value = obj[key];

Example: The below example uses Bracket Notation to Get an Object Value By Key in TypeScript.

const obj: { [key: string]: string } = {
    name: "GeeksforGeeks",
    category: "Programming",
    language: "TypeScript",
};
const res: string = obj['category'];
console.log(res);

Output:

"Programming" 

Using Optional Chaining

In this approach, we are using optional chaining in TypeScript, we access the value associated with the "language" key within the object obj. The result, is then converted to uppercase which is stored in the variable res, which contains "TYPESCRIPT" and is then printed to the console.

Syntax:

object?.property
object?.method()
object?.[expression]

Example: The below example uses Optional Chaining to Get an Object Value By Key in TypeScript.

const obj: { name?: string; category?: string; language?: string } = {
    name: "GeeksforGeeks",
    category: "Programming",
    language: "TypeScript",
};
const res: string | undefined = obj.language?.toUpperCase();
console.log(res);

Output:

"TYPESCRIPT" 

Using Object.hasOwnProperty() Method

This method checks if an object contains a specified property as its own property, and if it does, retrieves the corresponding value. It's particularly useful when you want to ensure that the property exists before accessing its value.

Syntax:

if (obj.hasOwnProperty(key)) {
    let value = obj[key];
}

Example: In this example we retrieves the value associated with the key 'category' from the object obj and logs it to the console.

const obj: { [key: string]: string } = {
    name: "GeeksforGeeks",
    category: "Programming",
    language: "TypeScript",
};

if (obj.hasOwnProperty('category')) {
    const res: string = obj['category'];
    console.log(res);
}

Output:

Programming

Using Object.entries() and Array.find()

In TypeScript, you can use Object.entries() to get an array of key-value pairs from an object. Then, you can use array methods like Array.find() to find the value associated with a specific key.

Example: In this example, we'll use Object.entries() and Array.find() to get the value associated with the key "category" from the object obj.

const obj: { [key: string]: string } = {
    name: "GeeksforGeeks",
    category: "Programming",
    language: "TypeScript",
};

const desiredKey = "category";
const value = Object.entries(obj).find(([key, val]) => key === desiredKey)?.[1];
console.log(value); // Logs "Programming"

Output

Programming

Using Object.keys() Method

In TypeScript, you can use the Object.keys() method to get an array of the object's own enumerable property names. Then, you can iterate over this array to find and access the value associated with a specific key.

Syntax:

Object.keys(obj).forEach(key => {
    if (key === specificKey) {
        let value = obj[key];
    }
});

Example: In this example, we'll use Object.keys() to get the value associated with the key "category" from the object obj.

let obj = { name: "GeeksforGeeks", category: "Programming", language: "TypeScript" };
let specificKey = "category";
let res: string | undefined;

Object.keys(obj).forEach(key => {
    if (key === specificKey) {
        res = obj[key];
    }
});
console.log(res);

Output:

Programming

Using TypeScript's in Operator

Another approach to access an object value by key in TypeScript is by using the in operator. This method checks if a property exists within the object before accessing its value. It's particularly useful for ensuring that the property exists and can handle dynamic keys effectively.

Example: In this example, we use the in operator to check if the key exists in the object and then access its value.

interface MyObject {
    name?: string;
    category?: string;
    language?: string;
}

const obj: MyObject = {
    name: "GeeksforGeeks",
    category: "Programming",
    language: "TypeScript"
};

const key = "category";
let value: string | undefined;

if (key in obj) {
    value = obj[key as keyof MyObject];
}

console.log(value);

Output:

Programming

Using TypeScript’s Record Utility Type

TypeScript’s Record utility type allows you to define an object type with specific keys and their corresponding value types. This approach ensures that the keys are consistent and the types are correctly enforced, making it easier to access object values by their keys.

Syntax:

type Record<K extends keyof any, T> = {
    [P in K]: T;
};

Example: The following example demonstrates how to define an object using the Record utility type and access its value by a specific key.

const obj: Record<'name' | 'category' | 'language', string> = {
    name: "GeeksforGeeks",
    category: "Programming",
    language: "TypeScript"
};
const key: keyof typeof obj = 'language';
const value: string = obj[key];
console.log(value);

TypeScript