Missverständlichkeit »typeof« vs "datentyp"

[peterS.]

gruss Don P,

...

null ist ein Wert vom Typ Null (es gibt nur diesen Wert des Types Null).

Meinetwegen auch vom Typ Null, aber eben kein Objekt, obwohl typeof
das behauptet.

... tut er doch gar nicht. da »ECMA 262«-konforme implementationen allesamt
schwach und dynamisch typisiert kann ein »typeof«-operator nur die primitiven
typen [undefined], [string], [boolean] und [number] von funktionen, objekten
und eben dem [null]-zeiger unterscheiden.

»typeof« wird niemals den korrekten "datentyp" eines objekts ermitteln koennen,
eben weil es im sprachkonzept keine strengen auspraegungen solcher typen gibt.

... Darum geht es ja hier. Trotzdem Danke für die Links.

null ist wie gesagt vom Typ Null, für typeof gelten einfach Sonderregeln.

Genau die Sonderregel für null ist es, die ich hier anprangere. Ich weiß,
dass es in der ECMAscript-Spezifikation so festgelegt ist, und dennoch ist
es ein Fehler, ...

da [null] als definierter *NICHT-TYP* die abwesenheit aller anderen typen
voraussetzt, finde ich es nur konsequent, dass der »typeof«-operator, in einer
sprache, die bis auf die genannten ermittelbaren ausnahmen nur noch die typen
[function] und [object] *kennt* in ebendiesem fall "object" zurueckliefert.

... was inzwischen allgemein anerkannt ist.

... wankelmuetige kleingeister das alles ;-)

... Man hat damals
einfach nicht richtig aufgepasst, und nun ist es eben so. Das macht null
aber trotzdem nicht zu einem Objekt, nur weil typeof hier falsch
spezifiziert ist. Der ganze Rest von JavaScript kennt kein Null-Objekt.

richtig, und dass hat auch niemand behauptet, auch nicht der »typeof«-operator.

nocheinmal ... das *type* in »typeof« steht in JavaScript NICHT fuer den
"datentyp" einer wie auch immer gearteten objektinstanz. es wird nur nach
primitiven typen und objekten unterschieden. und da [[Function]] eine
sonderstellung[*1] einnimmt, wird eben noch zwischen [function] und [object]
differenziert.

[*1] JavaScript - Grundkonzepte ... und dort:
»Funktionen als Datentypen: ...« sowie
»Funktionen als Konstruktoren von Objekten eines bestimmten Typs: ...«

...

Mit welcher Begründung sollte typeof jetzt plötzlich bei Arrays ...
was anderes als "object" zurückliefern.
(...) Es gibt aber kein primitives Array, sondern die sind immer
Objekte, leider. typeof sollte hier IMHO trotzdem 'array' sagen.

Eine Begründung sehe ich da nicht, ich kann mich nur Svens Ausführungen
anschließen: typeof ist was anderes als constructor oder instanceof.

Zugegeben, das Ergebnis von "typeof []" ist Geschmacksache.

nein - die namenswahl des operators ist zugegebenermassen ungluecklich, weil
so oft missverstanden; ersteres (das ergebnis) hingegen ist wohlueberlegt.

Es wäre m.E. eben sinnvoll, wenn 'array' herauskäme. Wegen typeof "" === 'string',
typeof 0 === 'number', typeof false === 'boolean' usw. ...

alles *primitives*

wäre es einfach schön,

... waere es in hoechstem masse inkonsequent ...

wenn auch typeof [] === 'array' gelten würde.

[[Array]]-instanzen sind schlussendlich objekte.

wie z.b. sollte »typeof« folgendes dilemma loesen:

var Collection = (function () {  
  
 /* code */  
  
 var cnstr = (function () {  
  
 /* code */  
  
 });  
 cnstr.prototype = [];  
  
 return cnstr;  
  
})();  
  
  
var coll = new Collection();  
  
alert(coll instanceof Collection); // [true]  
alert(coll instanceof Array); // [true]  
alert(coll instanceof Object); // [true]  
  
alert(typeof coll); // "object"  
  
alert(coll.constructor); // [[Array]]: (function Array () {[native code]})

Dass typeof null === 'object' gilt, ist jedenfalls kompletter Unsinn.

siehe oben.

Klar kann ich für Arrays auch constructor oder instanceof bemühen, aber muss
das denn unbedingt sein? Wenn ich ein Array habe, dann interessiert es mich
nicht wirklich, dass es auch ein Objekt ist, zumal ja fast alles in JavaScript
Objekte sind. Ein Array ist aber schon nochmal etwas besonderes, in allen anderen
Programmiersprachen ist das bekanntlich ein eigener, nicht unwichtiger Datentyp.

siehe missverstaendlichkeit »typeof« vs "datentyp" und
siehe JavaScripts schwaches und dynamisches typenkonzept.

Wenn man schon einen typeof Operator in einer ansonsten schier typlosen Sprache
etabliert, dann sollte der doch auch sinnvolle Ergebnisse liefern, meine ich.

http://www.pseliger.de/jsExtendedApi/jsApi.Object.typeDetection.js
http://www.pseliger.de/jsExtendedApi/jsApi.Object.typeDetection.new.dev.js

so long - peterS. - [e-mail]