In diesem Kapitel werden Vergleichsoperatoren beschrieben. Diese Operatoren prüfen die Gleichheit (z. B. gleich, kleiner als, identisch gleich usw.) zwischen zwei Werten und geben je nach Beziehung der Operanden wahr oder falsch zurück. Vergleichsoperatoren geben immer boolesche Werte zurück, und diese Werte werden am häufigsten in Anweisungen wie , while oder for verwendet, um den Ablauf der Programmausführung zu steuern.

Hinweis: Wenn Sie versuchen, das Ergebnis des Vergleichsvorgangs auf dem Bildschirm anzuzeigen, wird der Wert „true“ im Browserfenster als 1 angezeigt. Der Wert „false“ entspricht der Zahl 0 und wird nicht auf dem Bildschirm angezeigt (im Prinzip werden Sie nicht angezeigt). sollte sich dies aus der Beschreibung des booleschen Typs merken). Wenn Sie das Ergebnis als wahr oder falsch sehen möchten, verwenden Sie die Funktion var_dump().

Es ist auch erwähnenswert: Wenn eine Zeichenfolge mit einer Zahl oder zwei Zeichenfolgen, die Zahlen enthalten, verglichen werden, wird jede Zeichenfolge in eine Zahl umgewandelt und sie werden als Zahlen verglichen.

Operator == (Gleichheiten)

Der Operator == (Gleichheit) akzeptiert Operanden jeden Typs; wenn die beiden Operanden gleich sind, gibt er true zurück, andernfalls gibt er false zurück.

Wenn die Operanden unterschiedliche Datentypen haben, versucht PHP, sie vor dem Vergleich in denselben Datentyp umzuwandeln. Beispielsweise gibt der Ausdruck „4“ == 4 „true“ zurück, da PHP die zu vergleichenden Werte automatisch umwandelt gleichen Datentyp. Ebenso gibt der Ausdruck $a == 1 true zurück, wenn die Variable $a den Wert 1 enthält. Wenn Sie beim Vergleich eine implizite Typkonvertierung vermeiden möchten, sollten Sie den Identitätsoperator verwenden, der später erläutert wird.

Operator === (Identitäten)

Der Operator === (Identität) akzeptiert Operanden jeden Typs und gibt true zurück, wenn ihre Werte gleich (gleich) sind, und false, wenn sie unterschiedlich sind. Wie unterscheidet es sich vom Gleichheitsoperator? Der Identitätsoperator testet zwei Operanden auf „Identität“ basierend auf einer strengen Definition einer Übereinstimmung, was bedeutet, dass die Werte der Operanden selbst nicht nur gleich sein müssen, sondern auch vom gleichen Datentyp sein müssen. Betrachten Sie als Beispiel einen Ausdruck wie 5 === "5" . Das Ergebnis dieses Ausdrucks ist falsch, da der Wert links eine Zahl und der Wert rechts eine Zeichenfolge ist, d. h. diese Werte ​haben unterschiedliche Datentypen. Denken Sie daran, dass die Operatoren == und === „gleich“ und „identisch/identisch gleich“ bedeuten.

Operator != oder<>(Ungleichheiten)

Ungleichheitsoperator hat zwei Typen: != und<>. Er ist das Gegenteil des ==-Operators und gibt „true“ zurück, wenn die Operanden nicht gleich sind. Der Ungleichheitsoperator gibt nur dann „false“ zurück, wenn die Werte auf beiden Seiten gleich sind.

$var2); // false zurückgeben var_dump("Home"<>"heim"); // true zurückgeben?>

Operator !== (Nichtidentität)

Der !== (Nicht-Identitäts)-Operator führt genau das Gegenteil des ===-Operators aus. Es gibt true zurück, wenn die Operandenwerte nicht gleich sind oder nicht vom gleichen Datentyp sind. Betrachten Sie als Beispiel den folgenden Ausdruck: 7 !== "7" , der Operator „non-identity“ gibt „true“ zurück, da der Wert auf der linken Seite eine Zahl und der Wert auf der rechten Seite eine Zeichenfolge ist, was bedeutet, dass sie unterschiedlich sind Datentypen. Von hier aus wird es leicht zu merken sein, dass die Operatoren != und !== „ungleich“ und „nicht identisch/identisch ungleich“ bedeuten.

Betreiber > (mehr)

Bei Verwendung des Operators > (größer als) gibt der Vergleich nur dann „true“ zurück, wenn der Wert links vom Operator größer ist als der Wert rechts davon. Wie andere Operatoren funktioniert der >-Operator nicht nur mit numerischen Werten, sondern auch mit Zeichenfolgenwerten. Aber wie kann eine Linie größer sein als eine andere?

Beim Arbeiten mit Zeichenfolgen ist ein Kleinbuchstabe größer als ein Großbuchstabe. Beim Vergleich von Zeichenfolgen prüft PHP zunächst den ersten Buchstaben der Zeichenfolge auf Nichtübereinstimmung. Wenn kein Unterschied gefunden wird, wird mit dem nächsten Zeichen fortgefahren und so weiter, bis ein Unterschied gefunden wird oder das Ende der Zeile erreicht wird. Wenn die beiden Werte auf beiden Seiten des >-Operators gleich sind, gibt der Operator auch false zurück.

3); // true zurückgeben var_dump("Hi" > "hi"); // false zurückgeben var_dump(1 > 1); // false zurückgeben ?>

Operator< (меньше)

Operator< (меньше ) является функциональной противоположностью оператора «больше». Он возвращает true , когда значение слева от него меньше значения, находящегося справа, и false , если значение левого операнда больше правого или значения равны.

Operator >= (größer oder gleich)

Operator >= ( mehr oder gleich) unterscheidet sich geringfügig von den zuvor besprochenen Vergleichsoperatoren. Es bietet die Möglichkeit, dass zwei Werte auf beiden Seiten gleich sind. Das heißt, damit true zurückgegeben wird, muss der Wert links vom Operator größer oder gleich dem Wert rechts davon sein. Der Größer-gleich-Operator gibt nur dann „Falsch“ zurück, wenn der Wert links davon kleiner als der Wert rechts davon ist.

= 5); // true zurückgeben var_dump("hi" >= "hi"); // true zurückgeben var_dump(1 >= 2); // false zurückgeben ?>

Operator<= (kleiner oder gleich)

Operator<= (меньше или равно) похож на оператор «больше или равно». Чтобы оператор <= вернул true , значение слева от оператора должно быть меньше или равно значению справа от него. Он возвращает false , только если значение слева от него больше, чем значение справа.

Vergleicht Zeichenfolgen.

Syntax:

Int strcmp(string str1, string str2)

substr_compare()

Binärsicherer Vergleich von 2 Strings mit Offset, case-sensitive oder case-insensitive (PHP 5)

Beschreibung:

Int substr_compare (string main_str, string str, int offset [, int length [, bool case_sensitivity]])

substr_compare() vergleicht die Zeichenfolge main_str beginnend bei dem durch das Offset-Argument angegebenen Zeichen mit der Zeichenfolge str. Der Vergleich umfasst maximal Zeichenlängen.

Gibt die Zahl 0 zurück, wenn sie größer als str ist, und 0, wenn die Zeichenfolgen gleich sind. Wenn die Länge größer oder gleich der Länge von main_str ist und ein Offset übergeben wird, gibt substr_compare() eine Warnung aus und gibt FALSE zurück.

Wenn case_sensitivity TRUE ist, wird beim Vergleich die Groß-/Kleinschreibung beachtet.

Beispiel für die Verwendung von substr_compare()

echo substr_compare("abcde", "bc", 1, 2); // 0
echo substr_compare("abcde", "bcg", 1, 2); // 0
echo substr_compare("abcde", "BC", 1, 2, true); // 0
echo substr_compare("abcde", "bc", 1, 3); // 1
echo substr_compare("abcde", "cd", 1, 2); // -1
echo substr_compare("abcde", "abc", 5, 1); // Warnung
?>

Vergleicht die Anfänge von Zeichenfolgen.
Syntax:

Int strncmp(string str1, string str2, int len)

Diese Funktion unterscheidet sich von strcmp() dadurch, dass sie nicht das gesamte Wort, sondern die ersten len Bytes vergleicht. Wenn len kleiner als die Länge der kleinsten Zeichenfolge ist, werden die gesamten Zeichenfolgen verglichen.
Diese Funktion vergleicht zwei Zeichenfolgen Zeichen für Zeichen (genauer gesagt Byte-Byte) und gibt Folgendes zurück:

0 – wenn die Zeichenfolgen vollständig übereinstimmen;

1 – wenn die Zeichenfolge str1 lexikographisch kleiner als str2 ist;

1 - wenn im Gegenteil str1 „größer“ als str2 ist.

Da der Vergleich byteweise erfolgt, wirkt sich die Groß-/Kleinschreibung der Zeichen auf die Vergleichsergebnisse aus.

strcasecmp

Vergleicht Zeichenfolgen ohne Berücksichtigung der Groß-/Kleinschreibung.
Syntax:

Int strcasecmp(string str1, string str2)

Dasselbe wie strcmp(), nur dass die Groß-/Kleinschreibung von Buchstaben nicht berücksichtigt wird.

$str1 = "Hallo!";
$str2 = "Hallo!";
if(!strcesecmp($str1, $str2))
echo "$str1 == $str2 beim Vergleich von Zeichenfolgen ohne Berücksichtigung der Groß- und Kleinschreibung";

strncasecmp

Vergleicht die Anfänge von Zeichenfolgen ohne Berücksichtigung der Groß-/Kleinschreibung.
Syntax:

Int strncasecmp(string str1, string str2, int len)

Die Funktion strncasecmp() ist eine Kombination der Funktionen strcasecmp() und strncmp().

strnatcmp

Führt einen „natürlichen“ Zeichenfolgenvergleich durch.
Syntax:

Int strnatcmp(string str1, string str2)

Diese Funktion simuliert den String-Vergleich, den ein Mensch verwenden würde.

$arr1 = $arr2 = array("img12.png", "img10.png", "img2.png", "img1.png");
echo „Normale Sortierung“;
usort($arr1, "strcmp");
print_r($arr1);
echo „nNatürliche Sortierung“;
usort($arr2, "strnatcmp");
print_r($arr2);

Dieses Skript gibt Folgendes aus:

Normales sortArray(
=> img1.png
=> img10.png
=> img12.png
=> img2.png
)

Natürliches sortArray(
=> img1.png
=> img2.png
=> img10.png
=> img12.png
)

strnatcasecmp

Führt einen „natürlichen“ Zeichenfolgenvergleich ohne Berücksichtigung der Groß-/Kleinschreibung durch.
Syntax:

Int strnatcasecmp(string str1, string str2)

Identisch mit strnatcmp(), außer dass die Groß-/Kleinschreibung ignoriert wird.

ähnlicher_text

Bestimmt die Ähnlichkeit zweier Zeichenfolgen.
Syntax:

Int ähnlicher_text(Zeichenfolge zuerst, Zeichenfolge zweitens [, doppeltes Prozent])

Die Funktion „like_text()“ berechnet die Ähnlichkeit zweier Zeichenfolgen mithilfe des von Oliver beschriebenen Algorithmus.
Aber anstelle eines Stapels (wie in Olivers Pseudocode) werden rekursive Aufrufe verwendet.
Die Komplexität des Algorithmus macht die Funktion langsam und ihre Geschwindigkeit ist proportional zu (N^3), wobei N die Länge der größten Zeichenfolge ist.
Die Funktion gibt die Anzahl der Zeichen zurück, die in beiden Zeichenfolgen übereinstimmten. Wenn der dritte optionale Parameter als Referenz übergeben wird, wird der Prozentsatz der Zeichenfolgenübereinstimmungen gespeichert.

Levenshtein

Bestimmung der Levenshtein-Differenz zweier Saiten.
Syntax:

Int levenshtein(string str1, string str2)
int levenshtein(string str1, string str2, int cost_ins, int cost_rep, int cost_del)
int levenshtein(string str1, string str2, Funktionskosten)

Der Levenshtein-Unterschied ist die Mindestanzahl an Zeichen, die ersetzt, eingefügt oder gelöscht werden müssten, um str1 in str2 umzuwandeln. Die Komplexität des Algorithmus ist proportional zum Produkt der Längen der Zeichenfolgen str1 und str2, wodurch die Funktion schneller als „like_text()“ ist.

Die erste Form der Funktion gibt die Anzahl der erforderlichen Operationen an Zeichenfolgezeichen zurück, um str1 in str2 umzuwandeln.

Das zweite Formular verfügt über drei zusätzliche Parameter: die Kosten für Einfüge-, Ersetzungs- und Löschvorgänge, wodurch es für die Berechnung besser geeignet, aber gleichzeitig weniger schnell ist. Der integrale Indikator der Transformationskomplexität wird zurückgegeben.
Mit der dritten Option können Sie die Funktion angeben, die zur Berechnung der Komplexität der Transformation verwendet wird.
Die Kostenfunktion wird mit den folgenden Argumenten aufgerufen:

Angewandte Operation (Einfügen, Ändern, Löschen): „I*, „R“, „D“;

tatsächliches Zeichen der ersten Zeile

tatsächliches Zeichen der zweiten Zeile

Zeilenposition 1

Zeilenposition 2

verbleibende Zeilenlänge 1

verbleibende Zeilenlänge 2

Die aufgerufene Funktion muss die Kosten dieser Operation zurückgeben.
Wenn einer der Strings länger als 255 Zeichen ist, gibt levenshtein() -1 zurück.
aber diese Länge ist mehr als ausreichend.

strcoll()

Vergleichen Sie Zeichenfolgen basierend auf dem aktuellen Gebietsschema (PHP 4 >= 4.0.5, PHP 5)

Beschreibung:

Int strcoll (String str1, String str2)

Gibt eine positive Zahl zurück, wenn str1 kleiner als str2 ist; eine negative Zahl, wenn str1 größer als str2 ist, und 0, wenn die Zeichenfolgen gleich sind. strcoll() verwendet beim Vergleich die Einstellungen des aktuellen Gebietsschemas. Wenn das Gebietsschema C oder POSIX ist, ist diese Funktion dieselbe wie strcmp().

Beachten Sie, dass bei dieser Funktion die Groß-/Kleinschreibung beachtet wird und sie im Gegensatz zu strcmp() nicht binärsicher ist.

PHP ist gut auf die Informationsverarbeitung ausgerichtet. Die Sprachsyntax wird durch einen umfassenden Satz von Vergleichsfunktionen, Zeichenfolgenverarbeitung und Vergleichsoperatoren dargestellt.

Jeder Algorithmus ist eine Folge von Entscheidungen und Aktionen. Aber bevor Sie eine Wahl treffen, müssen Sie etwas mit etwas vergleichen. Strings sind der umfangreichste, effizienteste und praktischste Mechanismus zur Steuerung eines Algorithmus. Zeilen sind eine Option zur Datendarstellung. Und Daten sind das Hauptanliegen jedes Algorithmus.

Konventionelle Vergleichs-Aktionslogik

Im Allgemeinen macht die Sprache keine besonderen Unterschiede in den Daten; in PHP ist der Vergleich einer Zeichenfolge und einer Zahl beispielsweise nicht viel anders. Eine Zahl ist auch dann eine Zeichenfolge, wenn sie nur Ziffern, einen Punkt und keine Zeichen enthält, die nicht zur Darstellung der Zahl in irgendeiner Form (mathematische Notation) verwendet werden.

Im Falle einer Kontinuität wird die Zahl ohne unnötige Fragen und ohne versteckte Fehler automatisch in die Zeichenfolge eingefügt, selbst wenn die Funktion gettype() „integer“ oder „double“ zurückgibt.

Es gibt jedoch einen Unterschied zwischen der Verwendung der Funktionen is_int() und is_numeric(). Der erste gibt „true“ aus, wenn der Parameter nur eine Ganzzahl ist, der zweite, wenn eine beliebige Zahl oder eine numerische Zeichenfolge vorliegt (die Variable ist vom Typ „string“, enthält aber alles, was die mathematische Notation bereitstellt).

Dieses einfache Beispiel ist ein gutes Beispiel dafür, wie PHP-String-Vergleichsoperatoren ("==", "===", "!=", ...) viele Überraschungen bereiten können. Variablen können ihren Typ ändern; es handelt sich nicht immer um Zahlen, aber sie können fast immer in einen String umgewandelt werden. Im Extremfall handelt es sich um eine leere Zeichenfolge.

Basierend auf dem oben Gesagten ist die String-Vergleichsfunktion die beliebteste in PHP. Es ist Sache des Entwicklers, zu entscheiden, welches er wählt. Es stehen viele Optionen zur Verfügung, darunter auch reguläre Ausdrücke.

Grenzen der verfügbaren Funktionalität

Der PHP-Vergleich zweier Strings gelingt gut mit der Funktion strpos() – der günstigsten, genauesten und praktischsten Option. Wenn es sich bei der Funktion um eine Zahl handelt, ist eine Zeichenfolge definitiv gleich der anderen oder eine ist in der anderen enthalten.

Ein radikal entgegengesetzter, aber auch absolut korrekter Ansatz ist die Verwendung regulärer Ausdrücke.

Wenn der Funktionsaufruf $cResult = scCheckFileName($cStr) „true“ zurückgibt, dann ist die Zeichenfolge der Name einer Word-Datei. Es wird nur eine Erweiterungsoption „.docx“ und keine Symbole im Namen haben: nur Buchstaben, Zahlen und Zeichen „_“, „-“.

Die Funktion kann problemlos in andere Dateitypen konvertiert werden: $cPtr = "/^((4,239))\.(html|js|css|png|jpg|docx|txt)(1)$/u". Diese Option zum Überprüfen einer Zeichenfolge erweitert den Bereich der geladenen Zeichenfolgen (in PHP wird der Zeichenfolgenvergleich beispielsweise verwendet, um „Dateien auf den Server hochzuladen, ohne dass die Möglichkeit eines Eingabefehlers besteht“) auf HTML, JS, CSS usw.

Die Verwendung von strpos() und preg_match() sind Extreme. Sie stehen in keinem direkten Zusammenhang mit der Frage des Begriffsvergleichs. Bei der Frage des Algorithmus geht es jedoch darum, eine Kombination von Stilen anzuwenden und alle Möglichkeiten zu nutzen, um ein zuverlässiges und korrektes Ergebnis zu erzielen.

PHP-Funktionalität: String-Vergleich

Das String-Vergleichsarsenal der Sprache umfasst nicht nur reine Vergleichsfunktionen, sondern auch eine Kombination mit direktem Suchen oder Ersetzen. Die Aktion muss nicht immer mit einem Vergleich identisch sein, da dieser nicht unbedingt eine Zeile verändert. Oft müssen Sie den einen oder anderen Zweig des Algorithmus auswählen.

Die übliche PHP-Version: Der String-Vergleich wird von der Funktion int strcmp (s1, s2) durchgeführt.

Funktionsergebnis:

• 0 – Zeichenfolgen sind gleich;
• -1 – die erste Zeile ist kleiner als die zweite;
• 1 – die erste Zeile ist größer als die zweite.

In der Praxis bedeutet dies, dass der erste String in den zweiten einbezogen wird, woraus die PHP-Funktion (String-Vergleich) eine Entscheidung trifft. Eine eingeschränktere Variante von strpos(), da im letzteren Fall die Position des Vorkommens bekannt sein kann.

Bei der Funktion strcmp() wird die Groß-/Kleinschreibung beachtet. Wenn Sie Zeichenfolgen ohne Berücksichtigung der Groß-/Kleinschreibung vergleichen müssen, empfiehlt PHP die Verwendung von strcasecmp(). Die Syntax ist ähnlich.

In der Praxis ist es oft notwendig, nicht mit der gesamten Saite, sondern nur mit einem Teil davon zu arbeiten. Zu diesem Zweck enthält der Satz von PHP-Funktionen (String-Vergleich) strncmp (s1, s2, N). Der dritte Parameter gibt an, nur N-Bytes zu vergleichen. Das Ergebnis ist das gleiche wie bei strcmp().

Arrays, Strings und Vergleich

Daten werden fast immer als Zeichenfolgen dargestellt. Wenn wir Arrays, Objekte oder Informationsstrukturen betrachten, dann sind dies einfach verschiedene Kombinationen einfacherer String-Strukturen.

String-Arrays und Strings können komplementär dargestellt werden. Ein Array mit der Funktion implode(array, symbol) in einen String umwandeln, zum Beispiel: $margins1 = implode(", ", $style->getInnerMargin()); ...die Arbeit des Algorithmus/Benutzers...; Mit $margins2 = implode(", ", $style->getInnerMargin()) können Sie alle Objektpositionen in einem Positionsstring zusammenführen.

Sie können dann einen PHP-String-Vergleich durchführen und auf einmal: $check = strcmp ($margins1, $margins2) und sicherstellen, dass der Algorithmus oder der Benutzer etwas geändert hat (oder nicht). Wenn Sie den Vergleich auf die übliche Weise durchführen, müssen Sie über die Elemente der Arrays iterieren. Das dauert länger und sieht umständlicher aus.

Objekte und Strings

Ein noch leistungsfähigerer Einsatz von PHP (String-Vergleich) lässt sich durch objektorientierte Ideen umsetzen.

Die moderne Vorstellung von Objekten geht davon aus, dass sie Eigenschaften und Methoden haben. Erstere werden normalerweise durch Zahlen, Zeichenfolgen, Arrays und andere Objekte dargestellt. Letztere umfassen häufig Methoden zum Schreiben (Put) in einen String und zum Wiederherstellen aus einem String (Get).

Im Gegensatz zu Arrays arbeitet ein Objekt mit seinen eigenen Eigenschaften und interagiert mit anderen Objekten. Ein Objekt ist „kompetent“ in Bezug auf die Eigenschaften, die für den Algorithmus, das Programm als Ganzes, tatsächlich von Bedeutung sind.

Dieser Punkt bietet die Grundlage und Möglichkeit, bei der Aufzeichnung nur die notwendigen Informationen in einer Zeile aufzuzeichnen und bei der Wiederherstellung aus einer Zeile alle Arbeitseigenschaften wieder in den gewünschten Zustand zu versetzen. Typischerweise enthält jedes Objekt wesentliche und betriebliche (temporäre) Informationen. Die Umsetzung dieser Idee ermöglicht es Ihnen, nicht nur Speicher, Speicherplatz und Datenbankeinträge zu sparen, sondern ermöglicht auch den Vergleich von Zeichenfolgen mit einfacheren und genaueren Mitteln.

Syntax und Semantik

PHP entwickelt sich dynamisch und seine Funktionalität, sowohl im Hinblick auf den Vergleich von Zeichenfolgen als auch auf deren Verarbeitung, wird ständig verbessert. Allerdings hindert den Entwickler nichts daran, den Schwerpunkt in den Bereich der Semantik zu verlagern.

Zweifellos ist die Funktionalität gut, aber ihre Verwendung lässt sich auf den semantischen Teil des Codes, auf Objekte, übertragen. Wenn ein Algorithmus als System der Interaktion von Objekten dargestellt wird, sieht er viel besser aus als eine Abfolge von Vergleichen und Aktionen im geradlinigen, klassischen Stil.