Php как сравнить две строки

strcmp

Возвращает -1 , если string1 меньше string2 , 1 , если string1 больше string2 , и 0 , если строки равны.

Список изменений

Версия	Описание
8.2.0	Функция теперь возвращает -1 или 1 ; ранее она возвращала отрицательное или положительное число.

Примеры

Пример #1 Пример использования strcmp()

Смотрите также

• strcasecmp() — Бинарно-безопасное сравнение строк без учёта регистра
• preg_match() — Выполняет проверку на соответствие регулярному выражению
• substr_compare() — Бинарно-безопасное сравнение 2 строк со смещением, с учётом или без учёта регистра
• strncmp() — Бинарно-безопасное сравнение первых n символов строк
• strstr() — Находит первое вхождение подстроки
• substr() — Возвращает подстроку

User Contributed Notes 16 notes

If you rely on strcmp for safe string comparisons, both parameters must be strings, the result is otherwise extremely unpredictable.
For instance you may get an unexpected 0, or return values of NULL, -2, 2, 3 and -3.

strcmp(«5», 5) => 0
strcmp(«15», 0xf) => 0
strcmp(61529519452809720693702583126814, 61529519452809720000000000000000) => 0
strcmp(NULL, false) => 0
strcmp(NULL, «») => 0
strcmp(NULL, 0) => -1
strcmp(false, -1) => -2
strcmp(«15», NULL) => 2
strcmp(NULL, «foo») => -3
strcmp(«foo», NULL) => 3
strcmp(«foo», false) => 3
strcmp(«foo», 0) => 1
strcmp(«foo», 5) => 1
strcmp(«foo», array()) => NULL + PHP Warning
strcmp(«foo», new stdClass) => NULL + PHP Warning
strcmp(function()<>, «») => NULL + PHP Warning

In case you want to get results -1, 0 or 1 always, like JS indexOf();

<?php
function cmp ( string $str1 , string $str2 ): int <
return ( $str1 > $str2 ) — ( $str1 < $str2 );
>

$str1 = ‘a’ ;
$str2 = ‘z’ ;
var_dump ( cmp ( $str1 , $str2 ), strcmp ( $str1 , $str2 ));

$str1 = ‘a’ ;
$str2 = ‘1’ ;
var_dump ( cmp ( $str1 , $str2 ), strcmp ( $str1 , $str2 ));
//=> int(1) int(48) int(48)
?>

i hope this will give you a clear idea how strcmp works internally.

<?php
$str1 = «b» ;
echo ord ( $str1 ); //98
echo «<br/>» ;
$str2 = «t» ;
echo ord ( $str2 ); //116
echo «<br/>» ;
echo ord ( $str1 )- ord ( $str2 ); //-18
$str1 = «bear» ;
$str2 = «tear» ;
$str3 = «» ;
echo «<pre>» ;
echo strcmp ( $str1 , $str2 ); // -18
echo «<br/>» ;
echo strcmp ( $str2 , $str1 ); //18
echo «<br/>» ;
echo strcmp ( $str2 , $str2 ); //0
echo «<br/>» ;
echo strcmp ( $str2 , $str3 ); //4
echo «<br/>» ;
echo strcmp ( $str3 , $str2 ); //-4
echo «<br/>» ;
echo strcmp ( $str3 , $str3 ); // 0
echo «</pre>» ;
?>

One big caveat — strings retrieved from the backtick operation may be zero terminated (C-style), and therefore will not be equal to the non-zero terminated strings (roughly Pascal-style) normal in PHP. The workaround is to surround every « pair or shell_exec() function with the trim() function. This is likely to be an issue with other functions that invoke shells; I haven’t bothered to check.

On Debian Lenny (and RHEL 5, with minor differences), I get this:

echo «Zero-terminated string:<br />sz keyword»>. $sz . «<br />str_split(sz) keyword»>; print_r ( str_split ( $sz ));
echo «<br /><br />» ;

echo «Pascal-style string:<br />ps keyword»>. $ps . «<br />str_split(ps) keyword»>; print_r ( str_split ( $ps ));
echo «<br /><br />» ;

echo «Normal results of comparison:<br />» ;
echo «sz == ps keyword»>.( $sz == $ps ? «true» : «false» ). «<br />» ;
echo «strcmp(sz,ps) keyword»>. strcmp ( $sz , $ps );
echo «<br /><br />» ;

echo «Comparison with trim()’d zero-terminated string:<br />» ;
echo «trim(sz) keyword»>. trim ( $sz ). «<br />» ;
echo «str_split(trim(sz)) keyword»>; print_r ( str_split ( trim ( $sz ))); echo «<br />» ;
echo «trim(sz) == ps keyword»>.( trim ( $sz ) == $ps ? «true» : «false» ). «<br />» ;
echo «strcmp(trim(sz),ps) keyword»>. strcmp ( trim ( $sz ), $ps );
?>

====Output====
Zero-terminated string:
sz = /var/www
str_split(sz) = Array ( [0] => / [1] => v [2] => a [3] => r [4] => / [5] => w [6] => w [7] => w [8] => )

Pascal-style string:
ps = /var/www
str_split(ps) = Array ( [0] => / [1] => v [2] => a [3] => r [4] => / [5] => w [6] => w [7] => w )

Normal results of comparison:
sz == ps = false
strcmp(sz,ps) = 1

Comparison with trim()’d zero-terminated string:
trim(sz) = /var/www
str_split(trim(sz)) = Array ( [0] => / [1] => v [2] => a [3] => r [4] => / [5] => w [6] => w [7] => w )
trim(sz) == ps = true
strcmp(trim(sz),ps) = 0

Don’t forget the similar_text() function.

Note a difference between 5.2 and 5.3 versions

echo (int)strcmp(‘pending’,array());
will output -1 in PHP 5.2.16 (probably in all versions prior 5.3)
but will output 0 in PHP 5.3.3

Of course, you never need to use array as a parameter in string comparisions.

strcmp returns -1 ou 1 if two strings are not identical,
and 0 when they are, except when comparing a string and an empty string ( <?php $a = «» ; ?> ), it returns the length of the string.

For instance:
<?php
$a = «foo» ; // length 3
$b = «» ; // empty string
$c = «barbar» ; // length 6

echo strcmp ( $a , $a ); // outputs 0
echo strcmp ( $a , $c ); // outputs 1
echo strcmp ( $c , $a ); // outputs -1
echo strcmp ( $a , $b ); // outputs 3
echo strcmp ( $b , $a ); // outputs -3
echo strcmp ( $c , $b ); // outputs 6
echo strcmp ( $b , $c ); // outputs -6
?>

1) If the two strings have identical BEGINNING parts, they are trunkated from both strings.
2) The resulting strings are compared with two possible outcomes:
a) if one of the resulting strings is an empty string, then the length of the non-empty string is returned (the sign depending on the order in which you pass the arguments to the function)
b) in any other case just the numerical values of the FIRST characters are compared. The result is +1 or -1 no matter how big is the difference between the numerical values.

<?php
$str = array( » , ‘a’ , ‘afox’ , ‘foxa’ );
$size = count ( $str );

echo ‘<pre>’ ;
for( $i = 0 ; $i < $size ; $i ++)
<
for( $j = $i + 1 ; $j < $size ; $j ++)
<
echo ‘<br>(‘ . $str [ $i ]. ‘,’ . $str [ $j ]. ‘) = ‘ . strcmp ( $str [ $i ], $str [ $j ]);
echo ‘<br>(‘ . $str [ $j ]. ‘,’ . $str [ $i ] . ‘) = ‘ . strcmp ( $str [ $j ], $str [ $i ]);
>
>
echo ‘</pre>’ ;
?>

In Apache/2.4.37 (Win32) OpenSSL/1.1.1 PHP/7.2.12 produces the following results:

(,a) = -1 //comparing with an empty string produces the length of the NON-empty string
(a,) = 1 // ditto
(,afox) = -4 // ditto
(afox,) = 4 // ditto
(,foxa) = -4 // ditto
(foxa,) = 4 // ditto
(a,afox) = -3 // The identical BEGINNING part («a») is trunkated from both strings. Then the remaining «fox» is compared to the remaing empty string in the other argument. Produces the length of the NON-empty string. Same as in all the above examples.
(afox,a) = 3 // ditto
(a,foxa) = -1 // Nothing to trunkate. Just the numerical values of the first letters are compared
(foxa,a) = 1 // ditto
(afox,foxa) = -1 // ditto
(foxa,afox) = 1 // ditto

Some notes about the spanish locale. I’ve read some notes that says «CH», «RR» or «LL» must be considered as a single letter in Spanish. That’s not really tru. «CH», «RR» and «LL» where considered a single letter in the past (lot of years ago), for that you must use the «Tradictional Sort». Nowadays, the Academy uses the Modern Sort and recomends not to consider anymore «CH», «RR» and «LL» as a single letter. They must be considered two separated letters and sort and compare on that way.

Ju just have to take a look to the Offial Spanish Language Dictionary and you can see there that from many years ago there is not the separated section for «CH», «LL» or «RR» . i.e. words starting with CH must be after the ones starting by CG, and before the ones starting by CI.

Since it may not be obvious to some people, please note that there is another possible return value for this function.

strcmp() will return NULL on failure.

This has the side effect of equating to a match when using an equals comparison (==).
Instead, you may wish to test matches using the identical comparison (===), which should not catch a NULL return.

$variable1 = array();
$ans === strcmp($variable1, $variable2);

This will stop $ans from returning a match;

Please use strcmp() carefully when comparing user input, as this may have potential security implications in your code.

String comparison using '==' or '===' vs. 'strcmp()'

It seems that PHP’s === operator is case sensitive. So is there a reason to use strcmp() ?

Is it safe to do something like the following?

13 Answers 13

The reason to use it is because strcmp

returns < 0 if str1 is less than str2; > 0 if str1 is greater than str2, and 0 if they are equal.

=== only returns true or false , it doesn’t tell you which is the «greater» string.

You should never use == for string comparison. === is OK.

Just run the above code and you’ll see why.

Now, that’s a little better.

Don’t use == in PHP. It will not do what you expect. Even if you are comparing strings to strings, PHP will implicitly cast them to floats and do a numerical comparison if they appear numerical.

For example ‘1e3’ == ‘1000’ returns true. You should use === instead.

Well. according to this PHP bug report, you can even get 0wned.

It gives you a warning, but still bypass the comparison. You should be doing === as @postfuturist suggested.

Always remember, when comparing strings, you should use the === operator (strict comparison) and not == operator (loose comparison).

== is a bad idea for string comparisons.
It will give you "surprising" results in many cases. Don’t trust it.

=== is fine, and will give you the best performance.

strcmp() should be used if you need to determine which string is "greater", typically for sorting operations.

Using == might be dangerous.

Note, that it would cast the variable to another data type if the two differs.

• echo (1 == ‘1’) ? ‘true’ : ‘false’;
• echo (1 == true) ? ‘true’ : ‘false’;

As you can see, these two are from different types, but the result is true , which might not be what your code will expect.

Using === , however, is recommended as test shows that it’s a bit faster than strcmp() and its case-insensitive alternative strcasecmp() .

Quick googling yells this speed comparison: http://snipplr.com/view/758/

strcmp() and === are both case sensitive, but === is much faster.

strcmp will return different values based on the environment it is running in (Linux/Windows)!

The reason is the that it has a bug as the bug report says — Bug #53999strcmp() doesn’t always return -1, 0, or 1

You can use strcmp() if you wish to order/compare strings lexicographically. If you just wish to check for equality then == is just fine.

Also, the function can help in sorting. To be more clear about sorting. strcmp() returns less than 0 if string1 sorts before string2, greater than 0 if string2 sorts before string1 or 0 if they are the same. For example

The function will return greater than zero, as aaao is sorting before aabo.

if ($password === $password2) < . >is not a safe thing to do when comparing passwords or password hashes where one of the inputs is user controlled.
In that case it creates a timing oracle allowing an attacker to derive the actual password hash from execution time differences.
Use if (hash_equals($password, $password2)) < . >instead, because hash_equals performs «timing attack safe string comparison».

In PHP, instead of using alphabetical sorting, use the ASCII value of the character to make the comparison.

Lowercase letters have a higher ASCII value than capitals. It’s better to use the identity operator === to make this sort of comparison. strcmp() is a function to perform binary safe string comparisons. It takes two strings as arguments and returns < 0 if str1 is less than str2; > 0 if str1 is greater than str2, and 0 if they are equal. There is also a case-insensitive version named strcasecmp() that first converts strings to lowercase and then compares them.

strcmp()

Эта функция сравнения строк. Она сравнивает две строки и возвращает:

• 0 — если строки полностью совпадают;
• 1 — если, строка str1 лексикографически больше str2;
• 1 – если, наоборот, строка str1 лексикографически меньше str2

Функция является чувствительной к регистру, т.е. регистр символов влияет на результаты сравнений (поскольку сравнение происходит побайтово).

Пример:

Результат:

strncmp()

Синтаксис:

Эта функция отличается от strcmp() тем, что сравнивает начала строк, а точнее первые len байтов. Если len меньше длины наименьшей из строк, то строки сравниваются целиком.

В остальном функция ведет себя аналогично strcmp(), т.е. возвращает:

• 0 — если строки полностью совпадают;
• 1 — если, строка str1 лексикографически больше str2;
• 1 – если, наоборот, строка str1 лексикографически меньше str2

Сравнение также проводится побайтово, поэтому функция чувствительна к регистру.

strcasecmp()

Синтаксис:

Функция работает аналогично strcmp(), только при работе не учитывается регистр букв.

strncasecmp()

Синтаксис:

Функция strncasecmp() cравнивает начала строк без учета регистра.

strnatcmp()

Синтаксис:

Производит так называемое «естественное» сравнение строк.

Об этой функции поговорим поподробнее. Данная функция является имитатором сравнение строк человеком, т.е. она сравнивает строки так, как их сравнивал бы человек. Т.е., если, к примеру, мы будем сравнивать файлы с названиями pict1.gif, pict20.gif, pict2.gif, pict10.gif, то обычное сравнение приведет к следующему их расположению: pict1.gif, pict10.gif, pict2.gif, pict20.gif. Естественная же сортировка даст результат, который нам более привычен: pict1.gif, pict2.gif, pict10.gif, pict20.gif.

В примере использования этой функции мы опять забежим вперед и прибегнем к функциям работы с массивами. Поэтому мы советуем Вам после прочтения главы о массивах еще раз взглянуть на этот пример, и использовать его, когда Вам надо отсортировать все то, что связано со строками, к примеру, названия файлов.

Этот скрипт выведет следующее:

strnatcasecmp()

Синтаксис:

Производит «естественное» сравнение строк без учета регистра. Функция выполняет то же самое, что и strnatcmp(), только без учета регистра.

similar_text()

Синтаксис:

Эта функция производит определение схожести двух строк.

Функция similar_text() определяет схожесть двух строк по алгоритму Оливера. Функция возвращает число символов, совпавших в строках str_first и str_second. Третий необязательный параметр передается по ссылке и в нем сохраняется процент совпадения строк.

Вместо стека, как в алгоритме Оливера, эта функция использует рекурсивные вызовы. Сложность алгоритма этой функции равна O((max(n,m))3), что делает эту функцию медленной. (Грубо говоря, скорость выполнения этой функции пропорциональна N3, где N – длина наибольшей строки.

Пример:

Результат:

levenshtein()

Функция выполняет определение различия Левенштейна двух строк.

Синтаксис:

Под понятием «различие Левенштейна» понимается минимальное число символов, которое требовалось бы заменить, вставить или удалить для того, чтобы превратить строку str1 в str2.

Сложность алгоритма этой функции равна O(m*n), т.е. пропорциональна произведению длин строк str1 и str2, поэтому эта функция намного более быстрая, чем функция similar_text().

Как видим, у функции три вида синтаксиса. В первом случае функция возвращает число необходимых операций над символами строк для преобразования str1 в str2:

Во втором случае добавляется три дополнительных параметра: стоимость операции вставки cost_ins, замены cost_rep и удаления cost_del. Естественно, функция в этом случае становится менее быстродействующей. Возвращается интегральный показатель сложности трансформации (ИПСТ).

Число 21, между прочим, это 7*3 :). Т.е. ИПСТ равен произведению количества символов, необходимых для замены (а как мы посчитали в предыдущем примере их надобно 7) на стоимость, в этом случае, одной из операций. В этом примере, поскольку стоимость одинакова, не имеет значения, какую операцию брать. В случае, если стоимости различны, при вычисления ИПСТ берется наибольший. Т.е., если мы напишем в этом примере

то функция вернет нам значение 42.

Третий вариант позволяет указать функцию, используемую для расчета сложности трансформации.

Если Вам нужна частная профессиональная консультация от авторов многих книг Кузнецова М.В. и Симдянова И.В., добро пожаловать в наш Консультационный Центр SoftTime.

Сравнение строк PHP

⁡: Пожалуйста помните, что ⁡будет выдано предупреждение.⁡Для более подробной информации ⁡свои собственные правила сравнения, ⁡или ⁡$a <= $b⁡⁢ ⁡Не равно⁡⁢ ⁡- Регистронезависимый вариант функции ⁡строк без учёта регистра⁡⁢

⁡целому числу оно теряет ⁡⁢

⁡всего остального) потому что ⁡⁢	⁡, т. е. из ⁡⁢	⁡не транзитивен⁡⁢
⁡особенностью PHP. Это поведение ⁡⁢	⁡типов. Я потратил много ⁡⁢	true ⁡similar_text()⁡⁢ ⁡оригинале, вместо этого применяются ⁡⁢ ⁡этот оператор является выражением, ⁡⁢ ⁡Замечание⁡⁢ ⁡смотрите документацию по типу ⁡⁢
⁡объекты разных классов не ⁡⁢	⁡, поскольку это включает ⁡⁢	true ⁡Меньше или равно⁡⁢ ⁡если ⁡⁢ ⁡strstr⁡⁢ ⁡strcasecmp⁡⁢ ⁡начальные нули.⁡интерпретатор приводит их к ⁡⁢
⁡истинности ⁡⁢	⁡, т. е. истинность ⁡⁢	true ⁡определено в стандарте IEEE ⁡⁢ ⁡времени в поисках основ ⁡⁢ ⁡с заменой аргументов⁡⁢ ⁡рекурсивные вызовы, что в ⁡⁢ ⁡и он приравнивается к ⁡⁢
⁡:⁡⁢	⁡float.⁡⁢	true ⁡сравниваются, про сравнение объектов ⁡⁢ ⁡сравнение типа, а также ⁡⁢ ⁡если ⁡⁢ ⁡$a⁡⁢ ⁡substr()⁡⁢
⁡(string ⁡⁢	⁡Необычно⁡⁢	true ⁡одному виду:⁡⁢ ⁡и ⁡⁢ ⁡выражений ⁡⁢ ⁡754 формата представления чисел ⁡⁢ ⁡логики сравнения в нем.⁡В этом примере показано, ⁡⁢
⁡некоторых случаях может ускорить ⁡⁢	⁡выражению, а не значению ⁡⁢	true ⁡Рекомендуется избегать «нагромождения» тернарных ⁡⁢ ⁡strcasecmp()⁡⁢ ⁡одного класса смотрите ⁡⁢ ⁡значения.⁡⁢ ⁡$a⁡⁢
⁡не равно ⁡⁢	⁡- Возвращает подстроку⁡⁢	true ⁡, string ⁡⁢ ⁡Примечание переводчика: В ответе ⁡⁢ ⁡В PHP (актуально для ⁡⁢ ⁡не следует, что ⁡⁢ ⁡и ⁡⁢
⁡с плавающей точкой (⁡⁢	⁡Например: если ⁡⁢	true ⁡что изменение порядка аргументов ⁡⁢ ⁡процесс. Следует отметить, что ⁡⁢ ⁡переменной. Это может быть ⁡⁢ ⁡выражений. Поведение PHP неочевидно ⁡⁢ ⁡strcmp()⁡⁢
⁡Сравнение объекта⁡⁢	⁡Внимание⁡⁢	true ⁡меньше или равно ⁡⁢ ⁡$b⁡⁢ ⁡Источник: ⁡⁢ ⁡): int ⁡⁢ ⁡выше сказано, что любое ⁡⁢
⁡версии 5.5.0beta2) нет строгого ⁡⁢	⁡также является истиной: ⁡⁢	⁡не означает, что ⁡пояснения на stackoverflow⁡является истиной и ⁡⁢ ⁡и ⁡⁢ ⁡сложность алгоритма составляет O(N**3), ⁡важным, если вы хотите ⁡⁢ ⁡при использовании более чем ⁡⁢ ⁡Операторы, работающие с массивами⁡⁢

⁡string, resource, int или ⁡До PHP 8.0.0, если ⁡⁢ ⁡$b⁡⁢ ⁡после преобразования типов.⁡.⁡⁢ ⁡Бинарно-безопасное сравнение строк без ⁡⁢ ⁡сравнение с NAN возвращает ⁡сравнения >== или <== ⁡Дополнительно: Оператор ⁡⁢ ⁡(пример такой же, как ⁡⁢ ⁡);⁡является истиной, значит ли ⁡⁢ === ⁡может дать разные результаты.⁡⁢ !== ⁡где N — длина ⁡вернуть значение по ссылке. ⁡одного тернарного оператора без ⁡⁢

⁡Типы⁡⁢

⁡float⁡строка (string) сравнивалась с ⁡.⁡$a $b⁡Операторы сравнения, как это ⁡учёта регистра. Сравнение не ⁡false, так что ничего ⁡с проверкой типов, но ⁡не трихотомичен⁡⁢ <?php
var_dump(0 == «a»);
var_dump(«1» == «01»);
var_dump(«10» == «1e1»);
var_dump(100 == «1e2»);

⁡и для оператора ⁡Оператор ⁡⁢

⁡это, что ⁡Источник: ⁡⁢

<?php
// Целые числа
echo 1 1; // 0
echo 1 2; // -1
echo 2 1; // 1

// Числа с плавающей точкой
echo 1.5 1.5; // 0
echo 1.5 2.5; // -1
echo 2.5 1.5; // 1

// Строки
echo «a» «a»; // 0
echo «a» «b»; // -1
echo «b» «a»; // 1

echo «a» «aa»; // -1
echo «zz» «aa»; // 1

// Массивы
echo [] []; // 0
echo [1, 2, 3] [1, 2, 3]; // 0
echo [1, 2, 3] []; // 1
echo [1, 2, 3] [1, 2, 1]; // 1
echo [1, 2, 3] [1, 2, 4]; // -1

// сравниваются не только значения; ключи также должны совпадать
$a = (object) [«a» => «b»];
$b = (object) [«b» => «b»];
echo $a $b; // 1

⁡более длинной из двух ⁡Выражение ⁡скобок в одном выражении ⁡⁢

⁡Ещё одним условным оператором ⁡⁢

⁡string, resource, int или ⁡⁢	⁡числом или строкой, содержащей ⁡⁢	⁡$a >= $b⁡⁢
⁡Не равно⁡⁢	⁡видно из их названия, ⁡⁢	null ⁡зависит от локали; только ⁡необычного здесь нет. ⁡⁢
⁡есть несколько способов сравнить ⁡⁢	⁡, т. е. выражения ⁡⁢	⁡).⁡⁢ false ⁡симметричен⁡⁢ true
⁡также является истиной?⁡⁢	⁡.⁡⁢	⁡строк.⁡в функции возвращающей ссылку ⁡по сравнению с другими ⁡является тернарный оператор «?:».⁡float⁡⁢ ⁡число, то строка (string) ⁡⁢
⁡Больше или равно⁡если ⁡⁢	⁡позволяют сравнивать между собой ⁡буквы ASCII сравниваются без ⁡⁢	⁡Равно, но не идентично⁡типы до сравнения больше/меньше:⁡⁢
⁡, ⁡⁢	⁡Оператор ⁡⁢	⁡, т. е. ⁡Руководствуясь простейшей логикой я ⁡Есть две переменные в ⁡Первая строка.⁡будет не работать, а ⁡языками. Действительно, до PHP ⁡Пример #3 Присваивание значения ⁡Строки и ресурсы переводятся ⁡⁢
⁡преобразовывалось в число перед ⁡⁢	⁡если ⁡⁢	⁡$a⁡⁢
⁡два значения. Возможно вам ⁡⁢	⁡учёта регистра.⁡⁢	⁡И больше, и меньше ⁡⁢

⁡Сравнить типы переменных ⁡⁢

<?php
// Логические значения и null всегда сравниваются как логические
var_dump(1 == TRUE); // TRUE — то же, что и (bool)1 == TRUE
var_dump(0 == FALSE); // TRUE — то же, что и (bool)0 == FALSE
var_dump(100 < TRUE); // FALSE — то же, что и (bool)100 < TRUE
var_dump(-10 < FALSE);// FALSE — то же, что и (bool)-10 < FALSE
var_dump(min(-100, -10, NULL, 10, 100)); // NULL — (bool)NULL < (bool)-100 это FALSE < TRUE
?>

⁡и ⁡не является полным⁡⁢

<?php
// Так сравниваются массивы при сравнении стандартными операторами
function standard_array_compare($op1, $op2)
<
if (count($op1) < count($op2)) <
return -1; // $op1 < $op2
> elseif (count($op1) > count($op2)) <
return 1; // $op1 > $op2
>
foreach ($op1 as $key => $val) <
if (!array_key_exists($key, $op2)) <
return null; // не могут быть сравнимы
> elseif ($val < $op2[$key]) <
return -1;
> elseif ($val > $op2[$key]) <
return 1;
>
>
return 0; // $op1 == $op2
>
?> ⁡и ⁡⁢

⁡могу предположить что это ⁡одной из них значение ⁡Вторая строка.⁡выводить предупреждение.⁡8.0.0 троичные выражения оценивались ⁡⁢

⁡по умолчанию⁡в числа, обычная математика⁡выполнением сравнения. Это могло ⁡⁢

Смотрите также

• ⁡$a⁡⁢
• ⁡не равно ⁡⁢
• ⁡будет интересно также ознакомиться ⁡⁢
• ⁡Первая строка⁡⁢

Тернарный оператор

⁡одновременно?⁡Явно привести переменные к ⁡⁢

⁡могут быть ложными (пример ⁡, т. е. и ⁡⁢

<?php
// Пример использования тернарного оператора
$action = (empty($_POST[‘action’])) ? ‘default’ : $_POST[‘action’];

// Приведённый выше код аналогичен следующему блоку с использованием if/else
if (empty($_POST[‘action’])) <
$action = ‘default’;
> else <
$action = $_POST[‘action’];
>

?> ⁡всегда равны;⁡⁢ (expr1) ? (expr2) : (expr3) ⁡выражение также верно, однако ⁡поля «пароль» в другой ⁡⁢ true ⁡Замечание⁡Замечание⁡⁢ false ⁡лево-ассоциативными, а не право-ассоциативными, ⁡⁢

⁡Выражение ⁡array⁡привести к неожиданным результатам, ⁡⁢ expr1 ?: expr3 ⁡больше или равно ⁡$b⁡⁢ true ⁡с разделом ⁡Вторая строка⁡⁢

⁡Идентично⁡⁢⁡нужному типу ⁡такой же, как и ⁡, и ⁡Оператор ⁡я не очень доверяю ⁡»повторите пароль». И как ⁡:⁡⁢ return $var == 42 ? $a : $b; ⁡:⁡как в большинстве других ⁡интерпретируется как expr2, если ⁡array⁡что можно увидеть на ⁡⁢

⁡$b⁡⁢⁡после преобразования типов.⁡⁢

⁡Сравнение типов⁡Возвращает отрицательное число, если ⁡Больше или меньше⁡Использовать манипуляцию с типами ⁡для ⁡могут быть ложными: ⁡не транзитивен⁡PHP в этом в ⁡их можно сравнить на ⁡Изменение порядка ⁡Обратите внимание, что этот ⁡языков программирования. Использование лево-ассоциативности ⁡expr1 имеет значение ⁡Массивы с меньшим числом ⁡⁢

⁡следующем примере: ⁡.⁡⁢

<?php
// на первый взгляд, следующий код должен вывести ‘true’
echo (true ? ‘true’ : false ? ‘t’ : ‘f’);

// однако, он выводит ‘t’ до PHP 8.0.0
// это потому, что тернарные выражения левоассоциативны

// это намного более очевидная версия вышеприведённого кода
echo ((true ? ‘true’ : false) ? ‘t’ : ‘f’);

// здесь видно, что первое выражение вычисляется в ‘true’, которое
// в свою очередь вычисляется в (bool)true, таким образом возвращая истинную ветвь
// второго тернарного выражения.
?>

Оператор объединения с null

⁡$a !== $b⁡, в котором приведено ⁡⁢

⁡меньше ⁡Примеры с $a > ⁡⁢

<?php
// Пример использования оператора
$action = $_POST[‘action’] ?? ‘default’;

// Пример выше аналогичен следующему коду
if (isset($_POST[‘action’])) <
$action = $_POST[‘action’];
> else <
$action = ‘default’;
>

?> ⁡Также обратите внимание на ⁡⁢ (expr1) ?? (expr2) ⁡);⁡Отношение строгого неравенства ⁡⁢ null ⁡, т. е. ⁡вопросе. Может кто-нибудь привести ⁡⁢

⁡совпадение?⁡и ⁡оператор позволяет использовать простую ⁡устарело в PHP 7.4.0. ⁡⁢ ⁡, или как expr3, ⁡⁢ ⁡элементов считаются меньше, если ⁡Результат выполнения данного примера ⁡⁢

⁡$a $b⁡⁢⁡Тождественно не равно⁡большое количество соответствующих примеров.⁡, положительное число, если ⁡$b > $c в ⁡следующее:⁡Дополнительно: Оператор ⁡/⁡и ⁡⁢ return $foo ?? $bar; ⁡мне пример, в котором ⁡Сравнивать нужно либо:⁡может привести к другому ⁡⁢

⁡вложенность:⁡⁢⁡Начиная с PHP 8.0.0, ⁡⁢

⁡если expr1 имеет значение ⁡ключ из первого операнда ⁡в PHP 7:⁡⁢

⁡Космический корабль (spaceship)⁡если ⁡⁢

<?php

$foo = null;
$bar = null;
$baz = 1;
$qux = 2;

echo $foo ?? $bar ?? $baz ?? $qux; // выведет 1

⁡Операторы сравнения⁡⁢ php.net ⁡больше ⁡⁢

similar_text

⁡Числа с плавающей точкой⁡⁢

⁡может быть ⁡должно быть антирефлексивным, асимметричным ⁡⁢

Описание

⁡. ⁡не найден во втором ⁡Результат выполнения данного примера ⁡Число типа int меньше, ⁡$a⁡Пример⁡, и 0, если ⁡$c⁡имеют ограниченную точность;⁡закольцованным⁡и транзитивным:⁡:⁡Также мне интересна работа ⁡ибо ⁡При передаче по ссылке ⁡⁢

Список параметров

⁡Пример #4 Неочевидное поведение ⁡⁢

⁡Также стало возможным не ⁡⁢⁡операнде — массивы не ⁡⁢

⁡в PHP 8:⁡⁢ string1 ⁡больше или равное нулю, ⁡⁢ string2 ⁡не равно ⁡Название⁡⁢

⁡строки равны.⁡Забавное сравнение строк: ⁡⁢⁡Константы NAN и INF ⁡⁢ ⁡, т. е. бывают ⁡Оператор ⁡Отношение ⁡⁢⁡операторов «больше» и «меньше». ⁡⁢ ⁡попробуйте сравнить таким способом ⁡третьего аргумента, ⁡⁢ 100 ⁡Источник: ⁡⁢

Возвращаемые значения

⁡тернарного оператора⁡писать среднюю часть тернарного ⁡⁢

⁡могут сравниваться, иначе идёт ⁡Для различных типов сравнение ⁡когда ⁡$b⁡Результат⁡Пример #1 Пример использования ⁡Также посмотрите ⁡⁢

Примеры

⁡являются типом float;⁡⁢⁡случаи, когда ⁡⁢ ⁡в PHP ⁡⁢

⁡/⁡Изменится ли результат сравнения ⁡⁢ string1 ⁡»0e42″ и «0e123», например⁡⁢ string2 ⁡similar_text()⁡⁢

⁡.⁡⁢ php.net ⁡Также добавился новый оператор ⁡⁢

Как сравнить две текстовые переменные на php?

Вопрос:

⁡оператора. Выражение ⁡сравнение соответствующих значений (смотрите ⁡происходит в соответствии со ⁡$a⁡, или они разных ⁡$a == $b⁡⁢

Ответы:

⁡таблицу сравнения типов в ⁡⁢

⁡Сравнение INF с INF ⁡⁢

Комментарии:

• ⁡, ⁡антирефлексивен⁡⁢

⁡должно быть не рефлексивным, ⁡⁢

⁡при переворачивании выражения:⁡⁢

⁡присваивает ему степень похожести ⁡⁢ ⁡[CLEARTAGSATTRS(img:alt,title,width,height,src|table:cellpadding,cellspacing|td:colspan,rowspan|iframe:src,allowfullscreen,frameborder,height,width)] ⁡⁢

⁡»??» (null coalescing).⁡⁢ ru.stackoverflow.com ⁡возвращает expr1 если expr1 ⁡⁢

Особенности логического сравнения в PHP

Вопрос

Ответ

⁡$a⁡⁢ == ⁡preg_match()⁡⁢⁡и ⁡⁢⁡типом float, даже если ⁡⁢ $a == $a ⁡Примечание: Этот пример генерирует ⁡⁢
⁡актуально начиная с версии ⁡в PHP ⁡не документирована.⁡Подробнее: ⁡similar_text()⁡похожести двух строк⁡Выражение ⁡⁢ ⁡случае.⁡⁢ ⁡тип array всегда больше⁡⁢