Warum `null> = 0 && null <= 0`, aber nicht` null == 0`?

Ich musste eine Routine schreiben, die den Wert einer Variablen um 1 erhöht, wenn ihr Typ ist, numberund der Variablen 0 zuweist, wenn nicht, wo die Variable anfänglich ist nulloder undefined.

Die erste Implementierung war, v >= 0 ? v += 1 : v = 0weil ich dachte, dass alles, was keine Zahl ist, einen arithmetischen Ausdruck falsch machen würde, aber es war falsch, da null >= 0es als wahr ausgewertet wird. Dann habe ich gelernt, dass es nullsich wie 0 verhält und die folgenden Ausdrücke alle als wahr ausgewertet werden.

• null >= 0 && null <= 0
• !(null < 0 || null > 0)
• null + 1 === 1
• 1 / null === Infinity
• Math.pow(42, null) === 1

Natürlich nullist nicht 0. null == 0wird als falsch bewertet. Dies macht den scheinbar tautologischen Ausdruck (v >= 0 && v <= 0) === (v == 0)falsch.

Warum ist nullwie 0, obwohl es eigentlich nicht 0 ist?

Ihre eigentliche Frage scheint zu sein:

Warum:

null >= 0; // true

Aber:

null == 0; // false

Was wirklich passiert, ist, dass der Operator "Größer als oder gleich" ( >=) einen Typzwang ( ) ausführt ToPrimitive, mit einem Hinweis vom Typ Number, tatsächlich haben alle relationalen Operatoren dieses Verhalten.

nullwird vom Equals Operator ( ==) in besonderer Weise behandelt . Kurz gesagt , es zwingt nur zu undefined:

null == null; // true
null == undefined; // true

Wert wie false, '', '0'und []unterliegt numerischen Typ Zwang, alle von ihnen auf Null zwingen.

Sie können die inneren Details dieses Prozesses im abstrakten Gleichheitsvergleichsalgorithmus und im abstrakten relationalen Vergleichsalgorithmus sehen .

Zusammenfassend:

• Relationaler Vergleich: Wenn beide Werte nicht vom Typ String sind, ToNumberwird für beide aufgerufen. Dies ist das gleiche wie das Hinzufügen eines +Front, das für Null erzwingt 0.

• Gleichheitsvergleich: ToNumberRuft nur Zeichenfolgen, Zahlen und Boolesche Werte auf.

Ich möchte die Frage erweitern, um die Sichtbarkeit des Problems weiter zu verbessern:

null >= 0; //true
null <= 0; //true
null == 0; //false
null > 0;  //false
null < 0;  //false

Es macht einfach keinen Sinn. Wie menschliche Sprachen müssen diese Dinge auswendig gelernt werden.

JavaScript bietet sowohl strenge als auch typkonvertierende Vergleiche

null >= 0;ist wahr, aber (null==0)||(null>0)falsch

null <= 0;ist wahr, aber (null==0)||(null<0)falsch

"" >= 0 ist auch wahr

Bei relationalen abstrakten Vergleichen (<=,> =) werden die Operanden vor dem Vergleich zunächst in Grundelemente und dann in denselben Typ konvertiert.

typeof null returns "object"

Wenn der Typ Objekt ist, versucht Javascript, das Objekt zu stringifizieren (dh null), werden die folgenden Schritte ausgeführt ( ECMAScript 2015 ):

1. Wenn PreferredTypenicht bestanden wurde, sei hint"Standard".
2. Else if PreferredTypeist hintString, lassen hint"string" sein.
3. Sonst PreferredTypeist hintNummer, sei hint"Nummer".
4. Lass exoticToPrimsein GetMethod(input, @@toPrimitive).
5. ReturnIfAbrupt(exoticToPrim).
6. Wenn exoticToPrimnicht undefiniert ist, dann
   a) Sei das Ergebnis Call(exoticToPrim, input, «hint»).
   b) ReturnIfAbrupt(result).
   c) Wenn Type(result)nicht Object, Ergebnis zurückgeben.
   d) Wirf eine TypeError-Ausnahme aus.
7. Wenn hint"Standard" ist, sei hint"Nummer".
8. Zurück OrdinaryToPrimitive(input,hint).

Die zulässigen Werte für den Hinweis sind "Standard", "Nummer" und "Zeichenfolge". Datumsobjekte sind unter den integrierten ECMAScript-Objekten insofern einzigartig, als sie "Standard" als äquivalent zu "Zeichenfolge" behandeln. Alle anderen integrierten ECMAScript-Objekte behandeln "Standard" als gleichwertig mit "Nummer" . ( ECMAScript 20.3.4.45 )

Also ich denke nullkonvertiert in 0.

Ich hatte das gleiche Problem !!. Derzeit ist meine einzige Lösung zu trennen.

var a = null;
var b = undefined;

if (a===0||a>0){ } //return false  !work!
if (b===0||b>0){ } //return false  !work!

//but 
if (a>=0){ } //return true !

console.log( null > 0 );  // (1) false
console.log( null == 0 ); // (2) false
console.log( null >= 0 ); // (3) true

Mathematisch ist das seltsam. Das letzte Ergebnis besagt, dass "null größer oder gleich Null ist", daher muss es in einem der obigen Vergleiche wahr sein, aber beide sind falsch.

Der Grund ist, dass eine Gleichstellungsprüfung ==und Vergleiche > < >= <=unterschiedlich funktionieren. Vergleiche wandeln null in eine Zahl um und behandeln sie als 0. Aus diesem Grund (3) null >= 0ist trueund (1) null > 0ist false.

Andererseits wird die Gleichheitsprüfung ==für undefinedund nullso definiert, dass sie sich ohne Konvertierungen gleichen und nichts anderes entsprechen. Aus diesem Grund (2) null == 0ist false.