type detection

[peterS.]

gruss Ihr Beiden,

alert("list ist ein String: " + ((typeof list) == 'string'));

es ist auch moeglich, die "constructor"-eigenschaft
   eines objekts abzufragen:

(list.contructor == String) bzw. (list.contructor == Array)

generell ist bei typ-erkennung auch immer darauf zu achten,
   ob das zu pruefende objekt mit dem wert [null] belegt ist,
   ob es ueberhaupt definiert ist und ob eigenschaften, welche
   abgefragt werden sollen, ueberhaupt existieren;

der operator "typeof" - den man im uebrigen auch funktional
   verwenden kann: "typeof()" - liefert nur die typen "string",
   "boolean", "number", "function", "object" und "undefined";
   zurueck, wobei "typeof(null)" ebenfalls "object" ergibt;

aehnlich wie im beispiel von [null] verhaelt es sich mit dem
   definierten nichtwert fuer Number-objekte [NaN]; ein "typeof"
   fuer diesen wert liefert "number" - hier hilft auch nicht die
   "constructor"-eigenschaft weiter, die "function Number(){...}"
   liefert;

ausserdem ist der zurueckgelieferte wert fuer einunddenselben
   objekt-typ konstruktionsbedingt:

var x = new String(12345); alert(typeof(x)); // ergibt "object";
   var x = "12345";           alert(typeof(x)); // ergibt "string";

weiterhin haengt der zurueckgelieferte objekt-typ von der
   browserimplementation ab:

MSIE und opera liefern fuer:
   var x = new RegExp("\s+","g"); alert(typeof(x)); // "object";
   var x = /\s+/g;                 alert(typeof(x)); // "object";
   wohingegen mozilla folgende implemtierung offenbart:
   var x = new RegExp("\s+","g"); alert(typeof(x)); // "function";
   var x = /\s+/g;                 alert(typeof(x)); // "function";

die in js vorhandenen bordmittel fuer exakte "type detection" sind
   also nicht immer ausreichend - die gerade beschriebenen faelle sollten
   dabei immer im auge behalten werden;

bei grossen objekt-orientierten js-projekten kommt dann sicher schnell
   der wunsch nach detaillierteren methoden zur typ-bestimmung von objekten
   auf - zumindest war das bei mir der fall - hier das ergebnis:

//typen-ermittlung;

this.isUndefined = function(obj) {
  return (typeof(obj) == "undefined");
};
this.isNull = function(obj) {
  return ((typeof(obj) == "object") && (obj === null));
};

//liefert [true] fuer jedes ECMA-object, welches das argument dieser globalen funktion ist;
this.isNative = function(obj) {
  return (!isUndefined(obj) && !isNull(obj) && (typeof(obj.constructor) == "function"));
};
//der rueckgabewert haengt von der browser-implementation ab:
//z.b. sind alle DOM-knoten im MSIE "Aliens", da diese objekte nicht die "constructor"-
//eigenschaft unterstuetzen (jedes native objekt sollte aber diese eigenschaft haben,
//wobei der konstruktor eine funktion sein muss);
this.isAlien = function(obj) {
  return (isObject(obj) && (typeof(obj.constructor) != "function"));
};
//gilt browseruebergreifend fuer alle DOM-knoten, deren eigenschaften, methoden und
//prototypen-objekte (bzw. deren konstruktor-funktionen, falls es solche gibt) noch
//im unveraenderten originalzustand vorliegen;
this.isNode = function(obj) {
  return (((isAlien(obj) && isUndefined(obj.prototype) && isUndefined(obj.constructor)) || (isNative(obj) && isUndefined(obj.prototype) && (obj.constructor == Object))) ? ((obj.nodeType&&obj.cloneNode) ? (true) : (false)) : (false));
};

this.isBoolean = function(obj) {
  return (isNative(obj) && (obj.constructor == Boolean));
};
this.isNumber = function(obj) {
  return (isNative(obj) && (obj.constructor == Number) && isFinite(obj));
};
this.isString = function(obj) {
  return (isNative(obj) && (obj.constructor == String));
};

//gibt [true] zurueck, falls das argument dieser globalen funktion
//eines der ECMA-objekte "Boolean", "Number" und "String" ist;
this.isPrimitive = function(obj) {
  return (isString(obj) || isNumber(obj) || isBoolean(obj));
};
//gibt [true] zurueck, falls das argument dieser globalen funktion
//eines der ECMA-objekte "Date", "Error", "RegExp", "Function",
//"Array" bzw. "Object", ein ueber eine selbstdefinierte
//konstruktor-funktion erzeugtes objekt oder aber ein DOM-knoten
//des clients ist;
this.isObject = function(obj) {
  return (!isUndefined(obj) && !isNull(obj) && !isPrimitive(obj));
};

this.isDate = function(obj) {
  return (isNative(obj) && (obj.constructor == Date));
};
this.isError = function(obj) {
  return (isNative(obj) && (obj.constructor == Error));
};
this.isRegExp = function(obj) {
  return (isNative(obj) && (obj.constructor == RegExp));
};
this.isFunction = function(obj) {
  return (isNative(obj) && (obj.constructor == Function));
};
this.isArray = function(obj) {
  return (isNative(obj) && (obj.constructor == Array));
};

//gibt [true] zurueck, falls es sich beim konstruktor ausschliesslich um das globale objekt "Object" handelt;
this.isObjectObject = function(obj) {
  return (isNative(obj) && !isNode(obj) && (obj.constructor == Object));
};
//gibt [true] zurueck, falls es sich beim konstruktor ausschliesslich um eine selbstdefinierte konstruktor-funktion handelt;
this.isConstructedObject = function(obj) {
  return (isNative(obj) && !isNode(obj) && (obj.constructor != String) && (obj.constructor != Number) && (obj.constructor != Boolean) && (obj.constructor != Object) && (obj.constructor != Array) && (obj.constructor != Function) && (obj.constructor != RegExp) && (obj.constructor != Error) && (obj.constructor != Date));
};

by(t)e by(t)e - peterS. - [e-mail]