Alex wrote:
^^^^
Bitte reparieren.
> danke für die ausführliche Antwort,
Gern geschehen. Unten noch ein paar Beispiele.
> dass muss ich mir mal in Ruhe zu Gemüte führen.
Ja.
> Ich muss vielleicht noch dazu sagen, Javascript ist nicht unbedingt meine
> Sprache ;)
Meine auch nicht. Es gibt nämlich kein “Javascript”, siehe auch
<
http://PointedEars.de/es-matrix>.
> […] Thomas 'PointedEars' Lahn:
>> Je nachdem, was Du vorhast (Beispiel?) ist es ausserdem der fhcsale
>> Ansatz. Du brauchst nicht über Objekteigenschaften iterieren, wenn Du die
>> Namen der Eigenschaften bereits kennst.
>
> Die Daten sind eine SOAP-Antwort eines Webservices mit dem "üblichen
> Angaben" drumherum (soap-env:Envelope ... { .. Header / Body usw.) . Im
> Body kommt es erster Key der Webservicename und danach die Daten. Die
> einzelnen Felder (Keys) sind bekannt, bestimmte davon müssen herausgesucht
> und die zugehörigen values ermittelt werden. In den Daten werden flache
> und tiefe Strukturen übermittelt. Sofern ich JSON richtig verstanden habe,
> sind bei tiefen Strukturen dann Arrays mit den entsprechenden
> Key:Value-Paaren verhanden.
Objekte sind in ECMAScript im allgemeinen ungeordnete Strukturen aus Paaren
bestehend aus Eigenschaftsname und Eigenschaftswert.
Arrays sind Objekte (Array-Instanzen). Die Paare für Daten bestehen dann
aus einem numerischen 0-basierten Index und Werten beliebigen Typs
(Objektreferenzen sind auch Werte, so kann man dann u. a. mehrdimensionale
Arrays emulieren). So ergibt sich *für Arrays* eine eindeutige Ordnung, was
die Index-Eigenschaften betrifft.
"use strict";
var a = [[0], true, new Date(2013, 10, 6), function () {}, JSON, Math,
42, {}, /rx/, "foo", ];
/* 42 */
a[6]
/* 11 */
a.length
a["length"]
/* undefined */
a["foo"]
Du meinst also _Objekte_, deren grundlegende Funktionsweise Du vielleicht
als „assoziatives Array“ oder „Dictionary“ aus anderen Programmiersprachen
kennst. Hier am Beispiel einer Object-Instanz (_kein_ Array):
var o = {
answer: 42,
"1": new Date()};
/* 42 */
o.answer
o["answer"]
/* "2013-…" */
o[1]
o["1"]
/* undefined */
o.length
o["length"]
/* SyntaxError: Unexpected number */
o.1
> Im Moment habe ich die Daten in einem Object, meine Javascript-Wissenstand
> nach wollte ich mir da jetzt entsprechend Methoden zu schreiben; so in der
> Art:(bitte nicht gleich steinigen ;) )
>
> function myObj() {
Kein Funktionsausdruck, sondern eine Funktionsdeklaration; daher besser „{“
auf die nächste Zeile.
> var _obj;
> this.add = function(JSONObj) {
> _Obj = JSONObj;
> return this;
> }
;
(Zuweisung)
> this.search = function(key) {
> bla ...
> return(value);
return value;
(keine Funktion)
> }
;
> }
„myObj“ wäre dann ein Konstruktor und sollte „MyObj“ geschrieben werden.
Sinnvoller wird es, wenn Du dem Konstruktor eine Referenz auf das aus JSON
erzeugte Objekt als Argument übergibst und den Wert des formalen Parameters
oder Arguments an _obj zuweist. Falls keine weiteren Manipulationen
gewünscht sind, kann bzw. sollte die add-Methode dann entfallen.
„_obj“ ist auch etwas anders als „_Obj“. Ansonsten ist Deine Konvention zur
Kennzeichnung “privater” Symbole gut; ich verwende sie auch.
function MyObj (obj)
{
var _obj = obj;
this.add = function (obj) {
_obj = obj;
return this;
};
this.search = function (key) {
// bla ...
return value;
};
}
Die Methoden heissen dann auch „privilegiert“ („privileged“), weil nur mit
ihnen auf das „private“ _obj zugegriffen werden kann (Closure).
Wie schon geschrieben ist es aber einfacher, die Methoden des aus JSON
erzeugten Objekts direkt zu verwenden, was bei Array-Instanzen über
Vererbung sinnvoll ist.
Bei Object-Instanzen sollte man es sich gut überlegen, Object.prototype zu
erweitern, weil diese Eigenschaften dann _alle_ Objekte erben. Wenn man es
nicht sauber – und damit leider nicht abwärtskompatibel – macht, tauchen
diese Eigenschaften in allen for-in-Schleifen wieder auf.
Wenn die nötigen Methoden fehlen, ist es statt eines benutzerdefinierten
Konstruktors oft einfacher und sinnvoller, dem Objekt die nötigen Methoden
zur Laufzeit hinzuzufügen –
var o = {foo: "bar"};
o.baz = function () {
return this.foo;
};
/* "bar" */
o.baz()
– oder so wie Du ein Wrapper-Objekt zu verwenden (Aggregation). (Letzteres
ist sogar die kompatibelste Methode, Host-Objekte wie z. B. DOM-Objekte zu
erweitern.)
Alternativ kann man mit Function.prototype.call() und
Function.prototype.apply() auch bestehende Methoden (Function-Instanzen) mit
einem anderen Objekt als this-Wert aufrufen (JSX:object.js emuliert diese
nützlichen Methoden, wenn man es nicht explizit verbietet).
var o = {
"0": "foo",
"1": "bar",
length: 2
};
/* "foo|bar" */
console.log([].join.call(o, "|"));
(„[]“ referenziert eine neue, „leere“ Array-Instanz. Das von “o”
referenzierte Objekt wird deshalb hier wie eine Array-Instanz behandelt,
also als wäre o.join("|") sinnvoll.)
Viele – nicht alle – der nativen Methoden sind generisch, d. h. sind auf
diese Weise wiederverwendbar. (In der ECMAScript Support Matrix sind sie
mit “[G]” gekennzeichnet.)
> Die "Sache" mit den Prototypes kenne ich noch nicht, muss ich mir auch
> ansehen.
Die Objektorientierung in den hier diskutierten ECMAScript-Implementierungen
ist prototypbasiert (nicht klassenbasiert): Objekte erben von anderen
Objekten über eine Prototyp-Kette; Klassen gibt es nicht. Das gehört also
zu den JavaScript-Grundkenntnissen.
<
https://developer.mozilla.org/>
> Also alles in allem viel zu lesen ...
Ja. Viel Spass dabei, und lass Dich nicht von den schlechten Büchern (es
gibt keine guten; nur solche, die nicht ganz so schlecht wie andere sind)
und Aussagen von Planlosen (es sieht viel einfacher aus als es ist, deshalb
gibt's da mehr als genügend solche Leute) verwirren.