How to Sort an Array of Objects by a String Property in JavaScript

By the end of this page, you will understand how JavaScript's Array.prototype.sort() works with arrays of objects, how to sort by a specific string property like last_nom, and when to use simple comparisons versus localeCompare() for safer string sorting.

JavaScript's sort() does not only work on plain strings or numbers. It can sort any array, including arrays of objects, as long as you provide a comparison function.

That comparison function tells JavaScript how to decide the order of two items:

• return a value less than 0 if a should come before b
• return greater than 0 if a should come after b
• return 0 if they are considered equal for sorting

When your array contains objects, JavaScript does not automatically know which property matters. So you choose the property yourself.

For string properties such as last_nom, you usually compare:

• a.last_nom and b.last_nom

There is no need to add a toString() method. That would not be the normal solution here.

This matters in real programming because data often comes as objects:

• users with names
• products with titles
• API responses with labels
• records with categories

Sorting by object properties is a very common task in frontend and backend JavaScript code.

Think of sort() as asking a referee to compare two players at a time.

If your array contains numbers, the referee can compare the numbers directly. If your array contains objects, the referee asks: which part of the object should I look at?

Your comparison function is the referee's rulebook.

For example:

• compare by last_nom
• if last_nom is alphabetically earlier, put it first
• otherwise put it later

So instead of changing the whole object into a string, you simply tell sort() which label on the object to use.

Basic syntax

array.sort((a, b) => {
  // return negative, positive, or 0
});

Sort objects by a string property

const objs = [
  { first_nom: 'Laszlo', last_nom: 'Jamf' },
  { first_nom: 'Pig', last_nom: 'Bodine' },
  { first_nom: 'Pirate', last_nom: 'Prentice' }
];

objs.sort((a, b) => a.last_nom.localeCompare(b.last_nom));

console.log(objs);

Output:

[
  { first_nom: 'Pig', last_nom: 'Bodine' },
  { first_nom: 'Laszlo', last_nom: 'Jamf' },
  { first_nom: 'Pirate', last_nom: 'Prentice' }
]

Why localeCompare() is useful

localeCompare() is designed for comparing strings alphabetically.

console.log('Bodine'.localeCompare('Jamf'));    // negative number
console.log('Prentice'.localeCompare('Jamf'));  // positive number
console.log('Jamf'.localeCompare('Jamf'));      // 0

Simpler manual comparison

You can also write:

objs.sort((a, b) => {
  if (a.last_nom < b.last_nom) return -1;
  if (a.last_nom > b.last_nom) return 1;
  return 0;
});

This works, but localeCompare() is shorter and clearer for strings.

Descending order

objs.sort((a, b) => b.last_nom.localeCompare(a.last_nom));

Case-insensitive sorting

objs.sort((a, b) =>
  a.last_nom.toLowerCase().localeCompare(b.last_nom.toLowerCase())
);

This is helpful when values may contain mixed uppercase and lowercase letters.

Consider this code:

const objs = [
  { first_nom: 'Laszlo', last_nom: 'Jamf' },
  { first_nom: 'Pig', last_nom: 'Bodine' },
  { first_nom: 'Pirate', last_nom: 'Prentice' }
];

objs.sort((a, b) => a.last_nom.localeCompare(b.last_nom));

Step by step:

1. sort() starts rearranging the array.

2. It picks two objects to compare.

3. For each pair, it runs this function:

   (a, b) => a.last_nom.localeCompare(b.last_nom)
   

4. Suppose it compares:

   a = { first_nom: 'Pig', last_nom: 'Bodine' }
   b = { first_nom: 'Laszlo', last_nom: 'Jamf' }
   

5. It evaluates:

   'Bodine'.localeCompare('Jamf')
   

6. That returns a negative number, so Bodine should come before Jamf.

7. If it compares Prentice with Jamf, the result is positive, so Prentice goes after Jamf.

8. After enough comparisons, the array becomes alphabetically ordered by last_nom.

Final result:

[
  { first_nom: 'Pig', last_nom: 'Bodine' },
  { first_nom: 'Laszlo', last_nom: 'Jamf' },
  { first_nom: 'Pirate', last_nom: 'Prentice' }
]

Important detail: sort() usually modifies the original array.

If you want a sorted copy instead, do this:

const sortedObjs = [...objs].sort((a, b) => a.last_nom.localeCompare(b.last_nom));

Sorting arrays of objects by string properties appears everywhere in JavaScript applications.

Common examples

• User lists: sort users by last name, first name, or username
• Product catalogs: sort products by title or category
• Admin dashboards: sort rows by status, department, or label
• Search results: display matching items alphabetically
• API data processing: sort fetched records before rendering
• File explorers: sort files by name

Example: sorting users before rendering

const users = [
  { id: 1, name: 'Zara' },
  { id: 2, name: 'Ali' },
  { id: 3, name: 'Mina' }
];

const sortedUsers = [...users].sort((a, b) => a.name.localeCompare(b.name));

console.log(sortedUsers);

Example: sorting API response data

const posts = [
  { title: 'JavaScript Basics' },
  { title: 'APIs for Beginners' },
  { title: 'Arrays Explained' }
];

posts.sort((a, b) => a.title.localeCompare(b.title));

This improves readability and gives users predictable output.

In real projects, developers often wrap sorting logic in reusable functions and combine it with validation.

Common pattern: reusable property sorter

function sortByStringProperty(array, property) {
  return [...array].sort((a, b) => {
    const valueA = a[property] ?? '';
    const valueB = b[property] ?? '';
    return valueA.localeCompare(valueB);
  });
}

const sorted = sortByStringProperty(objs, 'last_nom');

This is useful when many screens need similar sorting.

Guarding against missing values

Real data is often messy. Some objects may not contain the property.

const people = [
  { name: 'Lina' },
  {},
  { name: 'Adam' }
];

people.sort((a, b) => (a.name ?? '').localeCompare(b.name ?? ''));

Sorting without mutating original data

In many codebases, especially with React or state management, mutation is avoided.

const sortedPeople = [...people].sort((a, b) => a.name.localeCompare(b.name));

Multi-level sorting

If two last names are the same, developers often add a fallback.

const people = [
  { first_nom: 'Anna', last_nom: 'Smith' },
  { first_nom: 'Bob', last_nom: 'Smith' },
  { first_nom: 'Cara', last_nom: 'Adams' }
];

people.sort((a, b) => {
  const lastNameResult = a.last_nom.localeCompare(b.last_nom);
  if (lastNameResult !== 0) return lastNameResult;
  return a.first_nom.localeCompare(b.first_nom);
});

This pattern is very common in tables, lists, and reports.

1. Forgetting to compare a property

Broken code:

objs.sort();

Why it is a problem:

• sort() without a compare function tries to convert items to strings
• for objects, that does not produce useful alphabetical sorting by last_nom

Fix:

objs.sort((a, b) => a.last_nom.localeCompare(b.last_nom));

2. Returning true or false instead of a negative/positive number

Broken code:

objs.sort((a, b) => a.last_nom > b.last_nom);

Why it is a problem:

• sort() expects a negative number, positive number, or 0
• true and false are not a proper comparison result

Fix:

objs.sort((a, b) => {
  if (a.last_nom < b.last_nom) return -1;
  if (a.last_nom > b.last_nom) return 1;
  return 0;
});

Or shorter:

objs.sort((a, b) => a.last_nom.localeCompare(b.last_nom));

3. Forgetting that sort() mutates the array

Broken assumption:

const sorted = objs.sort((a, b) => a.last_nom.localeCompare(b.last_nom));
// objs is also changed

Fix if you want a copy:

const sorted = [...objs].sort((a, b) => a.last_nom.localeCompare(b.last_nom));

4. Not handling missing properties

Broken code:

objs.sort((a, b) => a.last_nom.localeCompare(b.last_nom));

If last_nom is missing on some object, this can fail.

Safer version:

objs.sort((a, b) => (a.last_nom ?? '').localeCompare(b.last_nom ?? ''));

5. Using toString() unnecessarily

You do not need to add a custom toString() method just to sort by a property.

Better approach:

objs.sort((a, b) => a.last_nom.localeCompare(b.last_nom));

Comparing ways to sort by a string property

sort() on numbers vs strings vs objects

toString() vs compare function

Quick reference

Sort objects by string property

array.sort((a, b) => a.property.localeCompare(b.property));

Example

objs.sort((a, b) => a.last_nom.localeCompare(b.last_nom));

Descending order

objs.sort((a, b) => b.last_nom.localeCompare(a.last_nom));

Case-insensitive

objs.sort((a, b) =>
  a.last_nom.toLowerCase().localeCompare(b.last_nom.toLowerCase())
);

Avoid mutating original array

const sorted = [...objs].sort((a, b) => a.last_nom.localeCompare(b.last_nom));

Safe when property may be missing

array.sort((a, b) => (a.name ?? '').localeCompare(b.name ?? ''));

Rules for compare function

• negative: a comes before b
• positive: a comes after b
• 0: equal order for sorting

Do not do this

objs.sort();
objs.sort((a, b) => a.last_nom > b.last_nom);

Usually no need for toString()

• Sort by the property directly
• Use a compare callback

Can JavaScript sort() sort arrays of objects?

Yes. sort() works on arrays of any values, including objects. For objects, you provide a compare function that tells JavaScript which property to compare.

How do I sort objects alphabetically by a property in JavaScript?

Use a compare function with localeCompare():

array.sort((a, b) => a.name.localeCompare(b.name));

Do I need a toString() method to sort objects?

No. That is not the usual solution. Just compare the property you want, such as a.last_nom and b.last_nom.

Does sort() change the original array?

Yes. sort() mutates the array. If you want a new sorted array, copy first with spread syntax.

What is the best way to sort strings in JavaScript?

For most cases, localeCompare() is the clearest and safest choice for string sorting.

How do I sort in descending alphabetical order?

Reverse the comparison:

array.sort((a, b) => b.name.localeCompare(a.name));

What if some objects are missing the property?

Use a fallback value:

array.sort((a, b) => (a.name ?? '').localeCompare(b.name ?? ''));

• JavaScript arrays — sorting is one of the most common array operations.
• Array.prototype.sort() — this is the exact method used to order array elements.
• Arrow functions — often used to write short compare callbacks.
• String localeCompare() — a common way to compare strings alphabetically.
• Object properties — sorting objects depends on reading the correct property.
• Immutability — important because sort() changes the original array.
• Compare functions — the core idea behind custom sorting logic.
• Filtering and mapping arrays — often used together with sorting in real code.