PHP programmieren, 4. Auflage

Kapitel 4. Strings

Diese Arbeit wurde mithilfe von KI übersetzt. Wir freuen uns über dein Feedback und deine Kommentare: [e-mail]

Die meisten Daten, auf die du beim Programmieren stößt, sind Zeichenfolgen, sogenannte Strings. Strings können Namen, Passwörter, Adressen, Kreditkartennummern, Links zu Fotos, Einkaufshistorien und vieles mehr enthalten. Aus diesem Grund hat PHP eine große Auswahl an Funktionen für die Arbeit mit Strings.

Dieses Kapitel zeigt dir, wie du Strings in deinen Programmen erstellen kannst. Dazu gehört auch das manchmal knifflige Thema der Interpolation (das Einfügen des Wertes einer Variablen in einen String) und die Funktionen zum Ändern, Zitieren, Manipulieren und Suchen von Strings. Am Ende dieses Kapitels wirst du ein Experte im Umgang mit Strings sein.

String-Konstanten zitieren

Es gibt vier Möglichkeiten, ein String-Literal in deinem PHP-Code zu schreiben: mit einfachen Anführungszeichen, mit doppelten Anführungszeichen, mit dem von der Unix-Shell abgeleiteten Format here document(heredoc) und mit seinem "Cousin" now document(nowdoc). Diese Methoden unterscheiden sich darin, ob sie spezielle Escape-Sequenzen erkennen, mit denen du andere Zeichen kodieren oder Variablen interpolieren kannst.

Variable Interpolation

Wenn du ein String-Literal mit doppelten Anführungszeichen oder einem Heredoc definierst, wird der String einer Variableninterpolation unterzogen. Bei der Interpolation werden die Variablennamen in der Zeichenkette durch die enthaltenen Werte ersetzt. Es gibt zwei Möglichkeiten, Variablen in Strings zu interpolieren.

Die einfachere der beiden Möglichkeiten ist, den Variablennamen in eine Zeichenkette mit doppelten Anführungszeichen oder in eine heredoc zu setzen:

$who = 'Kilroy';
$where = 'here';
echo "$who was $where";
Kilroy was here

Die andere Möglichkeit ist, die Variable, die interpoliert werden soll, mit geschweiften Klammern zu umgeben. Mit dieser Syntax wird sichergestellt, dass die richtige Variable interpoliert wird. Klassischerweise werden geschweifte Klammern verwendet, um den Variablennamen vom umgebenden Text zu trennen:

$n = 12;
echo "You are the {$n}th person";
You are the 12th person

Ohne die geschweiften Klammern würde PHP versuchen, den Wert der Variable $nth zu drucken.

Anders als in einigen Shell-Umgebungen werden Strings in PHP nicht wiederholt für die Interpolation verarbeitet. Stattdessen werden alle Interpolationen in einem String mit doppelten Anführungszeichen zuerst verarbeitet und das Ergebnis wird als Wert des Strings verwendet:

$bar = 'this is not printed';
$foo = '$bar'; // single quotes
print("$foo");
$bar

Einquotierte Strings

Strings in einfachen Anführungszeichen und nowdocs interpolieren keine Variablen. So wird der Variablenname in der folgenden Zeichenkette nicht erweitert, weil das Stringliteral, in dem er vorkommt, in einfachen Anführungszeichen steht:

$name = 'Fred';
$str = 'Hello, $name'; // single-quoted
echo $str;
Hello, $name

Die einzigen Escape-Sequenzen, die in Strings mit einfachen Anführungszeichen funktionieren, sind \', das ein einfaches Anführungszeichen in einen String mit einfachen Anführungszeichen setzt, und \\, das einen Backslash in einen String mit einfachen Anführungszeichen setzt. Jedes andere Vorkommen eines Backslashs wird einfach als Backslash interpretiert :

$name = 'Tim O\'Reilly';// escaped single quote
echo $name;
$path = 'C:\\WINDOWS'; // escaped backslash
echo $path;
$nope = '\n'; // not an escape
echo $nope;
Tim O'Reilly
C:\WINDOWS
\n

Doppelquotierte Saiten

Strings in doppelten Anführungszeichen interpolieren Variablen und erweitern die vielen PHP-Escape-Sequenzen. Tabelle 4-1 listet die Escape-Sequenzen auf, die PHP in Strings mit doppelten Anführungszeichen erkennt.

Tabelle 4-1. Escape-Sequenzen in Zeichenketten mit doppelten Anführungszeichen

Escape-Sequenz	Dargestelltes Zeichen
\"	Doppelte Anführungszeichen
\n	Newline
\r	Wagenrücklauf
\t	Registerkarte
\\	Backslash
\$	Dollarzeichen
\{	Linke geschweifte Klammer
\}	Rechte geschweifte Klammer
\[	Linke eckige Klammer
\]	Rechte eckige Klammer
\0 über \777	ASCII-Zeichen, das durch einen Oktalwert dargestellt wird
\x0 über \xFF	ASCII-Zeichen, dargestellt durch den Hex-Wert
\u	UTF-8 Kodierung

Wenn eine unbekannte Escape-Sequenz (d.h. ein Backslash gefolgt von einem Zeichen, das nicht zu den in Tabelle 4-1 aufgeführten Zeichen gehört) in einem String-Literal mit doppelten Anführungszeichen gefunden wird, wird sie ignoriert (wenn du die Warnstufe E_NOTICE eingestellt hast, wird bei solchen unbekannten Escape-Sequenzen eine Warnung ausgegeben):

$str = "What is \c this?";// unknown escape sequence
echo $str;
What is \c this?

Hier Dokumente

Du kannst mehrzeilige Strings ganz einfach mit einem heredoc in dein Programm einfügen, wie folgt:

$clerihew = <<< EndOfQuote
Sir Humphrey Davy
Abominated gravy.
He lived in the odium
Of having discovered sodium.

EndOfQuote;
echo $clerihew;
Sir Humphrey Davy
Abominated gravy.
He lived in the odium
Of having discovered sodium.

Das <<< Bezeichner-Token teilt dem PHP-Parser mit, dass du einen Heredoc schreibst. Du wählst den Bezeichner aus (in diesem FallEndOfQuote ) und kannst ihn in Anführungszeichen setzen, wenn du möchtest (z. B. "EndOfQuote"). In der nächsten Zeile beginnt der Text, der vom Heredoc zitiert wird, bis er eine Zeile erreicht, die nur den Bezeichner enthält. Um sicherzustellen, dass der zitierte Text im Ausgabebereich genau so angezeigt wird, wie du ihn angelegt hast, aktiviere den Klartextmodus, indem du diesen Befehl am Anfang deiner Codedatei hinzufügst:

header('Content-Type: text/plain;');

Wenn du die Kontrolle über deine Servereinstellungen hast, kannst du alternativ default_mimetype in der php.ini-Datei auf plain setzen:

default_mimetype = "text/plain"

Dies ist jedoch nicht empfehlenswert, da die gesamte Ausgabe vom Server im Klartextmodus erfolgt, was sich auf das Layout der meisten deiner Webcodes auswirken würde.

Wenn du den Klartextmodus für dein Heredoc nicht einstellst, ist die Standardeinstellung normalerweise der HTML-Modus, der die Ausgabe einfach in einer Zeile anzeigt.

Wenn du eine Heredoc für einen einfachen Ausdruck verwendest, kannst du ein Semikolon nach dem abschließenden Bezeichner setzen, um die Anweisung zu beenden (wie im ersten Beispiel gezeigt). Wenn du eine heredoc in einem komplexeren Ausdruck verwendest, musst du den Ausdruck jedoch in der nächsten Zeile fortsetzen, wie hier gezeigt:

printf(<<< Template
%s is %d years old.
Template
, "Fred", 35);

Einfache und doppelte Anführungszeichen in einem Heredoc werden beibehalten:

$dialogue = <<< NoMore
"It's not going to happen!" she fumed.
He raised an eyebrow. "Want to bet?"
NoMore;
echo $dialogue;
"It's not going to happen!" she fumed.
He raised an eyebrow. "Want to bet?"

Das gilt auch für Leerzeichen:

$ws = <<< Enough
 boo
 hoo
Enough;
// $ws = " boo\n hoo";

Neu in PHP 7.3 ist die Einrückung des heredoc-Terminators. Dies ermöglicht eine besser lesbare Formatierung bei eingebettetem Code, wie in der folgenden Funktion:

function sayIt() {
 $ws = <<< "StufftoSay"
 The quick brown fox
 Jumps over the lazy dog.
 StufftoSay;
return $ws;
}

echo sayIt() ;

    The quick brown fox
    Jumps over the lazy dog.

Der Zeilenumbruch vor dem abschließenden Terminator wird entfernt, sodass diese beiden Zuweisungen identisch sind:

$s = 'Foo';
// same as
$s = <<< EndOfPointlessHeredoc
Foo
EndOfPointlessHeredoc;

Wenn du einen Zeilenumbruch am Ende deines Strings mit Heredoc-Zeichen haben willst, musst du ihn selbst hinzufügen:

$s = <<< End
Foo

End;

Zeichenketten drucken

Es gibt vier Möglichkeiten, die Ausgabe an den Browser zu senden. Mit dem echo Konstrukt kannst du viele Werte auf einmal ausgeben, während print() nur einen Wert ausgibt. Die Funktion printf() erstellt eine formatierte Zeichenkette, indem sie Werte in eine Vorlage einfügt. Die Funktion print_r() ist nützlich für die Fehlersuche; sie gibt den Inhalt von Arrays, Objekten und anderen Dingen in einer mehr oder weniger gut lesbaren Form aus.

echo

Um eine Zeichenkette in den HTML-Code einer von PHP erzeugten Seite einzufügen, verwendest du echo . Obwohl echo wie eine Funktion aussieht und sich auch größtenteils so verhält, ist es ein Sprachkonstrukt. Das bedeutet, dass du die Klammern weglassen kannst, sodass die folgenden Ausdrücke gleichwertig sind:

echo "Printy";
echo("Printy"); // also valid

Du kannst mehrere zu druckende Artikel angeben, indem du sie mit Kommas trennst:

echo "First", "second", "third";
Firstsecondthird

Es ist ein Parse-Fehler, Klammern zu verwenden, wenn du versuchst, mehrere Werte auszugeben:

// this is a parse error
echo("Hello", "world");

Da echo keine echte Funktion ist, kannst du sie nicht als Teil eines größeren Ausdrucks verwenden:

// parse error
if (echo("test")) {
 echo("It worked!");
}

Du kannst solche Fehler leicht beheben, indem du die Funktionen print() oder printf() verwendest.

drucken()

Die Funktion print() sendet einen Wert (ihr Argument) an den Browser:

if (print("test\n")) {
 print("It worked!");
}
test
It worked!

printf()

Die Funktion printf() gibt eine Zeichenkette aus, die durch das Ersetzen von Werten in einer Vorlage (dem Format-String) erstellt wurde. Sie ist von der gleichnamigen Funktion in der Standard-C-Bibliothek abgeleitet. Das erste Argument von printf() ist die Formatzeichenkette . Die übrigen Argumente sind die Werte, die ersetzt werden sollen. Ein % Zeichen in der Formatzeichenkette zeigt eine Ersetzung an.

Formatmodifikatoren

Jede Ersetzungsmarkierung in der Vorlage besteht aus einem Prozentzeichen (%), möglicherweise gefolgt von Modifikatoren aus der folgenden Liste, und endet mit einer Typangabe. (Verwende %%, um ein einzelnes Prozentzeichen in der Ausgabe zu erhalten.) Die Modifikatoren müssen in der Reihenfolge erscheinen, in der sie hier aufgeführt sind:

1. Ein Padding-Spezifizierer, der das Zeichen angibt, mit dem die Ergebnisse auf die entsprechende Stringgröße aufgefüllt werden sollen. Gib 0, ein Leerzeichen oder ein beliebiges Zeichen mit vorangestelltem einfachen Anführungszeichen an. Die Standardeinstellung ist das Auffüllen mit Leerzeichen.

2. Ein Zeichen. Dies hat bei Zeichenketten eine andere Wirkung als bei Zahlen. Bei Zeichenketten erzwingt ein Minus (–) hier, dass die Zeichenkette linksbündig ausgerichtet wird (die Standardeinstellung ist rechtsbündig). Bei Zahlen bewirkt ein Plus (+), dass positive Zahlen mit einem vorangestellten Pluszeichen gedruckt werden (z. B. wird 35 als +35 gedruckt).

3. Die Mindestanzahl von Zeichen, die dieses Element enthalten soll. Wenn das Ergebnis weniger als diese Anzahl von Zeichen enthält, bestimmen das Vorzeichen und der Padding-Spezifizierer, wie auf diese Länge aufgefüllt werden soll.

4. Bei Fließkommazahlen eine Präzisionsangabe, die aus einem Punkt und einer Zahl besteht; damit wird festgelegt, wie viele Nachkommastellen angezeigt werden. Bei anderen Typen als double wird diese Angabe ignoriert.

Typenbezeichner

Der Type Specifier sagt printf(), welche Art von Daten ersetzt wird. Dies bestimmt die Interpretation der zuvor aufgeführten Modifikatoren. Es gibt acht Typen, die in Tabelle 4-2 aufgeführt sind.

Tabelle 4-2. printf()-Typspezifizierer

Spezifizierer	Bedeutung
%	Zeigt das Prozentzeichen an.
b	Das Argument ist eine ganze Zahl und wird als Binärzahl angezeigt.
c	Das Argument ist eine ganze Zahl und wird als das Zeichen mit diesem Wert angezeigt.
d	Das Argument ist eine ganze Zahl und wird als Dezimalzahl angezeigt.
e	Das Argument ist ein Double und wird in wissenschaftlicher Notation angezeigt.
E	Das Argument ist ein Double und wird in wissenschaftlicher Notation mit Großbuchstaben dargestellt.
f	Das Argument ist eine Gleitkommazahl und wird als solche im Format des aktuellen Gebietsschemas angezeigt.
F	Das Argument ist eine Gleitkommazahl und wird als solche angezeigt.
g	Das Argument ist ein Double und wird entweder in wissenschaftlicher Notation (wie bei der Typangabe %e ) oder als Gleitkommazahl (wie bei der Typangabe %f ) angezeigt, je nachdem, was kürzer ist.
G	Das Argument ist ein Double und wird entweder in wissenschaftlicher Notation (wie bei der Typangabe %E ) oder als Gleitkommazahl (wie bei der Typangabe %f ) angezeigt, je nachdem, was kürzer ist.
o	Das Argument ist eine Ganzzahl und wird als Oktalzahl (Basis 8) angezeigt.
s	Das Argument ist eine Zeichenkette und wird als solche angezeigt.
u	Das Argument ist eine Ganzzahl ohne Vorzeichen und wird als Dezimalzahl angezeigt.
x	Das Argument ist eine Ganzzahl und wird als Hexadezimalzahl (Basis 16) angezeigt; es werden Kleinbuchstaben verwendet.
X	Das Argument ist eine ganze Zahl und wird als Hexadezimalzahl (Basis 16) angezeigt; es werden Großbuchstaben verwendet.

Die Funktion printf() sieht für Menschen, die keine C-Programmierer sind, unverschämt komplex aus. Wenn du dich aber erst einmal an sie gewöhnt hast, wirst du feststellen, dass sie ein mächtiges Formatierungswerkzeug ist. Hier sind einige Beispiele:

• Eine Gleitkommazahl mit zwei Nachkommastellen:

  printf('%.2f', 27.452);
  27.45

• Dezimale und hexadezimale Ausgabe:

  printf('The hex value of %d is %x', 214, 214);
  The hex value of 214 is d6

• Auffüllen einer Ganzzahl auf drei Nachkommastellen:

  printf('Bond. James Bond. %03d.', 7);
  Bond. James Bond. 007.

• Formatieren eines Datums:

  printf('%02d/%02d/%04d', $month, $day, $year);
  02/15/2005

• Ein Prozentsatz:

  printf('%.2f%% Complete', 2.1);
  2.10% Complete

• Auffüllen einer Fließkommazahl:

  printf('You\'ve spent $%5.2f so far', 4.1);
  You've spent $ 4.10 so far

Die Funktion sprintf() nimmt die gleichen Argumente wie printf(), gibt aber die aufgebaute Zeichenkette zurück, anstatt sie zu drucken. So kannst du die Zeichenkette zur späteren Verwendung in einer Variablen speichern:

$date = sprintf("%02d/%02d/%04d", $month, $day, $year);
// now we can interpolate $date wherever we need a date

print_r() und var_dump()

Die Funktion print_r() zeigt auf intelligente Weise an, was ihr übergeben wird, anstatt alles in eine Zeichenkette zu verwandeln, wie echo und print() es tun. Zeichenketten und Zahlen werden einfach ausgedruckt. Arrays erscheinen als eingeklammerte Listen von Schlüsseln und Werten, denen Array vorangestellt ist:

$a = array('name' => 'Fred', 'age' => 35, 'wife' => 'Wilma');
print_r($a);
Array
(
 [name] => Fred
 [age] => 35
 [wife] => Wilma)

Wenn du print_r() für ein Array verwendest, wird der interne Iterator an die Position des letzten Elements im Array verschoben. In Kapitel 5 findest du mehr über Iteratoren und Arrays.

Wenn du ein Objekt print_r() aufrufst, siehst du das Wort Object, gefolgt von den initialisierten Eigenschaften des Objekts, die als Array angezeigt werden:

class P {
 var $name = 'nat';
 // ...
}

$p = new P;
print_r($p);
Object
(
 [name] => nat)

Boolesche Werte und NULL werden von print_r() nicht sinnvoll angezeigt:

print_r(true); // prints "1";
1
print_r(false); // prints "";

print_r(null); // prints "";

Aus diesem Grund wird var_dump() der Funktion print_r() zum Debuggen vorgezogen. Die Funktion var_dump() zeigt jeden PHP-Wert in einem für Menschen lesbaren Format an:

var_dump(true);
var_dump(false);
var_dump(null);
var_dump(array('name' => "Fred", 'age' => 35));
class P {
 var $name = 'Nat';
 // ...
}
$p = new P;
var_dump($p);
bool(true)
bool(false)
bool(null)
array(2) {
 ["name"]=>
 string(4) "Fred"
 ["age"]=>
 int(35)
}
object(p)(1) {
 ["name"]=>
 string(3) "Nat"
}

Hüte dich davor, print_r() oder var_dump() auf eine rekursive Struktur wie $GLOBALS anzuwenden (die einen Eintrag für GLOBALS hat, der auf sich selbst zurückverweist). Die Funktion print_r() führt eine Endlosschleife aus, während var_dump() nach dreimaligem Besuch desselben Elements abbricht.

Zugriff auf einzelne Zeichen

Die Funktion strlen() gibt die Anzahl der Zeichen in einer Zeichenkette zurück:

$string = 'Hello, world';
$length = strlen($string); // $length is 12

Du kannst die String-Offset-Syntax auf einen String anwenden, um einzelne Zeichen anzusprechen:

$string = 'Hello';
for ($i=0; $i < strlen($string); $i++) {
 printf("The %dth character is %s\n", $i, $string{$i});
}
The 0th character is H
The 1th character is e
The 2th character is l
The 3th character is l
The 4th character is o

Saiten reinigen

Oft müssen die Zeichenketten, die wir von Dateien oder Benutzern erhalten, bereinigt werden, bevor wir sie verwenden können. Zwei häufige Probleme mit Rohdaten sind das Vorhandensein von Leerzeichen und die falsche Großschreibung (Groß- und Kleinschreibung).

Whitespace entfernen

Mit den Funktionen trim() , ltrim() , und rtrim() kannst du führende oder nachgestellte Leerzeichen entfernen:

$trimmed = trim(string [, charlist ]);
$trimmed = ltrim(string [, charlist ]);
$trimmed = rtrim(string [, charlist ]);

trim() gibt eine Kopie von string zurück, bei der Leerzeichen am Anfang und am Ende entfernt wurden. ltrim() ( l steht für left) macht dasselbe, entfernt aber nur die Leerzeichen am Anfang des Strings. rtrim() (das r steht für rechts) entfernt nur die Leerzeichen am Ende der Zeichenkette. Das optionale Argument charlist ist eine Zeichenkette, die alle zu entfernenden Zeichen angibt. Die Standardzeichen, die entfernt werden sollen, sind in Tabelle 4-3 aufgeführt.

Tabelle 4-3. Standardzeichen, die von trim(), ltrim() und rtrim() entfernt werden

Charakter	ASCII-Wert	Bedeutung
" "	0x20	Raum
"\t"	0x09	Registerkarte
"\n"	0x0A	Newline (Zeilenvorschub)
"\r"	0x0D	Wagenrücklauf
"\0"	0x00	NUL-Byte
"\x0B"	0x0B	Vertikale Registerkarte

Zum Beispiel:

$title = " Programming PHP \n";
$str1 = ltrim($title); // $str1 is "Programming PHP \n"
$str2 = rtrim($title); // $str2 is " Programming PHP"
$str3 = trim($title); // $str3 is "Programming PHP"

Bei einer Zeile mit tabulatorgetrennten Daten kannst du mit dem Argument charlist führende oder nachgestellte Leerzeichen entfernen, ohne die Tabulatoren zu löschen:

$record = " Fred\tFlintstone\t35\tWilma\t \n";
$record = trim($record, " \r\n\0\x0B");
// $record is "Fred\tFlintstone\t35\tWilma"

Wechselnder Fall

PHP verfügt über mehrere Funktionen zum Ändern der Groß- und Kleinschreibung von Strings: strtolower() und strtoupper() bearbeiten ganze Strings, ucfirst() nur das erste Zeichen des Strings und ucwords() das erste Zeichen jedes Worts im String. Jede Funktion nimmt eine Zeichenkette als Argument und gibt eine Kopie dieser Zeichenkette zurück, die entsprechend geändert wurde. Ein Beispiel:

$string1 = "FRED flintstone";
$string2 = "barney rubble";
print(strtolower($string1));
print(strtoupper($string1));
print(ucfirst($string2));
print(ucwords($string2));
fred flintstone
FRED FLINTSTONE
Barney rubble
Barney Rubble

Wenn du eine Zeichenkette mit gemischter Groß- und Kleinschreibung hast, die du in die "Titel-Schreibweise" umwandeln möchtest, bei der der erste Buchstabe eines jeden Wortes in Großbuchstaben und der Rest in Kleinbuchstaben geschrieben ist (und du dir nicht sicher bist, welche Groß- und Kleinschreibung die Zeichenkette zu Beginn hat), verwende eine Kombination aus strtolower() und ucwords():

print(ucwords(strtolower($string1)));
Fred Flintstone

Kodierung und Escaping

Da PHP-Programme oft mit HTML-Seiten, Webadressen (URLs) und Datenbanken interagieren, gibt es Funktionen, die dir bei der Arbeit mit diesen Datentypen helfen. HTML, Webadressen und Datenbankbefehle sind allesamt Strings, aber sie erfordern jeweils unterschiedliche Zeichen, die auf unterschiedliche Weise escaped werden müssen. So muss zum Beispiel ein Leerzeichen in einer Webadresse als %20 geschrieben werden, während ein wörtliches Kleiner-als-Zeichen (<) in einem HTML-Dokument als < geschrieben werden muss. PHP verfügt über eine Reihe von eingebauten Funktionen, um diese Kodierungen umzuwandeln.

HTML

Sonderzeichen in HTML werden durch Entitäten wie & (&) und < (<) dargestellt. Es gibt zwei PHP-Funktionen, die Sonderzeichen in einem String in ihre Entitäten umwandeln: eine, um HTML-Tags zu entfernen, und eine, um nur Meta-Tags zu extrahieren.

Entity-Quoting aller Sonderzeichen

Die Funktion htmlentities() verwandelt alle Zeichen mit HTML-Entity-Äquivalenten in diese Äquivalente (mit Ausnahme des Leerzeichens). Dazu gehören das Kleiner-als-Zeichen (<), das Größer-als-Zeichen (>), das kaufmännische Und (&) und Zeichen mit Akzent .

Zum Beispiel:

$string = htmlentities("Einstürzende Neubauten");
echo $string;
Einstürzende Neubauten

Die entity-escaped Version, ü (zu sehen im Quelltext), wird auf der gerenderten Webseite korrekt als ü angezeigt. Wie du sehen kannst, wurde das Leerzeichen nicht in   umgewandelt.

Die Funktion htmlentities() nimmt bis zu drei Argumente entgegen:

$output = htmlentities(input, flags, encoding);

Der Parameter Kodierung, falls angegeben, gibt den Zeichensatz an. Die Vorgabe ist "UTF-8". Der Parameter flags bestimmt, ob einfache und doppelte Anführungszeichen in ihre Entitätsformen umgewandelt werden. ENT_COMPAT (Standardeinstellung) konvertiert nur doppelte Anführungszeichen, ENT_QUOTES konvertiert beide Arten von Anführungszeichen und ENT_NOQUOTES konvertiert keine von beiden. Es gibt keine Option, die nur einfache Anführungszeichen umwandelt. Zum Beispiel:

$input = <<< End
"Stop pulling my hair!" Jane's eyes flashed.<p>
End;

$double = htmlentities($input);
// &quot;Stop pulling my hair!&quot; Jane's eyes flashed.&lt;p&gt;

$both = htmlentities($input, ENT_QUOTES);
// &quot;Stop pulling my hair!&quot; Jane&#039;s eyes flashed.&lt;p&gt;

$neither = htmlentities($input, ENT_NOQUOTES);
// "Stop pulling my hair!" Jane's eyes flashed.&lt;p&gt;

Entity-Quoting nur HTML-Syntaxzeichen

Die Funktion htmlspecialchars() wandelt die kleinstmögliche Menge von Entities um, um gültiges HTML zu erzeugen. Die folgenden Entities werden umgewandelt:

• Ampersands (&) werden umgewandelt in &

• Doppelte Anführungszeichen (") werden umgewandelt in "

• Einfache Anführungszeichen (') werden in ' umgewandelt (wenn ENT_QUOTES eingeschaltet ist, wie für htmlentities() beschrieben)

• Kleiner-als-Zeichen (<) werden umgewandelt in <

• Größer-als-Zeichen (>) werden umgewandelt in >

Wenn du eine Anwendung hast, die Daten anzeigt, die ein Benutzer in ein Formular eingegeben hat, musst du diese Daten durch htmlspecialchars() laufen lassen, bevor du sie anzeigst oder speicherst. Wenn du das nicht tust und der Benutzer eine Zeichenfolge wie "angle < 30" oder "sturm & drang" eingibt, hält der Browser die Sonderzeichen für HTML, was zu einer verstümmelten Seite führt.

Wie htmlentities() kann auch htmlspecialchars() bis zu drei Argumente aufnehmen:

$output = htmlspecialchars(input, [flags, [encoding]]);

Die Argumente Flags und Encoding haben die gleiche Bedeutung wie bei htmlentities().

Es gibt keine speziellen Funktionen für die Rückkonvertierung von Entitäten in den Originaltext, da dies nur selten nötig ist. Es gibt jedoch eine relativ einfache Möglichkeit, dies zu tun. Mit der Funktion get_html_translation_table() kannst du die Übersetzungstabelle abrufen, die von einer dieser Funktionen in einem bestimmten Zitierstil verwendet wird. Um zum Beispiel die Übersetzungstabelle zu erhalten, die htmlentities() verwendet, mache Folgendes:

$table = get_html_translation_table(HTML_ENTITIES);

Um die Tabelle für htmlspecialchars() im ENT_NOQUOTES Modus zu erhalten, benutze:

$table = get_html_translation_table(HTML_SPECIALCHARS, ENT_NOQUOTES);

Ein netter Trick ist es, diese Übersetzungstabelle zu verwenden, sie mit array_flip() zu spiegeln und sie mit strtr() zu füttern, um sie auf eine Zeichenkette anzuwenden und damit effektiv das Gegenteil von htmlentities() zu tun:

$str = htmlentities("Einstürzende Neubauten"); // now it is encoded

$table = get_html_translation_table(HTML_ENTITIES);
$revTrans = array_flip($table);

echo strtr($str, $revTrans); // back to normal
Einstürzende Neubauten

Du kannst natürlich auch die Übersetzungstabelle holen, sie mit anderen Übersetzungen ergänzen und dann strtr() machen. Wenn du zum Beispiel möchtest, dass htmlentities() auch jedes Leerzeichen in   kodiert, würdest du das tun:

$table = get_html_translation_table(HTML_ENTITIES);
$table[' '] = ' ';
$encoded = strtr($original, $table);

Entfernen von HTML-Tags

Die Funktion strip_tags() entfernt HTML-Tags aus einer Zeichenkette:

$input = '<p>Howdy, &quot;Cowboy&quot;</p>';
$output = strip_tags($input);
// $output is 'Howdy, &quot;Cowboy&quot;'

Die Funktion kann ein zweites Argument annehmen, das eine Reihe von Tags angibt, die in der Zeichenkette belassen werden sollen. Es werden nur die Anfangsformen der Tags aufgelistet. Die Schlussformen der im zweiten Parameter aufgeführten Tags werden ebenfalls beibehalten:

$input = 'The <b>bold</b> tags will <i>stay</i><p>';
$output = strip_tags($input, '<b>');
// $output is 'The <b>bold</b> tags will stay'

Attribute in erhaltenen Tags werden durch strip_tags() nicht verändert. Da sich Attribute wie style und onmouseover auf das Aussehen und Verhalten von Webseiten auswirken können, wird durch die Erhaltung einiger Tags mit strip_tags() nicht unbedingt das Potenzial für Missbrauch beseitigt.

Meta-Tags extrahieren

Die Funktion get_meta_tags() gibt ein Array der Meta-Tags für eine HTML-Seite zurück, die als lokaler Dateiname oder URL angegeben wird. Der Name des Meta-Tags (keywords, author, description, etc.) wird zum Schlüssel im Array und der Inhalt des Meta-Tags zum entsprechenden Wert:

$metaTags = get_meta_tags('http://www.example.com/');
echo "Web page made by {$metaTags['author']}";
Web page made by John Doe

Die allgemeine Form der Funktion ist:

$array = get_meta_tags(filename [, use_include_path]);

Übergib einen true Wert für use_include_path, damit PHP versucht, die Datei mit dem Standard-Include-Pfad zu öffnen.

URLs

PHP bietet Funktionen zur Konvertierung in und aus URL-Kodierung, mit denen du URLs erstellen und dekodieren kannst. Es gibt eigentlich zwei Arten der URL-Kodierung, die sich darin unterscheiden, wie sie Leerzeichen behandeln. Die erste (durch RFC 3986 spezifizierte) behandelt ein Leerzeichen als ein weiteres illegales Zeichen in einer URL und kodiert es als %20. Die zweite (die das application/x-www-form-urlencoded System implementiert) kodiert ein Leerzeichen als + und wird beim Aufbau von Abfrage-Strings verwendet.

Beachte, dass du diese Funktionen nicht auf eine vollständige URL, wie http://www.example.com/hello, anwenden solltest, da sie die Doppelpunkte und Schrägstriche auslassen, um sie zu erzeugen:

http%3A%2F%2Fwww.example.com%2Fhello

Codiere nur Teil-URLs (das Bit nach http://www.example.com/) und füge das Protokoll und den Domainnamen später hinzu.

RFC 3986 Kodierung und Dekodierung

Um eine Zeichenkette gemäß den URL-Konventionen zu kodieren, verwendest du rawurlencode() :

$output = rawurlencode(input);

Diese Funktion nimmt eine Zeichenkette und gibt eine Kopie mit illegalen URL-Zeichen zurück, die in der Konvention %dd kodiert sind.

Wenn du dynamisch Hypertext-Referenzen für Links auf einer Seite erzeugst, musst du sie mit rawurlencode() umwandeln:

$name = "Programming PHP";
$output = rawurlencode($name);
echo "http://localhost/{$output}";
http://localhost/Programming%20PHP

Die Funktion rawurldecode() dekodiert URL-kodierte Zeichenketten:

$encoded = 'Programming%20PHP';
echo rawurldecode($encoded);
Programming PHP

Kodierung von Abfragezeichenfolgen

Die Funktionen urlencode() und urldecode() unterscheiden sich von ihren rohen Gegenstücken nur dadurch, dass sie Leerzeichen als Pluszeichen (+) kodieren und nicht als die Sequenz %20. Dies ist das Format für die Erstellung von Query-Strings und Cookie-Werten. Diese Funktionen können nützlich sein, um formularähnliche URLs im HTML zu erstellen. PHP dekodiert Abfragezeichenfolgen und Cookie-Werte automatisch, so dass du diese Funktionen nicht verwenden musst, um diese Werte zu verarbeiten. Die Funktionen sind nützlich, um Abfragezeichenfolgen zu erzeugen:

$baseUrl = 'http://www.google.com/q=';
$query = 'PHP sessions -cookies';
$url = $baseUrl . urlencode($query);
echo $url;

http://www.google.com/q=PHP+sessions+-cookies

SQL

Die meisten Datenbanksysteme verlangen, dass Zeichenkettenliterale in deinen SQL-Abfragen escaped werden. Das Kodierungsschema von SQL ist ziemlich einfach - einfache Anführungszeichen, doppelte Anführungszeichen, NUL-Bytes und Backslashes müssen mit einem Backslash versehen werden. Die Funktion addslashes() fügt diese Schrägstriche hinzu, und die Funktion stripslashes() entfernt sie:

$string = <<< EOF
"It's never going to work," she cried,
as she hit the backslash (\) key.
EOF;
$string = addslashes($string);
echo $string;
echo stripslashes($string);
\"It\'s never going to work,\" she cried,
as she hit the backslash (\\) key.
"It's never going to work," she cried,
as she hit the backslash (\) key.

C-String Kodierung

Die Funktion addcslashes() umgeht beliebige Zeichen, indem sie Backslashes davor setzt. Mit Ausnahme der Zeichen in Tabelle 4-4 werden Zeichen mit ASCII-Werten kleiner als 32 oder größer als 126 mit ihren Oktalwerten kodiert (z. B. "\002"). Die Funktionen addcslashes() und stripcslashes() werden mit nicht standardisierten Datenbanksystemen verwendet, die ihre eigenen Vorstellungen davon haben, welche Zeichen escaped werden müssen.

Tabelle 4-4. Einzelbuchstaben-Escapes, die von addcslashes() und stripcslashes() erkannt werden

ASCII-Wert	Kodierung
7	\a
8	\b
9	\t
10	\n
11	\v
12	\f
13	\r

Rufe addcslashes() mit zwei Argumenten auf - der zu kodierenden Zeichenkette und den zu entschlüsselnden Zeichen:

$escaped = addcslashes(string, charset);

Gib einen Bereich von Zeichen an, die mit dem ".." Konstrukt entschlüsselt werden sollen:

echo addcslashes("hello\tworld\n", "\x00..\x1fz..\xff");
hello\tworld\n

Hüte dich davor, '0', 'a', 'b', 'f', 'n', 'r', 't' oder 'v' im Zeichensatz anzugeben, da sie in '\0', '\a' und so weiter umgewandelt werden. Diese Escapes werden von C und PHP erkannt und können zu Verwirrung führen.

stripcslashes() nimmt eine Zeichenkette und gibt eine Kopie zurück, bei der die Escapes erweitert sind:

$string = stripcslashes(escaped);

Zum Beispiel:

$string = stripcslashes('hello\tworld\n');
// $string is "hello\tworld\n"

Strings vergleichen

PHP hat zwei Operatoren und sechs Funktionen, um Zeichenketten miteinander zu vergleichen.

Genaue Vergleiche

Du kannst zwei Strings mit den Operatoren == und === auf Gleichheit vergleichen. Diese Operatoren unterscheiden sich darin, wie sie mit Nicht-String-Operanden umgehen. Der Operator == wandelt String-Operanden in Zahlen um und meldet daher, dass 3 und "3" gleich sind. Aufgrund der Regeln für das Casting von Strings in Zahlen würde er auch melden, dass 3 und "3b" gleich sind, da nur der Teil des Strings bis zu einem Nicht-Zahlenzeichen beim Casting verwendet wird. Der Operator === führt kein Casting durch und gibt false zurück, wenn sich die Datentypen der Argumente unterscheiden:

$o1 = 3;
$o2 = "3";

if ($o1 == $o2) {
 echo("== returns true<br>");
}
if ($o1 === $o2) {
 echo("=== returns true<br>");
}
== returns true

Die Vergleichsoperatoren (<, <=, >, >=) funktionieren auch bei Strings:

$him = "Fred";
$her = "Wilma";

if ($him < $her) {
 print "{$him} comes before {$her} in the alphabet.\n";
}
Fred comes before Wilma in the alphabet

Allerdings liefern die Vergleichsoperatoren unerwartete Ergebnisse, wenn sie Strings und Zahlen vergleichen:

$string = "PHP Rocks";
$number = 5;

if ($string < $number) {
 echo("{$string} < {$number}");
}
PHP Rocks < 5

Wenn ein Argument eines Vergleichsoperators eine Zahl ist, wird das andere Argument in eine Zahl umgewandelt. Das bedeutet, dass "PHP Rocks" in eine Zahl umgewandelt wird und 0 ergibt (da der String nicht mit einer Zahl beginnt). Da 0 kleiner als 5 ist, gibt PHP "PHP Rocks < 5" aus.

Um zwei Zeichenketten explizit als Zeichenketten zu vergleichen und dabei ggf. Zahlen in Zeichenketten umzuwandeln, verwendest du die Funktion strcmp() :

$relationship = strcmp(string_1, string_2);

Die Funktion gibt eine Zahl zurück, die kleiner als 0 ist, wenn string_1 vor string_2 sortiert ist, größer als 0, wenn string_2 vor string_1 sortiert ist, oder 0, wenn sie gleich sind:

$n = strcmp("PHP Rocks", 5);
echo($n);
1

Eine Variante von strcmp() ist strcasecmp() , die Zeichenketten in Kleinbuchstaben umwandelt, bevor sie verglichen werden. Die Argumente und Rückgabewerte sind die gleichen wie bei strcmp():

$n = strcasecmp("Fred", "frED"); // $n is 0

Eine andere Variante des String-Vergleichs besteht darin, nur die ersten paar Zeichen des Strings zu vergleichen. Die Funktionen strncmp() und strncasecmp() benötigen ein zusätzliches Argument, nämlich die Anzahl der ersten Zeichen, die für den Vergleich verwendet werden sollen:

$relationship = strncmp(string_1, string_2, len);
$relationship = strncasecmp(string_1, string_2, len);

Die letzte Variante dieser Funktionen ist der Vergleich in natürlicher Reihenfolge mit strnatcmp() und strnatcasecmp(), die die gleichen Argumente wie strcmp() verwenden und die gleichen Werte zurückgeben. Der Vergleich in natürlicher Reihenfolge identifiziert numerische Teile der zu vergleichenden Zeichenketten und sortiert die Zeichenketten getrennt von den numerischen Teilen.

Tabelle 4-5 zeigt Zeichenketten in natürlicher und ASCII-Reihenfolge.

Tabelle 4-5. Natürliche Reihenfolge versus ASCII-Reihenfolge

Natürliche Ordnung	ASCII-Bestellung
pic1.jpg	pic1.jpg
pic5.jpg	pic10.jpg
pic10.jpg	pic5.jpg
pic50.jpg	pic50.jpg

Ungefähre Gleichheit

PHP bietet mehrere Funktionen, mit denen du testen kannst, ob zwei Strings ungefähr gleich sind:soundex() , metaphone(), similar_text() und levenshtein() :

$soundexCode = soundex($string);
$metaphoneCode = metaphone($string);
$inCommon = similar_text($string_1, $string_2 [, $percentage ]);
$similarity = levenshtein($string_1, $string_2);
$similarity = levenshtein($string_1, $string_2 [, $cost_ins, $cost_rep, 
$cost_del ]);

Die Algorithmen Soundex und Metaphone liefern jeweils eine Zeichenkette, die ungefähr die englische Aussprache eines Wortes wiedergibt. Um zu sehen, ob zwei Zeichenketten mit diesen Algorithmen annähernd gleich sind, vergleichst du ihre Aussprachen. Du kannst Soundex-Werte nur mit Soundex-Werten und Metaphone-Werte nur mit Metaphone-Werten vergleichen. Der Metaphone-Algorithmus ist im Allgemeinen genauer, wie das folgende Beispiel zeigt:

$known = "Fred";
$query = "Phred";

if (soundex($known) == soundex($query)) {
 print "soundex: {$known} sounds like {$query}<br>";
}
else {
 print "soundex: {$known} doesn't sound like {$query}<br>";
}

if (metaphone($known) == metaphone($query)) {
 print "metaphone: {$known} sounds like {$query}<br>";
}
else {
 print "metaphone: {$known} doesn't sound like {$query}<br>";
}
soundex: Fred doesn't sound like Phred
metaphone: Fred sounds like Phred

Die Funktion similar_text() gibt die Anzahl der Zeichen zurück, die ihre beiden String-Argumente gemeinsam haben. Das dritte Argument, falls vorhanden, ist eine Variable, in der die Gemeinsamkeit als Prozentsatz gespeichert wird:

$string1 = "Rasmus Lerdorf";
$string2 = "Razmus Lehrdorf";
$common = similar_text($string1, $string2, $percent);
printf("They have %d chars in common (%.2f%%).", $common, $percent);
They have 13 chars in common (89.66%).

Der Levenshtein-Algorithmus berechnet die Ähnlichkeit zweier Zeichenketten anhand der Anzahl der Zeichen, die du hinzufügen, ersetzen oder entfernen musst, damit sie gleich sind. Zum Beispiel haben "cat" und "cot" einen Levenshtein-Abstand von 1, weil du nur ein Zeichen ändern musst (das "a" in ein "o"), damit sie gleich sind:

$similarity = levenshtein("cat", "cot"); // $similarity is 1

Dieses Maß für die Ähnlichkeit ist in der Regel schneller zu berechnen als das der similar_text() Funktion. Optional kannst du der Funktion drei Werte übergeben, um levenshtein() Funktion drei Werte übergeben, um Einfügungen, Löschungen und Ersetzungen individuell zu gewichten - zum Beispiel, um ein Wort mit einer Verkürzung zu vergleichen.

In diesem Beispiel werden Einfügungen beim Vergleich einer Zeichenkette mit ihrer möglichen Verkürzung zu stark gewichtet, da Verkürzungen niemals Zeichen einfügen sollten:

echo levenshtein('would not', 'wouldn\'t', 500, 1, 1);

Strings manipulieren und durchsuchen

PHP hat viele Funktionen, um mit Strings zu arbeiten. Die am häufigsten verwendeten Funktionen zum Suchen und Ändern von Strings sind diejenigen, die reguläre Ausdrücke verwenden, um den fraglichen String zu beschreiben. Die in diesem Abschnitt beschriebenen Funktionen verwenden keine regulären Ausdrücke - sie sind zwar schneller als reguläre Ausdrücke, funktionieren aber nur, wenn du nach einer festen Zeichenkette suchst (z. B. wenn du nach "12/11/01" suchst und nicht nach "beliebigen, durch Schrägstriche getrennten Zahlen").

Unterbegriffe

Wenn du weißt, wo die Daten, an denen du interessiert bist, in einer größeren Zeichenkette liegen, kannst du sie mit der Funktion substr() herauskopieren:

$piece = substr(string, start [, length ]);

Das Argument start ist die Position in der Zeichenkette, an der das Kopieren beginnen soll, wobei 0 den Anfang der Zeichenkette bedeutet. Das Argument length ist die Anzahl der zu kopierenden Zeichen (standardmäßig wird bis zum Ende der Zeichenkette kopiert). Zum Beispiel:

$name = "Fred Flintstone";
$fluff = substr($name, 6, 4); // $fluff is "lint"
$sound = substr($name, 11); // $sound is "tone"

Um zu erfahren, wie oft eine kleinere Zeichenkette in einer größeren vorkommt, benutze substr_count() :

$number = substr_count(big_string, small_string);

Zum Beispiel:

$sketch = <<< EndOfSketch
Well, there's egg and bacon; egg sausage and bacon; egg and spam;
egg bacon and spam; egg bacon sausage and spam; spam bacon sausage
and spam; spam egg spam spam bacon and spam; spam sausage spam spam
bacon spam tomato and spam;
EndOfSketch;
$count = substr_count($sketch, "spam");
print("The word spam occurs {$count} times.");
The word spam occurs 14 times.

Die Funktion substr_replace() erlaubt viele Arten von Stringänderungen:

$string = substr_replace(original, new, start [, length ]);

Die Funktion ersetzt den Teil des Originals, der durch die Werte start (0 bedeutet den Anfang der Zeichenkette) und length angegeben ist, durch die Zeichenkette new. Wenn kein viertes Argument angegeben wird, entfernt substr_replace() den Text vom Anfang bis zum Ende der Zeichenkette.

Zum Beispiel:

$greeting = "good morning citizen";
$farewell = substr_replace($greeting, "bye", 5, 7);
// $farewell is "good bye citizen"

Verwende eine Länge von 0, um einzufügen, ohne zu löschen:

$farewell = substr_replace($farewell, "kind ", 9, 0);
// $farewell is "good bye kind citizen"

Verwende eine Ersetzung von "", um ohne Einfügen zu löschen:

$farewell = substr_replace($farewell, "", 8);
// $farewell is "good bye"

So kannst du am Anfang des Strings einfügen:

$farewell = substr_replace($farewell, "now it's time to say ", 0, 0);
// $farewell is "now it's time to say good bye"'

Ein negativer Wert für start gibt die Anzahl der Zeichen ab dem Ende der Zeichenfolge an, ab der die Ersetzung beginnen soll:

$farewell = substr_replace($farewell, "riddance", −3);
// $farewell is "now it's time to say good riddance"

Eine negative Länge gibt die Anzahl der Zeichen ab dem Ende der Zeichenfolge an, bei der das Löschen beendet werden soll:

$farewell = substr_replace($farewell, "", −8, −5);
// $farewell is "now it's time to say good dance"

Verschiedene String-Funktionen

Die Funktion strrev() nimmt einen String und gibt eine umgekehrte Kopie davon zurück:

$string = strrev(string);

Zum Beispiel:

echo strrev("There is no cabal");
labac on si erehT

Die Funktion str_repeat() nimmt eine Zeichenkette und einen Zähler und gibt eine neue Zeichenkette zurück, die aus dem Argument string besteht, das zigmal wiederholt wurde:

$repeated = str_repeat(string, count);

Zum Beispiel, um ein grobes wellenförmiges horizontales Lineal zu bauen:

echo str_repeat('_.-.', 40);

Die Funktion str_pad() füllt eine Zeichenkette mit einer anderen auf. Optional kannst du angeben, mit welchem String aufgefüllt werden soll und ob links, rechts oder beides aufgefüllt werden soll:

$padded = str_pad(to_pad, length [, with [, pad_type ]]);

Die Standardeinstellung ist, dass rechts mit Leerzeichen aufgefüllt wird:

$string = str_pad('Fred Flintstone', 30);
echo "{$string}:35:Wilma";
Fred Flintstone :35:Wilma

Das optionale dritte Argument ist die Zeichenkette, mit der aufgefüllt werden soll:

$string = str_pad('Fred Flintstone', 30, '. ');
echo "{$string}35";
Fred Flintstone. . . . . . . .35

Das optionale vierte Argument kann STR_PAD_RIGHT (die Standardeinstellung), STR_PAD_LEFT oder STR_PAD_BOTH (zum Zentrieren) sein. Zum Beispiel:

echo '[' . str_pad('Fred Flintstone', 30, ' ', STR_PAD_LEFT) . "]\n";
echo '[' . str_pad('Fred Flintstone', 30, ' ', STR_PAD_BOTH) . "]\n";
[ Fred Flintstone]
[ Fred Flintstone ]

Eine Zeichenkette zerlegen

PHP bietet mehrere Funktionen, mit denen du einen String in kleinere Bestandteile zerlegen kannst. In aufsteigender Reihenfolge der Komplexität sind dies explode(), strtok() und sscanf().

Explodieren und implodieren

Daten kommen oft als Strings an, die in ein Array von Werten zerlegt werden müssen. Du könntest zum Beispiel die kommagetrennten Felder einer Zeichenkette wie "Fred,25,Wilma aufteilen wollen." In solchen Fällen kannst du die Funktion explode() verwenden:

$array = explode(separator, string [, limit]);

Das erste Argument, separator, ist eine Zeichenkette, die das Feldtrennzeichen enthält. Das zweite Argument, string, ist die zu teilende Zeichenkette. Das optionale dritte Argument, limit, ist die maximale Anzahl der Werte, die im Array zurückgegeben werden sollen. Wenn das Limit erreicht ist, enthält das letzte Element des Arrays den Rest des Strings:

$input = 'Fred,25,Wilma';
$fields = explode(',', $input);
// $fields is array('Fred', '25', 'Wilma')
$fields = explode(',', $input, 2);
// $fields is array('Fred', '25,Wilma')

Die Funktion implode() macht genau das Gegenteil von explode()- sie erstellt eine große Zeichenkette aus einem Array von kleineren Zeichenketten:

$string = implode(separator, array);

Das erste Argument, Separator, ist die Zeichenkette, die zwischen die Elemente des zweiten Arguments, Array, gesetzt wird. Um die einfache kommagetrennte Zeichenkette zu rekonstruieren, sagst du einfach:

$fields = array('Fred', '25', 'Wilma');
$string = implode(',', $fields); // $string is 'Fred,25,Wilma'

Die Funktion join() ist ein Alias für implode().

Tokenisierung

Mit der Funktion strtok() kannst du durch eine Zeichenkette iterieren und jedes Mal ein neues Stück (Token) erhalten. Wenn du die Funktion zum ersten Mal aufrufst, musst du zwei Argumente übergeben: die Zeichenkette, die durchlaufen werden soll, und das Trennzeichen für das Token. Zum Beispiel:

$firstChunk = strtok(string, separator);

Um den Rest der Token abzurufen, rufst du wiederholt strtok() mit nur dem Trennzeichen auf:

$nextChunk = strtok(separator);

Betrachte zum Beispiel diese Aufforderung:

$string = "Fred,Flintstone,35,Wilma";
$token = strtok($string, ",");

while ($token !== false) {
 echo("{$token}<br />");
 $token = strtok(",");
}
Fred
Flintstone
35
Wilma

Die Funktion strtok() gibt false zurück, wenn es keine weiteren Token mehr gibt, die zurückgegeben werden können.

Rufe strtok() mit zwei Argumenten auf, um den Iterator zu reinitialisieren. Dadurch wird der Tokenizer vom Anfang der Zeichenkette aus neu gestartet.

sscanf()

Die Funktion sscanf() zerlegt einen String nach einer printf()-ähnlichen Vorlage:

$array = sscanf(string, template);
$count = sscanf(string, template, var1, ... );

Wird sscanf() ohne die optionalen Variablen verwendet, wird ein Array mit Feldern zurückgegeben:

$string = "Fred\tFlintstone (35)";
$a = sscanf($string, "%s\t%s (%d)");
print_r($a);
Array
(
 [0] => Fred
 [1] => Flintstone
 [2] => 35)

Übergib Referenzen auf Variablen, damit die Felder in diesen Variablen gespeichert werden. Die Anzahl der zugewiesenen Felder wird zurückgegeben:

$string = "Fred\tFlintstone (35)";
$n = sscanf($string, "%s\t%s (%d)", $first, $last, $age);
echo "Matched {$n} fields: {$first} {$last} is {$age} years old";
Matched 3 fields: Fred Flintstone is 35 years old

String-Suchfunktionen

Es gibt mehrere Funktionen, die eine Zeichenkette oder ein Zeichen innerhalb einer größeren Zeichenkette finden. Sie gehören zu drei Familien: strpos() und strrpos(), die eine Position zurückgeben; strstr(), strchr() und friends, die die gefundene Zeichenkette zurückgeben; und strspn() und strcspn(), die zurückgeben, wie viel vom Anfang der Zeichenkette mit einer Maske übereinstimmt.

In allen Fällen, in denen du eine Zahl als zu suchende "Zeichenfolge" angibst, behandelt PHP diese Zahl als den Ordinalwert des gesuchten Zeichens. Diese Funktionsaufrufe sind also identisch, denn 44 ist der ASCII-Wert des Kommas:

$pos = strpos($large, ","); // find first comma
$pos = strpos($large, 44); // also find first comma

Alle Funktionen zum Suchen von Zeichenketten geben false zurück, wenn sie die angegebene Teilzeichenkette nicht finden können. Wenn die Teilzeichenkette am Anfang der Zeichenkette steht, geben die Funktionen 0 zurück. Da false in die Zahl 0 umgewandelt wird, musst du den Rückgabewert immer mit === vergleichen, wenn du einen Fehler feststellst:

if ($pos === false) {
 // wasn't found
}
else {
 // was found, $pos is offset into string
}

Sucht die zurückkehrende Position

Die Funktion strpos() findet das erste Vorkommen einer kleinen Zeichenkette in einer größeren Zeichenkette:

$position = strpos(large_string, small_string);

Wenn der kleine String nicht gefunden wird, gibt strpos() false zurück.

Die Funktion strrpos() findet das letzte Vorkommen eines Zeichens in einer Zeichenkette. Sie nimmt dieselben Argumente entgegen und gibt denselben Typ von Wert zurück wie strpos().

Zum Beispiel:

$record = "Fred,Flintstone,35,Wilma";
$pos = strrpos($record, ","); // find last comma
echo("The last comma in the record is at position {$pos}");
The last comma in the record is at position 18

Sucht den Rest der Zeichenkette zurück

Die Funktion strstr() findet das erste Vorkommen einer kleinen Zeichenkette in einer größeren Zeichenkette und kehrt von dieser kleinen Zeichenkette an zurück. Zum Beispiel:

$record = "Fred,Flintstone,35,Wilma";
$rest = strstr($record, ","); // $rest is ",Flintstone,35,Wilma"

Die Varianten auf strstr() sind:

stristr()

Groß- und Kleinschreibung nicht beachten strstr()

strchr()

Alias für strstr()

strrchr()

Findet das letzte Vorkommen eines Zeichens in einer Zeichenkette

Wie bei strrpos() sucht strrchr() rückwärts in der Zeichenkette, aber nur nach einem einzelnen Zeichen, nicht nach einer ganzen Zeichenkette.

Suchen mit Masken

Wenn du dachtest, strrchr() sei esoterisch, hast du noch nichts gesehen. Die Funktionen strspn() und strcspn() sagen dir, wie viele Zeichen am Anfang einer Zeichenkette aus bestimmten Zeichen bestehen:

$length = strspn(string, charset);

Diese Funktion prüft zum Beispiel, ob eine Zeichenkette eine Oktalzahl enthält:

function isOctal($str)
{
 return strspn($str, '01234567') == strlen($str);
}

Das c in strcspn() steht für Komplement - esgibt an, wie viel vom Anfang der Zeichenkette nicht aus den Zeichen des Zeichensatzes besteht. Verwende sie, wenn die Anzahl der interessanten Zeichen größer ist als die Anzahl der uninteressanten Zeichen. Diese Funktion prüft zum Beispiel, ob eine Zeichenkette NUL-Bytes, Tabulatoren oder Zeilenumbrüche enthält:

function hasBadChars($str)
{
 return strcspn($str, "\n\t\0") != strlen($str);
}

URLs zerlegen

Die Funktion parse_url() gibt ein Array von Komponenten einer URL zurück:

$array = parse_url(url);

Zum Beispiel:

$bits = parse_url("http://me:[e-mail]/cgi-bin/board?user=fred");
print_r($bits);

Array
(
 [scheme] => http
 [host] => example.com
 [user] => me
 [pass] => secret
 [path] => /cgi-bin/board
 [query] => user=fred)

Die möglichen Schlüssel des Hashes sind scheme, host, port, user, pass, path, query und fragment.

Reguläre Ausdrücke

Wenn du eine komplexere Suchfunktion brauchst, als die vorherigen Methoden bieten, kannst du einen regulären Ausdruck verwenden - eine Zeichenkette, die ein Muster darstellt. Die Funktionen für reguläre Ausdrücke vergleichen dieses Muster mit einer anderen Zeichenkette und prüfen, ob ein Teil der Zeichenkette mit dem Muster übereinstimmt. Einige Funktionen sagen dir, ob es eine Übereinstimmung gab, während andere die Zeichenkette verändern.

Es gibt drei Verwendungszwecke für reguläre Ausdrücke: den Abgleich, der auch verwendet werden kann, um Informationen aus einer Zeichenkette zu extrahieren; das Ersetzen von passendem Text durch neuen Text; und das Aufteilen einer Zeichenkette in eine Reihe kleinerer Teile. PHP hat für alle diese Funktionen Funktionen. preg_match() führt zum Beispiel einen Abgleich mit einem regulären Ausdruck durch.

Perl gilt seit langem als Maßstab für leistungsstarke reguläre Ausdrücke. PHP verwendet eine C-Bibliothek namens pcre, die das Arsenal der regulären Ausdrücke von Perl fast vollständig unterstützt. Reguläre Ausdrücke in Perl wirken auf beliebige Binärdaten, so dass du sicher mit Mustern oder Zeichenketten übereinstimmen kannst, die das NUL-Byte (\x00) enthalten.

Die Grundlagen

Die meisten Zeichen in einem regulären Ausdruck sind wörtliche Zeichen, das heißt, sie passen nur auf sich selbst. Wenn du zum Beispiel nach dem regulären Ausdruck "/cow/" in der Zeichenfolge "Dave was a cowhand" suchst, erhältst du eine Übereinstimmung, weil "cow" in dieser Zeichenfolge vorkommt.

Einige Zeichen haben in regulären Ausdrücken besondere Bedeutungen. Ein Caret (^) am Anfang eines regulären Ausdrucks zeigt zum Beispiel an, dass er auf den Anfang der Zeichenkette passen muss (oder genauer gesagt, verankert den regulären Ausdruck am Anfang der Zeichenkette):

preg_match("/^cow/", "Dave was a cowhand"); // returns false
preg_match("/^cow/", "cowabunga!"); // returns true

Ebenso bedeutet ein Dollarzeichen ($) am Ende eines regulären Ausdrucks, dass er mit dem Ende der Zeichenkette übereinstimmen muss (d.h. er verankert den regulären Ausdruck am Ende der Zeichenkette):

preg_match("/cow$/", "Dave was a cowhand"); // returns false
preg_match("/cow$/", "Don't have a cow"); // returns true

Ein Punkt (.) in einem regulären Ausdruck passt auf jedes einzelne Zeichen:

preg_match("/c.t/", "cat"); // returns true
preg_match("/c.t/", "cut"); // returns true
preg_match("/c.t/", "c t"); // returns true
preg_match("/c.t/", "bat"); // returns false
preg_match("/c.t/", "ct"); // returns false

Wenn du eines dieser Sonderzeichen (ein sogenanntes Metacharacter) finden willst, musst du es mit einem Backslash entwerten:

preg_match("/\$5.00/", "Your bill is $5.00 exactly"); // returns true
preg_match("/$5.00/", "Your bill is $5.00 exactly"); // returns false

Reguläre Ausdrücke unterscheiden standardmäßig zwischen Groß- und Kleinschreibung, so dass der reguläre Ausdruck "/cow/" nicht auf die Zeichenfolge "COW" passt. Wenn du eine Übereinstimmung ohne Berücksichtigung der Groß- und Kleinschreibung durchführen willst, gibst du ein Flag an, um dies zu kennzeichnen (wie du später in diesem Kapitel sehen wirst).

Bisher haben wir nichts getan, was wir nicht auch mit den String-Funktionen hätten tun können, die wir bereits gesehen haben, wie strstr(). Die eigentliche Stärke der regulären Ausdrücke liegt in ihrer Fähigkeit, abstrakte Muster anzugeben, die auf viele verschiedene Zeichenfolgen passen. Du kannst drei grundlegende Arten von abstrakten Mustern in einem regulären Ausdruck angeben :

• Eine Reihe zulässiger Zeichen, die in der Zeichenfolge vorkommen können (z. B. alphabetische Zeichen, numerische Zeichen, bestimmte Interpunktionszeichen)

• Eine Reihe von Alternativen für die Zeichenfolge (z. B. "com", "edu", "net" oder "org")

• Eine sich wiederholende Sequenz in der Zeichenfolge (z. B. mindestens ein, aber nicht mehr als fünf numerische Zeichen)

Diese drei Arten von Mustern können auf unzählige Arten kombiniert werden, um reguläre Ausdrücke zu erstellen, die z. B. auf gültige Telefonnummern und URLs passen.

Charakter-Klassen

Um eine Reihe von zulässigen Zeichen in deinem Muster festzulegen, kannst du entweder selbst eine Zeichenklasse erstellen oder eine vordefinierte verwenden. Du kannst deine eigene Zeichenklasse erstellen, indem du die zulässigen Zeichen in eckige Klammern einschließt:

preg_match("/c[aeiou]t/", "I cut my hand"); // returns true
preg_match("/c[aeiou]t/", "This crusty cat"); // returns true
preg_match("/c[aeiou]t/", "What cart?"); // returns false
preg_match("/c[aeiou]t/", "14ct gold"); // returns false

Die Engine für reguläre Ausdrücke findet ein "c" und prüft dann, ob das nächste Zeichen eines der Zeichen "a", "e", "i", "o" oder "u" ist. Wenn es kein Vokal ist, schlägt die Übereinstimmung fehl und die Engine sucht erneut nach einem "c". Wenn ein Vokal gefunden wird, prüft die Engine, ob das nächste Zeichen ein "t" ist. Wenn ja, ist die Engine am Ende der Übereinstimmung und gibt true zurück. Wenn das nächste Zeichen kein "t" ist, sucht die Engine erneut nach einem "c".

Du kannst eine Zeichenklasse mit einem Caret (^) am Anfang negieren:

preg_match("/c[^aeiou]t/", "I cut my hand"); // returns false
preg_match("/c[^aeiou]t/", "Reboot chthon"); // returns true
preg_match("/c[^aeiou]t/", "14ct gold"); // returns false

In diesem Fall sucht die Engine für reguläre Ausdrücke nach einem "c" gefolgt von einem Zeichen, das kein Vokal ist, gefolgt von einem "t".

Du kannst einen Bereich von Zeichen mit einem Bindestrich (-) definieren. Das vereinfacht Zeichenklassen wie "alle Buchstaben" und "alle Ziffern":

preg_match("/[0-9]%/", "we are 25% complete"); // returns true
preg_match("/[0123456789]%/", "we are 25% complete"); // returns true
preg_match("/[a-z]t/", "11th"); // returns false
preg_match("/[a-z]t/", "cat"); // returns true
preg_match("/[a-z]t/", "PIT"); // returns false
preg_match("/[a-zA-Z]!/", "11!"); // returns false
preg_match("/[a-zA-Z]!/", "stop!"); // returns true

Wenn du eine Zeichenklasse festlegst, verlieren einige Sonderzeichen ihre Bedeutung, während andere neue Bedeutungen erhalten. Insbesondere der Anker $ und der Punkt verlieren ihre Bedeutung in einer Zeichenklasse, während das Zeichen ^ nicht länger ein Anker ist, sondern die Zeichenklasse negiert, wenn es das erste Zeichen nach der offenen Klammer ist. So passt zum Beispiel [^\]] auf jedes Zeichen, das keine geschlossene Klammer ist, während [$.^] auf ein Dollarzeichen, einen Punkt oder ein Caret passt.

Die verschiedenen Bibliotheken für reguläre Ausdrücke definieren Abkürzungen für Zeichenklassen, einschließlich Ziffern, alphabetische Zeichen und Leerzeichen.

Alternativen

Du kannst das vertikale Pipe-Zeichen (|) verwenden, um Alternativen in einem regulären Ausdruck anzugeben :

preg_match("/cat|dog/", "the cat rubbed my legs"); // returns true
preg_match("/cat|dog/", "the dog rubbed my legs"); // returns true
preg_match("/cat|dog/", "the rabbit rubbed my legs"); // returns false

Der Vorrang der Alternation kann überraschen: "/^cat|dog$/" wählt aus "^cat" und "dog$" aus, was bedeutet, dass er auf eine Zeile passt, die entweder mit "cat" beginnt oder mit "dog" endet. Wenn du eine Zeile willst, die nur "cat" oder "dog" enthält, musst du den regulären Ausdruck "/^(cat|dog)$/" verwenden.

Du kannst Zeichenklassen und Alternation kombinieren, um z.B. nach Zeichenfolgen zu suchen, die nicht mit einem Großbuchstaben beginnen:

preg_match("/^([a-z]|[0-9])/", "The quick brown fox"); // returns false
preg_match("/^([a-z]|[0-9])/", "jumped over"); // returns true
preg_match("/^([a-z]|[0-9])/", "10 lazy dogs"); // returns true

Sich wiederholende Sequenzen

Um ein sich wiederholendes Muster anzugeben, verwendest du einen Quantifizierer. Der Quantifizierer steht hinter dem Muster, das wiederholt werden soll, und gibt an, wie oft das Muster wiederholt werden soll. Tabelle 4-6 zeigt die Quantifizierer, die von den regulären Ausdrücken von PHP unterstützt werden.

Tabelle 4-6. Quantifizierer für reguläre Ausdrücke

Quantifizierer	Bedeutung
?	0 oder 1
*	0 oder mehr
+	1 oder mehr
{ n }	Genau n-mal
{ n , m }	Mindestens n, höchstens m Mal
{ n ,}	Mindestens n Mal

Um ein einzelnes Zeichen zu wiederholen, fügst du einfach den Quantifizierer nach dem Zeichen ein:

preg_match("/ca+t/", "caaaaaaat"); // returns true
preg_match("/ca+t/", "ct"); // returns false
preg_match("/ca?t/", "caaaaaaat"); // returns false
preg_match("/ca*t/", "ct"); // returns true

Mit Quantifizierern und Zeichenklassen können wir tatsächlich etwas Nützliches tun, zum Beispiel gültige US-Telefonnummern abgleichen:

preg_match("/[0-9]{3}-[0-9]{3}-[0-9]{4}/", "303-555-1212"); // returns true
preg_match("/[0-9]{3}-[0-9]{3}-[0-9]{4}/", "64-9-555-1234"); // returns false

Subpatterns

Du kannst Klammern verwenden, um Teile eines regulären Ausdrucks zu gruppieren, damit sie als eine Einheit, ein sogenanntes Untermuster, behandelt werden:

preg_match("/a (very )+big dog/", "it was a very very big dog"); // returns true
preg_match("/^(cat|dog)$/", "cat"); // returns true
preg_match("/^(cat|dog)$/", "dog"); // returns true

Die Klammern bewirken auch, dass die Teilzeichenkette, die mit dem Teilmuster übereinstimmt, erfasst wird. Wenn du ein Array als drittes Argument an eine Übereinstimmungsfunktion übergibst, wird das Array mit allen erfassten Teilzeichenketten aufgefüllt:

preg_match("/([0-9]+)/", "You have 42 magic beans", $captured);
// returns true and populates $captured

Das nullte Element des Arrays wird auf die gesamte Zeichenkette gesetzt, die abgeglichen werden soll. Das erste Element ist die Teilzeichenkette, die mit dem ersten Teilmuster übereinstimmt (falls es eines gibt), das zweite Element ist die Teilzeichenkette, die mit dem zweiten Teilmuster übereinstimmt, usw.

Begrenzungszeichen

Reguläre Ausdrücke im Perl-Stil ahmen die Perl-Syntax für Muster nach, was bedeutet, dass jedes Muster von einem Paar Begrenzungszeichen eingeschlossen sein muss. Traditionell wird das Zeichen Schrägstrich (/) verwendet; zum Beispiel /Muster/. Es kann aber auch jedes andere nicht-alphanumerische Zeichen als der umgekehrte Schrägstrich (\) verwendet werden, um ein Muster im Perl-Stil zu begrenzen. Dies ist nützlich, um Zeichenketten zu finden, die Schrägstriche enthalten, wie z. B. Dateinamen. Die folgenden Muster sind zum Beispiel gleichwertig:

preg_match("/\/usr\/local\//", "/usr/local/bin/perl"); // returns true
preg_match("#/usr/local/#", "/usr/local/bin/perl"); // returns true

Klammern (()), geschweifte Klammern ({}), eckige Klammern ([]) und spitze Klammern (<>) können als Musterbegrenzer verwendet werden:

preg_match("{/usr/local/}", "/usr/local/bin/perl"); // returns true

Im Abschnitt "Optionen am Ende des Ausdrucks" werden die Ein-Zeichen-Modifikatoren beschrieben, die du nach dem abschließenden Begrenzungszeichen einfügen kannst, um das Verhalten der Engine für reguläre Ausdrücke zu ändern. Ein sehr nützlicher Modifikator ist x, der dafür sorgt, dass die Engine für reguläre Ausdrücke Leerzeichen und #-markierte Kommentare aus dem regulären Ausdruck entfernt, bevor sie ihn abgleichen. Diese beiden Muster sind identisch, aber das eine ist viel einfacher zu lesen:

'/([[:alpha:]]+)\s+\1/'
'/( # start capture
[[:alpha:]]+ # a word
\s+ # whitespace
\1 # the same word again
 ) # end capture
/x'

Match-Verhalten

Der Punkt (.) passt auf jedes Zeichen, außer auf einen Zeilenumbruch (\n). Das Dollarzeichen ($) passt am Ende der Zeichenkette oder, wenn die Zeichenkette mit einem Zeilenumbruch endet, direkt vor diesem Zeilenumbruch:

preg_match("/is (.*)$/", "the key is in my pants", $captured);
// $captured[1] is 'in my pants'

Charakter-Klassen

Wie in Tabelle 4-7 dargestellt, definieren Perl-kompatible reguläre Ausdrücke eine Reihe von benannten Zeichensätzen, die du in Zeichenklassen verwenden kannst. Die Erweiterungen in Tabelle 4-7 sind für Englisch. Die tatsächlichen Buchstaben variieren von Land zu Land.

aJede [: etwas :] Klasse kann anstelle eines Zeichens in einer Zeichenklasse verwendet werden. Um zum Beispiel jedes Zeichen zu finden, das eine Ziffer, ein Großbuchstabe oder ein "at"-Zeichen (@) ist, kannst du den folgenden regulären Ausdruck verwenden:

[@[:digit:][:upper:]]

Du kannst eine Zeichenklasse jedoch nicht als Endpunkt eines Bereichs verwenden:

preg_match("/[A-[:lower:]]/", "string");// invalid regular expression

Einige Gebietsschemata betrachten bestimmte Zeichenfolgen als ein einziges Zeichen - diese werden collating sequences genannt. Um eine dieser mehrstelligen Zeichenfolgen in einer Zeichenklasse zu finden, schließe sie mit [. und .] ein. Wenn dein Gebietsschema zum Beispiel die Sortierfolge ch vorsieht, kannst du s, t oder ch mit dieser Zeichenklasse abgleichen:

[st[.ch.]]

Die letzte Erweiterung der Zeichenklassen ist dieÄquivalenzklasse , die du angibst, indem du das Zeichen in [= und =] einschließt. Äquivalenzklassen entsprechen Zeichen, die die gleiche Sortierreihenfolge haben, wie sie im aktuellen Gebietsschema definiert ist. Ein Gebietsschema kann zum Beispiel festlegen, dass a, á und ä die gleiche Sortierreihenfolge haben. Die Äquivalenzklasse für eines dieser Zeichen ist [=a=].

Tabelle 4-7. Zeichenklassen

Klasse	Beschreibung	Erweiterung
[:alnum:]	Alphanumerische Zeichen	[0-9a-zA-Z]
[:alpha:]	Alphabetische Zeichen (Buchstaben)	[a-zA-Z]
[:ascii:]	7-Bit-ASCII	[\x01-\x7F]
[:blank:]	Horizontale Leerzeichen (Leerzeichen, Tabulator)	[ \t]
[:cntrl:]	Kontrollzeichen	[\x01-\x1F]
[:digit:]	Ziffern	[0-9]
[:graph:]	Zeichen, die mit Tinte gedruckt werden (Nicht-Leerzeichen, Nicht-Kontrollzeichen)	[^\x01-\x20]
[:lower:]	Kleinbuchstabe	[a-z]
[:print:]	Druckbares Zeichen (Grafikklasse plus Leerzeichen und Tabulator)	[\t\x20-\xFF]
[:punct:]	Jedes Interpunktionszeichen, wie der Punkt (.) und das Semikolon (;)	[-!"#$%&'()*+,./:;<=>?@[\\\]^_'{|}~]
[:space:]	Leerzeichen (Zeilenumbruch, Wagenrücklauf, Tabulator, Leerzeichen, vertikaler Tabulator)	[\n\r\t \x0B]
[:upper:]	Großbuchstabe	[A-Z]
[:xdigit:]	Hexadezimalziffer	[0-9a-fA-F]
\s	Whitespace	[\r\n \t]
\S	Nicht-Whitespace	[^\r\n \t]
\w	Wort (Bezeichner) Zeichen	[0-9A-Za-z_]
\W	Nicht-Wort (Bezeichner) Zeichen	[^0-9A-Za-z_]
\d	Ziffer	[0-9]
\D	Nicht-zifferige	[^0-9]

Anker

Ein Anker schränkt eine Übereinstimmung auf eine bestimmte Stelle in der Zeichenkette ein (Anker entsprechen nicht den tatsächlichen Zeichen in der Zielzeichenkette). Tabelle 4-8 listet die Anker auf, die von regulären Ausdrücken unterstützt werden.

Tabelle 4-8. Verankerungen

Anker	Streichhölzer
^	Anfang der Zeichenfolge
$	Ende der Zeichenfolge
[[:<:]]	Anfang des Wortes
[[:>:]]	Ende des Wortes
\b	Wortgrenze (zwischen \w und \W oder am Anfang oder Ende der Zeichenfolge)
\B	Nicht-Wort-Grenze (zwischen \w und \w, oder \W und \W)
\A	Anfang der Zeichenfolge
\Z	Ende der Zeichenkette oder vor \n am Ende
\z	Ende der Zeichenfolge
^	Beginn der Zeile (oder nach \n, wenn /m aktiviert ist)
$	Ende der Zeile (oder vor \n, wenn das /m Flag aktiviert ist)

Eine Wortgrenze ist definiert als der Punkt zwischen einem Leerzeichen und einem Bezeichnerzeichen (alphanumerisch oder Unterstrich):

preg_match("/[[:<:]]gun[[:>:]]/", "the Burgundy exploded"); // returns false
preg_match("/gun/", "the Burgundy exploded"); // returns true

Beachte, dass der Anfang und das Ende einer Zeichenkette auch als Wortgrenzen gelten.

Quantifizierer und Gier

Quantifizierer für reguläre Ausdrücke sind in der Regel gierig. Das heißt, dass die Engine bei einem Quantifizierer so viel wie möglich abgleicht, ohne den Rest des Musters zu vernachlässigen. Zum Beispiel:

preg_match("/(<.*>)/", "do <b>not</b> press the button", $match);
// $match[1] is '<b>not</b>'

Der reguläre Ausdruck passt vom ersten Kleiner-als-Zeichen bis zum letzten Größer-als-Zeichen. In der Tat passt .* auf alles, was nach dem ersten Kleiner-als-Zeichen kommt, und die Engine geht zurück, um immer weniger zu finden, bis schließlich ein Größer-als-Zeichen gefunden wird.

Diese Gierigkeit kann ein Problem sein. Manchmal brauchst du eine minimale (nicht gierige) Übereinstimmung, d.h.Quantoren, die so wenig wie möglich übereinstimmen, um den Rest des Musters zu erfüllen. Perl bietet eine parallele Menge von Quantoren, die minimal übereinstimmen. Sie sind leicht zu erinnern, denn sie sind die gleichen wie die gierigen Quantoren, nur mit einem angehängten Fragezeichen (?). Tabelle 4-9 zeigt die entsprechenden gierigen und nicht-gierigen Quantoren, die von regulären Ausdrücken im Perl-Stil unterstützt werden.

Tabelle 4-9. Greedy- und Nongreedy-Quantoren in Perl-kompatiblen regulären Ausdrücken

Gieriger Quantifizierer	Nicht-reduzierter Quantifizierer
?	??
*	*?
+	+?
{m}	{m}?
{m,}	{m,}?
{m,n}	{m,n}?

Hier erfährst du, wie du einen Tag mit einem nicht-reduzierten Quantifizierer zuordnen kannst:

preg_match("/(<.*?>)/", "do <b>not</b> press the button", $match);
// $match[1] is "<b>"

Eine andere, schnellere Möglichkeit ist, eine Zeichenklasse zu verwenden, die jedes Nicht-größer-als-Zeichen bis zum nächsten Größer-als-Zeichen abgleicht:

preg_match("/(<[^>]*>)/", "do <b>not</b> press the button", $match);
// $match[1] is '<b>'

Nicht fangende Gruppen

Wenn du einen Teil eines Musters in Klammern einschließt, wird der Text, der zu diesem Teilmuster passt, erfasst und kann später abgerufen werden. Manchmal möchtest du jedoch ein Untermuster erstellen, ohne den passenden Text zu erfassen. In Perl-kompatiblen regulären Ausdrücken kannst du dies mit dem Konstrukt (?: subpattern ) erreichen:

preg_match("/(?:ello)(.*)/", "jello biafra", $match);
// $match[1] is " biafra"

Rückverweise

Du kannst dich mit einem Rückverweis auf Text beziehen, der zuvor in einem Muster erfasst wurde: \1 bezieht sich auf den Inhalt des ersten Untermusters, \2 auf das zweite und so weiter. Wenn du Untermuster verschachtelst, beginnt das erste mit der ersten öffnenden Klammer, das zweite mit der zweiten öffnenden Klammer, und so weiter.

So werden zum Beispiel verdoppelte Wörter identifiziert:

preg_match("/([[:alpha:]]+)\s+\1/", "Paris in the the spring", $m);
// returns true and $m[1] is "the"

Die Funktion preg_match() erfasst höchstens 99 Teilmuster; Teilmuster nach dem 99. werden ignoriert.

Nachlaufende Optionen

Mit regulären Ausdrücken im Perl-Stil kannst du einstellige Optionen (Flags) hinter das Muster des regulären Ausdrucks setzen, um die Interpretation bzw. das Verhalten der Übereinstimmung zu ändern. Wenn du z. B. die Groß- und Kleinschreibung nicht beachten willst, verwende einfach das Flag i:

preg_match("/cat/i", "Stop, Catherine!"); // returns true

Tabelle 4-10 zeigt, welche Perl-Modifikatoren in Perl-kompatiblen regulären Ausdrücken unterstützt werden.

Tabelle 4-10. Perl-Flags

Modifikator	Bedeutung
/regexp/i	Fall-insensitiv anpassen
/regexp/s	Der Punkt (.) passt auf jedes Zeichen, auch auf den Zeilenumbruch (\n).
/regexp/x	Whitespace und Kommentare aus dem Muster entfernen
/regexp/m	Sorge dafür, dass das Caret (^) nach und das Dollarzeichen ($) vor den internen Zeilenumbrüchen (\n) steht.
/regexp/e	Wenn die Ersetzungszeichenfolge PHP-Code ist, eval() sie, um die tatsächliche Ersetzungszeichenfolge zu erhalten

Die Perl-kompatiblen Funktionen von PHP für reguläre Ausdrücke unterstützen auch andere Modifikatoren, die von Perl nicht unterstützt werden, wie in Tabelle 4-11 aufgeführt.

Tabelle 4-11. Zusätzliche PHP-Flags

Modifikator	Bedeutung
/regexp/U	Kehrt die Gier des Untermusters um; * und + stimmen nun so wenig wie möglich überein, anstatt so viel wie möglich
/regexp/u	Bewirkt, dass Musterzeichenketten als UTF-8 behandelt werden
/regexp/X	Bewirkt, dass ein Backslash, gefolgt von einem Zeichen ohne besondere Bedeutung, einen Fehler auslöst
/regexp/A	Bewirkt, dass der Anfang der Zeichenkette so verankert wird, als wäre das erste Zeichen des Musters ^
/regexp/D	Bewirkt, dass das Zeichen $ nur am Ende einer Zeile passt
/regexp/S	Bewirkt, dass der Expression Parser die Struktur des Musters genauer untersucht, so dass er beim nächsten Mal etwas schneller läuft (z. B. in einer Schleife)

Es ist möglich, mehr als eine Option in einem einzigen Muster zu verwenden, wie im folgenden Beispiel gezeigt wird:

$message = <<< END
To: you@youcorp
From: me@mecorp
Subject: pay up

Pay me or else!
END;

preg_match("/^subject: (.*)/im", $message, $match);

print_r($match);

// output: Array ( [0] => Subject: pay up [1] => pay up )

Inline-Optionen

Du kannst nicht nur musterweite Optionen nach dem abschließenden Musterbegrenzer angeben, sondern auch Optionen innerhalb eines Musters, damit sie nur für einen Teil des Musters gelten. Die Syntax dafür lautet:

(?flags:subpattern)

In diesem Beispiel ist zum Beispiel nur das Wort "PHP" unabhängig von der Groß- und Kleinschreibung:

echo preg_match('/I like (?i:PHP)/', 'I like pHp', $match);
print_r($match) ;
// returns true (echo: 1)
// $match[0] is 'I like pHp'

Die Optionen i, m, s, U, x und X können auf diese Weise intern angewendet werden. Du kannst mehrere Optionen auf einmal verwenden:

preg_match('/eat (?ix:foo d)/', 'eat FoOD'); // returns true

Stelle einer Option einen Bindestrich (-) voran, um sie zu deaktivieren:

echo preg_match('/I like (?-i:PHP)/', 'I like pHp', $match);
print_r($matche) ;
// returns false (echo: 0)
// $match[0] is ''

Eine alternative Form aktiviert oder deaktiviert die Flaggen bis zum Ende des einschließenden Untermusters oder Musters:

preg_match('/I like (?i)PHP/', 'I like pHp'); // returns true
preg_match('/I (like (?i)PHP) a lot/', 'I like pHp a lot', $match);
// $match[1] is 'like pHp'

Inline-Flags ermöglichen kein Capturing. Dafür brauchst du einen zusätzlichen Satz von Erfassungsklammern.

Vorausschauen und Zurückblicken

In Mustern ist es manchmal nützlich, sagen zu können: "Triff hier zu, wenn dies das Nächste ist." Das ist besonders häufig der Fall, wenn du eine Zeichenkette aufteilst. Der reguläre Ausdruck beschreibt das Trennzeichen, das nicht zurückgegeben wird. Mit lookahead kannst du sicherstellen, dass nach dem Trennzeichen noch weitere Daten kommen (ohne dass sie übereinstimmen und somit nicht zurückgegeben werden). Ähnlich prüft lookbehind den vorangehenden Text.

Lookahead und Lookbehind gibt es in zwei Formen: positiv und negativ. Ein positiver Lookahead oder Lookbehind sagt: "Der nächste/vorangehende Text muss so sein." Ein negativer Lookahead oder Lookbehind bedeutet: "Der nächste/vorangehende Text darf nicht so sein." Tabelle 4-12 zeigt die vier Konstrukte, die du in Perl-kompatiblen Mustern verwenden kannst. Keines dieser Konstrukte erfasst Text.

Tabelle 4-12. Lookahead- und Lookbehind-Assertions

Konstruiere	Bedeutung
(?=Untermuster)	Positive Vorausschau
(?!Untermuster)	Negative Vorausschau
(?<=Untermuster)	Positiver Blick nach hinten
(?<!Untermuster)	Negativer Rückblick

Eine einfache Anwendung von positivem Lookahead ist das Aufteilen einer Unix mbox-Maildatei in einzelne Nachrichten. Das Wort "From", das am Anfang einer Zeile steht, zeigt den Beginn einer neuen Nachricht an. Du kannst also die Mailbox in Nachrichten aufteilen, indem du das Trennzeichen als den Punkt angibst, an dem der nächste Text "From" am Anfang einer Zeile steht:

$messages = preg_split('/(?=^From )/m', $mailbox);

Eine einfache Anwendung von Negative Lookbehind ist das Extrahieren von Zeichenketten, die Trennzeichen in Anführungszeichen enthalten. So kannst du zum Beispiel eine Zeichenkette in einfachen Anführungszeichen extrahieren (beachte, dass der reguläre Ausdruck mit dem Modifikator x kommentiert wird):

$input = <<< END
name = 'Tim O\'Reilly';
END;

$pattern = <<< END
' # opening quote
( # begin capturing
 .*? # the string
 (?<! \\\\ ) # skip escaped quotes
) # end capturing
' # closing quote
END;
preg_match( "($pattern)x", $input, $match);
echo $match[1];
Tim O\'Reilly

Die einzige Schwierigkeit besteht darin, dass wir, um ein Muster zu erhalten, das überprüft, ob das letzte Zeichen ein Backslash war, den Backslash escapen müssen, um zu verhindern, dass die Engine für reguläre Ausdrücke \) sieht, was eine wörtliche geschlossene Klammer bedeuten würde. Mit anderen Worten, wir müssen den Backslash mit einem Backslash versehen: \\). Aber die String-Quoting-Regeln von PHP besagen, dass \\ einen einzelnen Backslash ergibt, so dass wir vier Backslashes brauchen, um einen durch den regulären Ausdruck zu bekommen! Das ist der Grund, warum reguläre Ausdrücke den Ruf haben, schwer zu lesen zu sein.

Perl beschränkt lookbehind auf Ausdrücke mit konstanter Breite. Das heißt, die Ausdrücke dürfen keine Quantoren enthalten, und wenn du eine Alternative verwendest, müssen alle Alternativen gleich lang sein. Die mit Perl kompatible Engine für reguläre Ausdrücke verbietet auch Quantoren in lookbehind, erlaubt aber Alternativen unterschiedlicher Länge.

Schnitt

Das selten verwendete einmalige Teilmuster ( Cut) verhindert, dass die Engine für reguläre Ausdrücke bei einigen Mustern den schlimmsten Fall auslöst. Das Teilmuster wird nie zurückgesetzt, wenn es einmal gefunden wurde.

Das einmalige Untermuster wird häufig verwendet, wenn du einen wiederholten Ausdruck hast, der selbst wiederholt werden kann:

/(a+|b+)*\.+/

Dieses Codeschnipsel braucht mehrere Sekunden, um einen Fehler zu melden:

$p = '/(a+|b+)*\.+$/';
$s = 'abababababbabbbabbaaaaaabbbbabbababababababbba..!';

if (preg_match($p, $s)) {
 echo "Y";
}
else {
 echo "N";
}

Der Grund dafür ist, dass die Engine für reguläre Ausdrücke alle möglichen Stellen ausprobiert, um die Übereinstimmung herzustellen, aber jede einzelne Stelle wieder verlassen muss, was Zeit kostet. Wenn du weißt, dass eine einmal gefundene Übereinstimmung niemals rückgängig gemacht werden soll, solltest du sie mit (?>subpattern):

$p = '/(?>a+|b+)*\.+$/';

Die Kürzung ändert nichts am Ausgang des Spiels, sie lässt es nur schneller fehlschlagen.

Bedingte Ausdrücke

Ein bedingter Ausdruck ist wie eine if Anweisung in einem regulären Ausdruck. Die allgemeine Form ist:

(?(condition)yespattern)
(?(condition)yespattern|nopattern)

Wenn die Behauptung erfolgreich ist, passt die Engine für reguläre Ausdrücke auf das yes-Muster. Bei der zweiten Form überspringt die Engine für reguläre Ausdrücke das Yes-Muster, wenn die Behauptung nicht erfolgreich ist, und versucht, das Nop-Muster zu finden.

Die Behauptung kann eine von zwei Arten sein: entweder ein Rückverweis oder ein Lookahead- oder Lookbehind-Match. Um eine zuvor übereinstimmende Teilzeichenkette zu referenzieren, ist die Assertion eine Zahl von 1 bis 99 (die meisten verfügbaren Rückverweise). Die Bedingung verwendet das Muster in der Assertion nur, wenn die Rückverweisung übereinstimmt. Wenn die Assertion keine Rückreferenz ist, muss es sich um eine positive oder negative Lookahead- oder Lookbehind-Assertion handeln.

Funktionen

Es gibt fünf Klassen von Funktionen, die mit Perl-kompatiblen regulären Ausdrücken arbeiten: Vergleichen, Ersetzen, Aufteilen, Filtern und eine Hilfsfunktion zum Zitieren von Text.

Passend dazu

Die Funktion preg_match() führt einen Mustervergleich im Stil von Perl für eine Zeichenkette durch. Sie ist das Äquivalent zum m// Operator in Perl. Die Funktion preg_match_all() nimmt dieselben Argumente entgegen und gibt denselben Rückgabewert wie die Funktion preg_match() zurück, außer dass sie ein Muster im Perl-Stil statt eines Standardmusters annimmt:

$found = preg_match(pattern, string [, captured ]);

Zum Beispiel:

preg_match('/y.*e$/', 'Sylvie'); // returns true
preg_match('/y(.*)e$/', 'Sylvie', $m); // $m is array('ylvie', 'lvi')

Es gibt zwar eine preg_match() Funktion, um die Groß- und Kleinschreibung zu berücksichtigen, aber keine preg_matchi() Funktion. Verwende stattdessen das i Flag für das Muster:

preg_match('y.*e$/i', 'SyLvIe'); // returns true

Mit der Funktion preg_match_all() werden die Übereinstimmungen ab der Stelle wiederholt, an der die letzte Übereinstimmung endete, bis keine weiteren Übereinstimmungen mehr möglich sind:

$found = preg_match_all(pattern, string, matches [, order ]);

Der Ordnungswert, entweder PREG_PATTERN_ORDER oder PREG_SET_ORDER, bestimmt die Anordnung der Treffer. Wir schauen uns beides an und verwenden diesen Code als Leitfaden:

$string = <<< END
13 dogs
12 rabbits
8 cows
1 goat
END;
preg_match_all('/(\d+) (\S+)/', $string, $m1, PREG_PATTERN_ORDER);
preg_match_all('/(\d+) (\S+)/', $string, $m2, PREG_SET_ORDER);

Bei PREG_PATTERN_ORDER (der Standardeinstellung) entspricht jedes Element des Arrays einem bestimmten Teilmuster der Erfassung. So ist $m1[0] ein Array mit allen Teilzeichenketten, die mit dem Muster übereinstimmen, $m1[1] ist ein Array mit allen Teilzeichenketten, die mit dem ersten Teilmuster übereinstimmen (die Zahlen), und $m1[2] ist ein Array mit allen Teilzeichenketten, die mit dem zweiten Teilmuster übereinstimmen (die Wörter). Das Array $m1 hat ein Element mehr, als es Teilmuster hat.

Bei PREG_SET_ORDER entspricht jedes Element des Arrays dem nächsten Versuch, das gesamte Muster zu finden. So ist $m2[0] ein Array mit der ersten Gruppe von Übereinstimmungen ('13 dogs', '13', 'dogs'), $m2[1] ist ein Array mit der zweiten Gruppe von Übereinstimmungen ('12 rabbits', '12', 'rabbits'), und so weiter. Das Array $m2 hat so viele Elemente, wie es erfolgreiche Übereinstimmungen für das gesamte Muster gab.

Beispiel 4-1 holt den HTML-Code einer bestimmten Webadresse in einen String und extrahiert die URLs aus diesem HTML-Code. Für jede URL wird ein Link zurück zu dem Programm generiert, das die URLs unter dieser Adresse anzeigt.

Beispiel 4-1. URLs aus einer HTML-Seite extrahieren

<?php
if (getenv('REQUEST_METHOD') == 'POST') {
 $url = $_POST['url'];
}
else {
 $url = $_GET['url'];
}
?>

<form action="<?php echo $_SERVER['PHP_SELF']; ?>" method="POST">
 <p>URL: <input type="text" name="url" value="<?php echo $url ?>" /><br />
 <input type="submit">
</form>

<?php
if ($url) {
 $remote = fopen($url, 'r'); {
 $html = fread($remote, 1048576); // read up to 1 MB of HTML
 }
 fclose($remote);

 $urls = '(http|telnet|gopher|file|wais|ftp)';
 $ltrs = '\w';
 $gunk = '/#~:.?+=&%@!\-';
 $punc = '.:?\-';
 $any = "{$ltrs}{$gunk}{$punc}";

 preg_match_all("{
 \b # start at word boundary
 {$urls}: # need resource and a colon
 [{$any}] +? # followed by one or more of any valid
 # characters—but be conservative
 # and take only what you need
 (?= # the match ends at
 [{$punc}]* # punctuation
 [^{$any}] # followed by a non-URL character
 | # or
 \$ # the end of the string
 )
 }x", $html, $matches);

 printf("I found %d URLs<P>\n", sizeof($matches[0]));

 foreach ($matches[0] as $u) {
 $link = $_SERVER['PHP_SELF'] . '?url=' . urlencode($u);
 echo "<a href=\"{$link}\">{$u}</a><br />\n";
 }
}

Ersetzen von

Die Funktion preg_replace() verhält sich wie die Such- und Ersetzungsfunktion in deinem Texteditor. Sie findet alle Vorkommnisse eines Musters in einer Zeichenkette und ändert diese Vorkommnisse in etwas anderes:

$new = preg_replace(pattern, replacement, subject [, limit ]);

Bei der häufigsten Verwendung werden alle Argumente mit Ausnahme des ganzzahligen Limits angegeben. Das Limit ist die maximale Anzahl der Vorkommen des zu ersetzenden Musters (die Standardeinstellung und das Verhalten, wenn ein Limit von −1 übergeben wird, sind alle Vorkommen):

$better = preg_replace('/<.*?>/', '!', 'do <b>not</b> press the button');
// $better is 'do !not! press the button'

Übergib ein Array von Strings als Subjekt, um die Ersetzung für alle Strings durchzuführen. Die neuen Zeichenketten werden von preg_replace() zurückgegeben:

$names = array('Fred Flintstone',
 'Barney Rubble',
 'Wilma Flintstone',
 'Betty Rubble');
$tidy = preg_replace('/(\w)\w* (\w+)/', '\1 \2', $names);
// $tidy is array ('F Flintstone', 'B Rubble', 'W Flintstone', 'B Rubble')

Um mehrere Ersetzungen für dieselbe Zeichenkette oder ein Array von Zeichenketten mit einem Aufruf von preg_replace() durchzuführen, übergibst du Arrays von Mustern und Ersetzungen:

$contractions = array("/don't/i", "/won't/i", "/can't/i");
$expansions = array('do not', 'will not', 'can not');
$string = "Please don't yell - I can't jump while you won't speak";
$longer = preg_replace($contractions, $expansions, $string);
// $longer is 'Please do not yell - I can not jump while you will not speak';

Wenn du weniger Ersetzungen als Muster angibst, wird der Text, der auf die zusätzlichen Muster passt, gelöscht. Das ist eine praktische Methode, um eine Menge Dinge auf einmal zu löschen:

$htmlGunk = array('/<.*?>/', '/&.*?;/');
$html = '&eacute; : <b>very</b> cute';
$stripped = preg_replace($htmlGunk, array(), $html);
// $stripped is ' : very cute'

Wenn du eine Reihe von Mustern, aber nur eine einzige Zeichenfolgenersetzung angibst, wird für jedes Muster die gleiche Ersetzung verwendet:

$stripped = preg_replace($htmlGunk, '', $html);

Die Ersetzung kann Rückverweise verwenden. Im Gegensatz zu Rückverweisen in Mustern ist die bevorzugte Syntax für Rückverweise in Ersetzungen jedoch $1, $2, $3, und so weiter. Zum Beispiel:

echo preg_replace('/(\w)\w+\s+(\w+)/', '$2, $1.', 'Fred Flintstone')
Flintstone, F.

Der /e Modifikator sorgt dafür, dass preg_replace() die Ersetzungszeichenfolge als PHP-Code behandelt, der die tatsächliche Zeichenfolge für die Ersetzung zurückgibt. So wird zum Beispiel jede Celsius-Temperatur in Fahrenheit umgewandelt:

$string = 'It was 5C outside, 20C inside';
echo preg_replace('/(\d+)C\b/e', '$1*9/5+32', $string);
It was 41 outside, 68 inside

Dieses komplexere Beispiel erweitert die Variablen in einem String:

$name = 'Fred';
$age = 35;
$string = '$name is $age';
preg_replace('/\$(\w+)/e', '$$1', $string);

Jede Übereinstimmung isoliert den Namen einer Variablen ($name, $age). Das $1 in der Ersetzung bezieht sich auf diese Namen, so dass der tatsächlich ausgeführte PHP-Code $name und $age ist. Dieser Code wird zum Wert der Variablen ausgewertet, der als Ersetzung verwendet wird. Puh!

Eine Variante von preg_replace() ist preg_replace_callback() . Diese ruft eine Funktion auf, um die Ersatzzeichenfolge zu erhalten. Der Funktion wird ein Array mit Übereinstimmungen übergeben (das nullte Element ist der gesamte Text, der mit dem Muster übereinstimmt, das erste ist der Inhalt des ersten erfassten Teilmusters usw.). Ein Beispiel:

function titlecase($s)
{
 return ucfirst(strtolower($s[0]));
}

$string = 'goodbye cruel world';
$new = preg_replace_callback('/\w+/', 'titlecase', $string);
echo $new;

Goodbye Cruel World

Splitting

Während du preg_match_all() verwendest, um Teile einer Zeichenkette zu extrahieren, wenn du weißt, was diese Teile sind, kannst du preg_split() verwenden, um Teile zu extrahieren, wenn du weißt, was die Teile voneinander trennt:

$chunks = preg_split(pattern, string [, limit [, flags ]]);

Das Muster passt auf ein Trennzeichen zwischen zwei Chunks. In der Standardeinstellung werden die Trennzeichen nicht zurückgegeben. Das optionale Limit gibt an, wie viele Chunks maximal zurückgegeben werden sollen (−1 ist die Vorgabe, d.h. alle Chunks). Das Argument flags ist eine bitweise ODER-Kombination der Flags PREG_SPLIT_NO_EMPTY (leere Chunks werden nicht zurückgegeben) und PREG_SPLIT_DELIM_CAPTURE (Teile der im Muster erfassten Zeichenfolge werden zurückgegeben).

Um zum Beispiel nur die Operanden eines einfachen numerischen Ausdrucks zu extrahieren, verwendest du:

$ops = preg_split('{[+*/−]}', '3+5*9/2');
// $ops is array('3', '5', '9', '2')

Um die Operanden und die Operatoren zu extrahieren, benutze:

$ops = preg_split('{([+*/−])}', '3+5*9/2', −1, PREG_SPLIT_DELIM_CAPTURE);
// $ops is array('3', '+', '5', '*', '9', '/', '2')

Ein leeres Muster passt auf jede Grenze zwischen Zeichen in der Zeichenkette sowie auf den Anfang und das Ende der Zeichenkette. Damit kannst du eine Zeichenkette in ein Array von Zeichen aufteilen:

$array = preg_split('//', $string);

Filtern eines Arrays mit einem regulären Ausdruck

Die Funktion preg_grep() gibt die Elemente eines Arrays zurück, die einem bestimmten Muster entsprechen :

$matching = preg_grep(pattern, array);

Um zum Beispiel nur die Dateinamen zu erhalten, die auf .txt enden, verwende:

$textfiles = preg_grep('/\.txt$/', $filenames);

Zitate für reguläre Ausdrücke

Die Funktion preg_quote() erstellt einen regulären Ausdruck, der nur auf eine bestimmte Zeichenkette passt:

$re = preg_quote(string [, delimiter ]);

Jedem Zeichen in einer Zeichenkette, das innerhalb eines regulären Ausdrucks eine besondere Bedeutung hat (z. B. * oder $), wird ein Backslash vorangestellt:

echo preg_quote('$5.00 (five bucks)');
\$5\.00 \(five bucks\)

Das optionale zweite Argument ist ein zusätzliches Zeichen, das in Anführungszeichen gesetzt wird. Normalerweise übergibst du hier dein Trennzeichen für den regulären Ausdruck:

$toFind = '/usr/local/etc/rsync.conf';
$re = preg_quote($toFind, '/');

if (preg_match("/{$re}/", $filename)) {
 // found it!
}

Unterschiede zu regulären Ausdrücken in Perl

Obwohl die PHP-Implementierung von regulären Ausdrücken im Perl-Stil sehr ähnlich ist, gibt es ein paar kleine Unterschiede zu den regulären Ausdrücken in Perl:

• Das NULL-Zeichen (ASCII 0) ist als literales Zeichen in einer Musterzeichenfolge nicht erlaubt. Du kannst es jedoch auf andere Weise referenzieren (\000, \x00, etc.).

• Die Optionen \E, \G, \L, \l, \Q, \u, und \U werden nicht unterstützt.

• Das (?{ some perl code }) Konstrukt wird nicht unterstützt.

• Die Modifikatoren /D, /G, /U, /u, /A und /X werden unterstützt.

• Der vertikale Tabulator \v zählt als Leerzeichen.

• Lookahead- und Lookbehind-Assertions können nicht mit *, + oder ? wiederholt werden.

• Eingeklammerte Submatches in negativen Aussagen werden nicht erinnert.

• Alternierende Zweige innerhalb einer Lookbehind-Assertion können unterschiedlich lang sein.

Was kommt als Nächstes?

Da du nun alles über Strings und die Arbeit mit ihnen weißt, werden wir uns als Nächstes mit Arrays beschäftigen. Diese zusammengesetzten Datentypen werden dich herausfordern, aber du musst dich gut mit ihnen vertraut machen, da PHP in vielen Bereichen mit ihnen arbeitet. Zu lernen, wie man Array-Elemente hinzufügt, Arrays sortiert und mit mehrdimensionalen Arrays umgeht, ist wichtig, um ein guter PHP-Entwickler zu sein.