In this tutorial, I will explain how to find an object in a TypeScript array using the find()
method. We will see various examples and scenarios to understand how to effectively search for specific objects within an array.
Understanding the TypeScript find() Method
The find()
method in TypeScript is used for searching the first element in an array that satisfies a given condition. It takes a testing function as an argument and returns the first element that matches the criteria. If no element is found, it returns undefined
.
Here’s the basic syntax of the find()
method:
const result = array.find(testingFunction);
The testingFunction
is a callback function that is executed for each element in the array until it finds a match. It takes three parameters:
element
: The current element being processed in the array.index
(optional): The index of the current element being processed.array
(optional): The array on which thefind()
method was called.
Let’s dive into some practical examples to understand how to use the find()
method effectively.
Example 1: Find an Object by Property
Suppose you have an array of objects representing employees in a company. Each employee object has properties like name
, age
, and position
. Let’s say you want to find an employee named “John Doe” in the TypeScript array.
interface Employee {
name: string;
age: number;
position: string;
}
const employees: Employee[] = [
{ name: "John Doe", age: 35, position: "Manager" },
{ name: "Jane Smith", age: 28, position: "Developer" },
{ name: "Michael Johnson", age: 42, position: "Director" },
];
const john = employees.find((employee) => employee.name === "John Doe");
console.log(john);
In this example, we define an interface Employee
to specify the structure of the employee objects. We then create an array employees
containing employee objects.
Using the find()
method, we search for an employee whose name
property matches “John Doe”. The result is stored in the john
variable, which will either be the matching employee object or undefined
if no match is found.
I executed the above TypeScript code using VS code and you can see the exact output in the screenshot below:

Check out Calculate the Sum of an Array in TypeScript
Example 2: Find an Object with Multiple Conditions
Let’s take a more complex scenario where you want to find an employee based on multiple conditions. For instance, you want to find an employee who is older than 30 and holds the position of “Manager”.
const manager = employees.find(
(employee) => employee.age > 30 && employee.position === "Manager"
);
console.log(manager);
In this example, we use the find()
method with a testing function that checks two conditions: employee.age > 30
and employee.position === "Manager"
. The find()
method will return the first employee object that satisfies both conditions.
Example 3: Find an Object in a Nested Array
Sometimes, you may encounter nested arrays where objects are buried deep within the structure. Let’s consider an example where you have an array of departments, each containing an array of employees. Your task is to find an employee named “Sarah Johnson” across all departments.
interface Department {
name: string;
employees: Employee[];
}
const departments: Department[] = [
{
name: "Engineering",
employees: [
{ name: "John Doe", age: 35, position: "Manager" },
{ name: "Jane Smith", age: 28, position: "Developer" },
],
},
{
name: "Marketing",
employees: [
{ name: "Michael Johnson", age: 42, position: "Director" },
{ name: "Sarah Johnson", age: 29, position: "Specialist" },
],
},
];
const sarah = departments
.find((department) =>
department.employees.find((employee) => employee.name === "Sarah Johnson")
)
?.employees.find((employee) => employee.name === "Sarah Johnson");
console.log(sarah);
In this example, we define an interface Department
that represents a department with a name
and an array of employees
. We create an array departments
containing department objects.
To find “Sarah Johnson”, we use a combination of the find()
method and optional chaining (?.
). We first search for the department that contains an employee named “Sarah Johnson” using departments.find()
.
If a department is found, we then use optional chaining to access the employees
array and find the specific employee object within that department.
Check out Reverse an Array in TypeScript
Best Practices and Tips
When using the find()
method to search for objects in TypeScript arrays, keep the following best practices and tips in mind:
- Be specific with your testing function: Ensure that your testing function accurately describes the conditions you want to match. Be as specific as possible to avoid false positives.
- Handle undefined results: Keep in mind that the
find()
method returnsundefined
if no match is found. Make sure to handle this case appropriately in your code. - Use optional chaining for nested arrays: When dealing with nested arrays, consider using optional chaining (
?.
) to safely access properties and avoid potential errors. - Consider performance: The
find()
method iterates over the array until it finds a match. If you have a large array and performance is a concern, consider using other methods likefilter()
orsome()
depending on your specific requirements.
Conclusion
In this tutorial, I explained how to find an object in a TypeScript array using the find() method with some examples.
You may also like:
I’m Bijay Kumar Sahoo, and I am honored to be awarded the Microsoft MVP. With over 18 years of experience in the IT industry, I got a chance to work on SharePoint Framework (SPFx) development, TypeScript, React, JavaScript, etc. My journey has taken me through esteemed organizations such as TCS, HP, and KPIT, where I have honed my skills and expanded my expertise. Check out more about me here.