globale variablen und funktionen

[Don P]

Hallo,

Es geht nicht um typeof, es geht um den Wert. null dient dazu in einem Kontext wo ein Objekt erwartet wird den Nichterfolg anzuzeigen, ansonsten wäre null überflüssig, dann würde auch false reichen.

Jetzt geht es nicht mehr um typeof? Ich glaube, du verwechselst da etwas. Es ging hier doch überhaupt *nur* um typeof, weil typeof null === 'object' gilt. Das hat zunächst überhaupt *nichts* damit zu tun, dass üblicherweise der Wert null zurückgegben wird, wenn ein entsprechendes Objekt nicht existiert.

false würde tatsächlich ausreichen, man könnte ebensogut 0 oder undefined oder NaN oder halt false zurückgeben, was man in selbstdefinierten Funktionen ja auch machen kann. Trotzdem wäre ein typgenauer Vergleich möglich, z.B. bei Rückgabe von false mit if(obj===false), oder bei NaN mit isNaN(obj). Wo ist da das Problem?

typeof benutzte ich eigentlich immer um rauszufinden, ob ein Wert definiert ist.

Ob etwas überhaupt definiert ist prüfe ich, wenn überhaupt nötig, mit if(sth!==undefined)...

Fehler: sth is not defined

Quelldatei: .../tmp.html
Zeile: 16

  
Ok, weil ich das so selten brauche, hab' ich es prompt falsch hingeschrieben. Hier wäre wirklich mal typeof von Nutzen:  
`if(typeof sth!=='undefined')`{:.language-javascript}...  
  

> Doch, null ist ein Objekt.  

Nein, ist es nicht!  
  

> Aber es geht um die Theorie.  
  
Mir geht es um die Praxis und die normale menschliche Logik. Ein Objekt in JS hat Eigenschaften und/oder Methoden, ggf. einen Prototyp und kann um weitere Eigenschaften und Methoden erweitert werden. null hat von alldem gar nichts, ist nur ein simpler Wert, und so steht es auch in der Spezifikation. Dort steht nämlich nicht, dass null ein Objekt ist. Wäre es eines, dann würde `alert(null.sth);`{:.language-javascript} keinen Fehler werfen, sondern höchstens 'undefined' ausgeben. Nicht einmal `alert(''.sth);`{:.language-javascript} wirft einen Fehler, obwohl der literale Leerstring auch kein Objekt ist, anscheinend aber doch noch objektiger als null.  
  

> Ein exakter Vergleich prüft auf den Typ, wenn null nicht ein Objekt wäre, gäbe es kein entsprechende Möglichkeit auf exakte Gleichheit zu prüfen.  
  
Objekte auf Gleichheit zu prüfen ist doch trivial, denn die müssen ohnehin identisch sein, damit sich true ergibt.  
Aber prüfen wir doch mal:  
~~~javascript
  
alert('' === String(''));        // true  
alert(typeof '' === 'string');   // true  
alert( 0 === Number(0));         // true  
alert(typeof 0 === 'number');    // true  
//Aber:  
alert( NaN === Number());        // false, wie jeder vergleich mit NaN, ok.  
alert(typeof NaN === 'number');  // true => eine Nicht-Zahl ist eine Zahl :(  
alert(null === Object());        // false, ok.  
alert(typeof null === 'object'); // true => ein Nicht-Objekt ist ein Objekt :(  

Viel besser wäre doch:

typeof null === 'null';  
typeof NaN === 'nan';  
typeof [] === 'array';

Schaden würde es wohl nicht, wäre einfach nur logisch.

Nehmen wir z.B. ein Array a mit i Elementen, und jedes Element a[i], das ein Objekt ist, soll um eine Eigenschaft p erweitert werden. Der Code

for (var i in a) { if(typeof a[i]==='object') {a[i].p = p;} }

funktioniert nicht zuverlässig, weil a[i] auch mal null sein könnte, was für typeof aber dummerweise egal ist. Also müssen wir umständlich notieren
if(typeof a[i]==='object' && a[i]!==null)...
was doch eigentlich gar nicht nötig wäre, wenn typeof vernünftige Auskünfte gäbe ^^.

Gruß, Don P