Zusammenfassung der mit dem Abfangen von MySQL-Zeichenfolgen verbundenen Funktionen

In diesem Artikel werden MySQL-Funktionen zum Abfangen von Zeichenfolgen vorgestellt. Der spezifische Inhalt ist wie folgt:

Bei der Arbeit müssen Sie möglicherweise bestimmte Felder mit einem bestimmten Trennzeichen als Feldwert zu einer Zeichenfolge zusammenfassen und in einer Datenbanktabelle speichern. Beispielsweise entspricht eine Aufgabe drei Ergebnissen, die in unterschiedlichen Datentabellen gespeichert sind. In diesem Fall können die Primärschlüssel dieser drei unterschiedlichen Tabellen in der vereinbarten Reihenfolge kombiniert werden (Primärschlüssel a: Primärschlüssel b: Primärschlüssel c). Wenn Sie die detaillierten Informationen der entsprechenden Aufgabenkategorien separat prüfen müssen, können Sie die Zeichenfolge (Primärschlüssel b) an einer bestimmten Position abfangen und für den Vorgang Tabelle b verbinden. Ich bin erst kürzlich zufällig auf diesen Vorgang gestoßen und habe mir deshalb die zugehörigen Funktionen zum Abfangen von MySQL-Zeichenfolgen für eine spätere Überprüfung herausgesucht.

1. links (Str, Länge)

Gibt len ​​Zeichen links vom String str zurück. Wenn eines der Argumente NULL ist, wird NULL zurückgegeben.

mysql> wähle links('shinejaie', 5);
+---------------------------------------------------------+
| links('shinejaie', 5) |
+---------------------------------------------------------+
| scheinen |
+---------------------------------------------------------+
1 Zeile im Satz (0,00 Sek.)

2. rechts (Str, Länge)

Gibt die letzten len Zeichen von rechts von str zurück. Wenn eines der Argumente NULL ist, wird NULL zurückgegeben.

mysql> wähle rechts('shinejaie', 4);
+---------------------------------------------------------+
| rechts('shinejaie', 4) |
+---------------------------------------------------------+
| jaie |
+---------------------------------------------------------+
1 Zeile im Satz (0,00 Sek.)

3. Teilstring_index(str, delim, Anzahl)

Gibt die Teilzeichenfolge von str vor dem Anzahl-Vorkommen des Trennzeichens delim zurück. Wenn die Anzahl positiv ist, wird alles links vom letzten Trennzeichen (weil von links gezählt wird) als Teilzeichenfolge zurückgegeben. Wenn die Anzahl negativ ist, wird alles rechts vom letzten Trennzeichen (weil von rechts gezählt wird) als Teilzeichenfolge zurückgegeben. Bei der Suche nach Trennzeichen berücksichtigt die Funktion die Groß- und Kleinschreibung. Wenn der durch den Parameter delim angegebene Wert nicht in der Zeichenfolge str gefunden wird, wird die gesamte Zeichenfolge zurückgegeben.

mysql> wähle Teilstring_index('home.cnblogs.com', '.', 2);
+---------------------------------------------------------+
| Teilstring_index('home.cnblogs.com', '.', 2) |
+---------------------------------------------------------+
| home.cnblogs |
+---------------------------------------------------------+
1 Zeile im Satz (0,00 Sek.)
mysql> wähle Teilstring_index('home.cnblogs.com', '/', 2);
+---------------------------------------------------------+
| Teilstring_index('home.cnblogs.com', '/', 2) |
+---------------------------------------------------------+
| home.cnblogs.com |
+---------------------------------------------------------+
1 Zeile im Satz (0,00 Sek.)

4. substring() und substr() ---> substring(str, pos), substring(str von pos), substring(str, pos, len), substring(str von pos für len)

In den oben genannten vier Funktionsvarianten gibt die Funktionsform ohne den Parameter len die Teilzeichenfolge nach der Position pos in str zurück; die Funktionsform mit dem Parameter len gibt die Teilzeichenfolge nach der Position pos in str mit einer Länge von len zurück. Die Funktionsform von FROM verwendet die Standard-SQL-Syntax. Der Parameter pos kann auch einen negativen Wert annehmen. In diesem Fall wird der String vom Ende des Strings str vorwärts (und nicht von vorne nach hinten) abgerufen, beginnend an der Position pos in umgekehrter Reihenfolge. Darüber hinaus kann ein negativer pos-Parameter mit jeder Form der substring()-Funktion verwendet werden.

mysql> wähle Teilzeichenfolge('shinejaie', 6);
+---------------------------------------------------------+
| Teilzeichenfolge('shinejaie',6) |
+---------------------------------------------------------+
| jaie |
+---------------------------------------------------------+
1 Zeile im Satz (0,00 Sek.)
mysql> wähle substr('shinejaie' aus 6);
+---------------------------------------------------------+
| substr('shinejaie' von 6) |
+---------------------------------------------------------+
| jaie |
+---------------------------------------------------------+
1 Zeile im Satz (0,00 Sek.)
mysql> Teilzeichenfolge auswählen('shinejaie', -9, 5);
+---------------------------------------------------------+
| Teilzeichenfolge('shinejaie', -9, 5) |
+---------------------------------------------------------+
| scheinen |
+---------------------------------------------------------+
1 Zeile im Satz (0,00 Sek.)

5. trim([{beide | führende | nachfolgende} [remstr] form] str)

Entfernt das durch remstr angegebene Präfix oder Suffix aus der Zeichenfolge str und gibt die resultierende Zeichenfolge zurück. Wenn die Bezeichner „beide“, „führend“ oder „nachlaufend“ nicht angegeben sind, ist der Standardwert „beide“, was bedeutet, dass sowohl das Präfix als auch das Suffix entfernt werden. remstr ist eigentlich ein optionaler Parameter. Wenn er nicht angegeben wird, werden Leerzeichen gelöscht.

mysql> wähle trim('shinejaie');
+---------------------------------------------------------+
| trim('shinejaie') |
+---------------------------------------------------------+
| Glanzjaie |
+---------------------------------------------------------+
1 Zeile im Satz (0,00 Sek.)
mysql> wähle trimmen (führendes „cn_“ von „cn_shinejaiecn_“);
+---------------------------------------------------------+
| trimmen(führendes „cn_“ von „cn_shinejaiecn_“) |
+---------------------------------------------------------+
| shinejaiecn_ |
+---------------------------------------------------------+
1 Zeile im Satz (0,00 Sek.)
mysql> wähle trim(beide ‚cn_‘ aus ‚cn_shinejaiecn_‘);
+---------------------------------------------------------+
| trimmen(beide 'cn_' von 'cn_shinejaiecn_') |
+---------------------------------------------------------+
| Glanzjaie |
+---------------------------------------------------------+
1 Zeile im Satz (0,00 Sek.)
mysql> wähle trim(nachgestelltes „cn_“ von „cn_shinejaiecn_“);
+---------------------------------------------------------+
| trimmen (nachgestelltes „cn_“ von „cn_shinejaiecn_“) |
+---------------------------------------------------------+
| cn_shinejaie |
+---------------------------------------------------------+
1 Zeile im Satz (0,00 Sek.)

Zusammenfassen

Oben finden Sie eine Zusammenfassung der vom Herausgeber eingeführten Funktionen zum Abfangen von MySQL-Zeichenfolgen. Ich hoffe, dass sie für alle hilfreich sein werden. Wenn Sie Fragen haben, hinterlassen Sie mir bitte eine Nachricht und der Herausgeber wird Ihnen rechtzeitig antworten. Ich möchte auch allen für ihre Unterstützung der Website 123WORDPRESS.COM danken!