JavaScript Datenstruktur

[wachteldonk]

Hallo,

ich muss per PHP eine Datenstruktur für Javascript ertsellen

Eine Beispielstruktru sieht so aus:

[
            [Date.UTC(1970,  9, 27), 0   ],
            [Date.UTC(1970, 10, 10), 0.6 ],
            [Date.UTC(1970, 10, 18), 0.7 ],
            [Date.UTC(1970, 11,  2), 0.8 ],
            [Date.UTC(1970, 11,  9), 0.6 ],
            [Date.UTC(1970, 11, 16), 0.6 ],
            [Date.UTC(1970, 11, 28), 0.67],
            [Date.UTC(1971,  0,  1), 0.81],
            [Date.UTC(1971,  0,  8), 0.78],
            [Date.UTC(1971,  0, 12), 0.98],
            [Date.UTC(1971,  0, 27), 1.84],
            [Date.UTC(1971,  1, 10), 1.80],
            [Date.UTC(1971,  1, 18), 1.80],
            [Date.UTC(1971,  1, 24), 1.92],
            [Date.UTC(1971,  2,  4), 2.49],
            [Date.UTC(1971,  2, 11), 2.79],
            [Date.UTC(1971,  2, 15), 2.73],
            [Date.UTC(1971,  2, 25), 2.61],
            [Date.UTC(1971,  3,  2), 2.76],
            [Date.UTC(1971,  3,  6), 2.82],
            [Date.UTC(1971,  3, 13), 2.8 ],
            [Date.UTC(1971,  4,  3), 2.1 ],
            [Date.UTC(1971,  4, 26), 1.1 ],
            [Date.UTC(1971,  5,  9), 0.25],
            [Date.UTC(1971,  5, 12), 0   ]
         ]
      }, {
         name: 'Winter 2008-2009',
         data: [
            [Date.UTC(1970,  9, 18), 0   ],
            [Date.UTC(1970,  9, 26), 0.2 ],
            [Date.UTC(1970, 11,  1), 0.47],
            [Date.UTC(1970, 11, 11), 0.55],
            [Date.UTC(1970, 11, 25), 1.38],
            [Date.UTC(1971,  0,  8), 1.38],
            [Date.UTC(1971,  0, 15), 1.38],
            [Date.UTC(1971,  1,  1), 1.38],
            [Date.UTC(1971,  1,  8), 1.48],
            [Date.UTC(1971,  1, 21), 1.5 ],
            [Date.UTC(1971,  2, 12), 1.89],
            [Date.UTC(1971,  2, 25), 2.0 ],
            [Date.UTC(1971,  3,  4), 1.94],
            [Date.UTC(1971,  3,  9), 1.91],
            [Date.UTC(1971,  3, 13), 1.75],
            [Date.UTC(1971,  3, 19), 1.6 ],
            [Date.UTC(1971,  4, 25), 0.6 ],
            [Date.UTC(1971,  4, 31), 0.35],
            [Date.UTC(1971,  5,  7), 0   ]
         ]
      }, {
         name: 'Winter 2009-2010',
         data: [
            [Date.UTC(1970,  9,  9), 0   ],
            [Date.UTC(1970,  9, 14), 0.15],
            [Date.UTC(1970, 10, 28), 0.35],
            [Date.UTC(1970, 11, 12), 0.46],
            [Date.UTC(1971,  0,  1), 0.59],
            [Date.UTC(1971,  0, 24), 0.58],
            [Date.UTC(1971,  1,  1), 0.62],
            [Date.UTC(1971,  1,  7), 0.65],
            [Date.UTC(1971,  1, 23), 0.77],
            [Date.UTC(1971,  2,  8), 0.77],
            [Date.UTC(1971,  2, 14), 0.79],
            [Date.UTC(1971,  2, 24), 0.86],
            [Date.UTC(1971,  3,  4), 0.8 ],
            [Date.UTC(1971,  3, 18), 0.94],
            [Date.UTC(1971,  3, 24), 0.9 ],
            [Date.UTC(1971,  4, 16), 0.39],
            [Date.UTC(1971,  4, 21), 0   ]
         ]

Worin liegen die Unetrschiede der einzelnen EBene, die it [],{} und () dargestelltw erden

udn wie shcaffe ich es diese Daten so zu übergeben das dieses "Date.UTC" ausgeführt wird?

 

[wollmaus]

Das, was du da hast, ist für JS völlig ausreichend, das Date.UTC() sollte jeweils "ausgeführt" werden, also durch den jeweiligen timestamp ersetzt werden.

Was die ganzen Klammern bedeuten:

Man nennt dies, was du dort hast, einen Objekt-Literal, die Definition eines Objektes über einen String.

Eckige Klammern markieren einen Array(indiziert, assoziative Arrays gibt es in JS nicht). Die einzelnen Array-Elemente sind dabei durch Kommas getrennt.

geschweifte Klammern markieren Objekte(oder auch das, was du aus PHP als assoziativen Array kennst). Die einzelnen Member werden dabei gemäß dem Schema:

label:wert

notiert.
Einzelne Member werden wieder getrennt durch kommas.

Diese eckigen und geschweiften Klammern kannst du dann nach Bedarf verschachteln.

Ein Beispiel:

<script>
var obj= [
          {'name':'member1',
           'data':[
                    [Date.UTC(1970,  9, 27), 0]
                  ]
          },
          {'name':'member2',
           'data':[
                    [Date.UTC(1980,  9, 27), 2],
                    [Date.UTC(1980, 10, 10), 1.6 ]
                  ]
          }
         ];
</script>

1. obj ist ein Array mit 2 Elementen, welche jeweils Objekte sind
2. Diese Objekte haben jeweils 2 Member, name(ein String) und data(ein Array)
3. Der data-Array enthält eine unterschiedliche Zahl an Elementen, jedes der Elemente besteht wiederum aus 1 Elementen, der Rückgabe des jeweiligen Date.UTC()-Aufrufs und einer Fliesskommazahl

Auf diesen Array obj und seinen Inhalt kannst du dann ganz normal zugreifen wie in JS üblich, es muss nichts umgewandelt werden, diese ganze Struktur ist bereits ein Objekt.

Beispiel: ermitteln von name des 1. Elements (nicht vergessen, Array-Indizes beginnen bei 0)

alert(obj[0]['name'])
//Ausgabe: member1

Beispiel: Ermitteln des Timestamps im 2.Element von Objekt, dessen data-members
und dessen 2. Array-Elementes, wiederum dessen 1. Element(das wäre Date.UTC(1980, 10, 10), der Timestamp für den 10. November 1980--bei JS-Datumsoperationen beginnt das Zählen des Monats bei 0, ein Wert 10 steht also für November und nicht für Oktober)

alert(obj[1]['data'][1][0]);
// Ausgabe:342662400000

Testhalber die Rückkontrolle, ob alles rechtens ist mit dem Timestamp:

alert(new Date(obj[1]['data'][1][0]).toGMTString())
//Ausgabe:Mon, 10 Nov 1980 00:00:00 GMT

Die runden Klammern in dem ganzen Konstrukt sind Bestandteil des Funktionsaufrufs(in dem Fall von Date.UTC() ), haben mit dem Objekt-Literal also nicht speziell etwas zu tun. In dem moment, wo dies Objekt gelesen wird, tritt an die Stelle dieses Funktionsaufrufes der Rückabewert der aufgerufenen Funktion(hier Timestamp)

Du kannst dir dieses ganze date.UTC()-Gedöns natürlich auch sparen und den Timestamp da gleich mit PHP ermitteln und im Objekt speichern. Das dürfte ein paar bytes sparen und die Funktionsaufrufe macht es überflüssig, was Ressourcen spart(vergesse dabei nicht, den Timestamp aus PHP mit 1000 zu multiplizieren, UNIX-Timestamp basiert auf Sekunden-Werten, während JS mit Millisekunden arbeitet)