Ist Parameter String oder Array?

[Robert]

Halli,

ich habe eine javascript-function, die ein Array von Strings bekommen soll.
Manchmal wird jedoch einfach nur ein String übergeben anstelle eines Arrays mit einem String.

Wie kann ich jetzt in der Funktion erkennen, ob ein String oder ein Array übergeben wurde?

function foo(list)
{
    alert(list.length); // kein Erfolg, length ist sowohl für Array als auch String erlaubt
    alert(list[0]); //kein Erfolg, gibt das erste Element des Array oder das erste Zeichen des String aus
}

Wie kann ich also erkennen, ob ich einen String oder ein Array habe?

Das ganze sollte (natürlich) in möglichst vielen Javascript-fähigen Browsern funktionieren, auf jeden Fall in Opera 7, IE ab 4, Netscape ab 4, Mozilla ab 1 ...

Vielen Dank im Voraus!

Robert

[MudGuard]

Hi,

Wie kann ich jetzt in der Funktion erkennen, ob ein String oder ein Array übergeben wurde?
function foo(list)
{

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

}

cu,
Andreas

[Robert]

Halli,

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

Wie dumm von mir, typeof zu vergessen. Danke für den Schlag auf den Hinterkopf!
Funktioniert bestens.

cu,
Robert

[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]