Используйте String.prototype.localeCompare как в вашем примере:

list.sort(function (a, b) {
    return ('' + a.attr).localeCompare(b.attr);
})

Мы заставляем a.attr быть строкой, чтобы избежать исключений. localeCompare поддерживается начиная с Internet Explorer 6 и Firefox 1. Вы также можете увидеть следующий код, который не поддерживает локаль:

if (item1.attr < item2.attr)
  return -1;
if ( item1.attr > item2.attr)
  return 1;
return 0;

Обновленный ответ (октябрь 2014 г.)

Меня очень раздражал этот естественный порядок сортировки строк, поэтому мне потребовалось некоторое время, чтобы исследовать эту проблему. Надеюсь, это поможет.

Короче

localeCompare() поддержка символов - это круто, просто используйте ее. Как указал Shog9, ответ на ваш вопрос:

return item1.attr.localeCompare(item2.attr);

Ошибки, обнаруженные во всех реализациях пользовательского javascript "естественный порядок сортировки строк".

Существует довольно много пользовательских реализаций, пытающихся выполнить сравнение строк, более точно называемое «естественным порядком сортировки строк».

«Играя» с этими реализациями, я всегда замечал какой-то странный выбор «естественного порядка сортировки» или, скорее, ошибки (или упущения в лучшем случае).

Обычно специальные символы (пробел, тире, амперсанд, скобки и т. Д.) Обрабатываются некорректно.

Затем вы обнаружите, что они смешиваются в разных местах, обычно это могут быть:

• некоторые будут между заглавными буквами Z и строчными буквами a.
• некоторые будут между "9" и прописной "A"
• некоторые будут после строчной буквы "z"

Когда можно было ожидать, что все специальные символы будут «сгруппированы» вместе в одном месте, за исключением, возможно, специального символа пробела (который всегда будет первым символом). То есть либо все перед числами, либо все между числами и буквами (строчные и прописные буквы «вместе» друг за другом), либо все после букв.

Я пришел к выводу, что все они не могут обеспечить согласованный порядок, когда я начинаю добавлять едва необычные символы (т. Е. Символы с диакритическими знаками или символами, такими как тире, восклицательный знак и т. Д.).

Исследование кастомных реализаций:

• Natural Compare Lite https://github.com/litejs/natural-compare-lite: сбой на последовательная сортировка https://github.com/litejs/natural-compare-lite/issues/1 и http://jsbin.com/bevututodavi/1/edit?js,console, сортировка основных латинских символов http://jsbin.com/bevututodavi/5/edit?js,console
• Natural Sort https://github.com/javve/natural-sort: не удается выполнить последовательную сортировку, см. проблема https://github.com/javve/natural-sort/issues/7 и просмотрите сортировку основных латинских символов http://jsbin.com/cipimposedoqe/3/edit?js,console
• Javascript Natural Sort https://github.com/overset/javascript-natural-sort: кажется довольно игнорируется с февраля 2012 г., не выполняет последовательную сортировку, см. проблему https://github.com/overset/javascript-natural-sort/issues/16
• Alphanum http://www.davekoelle.com/files/alphanum.js, не работает на последовательная сортировка, см. http://jsbin.com/tuminoxifuyo/1/edit?js,console

Реализации "естественного порядка сортировки строк" в браузерах через localeCompare()

localeCompare() самая старая реализация (без аргументов locales и options) поддерживается IE6 +, см. http://msdn.microsoft.com/en-us/library/ie/s4esdbwz(v=vs.94).aspx (прокрутите вниз до метода localeCompare ()). Встроенный метод localeCompare() намного лучше справляется с сортировкой, даже с международными и специальными символами. Единственная проблема с использованием метода localeCompare() заключается в том, что "используются языковой стандарт и порядок сортировки полностью зависит от реализации ". Другими словами, при использовании localeCompare, например stringOne.localeCompare (stringTwo): Firefox, Safari, Chrome и IE имеют другой порядок сортировки для строк.

Исследование встроенных в браузер реализаций:

• http://jsbin.com/beboroyifomu/1/edit?js,console - сравнение основных латинских символов с localeCompare () http://jsbin.com/viyucavudela/2/ - сравнение основных латинских символов с localeCompare () для тестирования в IE8
• http://jsbin.com/beboroyifomu/2/edit?js,console - основные латинские символы при сравнении строк: проверка согласованности в строке по сравнению с одиночным символом
• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/localeCompare - IE11 + поддерживает новые аргументы локалей и параметров.

Сложность «естественного порядка сортировки строк»

Реализация надежного алгоритма (то есть последовательного, но также охватывающего широкий диапазон символов) - очень сложная задача. UTF8 содержит более 2000 символов & охватывает более 120 скриптов (языков). Наконец, есть некоторая спецификация для этой задачи, она называется "Алгоритм сортировки Unicode", который можно найти по адресу http://www.unicode.org/reports/tr10/. Дополнительную информацию об этом можно найти в опубликованном мной вопросе https://softwareengineering.stackexchange.com/questions/257286/is-there-any-language-agnostic-specification-for-string-natural-sorting-order

Окончательный вывод

Поэтому, учитывая текущий уровень поддержки, предоставляемой пользовательскими реализациями javascript, с которыми я столкнулся, мы, вероятно, никогда не увидим ничего, приближающегося к поддержке всех этих символов и скриптов (языков). Следовательно, я бы предпочел использовать собственный метод localeCompare () браузеров. Да, у него есть обратная сторона - непоследовательность в разных браузерах, но базовое тестирование показывает, что он охватывает гораздо более широкий диапазон символов, обеспечивая надежный и значимый порядок сортировки.

Итак, как указал Shog9, ответ на ваш вопрос:

return item1.attr.localeCompare(item2.attr);

Дальнейшее чтение:

• https://softwareengineering.stackexchange.com/questions/257286/is-there-any-language-agnostic-specification-for-string-natural-sorting-order.
• Как вы выполняете сравнение строк в JavaScript?
• Javascript: естественный вид буквенно-цифровых строк
• Сортировка массива числовых и алфавитных элементов (естественная сортировка)
• Сортировка смешанного буквенно-цифрового массива
• https://web.archive.org/web/20130929122019/http://my.opera.com/GreyWyvern/blog/show.dml/1671288
• https://web.archive.org/web/20131005224909/http://www.davekoelle.com/alphanum.html
• http://snipplr.com/view/36012/javascript-natural-sort/
• http://blog.codinghorror.com/sorting-for-humans-natural-sort-order/

Благодаря хорошему ответу Shog9, который, как мне кажется, направил меня в "правильном" направлении.

Ответ (в современном ECMAScript)

list.sort((a, b) => (a.attr > b.attr) - (a.attr < b.attr))

Or

list.sort((a, b) => +(a.attr > b.attr) || -(a.attr < b.attr))

Описание

Приведение логического значения к числу дает следующее:

• true -> 1
• false -> 0

Рассмотрим три возможных шаблона:

• x больше, чем y: (x > y) - (y < x) -> 1 - 0 -> 1
• x равно y: (x > y) - (y < x) -> 0 - 0 -> 0
• x меньше y: (x > y) - (y < x) -> 0 - 1 -> -1

(Альтернатива)

• x больше, чем y: +(x > y) || -(x < y) -> 1 || 0 -> 1
• x равно y: +(x > y) || -(x < y) -> 0 || 0 -> 0
• x меньше y: +(x > y) || -(x < y) -> 0 || -1 -> -1

Таким образом, эта логика эквивалентна типичным функциям компаратора сортировки.

if (x == y) {
    return 0;
}
return x > y ? 1 : -1;

Вы должны использовать здесь> или ‹и ==. Итак, решение было бы таким:

list.sort(function(item1, item2) {
    var val1 = item1.attr,
        val2 = item2.attr;
    if (val1 == val2) return 0;
    if (val1 > val2) return 1;
    if (val1 < val2) return -1;
});

поскольку строки можно сравнивать непосредственно в javascript, это выполнит свою работу

list.sort(function (a, b) {
    return a.attr > b.attr ? 1: -1;
})

вычитание в функции сортировки используется только тогда, когда желательна не алфавитная (числовая) сортировка, и, конечно, она не работает со строками

Вложенная тернарная стрелочная функция

(a,b) => (a < b ? -1 : a > b ? 1 : 0)

Меня это беспокоило давно, поэтому я, наконец, исследовал это и дал вам длинную причину того, почему все обстоит именно так.

Из спецификации:

Section 11.9.4   The Strict Equals Operator ( === )

The production EqualityExpression : EqualityExpression === RelationalExpression
is evaluated as follows: 
- Let lref be the result of evaluating EqualityExpression.
- Let lval be GetValue(lref).
- Let rref be the result of evaluating RelationalExpression.
- Let rval be GetValue(rref).
- Return the result of performing the strict equality comparison 
  rval === lval. (See 11.9.6)

Итак, теперь мы переходим к 11.9.6.

11.9.6   The Strict Equality Comparison Algorithm

The comparison x === y, where x and y are values, produces true or false. 
Such a comparison is performed as follows: 
- If Type(x) is different from Type(y), return false.
- If Type(x) is Undefined, return true.
- If Type(x) is Null, return true.
- If Type(x) is Number, then
...
- If Type(x) is String, then return true if x and y are exactly the 
  same sequence of characters (same length and same characters in 
  corresponding positions); otherwise, return false.

Вот и все. Оператор тройного равенства, примененный к строкам, возвращает истину, если аргументы являются точно такими же строками (одинаковой длины и одинаковых символов в соответствующих позициях).

Таким образом, === будет работать в тех случаях, когда мы пытаемся сравнить строки, которые могли поступить из разных источников, но которые, как мы знаем, в конечном итоге будут иметь одинаковые значения - достаточно распространенный сценарий для встроенных строк в нашем коде. Например, если у нас есть переменная с именем connection_state, и мы хотим знать, в каком из следующих состояний ['connecting', 'connected', 'disconnecting', 'disconnected'] она сейчас находится, мы можем напрямую использовать ===.

Но это еще не все. Чуть выше 11.9.4 есть короткое примечание:

NOTE 4     
  Comparison of Strings uses a simple equality test on sequences of code 
  unit values. There is no attempt to use the more complex, semantically oriented
  definitions of character or string equality and collating order defined in the 
  Unicode specification. Therefore Strings values that are canonically equal
  according to the Unicode standard could test as unequal. In effect this 
  algorithm assumes that both Strings are already in normalized form.

Хм. Что теперь? Строки, полученные извне, могут быть и, скорее всего, будут странными юникодами, и наши нежные === не воздадут им должное. На помощь приходит localeCompare:

15.5.4.9   String.prototype.localeCompare (that)
    ...
    The actual return values are implementation-defined to permit implementers 
    to encode additional information in the value, but the function is required 
    to define a total ordering on all Strings and to return 0 when comparing
    Strings that are considered canonically equivalent by the Unicode standard. 

Теперь мы можем идти домой.

tl; dr;

Для сравнения строк в javascript используйте localeCompare; если вы знаете, что строки не имеют компонентов, отличных от ASCII, потому что они, например, являются внутренними константами программы, тогда === также работает.

Объяснение того, почему подход в вопросе не работает:

let products = [
    { name: "laptop", price: 800 },
    { name: "phone", price:200},
    { name: "tv", price: 1200}
];
products.sort( (a, b) => {
    {let value= a.name - b.name; console.log(value); return value}
});

> 2 NaN

Вычитание между строками возвращает NaN.

Повторяя ответ @Alejadro, правильный подход -

products.sort( (a,b) => a.name > b.name ? 1 : -1 )

list.sort(function(item1, item2){
    return +(item1.attr > item2.attr) || +(item1.attr === item2.attr) - 1;
}) 

Как работают образцы:

+('aaa'>'bbb')||+('aaa'==='bbb')-1
+(false)||+(false)-1
0||0-1
-1

+('bbb'>'aaa')||+('bbb'==='aaa')-1
+(true)||+(false)-1
1||0-1
1

+('aaa'>'aaa')||+('aaa'==='aaa')-1
+(false)||+(true)-1
0||1-1
0

В своей операции в исходном вопросе вы выполняете следующую операцию:

item1.attr - item2.attr

Итак, предполагая, что это числа (например, item1.attr = "1", item2.attr = "2"), вы все равно можете использовать оператор "===" (или другие строгие оценщики) при условии, что вы гарантируете тип. Следующее должно работать:

return parseInt(item1.attr) - parseInt(item2.attr);

Если они alphaNumeric, тогда используйте localCompare ().

Используйте sort () прямо без каких-либо - или <

const areas = ['hill', 'beach', 'desert', 'mountain']
console.log(areas.sort())

// To print in descending way
console.log(areas.sort().reverse())

Должны быть функции по возрастанию и по убыванию

            if (order === 'asc') {
                return a.localeCompare(b);
            }
            return b.localeCompare(a);