String aufteilen in Arduino
In diesem Tutorial wird das Teilen eines Strings mit der Funktion substring() in Arduino besprochen.
Verwenden Sie die Funktion substring(), um einen String in Arduino aufzuteilen
Arduino bietet eine eingebaute Funktion substring(), um einen gegebenen String zu teilen. Wir können eine Zeichenfolge unter Verwendung des Start- und Endindexwerts aufteilen.
Die Funktion substring() hat zwei Argumente. Das erste Argument ist der Anfangsindexwert, ab dem wir den Aufteilungsprozess starten möchten, und das zweite ist der Endindexwert, bei dem der Aufteilungsprozess endet.
Syntax:
Sub_string = MyString.substring(from, to);
Die Variable Sub_string enthält die Ausgabe der Funktion substring(), und die Variable MyString enthält die ursprüngliche Zeichenfolge, die wir aufteilen möchten. Die Variable von enthält den Startindex und die Variable bis enthält den Endindex.
Lassen Sie uns einen String definieren und ihn mit der Funktion substring() aufteilen und auf dem seriellen Monitor von Arduino ausgeben.
Beispiel:
String My_S = "hello world";
void setup() { Serial.begin(9600); }
void loop() {
String sub_S = My_S.substring(0, 5);
Serial.println(sub_S);
delay(1000);
}
Ausgabe:
hello
Im obigen Code druckt die Funktion Serial.println() das Ergebnis auf dem seriellen Monitor von Arduino. Die Zeichenfolgenaufteilung beginnt bei 0, enthält das Indexzeichen 0 und endet bei Index 5, mit Ausnahme des Zeichens bei Index 5.
Wir können den Zeichenindex auch mit der Funktion indexOf() von Arduino finden. Der Funktionsindex akzeptiert zwei Argumente.
Das erste Argument ist obligatorisch und repräsentiert das Zeichen oder die Zeichenfolge, deren Index wir finden möchten. Das zweite Argument ist optional und stellt den Startindex dar, um den Index des Zeichens zu finden.
Standardmäßig beginnt die Funktion indexOf(), den String von Anfang an zu durchsuchen, um den Index des angegebenen Zeichens zu finden, aber wir können auch einen Index als Ausgangspunkt übergeben, indem wir das zweite Argument der Funktion indexOf() verwenden.
Syntax:
int index = MyString.indexOf(val, from);
Die Variable index speichert den Variablenindex val, der ein Zeichen oder eine Zeichenfolge im obigen Code enthält. Die from-Variable definiert den Startindex, der als Ausgangspunkt verwendet wird, um den Index des angegebenen Zeichens zu finden.
Wir verwenden die Funktion indexOf(), wenn wir den Zeichenindex nicht kennen, um substring() zu übergeben.
Wenn wir beispielsweise die angegebene Zeichenfolge mit dem Leerzeichen als Endindex aufteilen möchten, können wir die Funktion indexOf() verwenden, um den Index des Leerzeichens zu finden, und ihn dann in der Funktion substring() verwenden um die Saite zu teilen.
Die Funktion indexOf() gibt -1 zurück, wenn der Index in der angegebenen Zeichenfolge nicht gefunden wird.
Beispiel:
String My_S = "hello world";
void setup() { Serial.begin(9600); }
void loop() {
int index = My_S.indexOf(' ');
String sub_S = My_S.substring(0, index);
Serial.println(index);
Serial.println(sub_S);
delay(1000);
}
Ausgabe:
5
hello
Im obigen Code enthält die Variable index den Index des Leerzeichens, das in der angegebenen Zeichenfolge vorhanden ist. Wie Sie sehen können, haben wir den Index und das Ergebnis der Zeichenfolgenaufteilung im Fenster des seriellen Monitors angezeigt.
Wir können eine Zeichenfolge auch basierend auf der Anzahl der Zeilen aufteilen.
Zum Beispiel, wenn eine Zeichenfolge mehrere Textzeilen enthält und wir jede Zeile aufteilen und als separate Zeichenfolge erhalten möchten.
Wir können die Funktion indexOf('\n') verwenden, um den Index einer neuen Zeile zu finden und den angegebenen String entsprechend aufzuteilen.
Die Funktion indexOf() beginnt mit der Suche nach dem Index am Anfang der angegebenen Zeichenfolge. Wir können aber auch die Funktion lastIndexOf() verwenden, die vom Ende eines Strings nach dem Index sucht.
Als zweites Argument können wir auch den Startindex innerhalb der Funktion lastIndexOf() übergeben. Lassen Sie uns zum Beispiel eine Zeichenfolge mit drei Zeilen aufteilen, die letzte Zeile abrufen und sie im Fenster des seriellen Monitors anzeigen.
Beispiel:
String My_S = "hello world\nGreetings\nPeople";
void setup() {
Serial.begin(9600);
Serial.println(My_S);
}
void loop() {
int index = My_S.lastIndexOf('\n');
int length = My_S.length();
String sub_S = My_S.substring(index, length);
Serial.println(sub_S);
delay(100000);
}
Ausgabe:
hello world
Greetings
People
People
Wir haben die Funktion lastIndexOf() im obigen Code verwendet, weil wir nur die letzte Textzeile in der angegebenen Zeichenfolge erhalten möchten. Die ersten drei Zeilen sind die gegebene Zeichenfolge in der Ausgabe, und die vierte Zeile ergibt sich aus der Zeichenfolgenaufteilung.
Wir haben die Funktion length() verwendet, um die Länge der angegebenen Zeichenfolge zu erhalten, die als Endindexwert in substring() verwendet wird. Wir haben die Funktion delay() verwendet, um die Codeausführung etwas zu verzögern, da die Schleife den Vorgang wiederholt.
Wenn wir nur die Teilung durchführen möchten, können wir den Code in die Funktion setup() schreiben, die nur einmal ausgeführt wird.
Wir können eine Zeichenfolge basierend auf einem beliebigen Zeichen aufteilen. Wir müssen nur seinen Index mit der Funktion indexOf() finden.
Wir können den String mit der Funktion substring() aufteilen. Angenommen, wir möchten alle Zeilen separat in einer bestimmten Zeichenfolge erhalten. Wir müssen eine Zeile erhalten, die verbleibende Zeichenfolge in einer Variablen speichern und dieselbe Operation erneut mit einer Schleife ausführen, bis alle Zeilen extrahiert wurden.
