Используйте 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;

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

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;
});

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

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

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.

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

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, потому что они, например, являются внутренними программными константами, тогда localeCompare также работает.

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

item1.attr - item2.attr

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

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

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

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

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

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

Или же

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;

<!doctype html>
<html>
<body>
<p id = "myString">zyxtspqnmdba</p>
<p id = "orderedString"></p>
<script>
var myString = document.getElementById("myString").innerHTML;
orderString(myString);
function orderString(str) {
    var i = 0;
    var myArray = str.split("");
    while (i < str.length){
        var j = i + 1;
        while (j < str.length) {
            if (myArray[j] < myArray[i]){
                var temp = myArray[i];
                myArray[i] = myArray[j];
                myArray[j] = temp;
            }
            j++;
        }
        i++;
    }
    var newString = myArray.join("");
    document.getElementById("orderedString").innerHTML = newString;
}
</script>
</body>
</html>

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

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

var str = ['v','a','da','c','k','l']
var b = str.join('').split('').sort().reverse().join('')
console.info(b)

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

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

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

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

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.info(value); return value}
});

> 2 NaN

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

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

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

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

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

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