Тази глава описва операторите за сравнение. Тези оператори проверяват за равенство (като равно на, по-малко от, идентично равно на и т.н.) между две стойности и връщат true или false в зависимост от това как са свързани операндите. Операторите за сравнение винаги връщат булеви стойности и тези стойности най-често се използват в изрази като , while или for за контролиране на потока на изпълнение на програмата.

Забележка: ако се опитате да покажете резултата от операция за сравнение на екрана, стойността true ще се покаже в прозореца на браузъра като 1. Стойността false съответства на числото 0 и не се показва на екрана (по принцип вие трябва да запомните това от описанието на булевия тип). Ако искате да видите резултата като true или false, използвайте функцията var_dump().

Също така си струва да се отбележи: ако се сравняват низ с число или два низа, които съдържат числа, всеки низ ще бъде преобразуван в число и те ще бъдат сравнени като числа.

Оператор == (равенства)

Операторът == (равенство) приема операнди от всякакъв тип, ако двата операнда са равни, връща true, в противен случай връща false.

Ако операндите са от различни типове данни, PHP ще се опита да ги преобразува в един и същ тип данни, преди да ги сравни, например изразът "4" == 4 ще върне истина, защото PHP автоматично ще преобразува стойностите, които се сравняват с същия тип данни. По подобен начин изразът $a == 1 ще върне истина, ако променливата $a съдържа стойност 1. Ако искате да избегнете имплицитно преобразуване на типа при сравняване, трябва да използвате оператора за идентичност, който ще бъде обсъден по-късно.

Оператор === (самоличности)

Операторът === (identity) приема операнди от всякакъв тип и връща true, ако стойностите им са еднакви (равни), и false, ако са различни. Как се различава от оператора за равенство? Операторът за идентичност тества два операнда за „идентичност“ въз основа на стриктна дефиниция на съвпадение, което означава, че освен че стойностите на самите операнди са еднакви, те също трябва да бъдат от един и същи тип данни. Като пример, разгледайте израз като 5 === "5" , резултатът от този израз ще бъде фалшив, тъй като стойността отляво е число, а стойността отдясно е низ, тоест тези стойности имат различни типове данни. Не забравяйте, че операторите == и === означават „равно на“ и „идентично/идентично равно“.

Оператор != или<>(неравенства)

Оператор за неравенствоима два типа: != и<>. Това е обратното на оператора == и връща true, ако операндите не са равни. Операторът за неравенство връща false само ако стойностите от двете му страни са равни една на друга.

$var2); // връща невярно var_dump("Начало"<>"дом"); // връща true ?>

Оператор !== (без идентичност)

Операторът !== (без идентичност) изпълнява точно обратното на оператора ===. Връща true, ако стойностите на операнда не са равни една на друга или не са от един и същи тип данни. Като пример, разгледайте следния израз: 7 !== "7" , операторът "non-identity" ще върне true, защото стойността отляво е число, а стойността отдясно е низ, което означава, че те са различни типове данни. От тук ще бъде лесно да запомните, че операторите != и !== означават „не е равно“ и „не е идентично/идентично, не е равно“.

Оператор > (още)

Когато използвате оператора > (по-голямо от), сравнението връща true само ако стойността вляво от оператора е по-голяма от стойността вдясно от него. Подобно на други оператори, операторът > работи не само с числови стойности, но и с низови стойности. Но как може една линия да е по-голяма от друга?

Когато работите с низове, малката буква е по-голяма от главната. Когато сравнява низове, PHP първо проверява първата буква на низа за несъответствие. Ако не се открие разлика, се преминава към следващия знак и така нататък, докато се открие разлика или се стигне до края на реда. Ако двете стойности от двете страни на оператора > са равни, операторът също ще върне false.

3); // връща вярно var_dump("Здравей" > "здравей"); // връща невярно var_dump(1 > 1); // връща невярно ?>

Оператор< (меньше)

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

Оператор >= (по-голямо или равно на)

Оператор >= ( по-голямо или равно на) е малко по-различен от операторите за сравнение, обсъдени по-рано. Добавя възможност две стойности от двете му страни да бъдат равни, т.е. за да бъде върнато true, стойността отляво на оператора трябва да е по-голяма или равна на стойността отдясно на него. Операторът "по-голямо" или "равно" връща false само ако стойността вляво от него е по-малка от стойността вдясно.

= 5); // връща вярно var_dump("hi" >= "hi"); // връща вярно var_dump(1 >= 2); // връща невярно ?>

Оператор<= (по-малко или равно на)

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

Сравнява низове.

Синтаксис:

Int strcmp(низ str1, низ str2)

substr_compare()

Двоично безопасно сравнение на 2 низа с отместване, чувствително към малки или малки букви (PHP 5)

Описание:

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

substr_compare() сравнява низа main_str, започващ от знака, определен от аргумента offset, с низа str. Сравнението включва максимум символи с дължина.

Връща 0, ако е по-голямо от str, и 0, ако низовете са равни. Ако дължината е по-голяма или равна на дължината на main_str и се подаде отместване, substr_compare() издава предупреждение и връща FALSE.

Ако case_sensitivity е TRUE, сравнението е чувствително към малки и малки букви.

Пример за използване на 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); // предупреждение
?>

Сравнява началото на низовете.
Синтаксис:

Int strncmp(низ str1, низ str2, int len)

Тази функция се различава от strcmp() по това, че сравнява не цялата дума, а първите len ​​байтове. Ако len е по-малко от дължината на най-малкия низ, тогава се сравняват целите низове.
Тази функция сравнява два низа символ по знак (по-точно байт байт) и връща:

0 - ако низовете съвпадат напълно;

1 - ако низът str1 е лексикографски по-малък от str2;

1 - ако, напротив, str1 е "по-голям" от str2.

Тъй като сравнението е байт по байт, регистърът на буквите влияе върху резултатите от сравненията.

strcasecmp

Сравнява низове по начин, който не е чувствителен към главни и малки букви.
Синтаксис:

Int strcasecmp(низ str1, низ str2)

Същото като strcmp(), само че не взема предвид регистъра на буквите.

$str1 = "Здравей!";
$str2 = "здравей!";
if(!strcesecmp($str1, $str2))
echo "$str1 == $str2 при сравняване на низове без регистър";

strncasecmp

Сравнява началото на низове без значение за малки и големи букви.
Синтаксис:

Int strncasecmp(низ str1, низ str2, int len)

Функцията strncasecmp() е комбинация от функциите strcasecmp() и strncmp().

strnatcmp

Извършва "естествено" сравнение на низове.
Синтаксис:

Int strnatcmp(низ str1, низ str2)

Тази функция симулира сравнението на низове, което човек би използвал.

$arr1 = $arr2 = масив ("img12.png", "img10.png", "img2.png", "img1.png");
echo "Нормално сортиране";
usort($arr1, "strcmp");
print_r($arr1);
echo "nЕстествено сортиране";
usort($arr2, "strnatcmp");
print_r($arr2);

Този скрипт ще изведе следното:

Нормален sortArray(
=> img1.png
=> img10.png
=> img12.png
=> img2.png
)

Естествен sortArray(
=> img1.png
=> img2.png
=> img10.png
=> img12.png
)

strnatcasecmp

Извършва "естествено" сравнение на низове без значение за малки и главни букви.
Синтаксис:

Int strnatcasecmp(низ str1, низ str2)

Същото като strnatcmp(), с изключение на това, че игнорира главни и малки букви.

подобен_текст

Определя сходството на два низа.
Синтаксис:

Int similar_text(първи низ, втори низ [, двоен процент])

Функцията similar_text() изчислява сходството на два низа, използвайки алгоритъма, описан от Оливър.
Но вместо стек (както в псевдокода на Оливър), той използва рекурсивни извиквания.
Сложността на алгоритъма прави функцията бавна и нейната скорост е пропорционална на (N^3), където N е дължината на най-големия низ.
Функцията връща броя символи, които съвпадат в двата низа. При предаване на третия незадължителен параметър по референция, той съхранява процента на съвпаденията на низа.

левещайн

Определяне на разликата на Левенщайн на две струни.
Синтаксис:

Int levenshtein(низ str1, низ str2)
int levenshtein(низ str1, низ str2, int cost_ins, int cost_rep, int cost_del)
int levenshtein(низ str1, низ str2, цена на функцията)

Разликата на Levenshtein е минималният брой знаци, които трябва да бъдат заменени, вмъкнати или изтрити, за да се превърне str1 в str2. Сложността на алгоритъма е пропорционална на произведението на дължините на низовете str1 и str2, което прави функцията по-бърза от similar_text().

Първата форма на функцията връща броя на необходимите операции върху символи от низ за трансформиране на str1 в str2.

Втората форма има три допълнителни параметъра: цената на операциите по вмъкване, замяна и изтриване, което я прави по-подходяща за изчисляване, но в същото време по-малко бърза. Интегралният индикатор за сложността на трансформацията се връща.
Третата опция ви позволява да посочите функцията, използвана за изчисляване на сложността на трансформацията.
Функцията на разходите се извиква със следните аргументи:

приложена операция (вмъкване, промяна, изтриване): "I*, "R", "D";

действителен знак от първия ред

действителен знак от втория ред

позиция на линия 1

позиция на линия 2

оставаща дължина на реда 1

оставаща дължина на реда 2

Извиканата функция ще трябва да върне цената на тази операция.
Ако един от низовете е по-дълъг от 255 знака, levenshtein() връща -1.
но тази дължина е повече от достатъчна.

strcoll()

Сравнете низове въз основа на текущия локал (PHP 4 >= 4.0.5, PHP 5)

Описание:

Int strcoll (низ str1, низ str2)

Връща положително число, ако str1 е по-малко от str2; отрицателно число, ако str1 е по-голямо от str2, и 0, ако низовете са равни. strcoll() използва настройките на текущия локал при сравняване. Ако локалът е C или POSIX, тази функция е същата като strcmp().

Имайте предвид, че тази функция е чувствителна към малки и главни букви и за разлика от strcmp(), не е двоично безопасна.

PHP е добре ориентиран към обработката на информация. Синтаксисът на езика е представен от пълнофункционален набор от функции за сравнение, обработка на низове и оператори за сравнение.

Всеки алгоритъм е последователност от избори и действия. Но преди да направите избор, трябва да сравните нещо с нещо. Низовете са най-обемният, ефективен и практичен механизъм за управление на алгоритъм. Редовете са опция за представяне на данни. А данните са основната грижа на всеки алгоритъм.

Конвенционална логика на сравнение-действие

Като цяло езикът не прави особени разлики в данните; например в PHP сравняването на низ и число не е много различно. Числото също е низ, когато съдържа само цифри, точка и никакви знаци, които не се използват за представяне на числото под каквато и да е форма (математическа нотация).

В случай на контентация числото автоматично се обединява в низа без ненужни въпроси и без скрити грешки, дори ако функцията gettype() връща "integer" или "double".

Има обаче разлика между използването на функцията is_int() и is_numeric(). Първият дава true, когато параметърът е само цяло число, вторият, когато произволно число или числов низ (променливата е от тип "низ", но съдържа всичко, което се предоставя от математическата нотация).

Този прост пример е добър пример за това как PHP операторите за сравнение на низове ("==", "===", "!=", ...) могат да представят много изненади. Променливите могат да променят типа си; те не винаги са числа, но почти винаги могат да бъдат преобразувани в низ. В екстремни случаи това ще бъде празен низ.

Въз основа на горното, функцията за сравнение на низове е най-популярната в PHP. От разработчика зависи кой да избере. Има много налични опции, включително регулярни изрази.

Ограничения на наличната функционалност

PHP сравнението на два низа се прави добре от функцията strpos() - най-евтината, най-точната и практична опция. Ако функцията е число, тогава един низ определено е равен на другия или единият е включен в другия.

Коренно противоположен, но и абсолютно правилен подход е използването на регулярни изрази.

Ако извикването на функцията $cResult = scCheckFileName($cStr) върне "true", тогава низът е името на файл на Word. Той ще има само една опция за разширение „.docx“ и няма символи в името: само букви, цифри и знаци „_“, „-“.

Функцията може лесно да се преобразува в други типове файлове: $cPtr = "/^((4,239))\.(html|js|css|png|jpg|docx|txt)(1)$/u". Тази опция за проверка на низ разширява обхвата на заредените (например в PHP сравнението на низове се използва „за качване на файлове на сървъра, без нито един шанс за грешка при въвеждане“) до html, js, css, ...

Използването на strpos() и preg_match() е крайност. Те не са пряко свързани с проблема за сравнение на термини. Но въпросът за алгоритъма е въпрос на прилагане на комбинация от стилове, като се използват всички възможности за постигане на надежден и правилен резултат.

PHP функционалност: сравнение на низове

Арсеналът на езика за сравнение на низове включва не само чисти функции за сравнение, но и комбинация с директно търсене или замяна. Действието не винаги трябва да е същото като сравнението, тъй като последното не променя непременно някой ред. Често трябва да изберете един или друг клон на алгоритъма.

Обичайната версия на PHP: сравнението на низове се извършва от функцията int strcmp (s1, s2).

Резултат от функцията:

• 0 - низовете са равни;
• -1 - първият ред е по-малък от втория;
• 1 - първият ред е по-голям от втория.

На практика това означава, че първият низ се включва във втория, от което PHP функцията (сравняване на низове) взема решение. По-ограничен вариант на strpos(), тъй като в последния случай позицията на събитието може да бъде известна.

Функцията strcmp() е чувствителна към главни и малки букви. Ако трябва да сравнявате низове без значение за малки и главни букви, PHP предлага да използвате strcasecmp(). Синтаксисът е подобен.

На практика често се налага да се работи не с целия низ, а само с част от него. За да направите това, наборът от PHP функции (сравняване на низове) включва strncmp (s1, s2, N). Третият параметър указва да се сравняват само N-байта. Резултатът е същият като strcmp().

Масиви, низове и сравнение

Данните почти винаги се представят като низове. Ако разгледаме масиви, обекти или информационни структури, тогава това са просто различни комбинации от по-прости низови структури.

Низовите масиви и низове могат да бъдат представени по допълващ начин. Трансформиране на масив в низ с помощта на функцията implode(array, symbol), например: $margins1 = implode(", ", $style->getInnerMargin()); ...работата на алгоритъма/потребителя...; $margins2 = implode(", ", $style->getInnerMargin()) ви позволява да обедините всички позиции на обекти в позиционен низ.

След това можете да направите сравнение на PHP низове и наведнъж: $check = strcmp ($margins1, $margins2) и да се уверите, че алгоритъмът или потребителят са променили нещо (или не). Ако извършите сравнението по обичайния начин, ще трябва да итерирате елементите на масивите. Това отнема повече време и изглежда по-тромаво.

Обекти и низове

Още по-мощно използване на PHP (сравняване на низове) може да се приложи чрез обектно-ориентирани идеи.

Съвременната представа за обектите предполага, че те имат свойства и методи. Първите обикновено се представят от числа, низове, масиви и други обекти. Последните често включват методи за запис (put) в низ и възстановяване от низ (get).

За разлика от масивите, обектът оперира със собствените си свойства и взаимодейства с други обекти. Един обект е „компетентен“ в това кои свойства от него имат реално значение за алгоритъма, програмата като цяло.

Тази точка осигурява основата и възможността при запис да записва само необходимата информация в ред, а при възстановяване от ред да възстанови всички работни свойства до желаното състояние. Обикновено всеки обект съдържа съществена и оперативна (временна) информация. Изпълнението на тази идея ви позволява да спестите не само памет, дисково пространство и записи в базата данни, но също така прави възможно сравняването на низове с помощта на по-прости и по-точни средства.

Синтаксис и семантика

PHP се развива динамично и неговата функционалност, както по отношение на сравняване на низове, така и по отношение на обработката им, непрекъснато се подобрява. Нищо обаче не пречи на разработчика да измести центъра на тежестта към областта на семантиката.

Несъмнено функционалността е добра, но използването й може да се прехвърли към семантичната част на кода, към обектите. Когато един алгоритъм е представен като система за взаимодействие на обекти, той изглежда много по-добре от последователност от сравнения и действия в прав последователен, класически стил.