Как сортировать объекты JavaScript по строковому свойству

Сортировка массива объектов JavaScript по строковому значению свойства

Чтобы отсортировать массив объектов JavaScript по строковому значению свойства, например last_nom, можно использовать метод Array.prototype.sort() с пользовательской функцией сравнения, которая обращается к конкретному свойству. Наиболее прямой подход - использовать localeCompare() для правильного сравнения строк, который автоматически обрабатывает разные наборы символов и чувствительность к регистру.

Содержание

• Базовый подход к сортировке
• Использование localeCompare для лучшего сравнения строк
• Сортировка без учета регистра
• Продвинутые техники сортировки
• Рекомендации по производительности
• Полный рабочий пример

Базовый подход к сортировке

Фундаментальный способ сортировки объектов по свойству - предоставить функцию сравнения методу sort(). Эта функция принимает два параметра (a и b, представляющие сравниваемые объекты) и должна возвращать:

• Отрицательное значение, если a должно идти перед b
• Положительное значение, если a должно идти после b
• Ноль, если они равны

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

// Базовая функция сравнения
objs.sort(function(a, b) {
    if (a.last_nom < b.last_nom) {
        return -1;
    }
    if (a.last_nom > b.last_nom) {
        return 1;
    }
    return 0;
});

Этот подход работает, но имеет ограничения при сравнении строк, особенно при работе с разными регистрами или специальными символами.

Использование localeCompare для лучшего сравнения строк

Для надежного сравнения строк используйте метод localeCompare(), который обеспечивает правильную лингвистическую сортировку в соответствии с текущей локалью:

objs.sort(function(a, b) {
    return a.last_nom.localeCompare(b.last_nom);
});

// Или с синтаксисом стрелочной функции (ES6+)
objs.sort((a, b) => a.last_nom.localeCompare(b.last_nom));

Метод localeCompare() специально разработан для сравнения строк и обрабатывает:

• Разные наборы символов (включая Unicode)
• Правильное алфавитное упорядочивание
• Чувствительность к регистру в соответствии с правилами локали

Сортировка без учета регистра

Если вы хотите сортировать без учета регистра, преобразуйте обе строки в одинаковый регистр перед сравнением:

objs.sort(function(a, b) {
    var lastNomA = a.last_nom.toLowerCase();
    var lastNomB = b.last_nom.toLowerCase();
    return lastNomA.localeCompare(lastNomB);
});

// Более лаконичная версия
objs.sort((a, b) => a.last_nom.toLowerCase().localeCompare(b.last_nom.toLowerCase()));

Это гарантирует, что “jamf”, “Bodine” и “Prentice” будут отсортированы правильно независимо от их исходного регистра.

Продвинутые техники сортировки

Многоуровневая сортировка

Вы можете сортировать по нескольким свойствам, связывая сравнения:

// Сортировка по last_nom, затем по first_nom, если last_nom одинаковые
objs.sort((a, b) => {
    const lastNameCompare = a.last_nom.localeCompare(b.last_nom);
    if (lastNameCompare !== 0) return lastNameCompare;
    return a.first_nom.localeCompare(b.first_nom);
});

Сортировка по динамическому свойству

Создайте повторно используемую функцию, которая может сортировать по любому свойству:

function sortByProperty(array, property, direction = 'asc') {
    return array.sort((a, b) => {
        const aVal = a[property];
        const bVal = b[property];
        
        if (typeof aVal === 'string' && typeof bVal === 'string') {
            const comparison = aVal.localeCompare(bVal);
            return direction === 'asc' ? comparison : -comparison;
        }
        
        return direction === 'asc' ? aVal - bVal : bVal - aVal;
    });
}

// Использование
sortByProperty(objs, 'last_nom');
sortByProperty(objs, 'first_nom', 'desc');

Преобразование Шварца (Decorate-Sort-Undecorate)

Для лучшей производительности с сложными объектами можно использовать шаблон преобразования Шварца:

function sortByAttribute(array, ...attrs) {
    return array
        .map(obj => {
            const decorated = attrs.map(attr => {
                const descending = attr.charAt(0) === '-';
                const property = descending ? attr.substring(1) : attr;
                return {
                    value: obj[property],
                    descending
                };
            });
            return { obj, decorated };
        })
        .sort((a, b) => {
            for (let i = 0; i < a.decorated.length; i++) {
                const { value: valA, descending: descA } = a.decorated[i];
                const { value: valB, descending: descB } = b.decorated[i];
                
                if (valA < valB) return descA ? 1 : -1;
                if (valA > valB) return descA ? -1 : 1;
            }
            return 0;
        })
        .map(({ obj }) => obj);
}

// Использование
sortByAttribute(objs, 'last_nom', 'first_nom');

Рекомендации по производительности

При работе с большими массивами учтите эти рекомендации по производительности:

1. Избегайте ненужного создания новых массивов - метод sort() изменяет массив на месте
2. Используйте простые функции сравнения - сложная логика в функциях сравнения может замедлить сортировку
3. Рассмотрите возможность предварительной сортировки - если массив редко изменяется, но часто сортируется, поддерживайте отсортированную копию
4. Используйте стабильные алгоритмы - сортировка JavaScript является стабильной, что означает, что равные элементы сохраняют свой исходный порядок

Полный рабочий пример

Вот полный, практический пример, показывающий, как сортировать ваш конкретный массив:

// Ваш исходный массив
var objs = [ 
    { first_nom: 'Laszlo', last_nom: 'Jamf'     },
    { first_nom: 'Pig',    last_nom: 'Bodine'   },
    { first_nom: 'Pirate', last_nom: 'Prentice' }
];

console.log('Исходный массив:', objs);

// Сортировка по last_nom с использованием localeCompare
objs.sort((a, b) => a.last_nom.localeCompare(b.last_nom));

console.log('Отсортированный по last_nom:', objs);

// Вывод:
// Исходный массив: [
//   { first_nom: 'Laszlo', last_nom: 'Jamf' },
//   { first_nom: 'Pig', last_nom: 'Bodine' },
//   { first_nom: 'Pirate', last_nom: 'Prentice' }
// ]
// Отсортированный по last_nom: [
//   { first_nom: 'Pig', last_nom: 'Bodine' },
//   { first_nom: 'Laszlo', last_nom: 'Jamf' },
//   { first_nom: 'Pirate', last_nom: 'Prentice' }
// ]

Важное замечание: вам НЕ нужно добавлять метод toString() к вашим объектам. Метод sort() отлично работает с пользовательскими функциями сравнения, которые напрямую обращаются к свойствам объектов.

Источники

1. Array.prototype.sort() - JavaScript | MDN
2. How to Sort an Array of Objects by Property Name in JavaScript - freeCodeCamp
3. JavaScript Program to Sort Array of Objects by Property Values - Programiz
4. Sort Array of Objects by String Property Value - Stack Abuse
5. How to sort an array of objects by property values ? - GeeksforGeeks
6. Sort an Array of Objects in JavaScript - Scaler Topics

Заключение

Сортировка объектов JavaScript по строковым значениям свойств становится простой, как только вы понимаете механизм функции сравнения. Ключевые выводы:

1. Используйте Array.prototype.sort() с пользовательской функцией сравнения, которая обращается к конкретному свойству, по которому вы хотите сортировать
2. Предпочитайте localeCompare() для сравнения строк, так как он лучше обрабатывает крайние случаи, чем простые операторы сравнения
3. Преобразуйте в нижний регистр для сортировки без учета регистра, когда это необходимо
4. Вам не нужно изменять ваши объекты - функция сравнения может напрямую обращаться к свойствам
5. Учитывайте производительность при работе с большими наборами данных или сложной логикой сортировки

Наиболее практичный подход для вашего конкретного случая:

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

Эта одна строка отсортирует ваши объекты массива по свойству last_nom в алфавитном порядке по возрастанию, автоматически обрабатывая все сложности сравнения строк.