• Jetzt anmelden. Es dauert nur 2 Minuten und ist kostenlos!

Variablen in FOR-Schleife benennen

C

colaholiker

Mitglied
Hallo allerseits,

ich möchte diesen String
t2 = Be:98,13.06.2024,21:30--Be:98,13.06.2024,21:30
oder z.B. den hier (eben verschiedene Anzahlen)
t2 = Be:98,13.06.2024,21:30--Be:98,13.06.2024,21:30--Be:44,13.06.2024,21:30
trennen und die Einzelteile als Variable benennen.
Letzteres ist der Knackpunkt.

hier mal ein Stückl meines Codes:
Code: 
        const
        Qc = t2.split("--");
        var
        lenQc = Qc.length;
        for(let i=0; i<lenQc, i++) {
         // ???  
        }
Da bei // ??? fehlt mir die Benennung der Variablen fü die Strings.
Das sollte so mit Q1, Q2, ... benannt werden.
Geht das? Wie ist die Syntax hier?
Code: 
var Q[i] = Qc[i].substring(Qc[i].indexOf("--"));
hab ich mal so hingeschrieben. Wie kann ich 'Q1', 'Q2'... herausbekommen um diese weiter verarbeiten zu können?
vielen Dank!
C.
 
Werbung:
Hallo colaholker,
die Gegenfrage "warum willst Du das überhaupt machen" ist häufig keine gute Idee, aber in dem Fall liegt sie mir auf der Zunge. Wenn die Bestandteile in einem Array vorliegen, wie es nach dem splitten der Fall ist, hat man eigentlich viel mehr Möglichkeiten, damit zu arbeiten, man kann Schleifen verwenden, mit dem Index in einer Variablen zugreifen etc.
In Javascript gibt es die Möglichkeit, das über das Window-Objekt zu machen, was Du dir wünschst:
Code: 
        for(let i=0; i<lenQc, i++) {
            window['Q' + (i + 1)] = Qc[i];
        }
        console.log(Q1);
        console.log(Q2);
Ich würde jedoch empfehlen, sie in einem selbst definierten Objekt zusammenzufassen:
Code: 
        let oQc = {};
        for(let i=0; i<lenQc, i++) {
            oQc['Q' + (i + 1)] = Qc[i];
        }
        console.log(oQc.Q1);
nach der Devise: Was zusammen gehört, sollte auch zusammen abgelegt werden. Du kannst dann mit Namen darauf zugreifen und hast trotzdem die Möglichkeit, darüber zu iterieren.
Beschreibe am besten Mal den Zusammenhang, in dem Du das brauchst, dann gibt es vielleicht noch bessere Lösungen.
 
Zuletzt bearbeitet:
Hi Sempervivum,

Ich glaube Dein oberes Beispiel kann mir weiterhelfen.

zum Zweck:
Insgesamt bekomme ich eine lange Zeichenkette mit verschiedenen Trennern.
Daher gibt es verschiedene Verarbeitungsschritte je Stringteil.
Ich bilde jedesmal Arrays, mit den Trennern '::', '--' und ','.

Im oberen Fall habe ich den zweiten Schritt gezeigt (Trenner: '--').
Das Problem für mich ist/war die Variable Anzahl dieser Elemente.

Q1...Qn werden dann nochmal bei ',' getrennt und 4. schließlich das Datum daraus mittels des Trenners '-' ins Format 'dd.mm.jjjj' gewandelt (sorry, mein Beispielstring oben zeigt bereits dieses Format, richtig ist aber 'jjj-mm-dd').

Das ganze wird dann als formatierter Text (mit <br> usw.) wieder zusammengesetzt und auf die Webseite gebracht.

Bisher kommt der formatierte String komplett vom Microcontroller, was dessen Flash beutelt und die Performance bremst. Ich mach' mal ein Bild vom aktuellen Stand.
Zeitbasis1.jpg
Es geht "um alles" im blauen Kasten.
Da das Ganze innerhalb einer einzigen Funktion bleibt sollte mir Dein erster Vorschlag mit dem Window-Objekt genügen.
Dann geht's jetzt mal weiter...
 
Werbung:
Auch wenn Du zufrieden bist und schreibst, dass dir das mit dem window-Objekt genügt: Wenn ich mir die ganze Prozedur durchlese, wäre das viel einfacher zu lösen, wenn Du gleich mit dem Array arbeitest. Als erstes mit "--" splitten, dann bekommst Du ein Array mit variabler Länge. Darüber eine Schleife mit forEach und die Notwendigkeit für die getrennten Variablen entfällt.
 
... würde dann so aussehen wenn man die gesplitteten Strings mit Regex in ihre Bestandteile zerlegt:
Code: 
        const
            srcStr = 'Be:98,13.06.2024,21:30--Be:98,13.06.2024,21:30--Be:44,13.06.2024,21:30',
            // String an den Minuszeichen aufspalten:
            splitted = srcStr.split('--'),
            // Regex für das Auslesen der Bestandteile bereit stellen:
            re = /([a-zA-Z]{2}:\d\d),(\d\d)\.(\d\d)\.(\d{4}),(\d\d:\d\d)/;
        // Array umformen:
        resultStr = splitted.map(item => {
            const
                // Regex auf den aktuellen Bestandteil anwenden:
                matches = item.match(re);
            // Resultierenden String aus den Bestandteilen zusammenbauen:
            return `${matches[1]},${matches[4]}-${matches[3]}-${matches[2]},${matches[5]}`;
        }).join('<br>'); // Bestandteile wieder mit '<br>' verbinden:

        console.log(resultStr);
 
Hm. Das geht über mein Verständnis, besonders wenn ich nach einiger Zeit wieder dran muß.

Inzwischen funktioniert der Teil mit dem Window-Object schonmal. Aber ich muß den Rest noch ausarbeiten.
Dann werde ich mal die komplette Funktion zeigen, damit die Sache besser verständlich wird.
Du schreibst ja
Sempervivum schrieb:
würde dann so aussehen
Zum Vergrößern anklicken....
aber das ist ja nur Schritt 2 von 1-4.

Jetz aber est mampfen! Guten Appetit!
 
Werbung:
Das geht über mein Verständnis, besonders wenn ich nach einiger Zeit wieder dran muß.
Zum Vergrößern anklicken....
Das habe ich schon befürchtet. Man muss ein wenig mit Regex und map vertraut sein um das zu verstehen aber auf längere Sicht lohnt es sich.

das ist ja nur Schritt 2 von 1-4.
Zum Vergrößern anklicken....
Ich denke, das macht schon ein wenig mehr. Man tut den Ausgangsstring t2 hinein und bekommt den fertig zusammen gebauten heraus:
Code: 
Be:98,2024-06-13,21:30<br>Be:98,2024-06-13,21:30<br>Be:44,2024-06-13,21:30

Dann wünsche ich guten Appetit.
 
Sempervivum schrieb:
Man muss ein wenig mit Regex und map vertraut sein um das zu verstehen aber auf längere Sicht lohnt es sich.
Zum Vergrößern anklicken....
Tja, wenn man es oft anwendet. Ich programmiere nur für mich, und will daß es später ohne ständiges Eingreifen läuft. Falls doch, ist RegEx längst verflogen :-(

Aber der Code sollte jetzt fertig sein. Hab nur gemerkt, daß jetzt das "blaue Fenster" zu klein ist.
Eine Frage noch zu .split, aber erstmal der Gesamtcode:
Code: 
function handleRQuitt(quittValue) {
//--
console.log('========= handleRQuitt(quittValue): ' + quittValue);
    var qv = quittValue;
    if (qv != "") {
        const
        Qm = qv.split("::");
        var
        t1 = Qm[0].substring(Qm[0].indexOf("::")) + " haben quittiert:<br>", //-- 1.Zeile
        t2 = Qm[1].substring(Qm[1].indexOf("::")),  //-- Clienten mit timeStamp
        t3 = Qm[2].substring(Qm[2].indexOf("::")),  //-- Anz. quittiert
        t4 = Qm[3].substring(Qm[3].indexOf("::")),  //-- Anz. doppelt quittiert
        t5 = Qm[4].substring(Qm[4].indexOf("::"));  //-- quitRollo (Empfangsbereitschaft)
    
        //-- verarbeiten t2 bei variabler Anzahl Clienten
        const
        Qc = t2.split("--");
        lenQc = Qc.length;
        t2 = "";
        for(let i=0; i<lenQc; i++){
            window['Q' + (i + 1)] = Qc[i];

            //-- Q1... aka Be:98,2024-07-01,11:34
            const
            Cls = window['Q' + (i + 1)].split(",");
            Cla = Cls[0].substring(Cls[0].indexOf(",")), //-- Be00:
            Clb = Cls[1].substring(Cls[1].indexOf(",")), //-- 2024-07-01
            Clc = Cls[2].substring(Cls[2].indexOf(",")); //-- 11:34
            const
            Cdt = Clb.split("-");
            var
            Ty = Cdt[0].substring(Cdt[0].indexOf(",")), //-- Jahr
            Tm = Cdt[1].substring(Cdt[1].indexOf(",")), //-- Monat
            Td = Cdt[2].substring(Cdt[2].indexOf(",")); //-- Tag
            t2 = t2 + Cla + '<br>' + Td + "." + Tm + "." + Ty + "," + Clc + '<br>';
        }
        //-- verarbeiten t3 u t4
        t3 = 'Anz.Quittungen: ' + t3 + '<br>';
        t4 = 'mehrfach quittiert: ' + t4 + '<br>';
        //-- verarbeiten t5
        if ( t5 == 0 ) {t5 = 'quittieren möglich';}
        if ( t5 == 1 ) {t5 = 'quittieren gesperrt';}
        //-- alles verbinden
        var msg = t1 + t2 + t3 + t4 + t5;

        document.getElementById("act_z1").innerHTML = msg;
    } else {
        document.getElementById("act_z1").innerHTML = "zZt. keine Quittungen";
    }
}
Ich mußte die ganze Verarbeitung von t2 noch mit in die Schleife packen.

Also meine Frage, nicht zum Thema:
Ich habe xy.split oft so verwendet:
Code: 
    const
    Tm = txt_all.split(",");
    t1 = " Kalenderwoche " + Tm[0].substring(Tm[0].indexOf(",")),
    t2 = " Wochentag " + Tm[1].substring(Tm[1].indexOf(",")),
    usw.
Also hinter Tm... ein Semkolon und t1,t2 usw. mit Komma abgeschlossen (das letzte t natürlich auch mit Semikolon.

- Wie wird das korrekt gemacht?
Hinter Tm... ein Komma, damit 'const' auch für die weiteren Zeilen gilt?
Oder wie im jetzigen Code das Semikolon lassen und die Split-Variablen z.B. mit 'var' deklarieren?
Der Code läuft auch ohne Deklaration der Element-Variablen t1,t2...

Gibt es da eine Fehlertoleranz in js oder sowas?
 
Was dieses betrifft:
Code: 
    const
    Tm = txt_all.split(","); // Hier wird die Anweisung abgeschlossen
    // Die folgenden haben weder ein var noch ein let noch ein const
    // und werden deshalb als globale Variablen angelegt:
    t1 = " Kalenderwoche " + Tm[0].substring(Tm[0].indexOf(",")),
    t2 = " Wochentag " + Tm[1].substring(Tm[1].indexOf(",")),
Ich hoffe, durch die Kommentare wird klar, was passiert. Ist zwar nicht fehlerhaft aber ich empfehle, es nicht so zu machen sondern so, und auch gleich sinnvoll einzurücken, damit man sofort sieht, wofür das "const" noch gilt:
Code: 
    const
        Tm = txt_all.split(","),
        t1 = " Kalenderwoche " + Tm[0].substring(Tm[0].indexOf(",")),
        t2 = " Wochentag " + Tm[1].substring(Tm[1].indexOf(",")),
        // usw. bis eine Anweisung mit ";" abgeschlossen wird

Was den vollständigen Code davor betrifft: So sind Entwickler verschieden, ich habe jetzt Probleme, deinen Code zu verstehen, vor allem dieses:
Code: 
            Cls = window['Q' + (i + 1)].split(",");
            Cla = Cls[0].substring(Cls[0].indexOf(",")), //-- Be00:
            Clb = Cls[1].substring(Cls[1].indexOf(",")), //-- 2024-07-01
            Clc = Cls[2].substring(Cls[2].indexOf(",")); //-- 11:34
Durch das split, wodurch Cls entstanden ist, sind doch alle Kommas aus den Texten im Array verschwunden? :rolleyes::rolleyes::rolleyes:
Ich erwarte, da das Komma nicht gefunden wird, dass indexOf eine -1 zurück gibt, wodurch dieses übrig bleibt:
Code: 
Cls[0].substring(-1)
Dazu sagt die Doku auf MDN:
Any argument value that is less than 0 or greater than str.length is treated as if it were 0 and str.length, respectively.
Zum Vergrößern anklicken....
D. h. die ganze Anweisung hat gar keine Auswirkung sondern liefert einfach den String zurück, wie er ist.

Und dieses:
Code: 
        for(let i=0; i<lenQc; i++){
            window['Q' + (i + 1)] = Qc[i];

            //-- Q1... aka Be:98,2024-07-01,11:34
            const
                Cls = window['Q' + (i + 1)].split(","),
Die Variablen Q1, Q2, Q3 werden zwar angelegt aber ich finde keine Zeile, wo Du sie direkt als Q1, Q2 etc. verwendest? :rolleyes::rolleyes::rolleyes: So wie es jetzt da steht kannst Du es vereinfachen zu:
Code: 
        for(let i=0; i<lenQc; i++){
            const
                Cls = Qc[i].split(","),
 
Zuletzt bearbeitet:
Werbung:
Sempervivum schrieb:
Ich hoffe, durch die Kommentare wird klar, was passiert. Ist zwar nicht fehlerhaft aber ich empfehle, es nicht so zu machen sondern so, und auch gleich sinnvoll einzurücken, damit man sofort sieht, wofür das "const" noch gilt:
Zum Vergrößern anklicken....
Ok, jetzt ist mir das klar, werde ich ab jetzt so machen.
Sempervivum schrieb:
Durch das split, wodurch Cls entstanden ist, sind doch alle Kommas aus den Texten im Array verschwunden?
Zum Vergrößern anklicken....
Ja klar, das sind doch Trennzeichen!
'Be:98,2024-07-01,11:34' ist z.B. ein Array bei i==0. Cla, Clb und Clc ergeben Name Datum Zeit.
Kommas als Text kommen nicht vor, sonst hätte ich was anderes zum Trennen verwendet.

Bei i==1 entsteht ein neues Array aus zB. 'Be:38,2024-07-01,11:34' und überschreibt das alte.
In der letzten Zeile der Schleife werden die Variablen an t2 übergeben und können im nächsten Durchlauf überschrieben werden.
Sempervivum schrieb:
Die Variablen Q1, Q2, Q3 werden zwar angelegt aber ich finde keine Zeile, wo Du sie direkt als Q1, Q2 etc. verwendest?
Zum Vergrößern anklicken....
Richtig! Ich verarbeite alle in der Schleife und 't2' ist das Ergebnis.
Das wird dann unten an 'msg' gehängt.
Sempervivum schrieb:
So wie es jetzt da steht kannst Du es vereinfachen zu:
Code: 
for(let i=0; i<lenQc; i++){
const
Cls = Qc[i].split(","),
Zum Vergrößern anklicken....
Hm, das sieht ja fast aus wie in meinem Startposting :-/
Werde ich mal so umbauen. Um 21:31 kommt dann der heiße Test.
...
Hab ich gemacht. Was ist aus dem ...(i+1)... geworden?

-Und, komisch wieder, daß es damit funktioniert hat (Posting #8) mit Cla = 'Cls[0]'.substring...

Naja, in einer guten Stunde...
 
Etwas OffTopic:
Das, was du im Eingangsposting geschrieben hast, gibt es in PHP tatsächlich schon. Allerdings hat sich das kaum durchgesetzt, genauso wie goto. Solche Dinge führen in der Regel zu einer unübersichtlichen Programmierung und der Quellcode lässt sich nach einiger Zeit kaum noch vernünftig lesen, ohne dass man sich erst wieder einarbeiten muss.
 
Werbung:
Du musst dich einloggen oder registrieren, um hier zu antworten.

Neueste Beiträge

Zurück
Oben