Сравните две строки с операторами «<» и «>» в ​​JavaScript

Question

Операторы сравнения, такие как > и <, возвращают значение Boolean, когда их ввод задан как два строковых значения.

Я пробовал несколько примеров:

/* String vs String */
console.log('firstName' < 'lastname'); // true
console.log('firstName' < 'Firstname'); // false
console.log('!firstName' < 'lastname'); // true
console.log('!firstName' < 'Firstname'); // true
console.log('!firstName' < '!Firstname'); // false
console.log('!firstName' < '_!Firstname'); // true
console.log('@!firstName' < '_!Firstname'); // true
console.log('@!firstName' < '2_!Firstname'); // false

/* String vs Number */
console.log('@!firstName' < 2); // false
console.log('@!firstName' < -1); // false

/* String vs Special Numbers */
console.log('@!firstName' < Infinity); // false
console.log('@!firstName' < -Infinity); // false
console.log('@!firstName' < -Infinity + Infinity); // false

/* String vs NaN */
console.log('@!firstName' < NaN); // false
console.log(NaN.toString()); // "NaN"
console.log('@!firstName' < "NaN"); // true

/* String vs Arrays */
console.log('firstName' < [Infinity, -Infinity]); // false
console.log('firstName' < ['Firstname', Infinity, -Infinity]); // false
console.log('firstName' < ['2_Firstname', Infinity, -Infinity]); // false

Мне действительно любопытно узнать, как JavaScript действительно оценивает такие выражения.В приведенных выше примерах я нахожу этот самый захватывающий console.log('@!firstName' < Infinity); // false.

Итак, у меня есть вопрос:

Как проводится сравнение с использованиемОператоры « больше » и « меньше » в JavaScript в этих сценариях (из приведенных выше примеров):

1. String vs String,
2. Строка против числа,
3. Строка против специальных чисел,
4. Строка против NaN,
5. Строка против массивов

Answer 1

Как сказано выше, формальная спецификация в стандарте: http://www.ecma -international.org / ecma-262 / 7.0 / # sec-abstract-реляционное сравнение , в терминах непрофессионала логиканапример:

1) String vs String

Разбейте обе строки на 16-битные единицы кода и сравните их численно.Обратите внимание, что кодовые единицы! = Символы, например "cafè" < "cafè" - это true (действительно).

2) Строка против другого примитива

Преобразование обоих в числа.Если один из них NaN, верните false, иначе сравните численно.+0 и -0 считаются равными, +/-Infinity больше / меньше, чем все остальное.

3) String vs Object

Попытка преобразовать объект в примитив, пытаясь,по порядку [Symbol.toPrimitive]("number"), valueOf и toString.Если у нас есть строка, перейдите к 1), в противном случае перейдите к 2).В частности, для массивов это вызовет toString, что совпадает с join.

Answer 2

String, Сравнение строк основано на упорядочении Unicode (a больше, чем A).

String, Сравнение чисел сначала преобразует строку в число перед сравнением (то же самое с бесконечностью).

String, Сравнение массива сначала преобразует массив в строку, а затем сравнивает, как указано выше.

Сравнение Javascript String
Сравнение объектов Javascript

Answer 3

Точные шаги описаны в спецификации , которая конкретно описывает, что делать в случае, если одна (или обе) стороны сравнения равны NaN или +Infinity или -Infinity.Например, для px < py оператор меньше чем вызывает Абстрактный алгоритм реляционного сравнения:

11.8.5 Абстрактный алгоритм реляционного сравнения

(Если оба сравниваемых элемента не являются строками, то:)

Пусть nx будет результатом вызова ToNumber (px).Поскольку px и py являются примитивными значениями, порядок оценки не важен.

Пусть ny будет результатом вызова ToNumber (py).

Если nx равно NaN, вернуть undefined.

Если ny равно NaN, вернуть неопределенное значение.

Если nx и ny являются одним и тем же числовым значением, вернуть false.

Если nx равно +0 и ny равно -0, вернуть false.

Если nx равно −0, а ny равно +0, вернуть false.

Если nx равно + ∞, вернуть false.

Если ny равно + ∞, вернуть true.

Если ny равен −∞, вернуть false.

Если nx равен −∞, вернуть true.

Если математическое значение nx меньше математического значения ny - примечаниечто эти математические значения конечны и не равны нулю - верните истину.В противном случае верните false.

Иначе, px и py являются строками

Если py является префиксом px, верните false.(Строковое значение p является префиксом строкового значения q, если q может быть результатом объединения p и некоторой другой строки r. Обратите внимание, что любая строка является префиксом самой себя, поскольку r может быть пустой строкой.)

Если px является префиксом py, вернуть true.

Пусть k наименьшее неотрицательное целое число, такое, что символ в позиции k в пределах px отличается от символа в позиции k в пределах py.(Такой ak должен быть, поскольку ни одна из String не является префиксом другого.)

Пусть m будет целым числом, которое является значением кодовой единицы для символа в позиции k в пределах px.

Пусть n будет целым числом, которое является значением единицы кода для символа в позиции k в пределах py.

Если m

Когда оба сравниваемых элемента являются строками, это эффективно приводит к кодовым точкам каждого сравниваемого символа.Например, 'firstName' < 'lastname', потому что код символа f (102) меньше, чем код символа l (108).Для '!firstName' < 'Firstname' код символа ! (33) меньше, чем код символа F (70), поэтому также оценивается как true.В следующем фрагменте приведен пример реализации:

function compare(left, right) {
  for (let i = 0; i < left.length; i++) {
    const c1 = left[i].charCodeAt();
    const c2 = right[i].charCodeAt();
    if (c1 !== c2) {
      console.log('Char code comparision:', c1 < c2, '< comparison:', left < right);
      break;
    }
  }
}

/* String vs String */
compare('firstName', 'lastname'); // true
compare('firstName', 'Firstname'); // false
compare('!firstName', 'lastname'); // true
compare('!firstName', 'Firstname'); // true
compare('!firstName', '!Firstname'); // false
compare('!firstName', '_!Firstname'); // true
compare('@!firstName', '_!Firstname'); // true
compare('@!firstName', '2_!Firstname'); // false