Parsen einer Zeichenkette in Arduino

1. Parsen eines Strings mit der Funktion strtok() in Arduino
2. Parsen einer Zeichenkette mit der Funktion “substring()” in Arduino

In diesem Tutorial wird das Parsen eines Strings mit den Funktionen strtok() und substring() in Arduino besprochen.

Parsen eines Strings mit der Funktion strtok() in Arduino

Ein String kann in Arduino Zeichen, Zahlen und Symbole enthalten. Wir können die Funktion strtok() in Arduino verwenden, um einen String zu trennen oder zu parsen.

Wenn wir beispielsweise eine Zeichenfolge mit durch Komma getrennten Teilzeichenfolgen haben, möchten wir jede Teilzeichenfolge mit dem Komma trennen und jede Teilzeichenfolge als separate Zeichenfolge oder Zeichen-Array speichern.

Syntax:

char *s = strtok(char *MyS, char *MyD);

Im obigen Code ist MyS eine konstante Zeichenvariable, die die Zeichenfolge enthält, die wir analysieren möchten, und MyD ist ebenfalls eine konstante Zeichenvariable, die das Trennzeichen, Zeichen oder Symbol enthält, das wir zum Analysieren verwenden angegebene Zeichenfolge. Die Funktion strtok() gibt den ersten Token oder das Array von Zeichen vor dem angegebenen Trennzeichen zurück.

Wir müssen NULL anstelle des angegebenen Strings übergeben, um das zweite String-Token zu erhalten, da der angegebene String ohne das erste Token in der Funktion strtok() gespeichert wird.

Lassen Sie uns beispielsweise eine Zeichenfolge definieren und diese mit dem Trennzeichen und der Funktion strtok() trennen.

char *MyS = "this is-delftstack.com-website";
char *MyD = "-";
void setup() {
  Serial.begin(9600);

  char *s = strtok(MyS, MyD);
  Serial.println(s);
  char *s1 = strtok(NULL, MyD);
  Serial.println(s1);
  char *s2 = strtok(NULL, MyD);
  Serial.println(s2);
}
void loop() {}

Ausgang:

this is
delftstack.com
website

Im obigen Code haben wir die Funktion strtok() dreimal verwendet, um alle drei Tokens in der angegebenen Zeichenfolge zu erhalten, und jedes Zeichenfolgen-Token wird in einem Zeichenarray gespeichert. Wir können auch eine Schleife verwenden, um alle verfügbaren Token in der angegebenen Zeichenfolge abzurufen, sodass wir den Code nicht wiederholt schreiben müssen.

Wir haben den Code in die Funktion setup() geschrieben, die nur einmal ausgeführt wird, wenn wir das Arduino-Board mit Strom versorgen, aber im Falle einer großen Zeichenfolge können wir den Code in die Funktion loop() schreiben, um sich selbst zu wiederholen. Wir erhalten das erste Token in der Funktion setup() und prüfen, ob das nächste Token in der Funktion loop() verfügbar ist.

Wenn verfügbar, speichern wir es in einem Array und wiederholen den Vorgang, bis keine Zeichenfolgen mehr in der angegebenen Zeichenfolge übrig sind.

Lassen Sie uns zum Beispiel die obige Zeichenfolge verwenden und alle verfügbaren Zeichenfolgen-Token finden, die dasselbe Trennzeichen oben verwenden.

char *MyS = "this is-delftstack.com-website-Welcome";
char *MyD = "-";
char *MyArray[10];
int i = 1;
void setup() {
  Serial.begin(9600);

  char *s = strtok(MyS, MyD);
  Serial.println(s);
  MyArray[0] = s;
}
void loop() {
  char *s1 = strtok(NULL, MyD);
  if (s1 != NULL) {
    MyArray[i] = s1;
    Serial.println(MyArray[i]);
    i = i + 1;
  }
}

Ausgang:

this is
delftstack.com
website
Welcome

Im obigen Code haben wir das Array mit der Größe 10 initialisiert, das zum Speichern der String-Token verwendet wird. Wir können es gemäß den in der angegebenen Zeichenfolge vorhandenen Zeichenfolgen-Token initialisieren.

Wir haben auch den Index initialisiert, der zum Speichern von Werten im Array verwendet wird. Wir werden es innerhalb der Funktion loop() inkrementieren.

Wir haben eine if-Anweisung verwendet, um zu prüfen, ob das Zeichenfolgen-Token NULL ist oder nicht. Wenn es nicht NULL ist, speichern wir es im Array und erhöhen den Index.

Beachten Sie, dass die Schleife wiederholt werden muss, um das nächste Zeichenketten-Token zu finden. Wir können eine Schleife in die Funktion setup() einfügen, wenn wir alle Token vor der Funktion loop() erhalten möchten.

Wir werden alle String-Token im Array gespeichert haben, bevor wir zur Funktion loop() wechseln. Das Trennzeichen kann ein beliebiges Zeichen, Symbol oder eine Zahl sein, die in der angegebenen Zeichenfolge vorhanden ist, und wir können auch Leerzeichen als Trennzeichen verwenden.

Parsen einer Zeichenkette mit der Funktion “substring()” in Arduino

Wir können auch die Funktion substring() in Arduino verwenden, um einen String zu trennen oder zu parsen. Entsprechend den gegebenen Indexwerten trennt der substring() einen Teilstring vom gegebenen String.

Wenn wir beispielsweise die ersten fünf Zeichen aus einem String erhalten möchten, können wir die Funktion substring() und den Indexwert 5 verwenden.

Syntax:

String s = MyS.substring(SIndex, EIndex);

Im obigen Code ist s die Zeichenfolgenvariable, die zum Speichern der Ausgabe der Funktion substring() verwendet wird, und MyS ist die angegebene Zeichenfolge mit einem Zeichenfolgendatentyp. Der SIndex ist der Startindex und EIndex der Endindex für den Teilstring.

Lassen Sie uns zum Beispiel einen String erstellen und seinen Teilstring im Index 0 bis 5 finden.

String MyS = "this is delftstack.com website Welcome";

void setup() {
  Serial.begin(9600);
  String s = MyS.substring(0, 5);
  Serial.println(s);
}
void loop() {}

Ausgang:

this

Im obigen Code haben wir den seriellen Monitor von Arduino verwendet, um das Ergebnis anzuzeigen. Wie Sie der Ausgabe entnehmen können, werden die ersten fünf Zeichen oder Indizes im Fenster des seriellen Monitors angezeigt.

Wir können nur vier Zeichen in der Ausgabe sehen, weil das fünfte Zeichen das Leerzeichen ist. Wenn wir den Index eines Zeichens nicht kennen, können wir die Funktion indexOf() verwenden, um den Index dieses Zeichens zu erhalten.

Syntax der Funktion indexOf():

int MyI = MyS.indexOf(char);

Im obigen Code speichert die Variable MyI die Ausgabe, die der Index des angegebenen Zeichens ist, und char ist das Zeichen, dessen Index wir finden möchten. MyS ist die String-Variable, die den gegebenen String enthält.

Zum Beispiel haben wir eine Reihe von Wörtern, die durch ein Leerzeichen getrennt sind, und wir möchten das erste Wort aus der Zeichenfolge erhalten. Wir können die Funktion indexOf() verwenden, um den Index des Leerzeichens zu finden, und diesen Index dann innerhalb der Funktion substring() übergeben, um das erste Wort zu erhalten.

String MyS = "this is delftstack.com website Welcome";

void setup() {
  Serial.begin(9600);
  int MyI = MyS.indexOf(" ");
  String s = MyS.substring(0, MyI);
  Serial.println(s);
}
void loop() {}

Ausgang:

this

Wie Sie in der obigen Ausgabe sehen können, haben wir das erste Wort aus der angegebenen Zeichenfolge extrahiert. Wenn wir die ganze Welt aus der gegebenen Zeichenfolge bekommen wollen, müssen wir eine Schleife verwenden.

Wir können auch ein zweites Argument innerhalb der Funktion indexOf() übergeben, um die Startposition festzulegen, die verwendet wird, um nach dem Index des angegebenen Zeichens zu suchen.

Wenn wir beispielsweise im obigen Beispiel die ersten beiden Wörter der Zeichenfolge erhalten möchten, können wir den Startindexwert auf 5 setzen, und die Funktion gibt den Indexwert des zweiten Trennzeichens zurück, das wir verwenden können um die ersten beiden Wörter zu extrahieren.

Wir haben den Code innerhalb der Funktion setup() im obigen Code geschrieben, der nur einmal ausgeführt wird. Aber wenn wir den Code innerhalb der Funktion loop() geschrieben haben, wiederholt sich der Code.

Wir können den Code in die Funktion loop() schreiben, um alle Teilzeichenfolgen zu finden, die in der angegebenen Zeichenfolge vorhanden sind.

Lassen Sie uns zum Beispiel alle Teilzeichenfolgen finden, die in der obigen Zeichenfolge vorhanden sind.

String MyS = "this is delftstack.com website Welcome";
int MyP = 0;
int MyI = 0;
String array[10];
int index = 0;
void setup() { Serial.begin(9600); }
void loop() {
  if (MyI >= 0) {
    MyI = MyS.indexOf(" ", MyP);
    String s = MyS.substring(MyP, MyI);
    Serial.println(s);
    MyP = MyI + 1;
    array[index] = s;
    Serial.println(array[index]);
    index = index + 1;
  }
}

Ausgang:

this
is
delftstack.com
website
Welcome

Im obigen Code haben wir den Indexwert des angegebenen Trennzeichens innerhalb der if-Anweisung verwendet, um zu prüfen, ob das Ende der angegebenen Zeichenfolge erreicht ist, da die indexOf()-Funktion einen negativen Wert zurückgibt, wenn der Index, den wir übergeben haben innerhalb der Funktion indexOf() überschreitet die Länge des angegebenen Strings.

Wir haben zwei Integer-Variablen MyP und MyI initialisiert, die für vorherige und aktuelle Indexwerte verwendet werden.

Wir werden den MyP oder vorherigen Indexwert verwenden, um den MyI oder nächsten Indexwert zu erhalten, und dann werden wir diese Werte verwenden, um die Teilzeichenfolge zu finden. Danach ändern wir den Wert des MyP oder vorherigen Index auf den aktuellen Index plus eins, damit sich die Schleife beim nächsten Mal wiederholt; Wir werden das nächste Wort bekommen.

Wir haben auch ein String-Array der Größe 10 initialisiert, um die Teilstrings gemäß dem Indexwert zu speichern. Wir werden den Index in der if-Anweisung erhöhen, um den nächsten Teilstring im nächsten Indexwert zu speichern.

Beachten Sie, dass sich die Schleife wiederholen muss, um alle in der angegebenen Zeichenfolge vorhandenen Teilzeichenfolgen zu erhalten. Wir können eine Schleife innerhalb der Funktion setup () verwenden, wenn wir die Teilstrings erhalten möchten, bevor wir die Funktion loop() starten.

Wir haben in den obigen Beispielen Leerzeichen als Trennzeichen verwendet, aber wir können jedes Zeichen, Symbol und jede Zahl verwenden, um die angegebene Zeichenfolge zu analysieren. Die Funktionen indexOf() und substring() gehören zur String-Klasse von Arduino und für weitere Details über die String-Klasse siehe diesen Link.