node-red/packages/node_modules/@node-red/nodes/locales/de/sequence/17-split.html

<!--
  Copyright JS Foundation and other contributors, http://js.foundation

  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at

  http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
-->

<script type="text/html" data-help-name="split">
    <p>Aufteilung einer Nachricht in Nachrichtensequenzen.</p>
    <h3>Eingangsdaten</h3>
    <dl class="message-properties">
        <dt>payload <span class="property-type">object | string | array | buffer</span></dt>
        <dd>Das Node-Verhalten wird durch den <code>msg.payload</code>-Typ bestimmt:
            <ul>
                <li><b>Zeichenfolge (string) / Binärer Puffer (buffer)</b>: Die Nachricht wird anhand des vorgegebenen Zeichens (Standard: <code>\n</code>),
                    der Buffer-Sequenz oder in feste Längen aufgeteilt</li>
                <li><b>Datenfeld (array)</b>: Die Nachricht wird entweder in einzelne Array-Elemente oder Arrays mit fester Länge aufgeteilt</li>
                <li><b>Objekt (object)</b>: Jedes Schlüssel/Wert-Paar wird einzeln als Nachricht gesendet</li>
            </ul>
        </dd>
    </dl>
    <h3>Ausgangsdaten</h3>
    <dl class="message-properties">
        <dt>parts <span class="property-type">object</span></dt>
        <dd>Diese Eigenschaft enthält Informationen darüber, wie die Nachricht von der ursprünglichen Nachricht abgeteilt wurde.
            Bei Übergabe an ein join-Node kann die Sequenz wieder zu einer einzigen Nachricht zusammengeführt werden.
            Diese Eigenschaft hat die folgenden Eigenschaften:
            <ul>
                <li><code>id</code>: Identifikator der Nachrichten-Gruppe</li>
                <li><code>index</code>: Position innerhalb der Gruppe</li>
                <li><code>count</code>: Gesamtzahl der Nachrichten in der Gruppe (sofern bekannt). Siehe dazu unten <i>Streaming-Modus</i>.</li>
                <li><code>type</code>: Nachrichtentyp string/array/object/buffer</li>
                <li><code>ch</code>: Die für das Aufteilen der String- oder Buffer-Nachricht verwendeten Daten, entweder als String oder als Byte-Array.</li>
                <li><code>key</code>: Schlüssel der Eigenschaft, aus der diese Nachricht erstellt wurde (nur bei einem Objekt).
                    Optional kann dieser Wert auch in andere Nachrichteneigenschaft kopiert werden, wie z.B. <code>msg.topic</code>.</li>
                <li><code>len</code>: Nachrichtenlänge bei Aufteilung in feste Längen</li>
            </ul>
        </dd>
    </dl>
    <h3>Details</h3>
    <p>Dieser Node macht es einfach, einen Flow zu erstellen, der gemeinsame Aktionen über eine Sequenz von Nachrichten ausführt,
       bevor die Sequenz mittels join-Node wieder zu einer einzigen Nachricht neu kombiniert wird.</p>
    <p>Der Node verwendet die <code>msg.parts</code>-Eigenschaft, um die einzelnen Sequenzteile nachzuverfolgen.</p>
    <h4><b>Streaming-Modus</b></h4>
    <p>Der Node kann auch zum Aufbereiten eines Nachrichtenstroms verwendet werden.
       So kann beispielsweise ein serielles Gerät, das <code>newline</code>-terminierte Befehle sendet,
       eine Nachricht mit einem noch unvollständigen Befehl am Ende liefern.
       Im Streaming-Modus teilt der Node die Nachricht in komplette Befehlsegmente auf.
       Befindet sich am Nachrichtenende ein unvollständiges Befehlsegment,
       so wird es im Node aufbewahrt und der nächsten empfangenen Nachricht vorangestellt.</p>
    <p>In diesem Modus wird die <code>msg.parts.count</code>-Eigenschaft nicht gesetzt,
       da die Anzahl der zu erwartenden Nachrichten im Stream unbekannt ist.
       Das bedeutet, dass ein nachfolgender join-Node nicht im Automatikmodus verwendet werden kann.</p>
</script>

<script type="text/html" data-help-name="join">
    <p>Verbindung von Nachrichtensequenzen zu einer einzigen Nachricht.</p>
    <p>Es sind drei Modi verfügbar:</p>
    <dl>
        <dt>Automatisch</dt>
        <dd>In Kombination mit dem split-Node verbindet es automatisch die Nachrichten, um die zuvor durchgeführte Aufteilung rückgängig zu machen.</dd>
        <dt>Manuell</dt>
        <dd>Die Nachrichtensequenzen können auf verschiedene Weisen verbunden werden.</dd>
        <dt>Sequenz reduzieren</dt>
        <dd>Einen Ausdruck auf alle Nachrichten einer Sequenz anwenden, um sie auf eine einzige Nachricht zu reduzieren.</dd>
    </dl>
    <h3>Eingangsdaten</h3>
    <dl class="message-properties">
        <dt class="optional">parts <span class="property-type">object</span></dt>
            <dd>Zur automatischen Verbindung einer Nachrichtensequenz sollten alle über diese Eigenschaft verfügen.
                Der split-Node erzeugt diese Eigenschaft, sie kann aber auch manuell erstellt werden.
                Sie hat die folgenden Eigenschaften:
                <ul>
                <li><code>id</code>: Identifikator der Nachrichten-Gruppe</li>
                <li><code>index</code>: Position innerhalb der Gruppe</li>
                <li><code>count</code>: Gesamtzahl der Nachrichten in der Gruppe (sofern bekannt). Siehe dazu unten "Streaming-Modus".</li>
                <li><code>type</code>: Nachrichtentyp string/array/object/buffer</li>
                <li><code>ch</code>: Die für das Aufteilen der String- oder Buffer-Nachricht verwendeten Daten, entweder als String oder als Byte-Array.</li>
                <li><code>key</code>: Schlüssel der Eigenschaft, aus der diese Nachricht erstellt wurde (nur bei einem Objekt).
                    Optional kann dieser Wert auch in andere Nachrichteneigenschaft kopiert werden, wie z.B. <code>msg.topic</code>.</li>
                <li><code>len</code>: Nachrichtenlänge bei Aufteilung in feste Längen</li>
                </ul>
            </dd>
        <dt class="optional">complete</dt>
        <dd>Wenn gesetzt, werden die Nutzdaten (Payload) hinzugefügt und die Ausgangsnachricht im aktuellen Zustand gesendet.</dd>
    </dl>
    <h3>Details</h3>

    <h4><b>Automatischer Modus</b></h4>
    <p>Der automatische Modus verwendet die <code>parts</code>-Eigenschaften der eingehenden Nachrichten,
       um die Sequenz in richtiger Reihenfolge zu verknüpften.
       Dies ermöglicht die Aufteilung des split-Nodes automatisch rückgängig zu machen.</p>

    <h4><b>Manueller Modus</b></h4>
    <p>Im manuellen Modus werden Nachrichtensequenzen auf verschiedenen Arten zusammengefügt:</p>
    <ul>
        <li><b>String</b> oder <b>Buffer</b>: Verbinden der ausgewählten Eigenschaft jeder Nachricht
        mit den vorgegebenen Join-Zeichen oder -Buffer</li>
        <li><b>Array</b>: Erstellung eines Ausgangsarrays durch Hinzufügen jeder ausgewählten Eigenschaft oder ganzer Nachrichten</li>
        <li><b>Schlüssel/Wert-Objekt</b>: Erzeugung von Schlüssel und Wert aus Eigenschaft jeder Nachricht</li>
        <li><b>Zusammengeführtes Objekt</b>: Erzeugung durch Zusammenführen der Eigenschaften jeder Nachricht als ein einziges Objekt</li>
    </ul>
    <p>Die anderen Eigenschaften der Ausgangsnachricht werden von der zuletzt empfangenen Nachricht übernommen,
       bevor das Ergebnis gesendet wird.</p>
    <p>Mit <i>Anzahl</i> kann vorgegeben werden, wie viele Nachrichten vor dem Erzeugen der Ausgangsnadchricht empfangen werden sollen.
       Bei Objektausgaben kann der Node nach Erreichen dieser Anzahl so eingestellt werden,
       dass er bei jeder nachfolgenden empfangenen Nachricht eine weitere Nachricht sendet.</p>
    <p>Mittels <i>Zeitablauf</i> kann das Senden einer neuen Nachricht mit dem Inhalt ausgelöst werden, was bisher empfangen wurde.</p>
    <p>Wenn eine Nachricht mit der <code>msg.complete</code>-Eigenschaft empfangen wird,
       wird die Ausgangsnachricht finalisiert und gesendet.
       Dadurch wird die Zählung aller Teile zurückgesetzt.</p>
    <p>Wenn eine Nachricht mit der <code>msg.reset</code>-Eigenschaft empfangen wird,
       wird die unvollständige Nachricht gelöscht und nicht gesendet.
       Dadurch wird die Zählung aller Teile zurückgesetzt.</p>

    <h4><b>Modus Sequenz reduzieren</b></h4>
    <p>In diesem Modus wird auf jede Nachricht einer Sequenz ein Ausdruck angewendet und
       das Ergebnis zu einer einzigen Nachricht akkumuliert.</p>
    <dl class="message-properties">
        <dt>Anfangswert</dt>
        <dd>Anfangswert des akkumulierten Wertes (<code>$A</code>).</dd>
        <dt>Reduktions-Ausdruck</dt>
        <dd>JSONata-Ausdruck, der für jede Nachricht in der Sequenz aufgerufen wird.
            Das Ergebnis wird als akkumulierter Wert an den nächsten Aufruf des Ausdrucks übergeben.
            Im Ausdruck können folgende spezielle Variablen verwendet werden:
            <ul>
                <li><code>$A</code>: Akkumulierter Wert</li>
                <li><code>$I</code>: Index der Nachricht innerhalb der Sequenz</li>
                <li><code>$N</code>: Anzahl der Nachrichten der Sequenz</li>
            </ul>
        </dd>
        <dt>Fix-up-Ausdruck</dt>
        <dd>Optionaler JSONata-Ausdruck, der nach Anwendung des Reduktions-Ausdrucks auf alle Nachrichten in der Sequenz angewendet wird.
            Im Ausdruck können folgende spezielle Variablen verwendet werden:
            <ul>
                <li><code>$A</code>: Akkumulierter Wert</li>
                <li><code>$N</code>: Anzahl der Nachrichten der Sequenz</li>
            </ul>
        </dd>
        <p>Standardmäßig wird der Reduktions-Ausdruck in Reihenfolge von der ersten bis zur letzten Nachricht der Sequenz angewendet.
           Er kann optional in umgekehrter Reihenfolge angewendet werden.</p>
    </dl>
    <p><b>Beispiel</b>: Die folgenden Einstellungen berechnen bei einer Sequenz von Zahlenwerten den Mittelwert:
        <ul>
            <li><b>Reduktions-Ausdruck</b>: <code>$A+payload</code></li>
            <li><b>Anfangswert</b>: <code>0</code></li>
            <li><b>Fix-up-Ausdruck</b>: <code>$A/$N</code></li>
        </ul>
    </p>
    <h4><b>Speichern von Nachrichten</b></h4>
    <p>Dieser Node puffert Nachrichten intern, um sequenzübergreifend zu arbeiten.
       Mit der Laufzeiteinstellung <code>nodeMessageBufferMaxLength</code> kann begrenzt werden,
       wie viele Nachrichten im Node zwischengespeichert werden sollen.</p>
</script>