PHP中的类型变戏法和（严格）大于/小于

115

PHP以其类型杂耍而闻名。我必须承认，这使我感到困惑，而且我很难在比较中找出基本的逻辑/基础知识。

例如：如果$a > $b为true并且$b > $c为true，是否还必须意味着$a > $c也始终为 true？

按照基本逻辑，我会说是，但是我对此感到困惑，因为我并不真的相信PHP。也许有人可以提供一个例子，而事实并非如此？

我也想知道使用严格的小于运算符和严格大于运算符（因为它们的含义被描述为严格的，我过去仅从相等性比较中知道），如果左右运算符与之互换，是否会有所不同严格不相等的值：

# Precondition:
if ($a === $b) {
    throw new Exception(
       'Both are strictly equal - can not compare strictly for greater or smaller'
    );
}

($a > $b) !== ($b > $a)

对于大多数类型比较组合，大多数较大/较小的比较运算符均未记录在文档中，因此在这种情况下阅读手册并没有真正的帮助。

— 哈克雷
source

我猜你想改正那条线($a > $b) !== ($b < $a)吗？

— Walter Tross 2013年

啊，好的，所以我误会了。将不得不相应地解决我的答案。所有那些写论文而不是回答并且没有仔细阅读您的问题的人们都

— 感到很有趣

208

PHP的比较运算符通过以下几种方式偏离了计算机科学的定义：

为了构成等价关系 ==，必须是自反的，对称的和可传递的：

PHP的==运算符不是自反的，即$a == $a并不总是正确的：
```
var_dump(NAN == NAN); // bool(false)
```
注意：任何涉及比较的事实NAN始终false并非特定于PHP。它是由IEEE 754浮点算法标准（更多信息）强制要求的。
PHP的==运算符是对称，即$a == $b和$b == $a始终相同。

PHP的==运营商是不可传递的，即从$a == $b与$b == $c它不如下$a == $c：

var_dump(true == "a"); // bool(true)
var_dump("a" == 0);    // bool(true)
var_dump(true == 0);   // bool(false)

为了构成部分秩序 <= / >=必须是反身，反对称和可及的：

PHP的<=运算符不是自反的，即$a <= $a并不总是true（示例与相同==）。

PHP的<=运算符不是反对称的，即来自$a <= $b和$b <= $a不遵循$a == $b：

var_dump(NAN <= "foo"); // bool(true)
var_dump("foo" <= NAN); // bool(true)
var_dump(NAN == "foo"); // bool(false)

PHP的<=运算符不是可传递的，即来自$a <= $b和$b <= $c不遵循$a <= $c（示例与相同==）。

另外：PHP的<=运算符不是total，即两者都不是$a <= $b，$b <= $a可以为false：

var_dump(new stdClass <= new DateTime); // bool(false)
var_dump(new DateTime <= new stdClass); // bool(false)

为了构成严格的偏序 < / >必须是反身，不对称和可传递的：

PHP的<运算符是不自反的，即$a < $a永远都不是。请注意，仅从PHP 5.4开始，这是正确的。先前INF < INF评估为true。
PHP的<运算符不是非对称的，即from $a < $b不遵循!($b < $a)（示例与非对称的示例相同<=）。

PHP的<运算符不是可传递的，即来自$a < $b和$b < $c不遵循$a < $c：

var_dump(-INF < 0);    // bool(true)
var_dump(0 < TRUE);    // bool(true)
var_dump(-INF < TRUE); // bool(false)

附加：PHP的<运算符不是三分法的，即不是所有运算符$a < $b，$b < $a并且$a == $b可以为false（示例与<=未总计的示例相同）。
附加：PHP的<运算符可以是圆形的，也就是说，它是可能的$a < $b，$b < $c并且$c < $a：
```
var_dump(INF < []);           // bool(true)
var_dump([] < new stdClass);  // bool(true)
var_dump(new stdClass < INF); // bool(true)
```
注意：上面的示例抛出“无法将stdClass类的对象转换为double”的通知。

在PHP Sadness 52-比较运算符上，您可以找到一些用于PHP比较运算符的漂亮图形。

最后一点，我想指出PHP 确实保证了两个平等（与其他几乎所有东西不同）。这两个总是成立，只是因为编译器将一个减少到另一个：

($a > $b) == ($b < $a)
($a >= $b) == ($b <= $a)

— 尼基
source

哇，真好。因此($a > $b) and ($b > $c)，$a > $c即使文档说那些</ >运算符说它们很严格，也无法像这样用PHP来表达逻辑表达式？

— hakre 2013年

IMHO运算符确实遵循数学规则，但仅在处理相同数据类型时才遵循。在这里（以及在许多其他情况下），类型转换才是真正造成混乱的原因。当比较数字和字符串以及特殊值时，类型转换是在运算符之前完成的，因此严格来说，比较运算符不会引起混淆，强制转换是...

— ivanhoe

@ ivanhoe011事实是：两者都是：) PHP的比较规则和PHP的强制转换规则不同，您不能简单地说这$a == $b与相同(type) $a === (type) $b。一个简单的例子是"15" == "0xf"，但是(int) "15" !== (int) "0xf"。而且PHP中的比较和转换规则都非常疯狂^^

— NikiC 2013年

@NikiC： (int)"0xf"计算为整数0，所以当然是0 !== 15。本示例中的比较行为完全符合预期。这是令人困惑的演员。我承认，这(INF < INF) === true是一个真正的比较问题，但这是一个特例，正如您所指出的，它已得到解决。好答案.. +1

— FtDRbwLXw6

我不一定会在那时就对类型强制实施有意义的某些决定来指责PHP的设计师...但是我觉得应当注意到PHP设计选择的结果，并立即意识到选择显然是错误的。最明显的例子是@ravz的评论。

— 乍得2013年

PHP 中没有 严格相同的比较运算符（>==或<==）（至少由PHP 5.6.14所支持），但是在检查Greater / Lower之前，有几种方法可以执行严格的类型检查：

检查两个变量类型 if (gettype($a) === gettype($b))
强制进行所需的类型转换，例如。 if ((string)$a === (string)$b)
强制您需要的类型变戏法。 if (($a . '') === ($b . ''))

请注意：

浮点精度受到限制
INF和NAN是类型的float下ieee754
某些Infinity等于其他Infinity（自PHP 5.4起）
科学计数法e始终是类型float，integer即使数目很小也永远不会
整数将PHP_INT_MAX自动转换为float
在系统边界上浮动会获得INF价值
未定义变量的类型和值 NULL
前面的整数0从八进制转换为十进制（按照惯例）
具有前导转化含的整数字符串0 到整数条的主导0

一些异国比较的列表：

很奇怪：
     $ aVS。$ b $ a> $ b $ a <$ b $ a <= $ b $ a> = $ b $ a == $ b $ a === $ b
  float（NAN）float（-INF）假假假假假假
  float（NAN）float（0）假假假假假假
  float（NAN）float（1）假假假假假假
  float（NAN）float（INF）否否否否否否
  float（NAN）float（NAN）假假假假假假
  float（NAN）int（-1）否否否否否否
  float（NAN）int（0）否否否否否否
  float（NAN）int（1）否否否否否否

相等但不相同：

     $ aVS。$ b $ a> $ b $ a <$ b $ a <= $ b $ a> = $ b $ a == $ b $ a === $ b

  NULL（NULL）array（）否否true true true true false
  NULL（NULL）bool（false）否否true true true true false
  NULL（NULL）float（0）否否真是真真假
  NULL（NULL）int（0）否否真真真真假
  NULL（NULL）str（''）否否真真真假
   array（）bool（false）否否true true true true false
 bool（false）float（0）false否true true true true false
 bool（false）int（0）否否true true true true false
   str（''）bool（false）假否真真真假
 bool（false）str（'0'）否否真真真假
 float（-INF）bool（true）假假真真真假
  bool（true）float（1）假否真真真假
  float（INF）bool（true）假假真真真假
  float（NAN）bool（true）假假真真真假
  bool（true）int（-1）否false否true true真false
  bool（true）int（1）假否真真真假
  bool（true）str（“ \ 0”）否否真真真假
  bool（true）str（'+'）否否否否是否否
  bool（true）str（'-'）否否否否否否
  bool（true）str（'01'）否否真是真真假
  bool（true）str（'1'）否否真是真真假
  bool（true）str（'false'）否否真是真真假
 str（'text'）bool（true）假假真真真假
 str（'true'）bool（true）假假真真真假
    int（0）float（0）假否真真真假
  str（“ \ 0”）float（0）假假真真真假
   str（''）float（0）假否真真真假
   str（'+'）float（0）假假真真真假
   str（'-'）float（0）假假真真真假
   str（'0'）float（0）假假真真真假
 str（'false'）float（0）否否true true true true false
 str（'text'）float（0）假假真真真假
 str（'true'）float（0）假假真真真假
    int（1）float（1）假假真真真假
   float（1）str（'01'）否否真真真假
   float（1）str（'1'）否否真真真假
  str（“ \ 0”）int（0）假假真真真假
   str（''）int（0）假假真真真假
   str（'+'）int（0）假假真真真假
   str（'-'）int（0）假假真真真假
    int（0）str（'0'）假假真真真假
 str（'false'）int（0）否否真真真真假
 str（'text'）int（0）假假真真真假
 str（'true'）int（0）假假真真真假
    int（1）str（'01'）假假真真真假
    int（1）str（'1'）假假真真真假
   str（'1'）str（'01'）假假真真真假

同时降低和提高？

     $ aVS。$ b $ a> $ b $ a <$ b $ a <= $ b $ a> = $ b $ a == $ b $ a === $ b
  float（NAN）str（“ \ 0”）true true true true false false
  float（NAN）str（''）true true true true false false
  float（NAN）str（'+'）true true true true false false
  float（NAN）str（'-'）true true true true false false
  float（NAN）str（'0'）true true true true false false
  float（NAN）str（'01'）true true true true false false
  float（NAN）str（'1'）true true true true false false
  float（NAN）str（'false'）true true true true false false
  float（NAN）str（'text'）true true true true false false
  float（NAN）str（'true'）true true true true false false

相等且相同：

     $ aVS。$ b $ a> $ b $ a <$ b $ a <= $ b $ a> = $ b $ a == $ b $ a === $ b
  NULL（NULL）NULL（NULL）假假真真真真
 float（-INF）float（-INF）假假真真真真
  float（INF）float（INF）假假真真真真

较低或较高：

     $ aVS。$ b $ a> $ b $ a <$ b $ a <= $ b $ a> = $ b $ a == $ b $ a === $ b

  NULL（NULL）bool（true）假真真假假假
 float（-INF）NULL（NULL）是否否是否否
  NULL（NULL）float（1）否是true是false false false
  float（INF）NULL（NULL）是否否是否否
  float（NAN）NULL（NULL）是否否是否否
  NULL（NULL）int（-1）假真真假假假
  NULL（NULL）int（1）否是true是false false false
  NULL（NULL）str（“ \ 0”）否是否否否
  NULL（NULL）str（'+'）假真真假假假
  NULL（NULL）str（'-'）假真真假假假假
  NULL（NULL）str（'0'）假真真假假假
  NULL（NULL）str（'01'）假真真假假假
  NULL（NULL）str（'1'）假真真假假假
  NULL（NULL）str（'false'）假真真假假假
  NULL（NULL）str（'text'）假真真假假假假
  NULL（NULL）str（'true'）假真真假假假
   array（）bool（true）假真真假假假
 float（-INF）array（）假真真假假假
   array（）float（0）是否否是否否
   array（）float（1）是否否是否否
  float（INF）array（）假真真假假假
  float（NAN）array（）否是否否否
   array（）int（-1）是否否是否否
   array（）int（0）是否否是否否
   array（）int（1）是否否是否是
   array（）str（“ \ 0”）是否否是否否
   str（''）array（）假真真假假假
   array（）str（'+'）true假false true假false
   array（）str（'-'）true假false true假false
   array（）str（'0'）true假false true假false
   array（）str（'01'）true假false true假false
   array（）str（'1'）true假false true假false
   array（）str（'false'）是否否是否否
   array（）str（'text'）true假false true假false
   array（）str（'true'）是否否是否否
  bool（true）bool（false）是否否是否否
 float（-INF）bool（false）是否否是否否
   float（1）bool（false）是否否是否否
  float（INF）bool（false）是否否是否否
  float（NAN）bool（false）是否否是否否
 bool（false）int（-1）false true true true false false false
    int（1）bool（false）是否否是否否
 bool（false）str（“ \ 0”）否是否否否
 bool（false）str（'+'）false true是false false false
 bool（false）str（'-'）假真真假假假
 bool（false）str（'01'）false是true是false false false
   str（'1'）bool（false）是否否是否否
 bool（false）str（'false'）假真真假假假
 str（'text'）bool（false）是否否是否否
 str（'true'）bool（false）是否否是否否
  bool（true）float（0）是否否是否否
  bool（true）int（0）是否否是否否
   str（''）bool（true）假真真假假假
  bool（true）str（'0'）是否否是否否
 float（-INF）float（0）假真是假假假
 float（-INF）float（1）假真真假假假
  float（INF）float（-INF）是否否是否否
 float（-INF）int（-1）假真真假假假
 float（-INF）int（0）否是true是false false false
 float（-INF）int（1）假真真假假假假
 float（-INF）str（“ \ 0”）否是否否否
 float（-INF）str（''）假真真假假假
 float（-INF）str（'+'）假真真假假假
 float（-INF）str（'-'）假真真假假假
 float（-INF）str（'0'）假真真假假假
 float（-INF）str（'01'）假真真假假假
 float（-INF）str（'1'）假真真假假假假
 float（-INF）str（'false'）假真真假假假
 float（-INF）str（'text'）假真真假假假假
 float（-INF）str（'true'）假真真假假假
   float（1）float（0）是否否是否否
  float（INF）float（0）是否否是否否
   float（0）int（-1）是否否是否否
    int（1）float（0）是否否是否否
   float（0）str（'01'）假真真假假假
   str（'1'）float（0）是否否是否否
  float（INF）float（1）是否否是否否
   float（1）int（-1）是否否是否否
   float（1）int（0）是否否是否否
   float（1）str（“ \ 0”）真假假真假假
   str（''）float（1）假真真假假假
   float（1）str（'+'）true假false true假false
   float（1）str（'-'）true假false true假false
   float（1）str（'0'）是否否是否否
   float（1）str（'false'）是否否是否否
 str（'text'）float（1）假真真假假假
 str（'true'）float（1）假真真假假假
  float（INF）int（-1）是否否是否否
  float（INF）int（0）是否否是否否
  float（INF）int（1）是否否是否否
  float（INF）str（“ \ 0”）真假假真假假
  float（INF）str（''）是否否是否否
  float（INF）str（'+'）是否否是否否
  float（INF）str（'-'）true假false true假false
  float（INF）str（'0'）是否否是否否
  float（INF）str（'01'）是否否是否否
  float（INF）str（'1'）是否否是否否
  float（INF）str（'false'）是否否是否否
  float（INF）str（'text'）true假false true假false
  float（INF）str（'true'）是否否是否否
    int（0）int（-1）真假假真假假
    int（1）int（-1）是否否否是否否
  str（“ \ 0”）int（-1）是否否是否否
   str（''）int（-1）真假假真假假
   str（'+'）int（-1）是否否是否否
   str（'-'）int（-1）真假假真假假
   str（'0'）int（-1）是否否是否否
   int（-1）str（'01'）假真真假假假
   str（'1'）int（-1）真假假真假假
 str（'false'）int（-1）是否否是否否
 str（'text'）int（-1）是否否是否是否
 str（'true'）int（-1）是否否是否否
    int（1）int（0）是否否是否否
    int（0）str（'01'）假真真假假假
   str（'1'）int（0）是否否是否否
    int（1）str（“ \ 0”）真假假真假假
   str（''）int（1）假真真假假假
    int（1）str（'+'）真假假真假假
    int（1）str（'-'）真假假真假假
    int（1）str（'0'）真假假真假假
    int（1）str（'false'）是否否是否否
 str（'text'）int（1）假真真假假假假
 str（'true'）int（1）假真真假假假
   str（''）str（“ \ 0”）假真真假假假
   str（'+'）str（“ \ 0”）是否否是否否
   str（'-'）str（“ \ 0”）是否否是否否
  str（“ \ 0”）str（'0'）false true true false false false
  str（“ \ 0”）str（'01'）假真真假假假
   str（'1'）str（“ \ 0”）是否否是否否
 str（'false'）str（“ \ 0”）是否否是否否
 str（'text'）str（“ \ 0”）是否否是否否
 str（'true'）str（“ \ 0”）是否否是否否
   str（''）str（'+'）假真真假假假
   str（''）str（'-'）假真真假假假
   str（''）str（'0'）假真真假假假
   str（''）str（'01'）假真真假假假
   str（''）str（'1'）假真真假假假
   str（''）str（'false'）假真真假假假
   str（''）str（'text'）假真真假假假
   str（''）str（'true'）假真真假假假
   str（'-'）str（'+'）true假false true假false
   str（'+'）str（'0'）假真真假假假
   str（'+'）str（'01'）假真真假假假
   str（'1'）str（'+'）是否否是否否
 str（'false'）str（'+'）是否否是否否
 str（'text'）str（'+'）true假false true假false
 str（'true'）str（'+'）是否否是否否
   str（'-'）str（'0'）假真真假假假
   str（'-'）str（'01'）假真真假假假假
   str（'1'）str（'-'）是否否是否否
 str（'false'）str（'-'）是否否是否否
 str（'text'）str（'-'）true假false true假false
 str（'true'）str（'-'）是否否是否否
   str（'0'）str（'01'）假真真假假假
   str（'1'）str（'0'）是否否是否否
 str（'false'）str（'0'）是否否是否否
 str（'text'）str（'0'）true假false true假false
 str（'true'）str（'0'）是否否是否否
 str（'false'）str（'01'）是否否是否否
 str（'text'）str（'01'）true假false true假false
 str（'true'）str（'01'）是否否是否否
   str（'1'）str（'false'）假真真假假假
 str（'text'）str（'1'）true假false true假false
 str（'true'）str（'1'）是否否是否否
 str（'text'）str（'false'）是否否是否否
 str（'true'）str（'false'）是否否是否否
 str（'true'）str（'text'）是否否是否否

$a > $b > $c难题何时：$a不大于$c。

A <C：浮点数（NAN）> str（'a'）> str（''）
A <C：浮点数（NAN）> str（'a'）> str（'1'）
A <C：浮点数（NAN）> str（'a'）> str（'A'）
A <C：浮点（NAN）> str（'a'）> str（'0'）
A <C：浮点数（NAN）> str（'1'）> str（''）
A <C：浮点（NAN）> str（'1'）> str（'0'）
A <C：浮点数（NAN）> str（'A'）> str（''）
A <C：浮点数（NAN）> str（'A'）> str（'1'）
A <C：浮点数（NAN）> str（'A'）> str（'0'）
A <C：浮点数（NAN）> str（'0'）> str（''）
A <C：str（''）> float（NAN）> str（'a'）
A <C：str（''）>浮点数（NAN）> str（'1'）
A <C：str（''）> float（NAN）> str（'A'）
A <C：str（''）>浮点数（NAN）> str（'0'）
A <C：str（'a'）> str（''）> float（NAN）
A <C：str（'a'）> str（'1'）> float（NAN）
A <C：str（'a'）> str（'A'）> float（NAN）
A <C：str（'a'）> str（'0'）> float（NAN）
A <C：str（'0'）> str（''）> float（NAN）
A == C：bool（true）> str（''）> float（NAN）
A == C：bool（true）> str（''）> float（-INF）
A == C：bool（true）> str（''）> int（-1）
A == C：bool（true）> str（''）> float（-1）
A == C：bool（true）> array（）> float（NAN）
A == C：bool（true）> array（）> float（INF）
A == C：bool（true）> array（）> float（-INF）
A == C：bool（true）> array（）> str（'a'）
A == C：bool（true）> array（）> int（1）
A == C：bool（true）> array（）> float（1）
A == C：bool（true）> array（）> str（'1'）
A == C：bool（true）> array（）> str（'A'）
A == C：bool（true）> array（）> int（-1）
A == C：bool（true）> array（）> float（-1）
A == C：bool（true）> int（0）> float（-INF）
A == C：bool（true）> int（0）> int（-1）
A == C：bool（true）> int（0）> float（-1）
A == C：bool（true）> str（'0'）> float（NAN）
A == C：bool（true）> str（'0'）> float（-INF）
A == C：bool（true）> str（'0'）> int（-1）
A == C：bool（true）> str（'0'）> float（-1）
A == C：bool（true）> float（0）> float（-INF）
A == C：bool（true）> float（0）> int（-1）
A == C：bool（true）> float（0）> float（-1）
A == C：int（1）> str（'a'）> str（'1'）
A == C：int（1）> str（'A'）> str（'1'）
A == C：float（1）> str（'a'）> str（'1'）
A == C：float（1）> str（'A'）> str（'1'）
A == C：str（'a'）> str（'1'）> int（0）
A == C：str（'a'）> str（'1'）> float（0）
A == C：str（''）> float（-INF）> NULL（NULL）
A == C：str（''）> float（-INF）> bool（false）
A == C：str（''）> int（-1）> NULL（空）
A == C：str（''）> int（-1）> bool（假）
A == C：str（''）> float（-1）> NULL（NULL）
A == C：str（''）> float（-1）> bool（false）
A == C：array（）> float（NAN）> NULL（NULL）
A == C：array（）> float（NAN）> bool（false）
A == C：array（）> float（INF）> NULL（NULL）
A == C：array（）> float（INF）> bool（false）
A == C：array（）> float（-INF）> NULL（NULL）
A == C：array（）> float（-INF）> bool（false）
A == C：array（）> str（'a'）> NULL（NULL）
A == C：array（）> str（'a'）> bool（false）
A == C：array（）> int（1）> NULL（NULL）
A == C：array（）> int（1）> bool（false）
A == C：array（）> float（1）> NULL（NULL）
A == C：array（）> float（1）> bool（false）
A == C：array（）> str（'1'）> NULL（NULL）
A == C：array（）> str（'1'）> bool（false）
A == C：array（）> str（'A'）> NULL（NULL）
A == C：array（）> str（'A'）> bool（false）
A == C：array（）> str（'0'）> NULL（NULL）
A == C：array（）> int（-1）> NULL（NULL）
A == C：array（）> int（-1）> bool（false）
A == C：array（）> float（-1）> NULL（NULL）
A == C：array（）> float（-1）> bool（false）
A == C：str（''）> float（NAN）> bool（false）
A == C：str（''）> float（NAN）> NULL（NULL）
A == C：str（'A'）> str（'1'）> int（0）
A == C：str（'A'）> str（'1'）> float（0）
A == C：int（0）>浮点（-INF）> NULL（NULL）
A == C：int（0）> float（-INF）> bool（false）
A == C：int（0）> int（-1）> NULL（NULL）
A == C：int（0）> int（-1）> bool（假）
A == C：int（0）> float（-1）> NULL（NULL）
A == C：int（0）> float（-1）> bool（false）
A == C：str（'0'）> float（NAN）> bool（false）
A == C：str（'0'）> float（-INF）> bool（false）
A == C：str（'0'）> int（-1）> bool（假）
A == C：str（'0'）> float（-1）> bool（false）
A == C：float（0）> float（-INF）> NULL（NULL）
A == C：float（0）> float（-INF）> bool（false）
A == C：浮点数（0）>整数（-1）> NULL（NULL）
A == C：float（0）> int（-1）> bool（false）
A == C：float（0）> float（-1）> NULL（NULL）
A == C：float（0）> float（-1）> bool（false）
A === C：str（'0'）> float（NAN）> str（'0'）
A === C：str（''）>浮点数（NAN）> str（''）
A === C：str（'a'）>浮点数（NAN）> str（'a'）
A === C：str（'1'）> float（NAN）> str（'1'）
A === C：str（'A'）>浮点数（NAN）> str（'A'）

_{有趣的字符串比较：“皇后”，>“国王”，>“杰克”，>“王牌”}

还要检查涵盖对的PHP类型比较表：

isset() 和 is_null()
if() 和 empty()
布尔==vs.===

检查PHP版本之间的差异。http://3v4l.org/MAfDu。

— ᵠ
source

+1更不用说带有固定列标题的可滚动“表格”了

— 不错的

类型转换时是否需要使用严格的运算符？我的意思是您已经写过，if ( (string)$a===(string)$b )但这不完全一样if ( (string)$a==(string)$b )吗？

— Voitcus

@Voitcus是两种类型的铸造(string)1==(string)'01'- > bool(true)和类型的骗局(1 . '')=='01'- > bool(true)不完全相同一样===时，你会得到bool(false)两个账号

— CSᵠ

一种选择：八进制值不是“分配时转换”的，而是由编译器解释的，编译器必须将ASCII转换为实际的二进制数。

— IMSoP 2013年

INFINITY is equal to INFINITY which is mathematically incorrect!是一个值得商de的声明。还要注意，NaN按照惯例，我所知道的任何编程语言都不得大于，小于或等于任何值。

— DaveRandom

在您对问题的第二部分进行更正之后，我将其余部分的答案留给其他人。我只想对您的问题的第一部分给出最令人惊讶的答案，即是否存在<和>运算符不传递的示例。这里是。

这些都是true：

"10" < "1a"
"1a" < "2"
"10" > "2"

如果<是传递（$a < $b∧ $b < $c⇒ $a < $c），最后一行是

"10" < "2"

但是PHP会尝试变得友善（？！），并尽可能将字符串解释为数字。

事实证明，由于上述不透明性，即使没有两个元素（并且也没有NAN），sort()也可以根据它们的输入顺序将相同的元素分类为不同的顺序。我在对sort（）的注释中指出了这一点，其本质是：==

sort(array("10", "1a", "2" )) => array("10", "1a", "2" )
sort(array("10", "2",  "1a")) => array("1a", "2",  "10")
sort(array("1a", "10", "2" )) => array("2",  "10", "1a")
sort(array("1a", "2",  "10")) => array("1a", "2",  "10")
sort(array("2",  "10", "1a")) => array("2",  "10", "1a")
sort(array("2",  "1a", "10")) => array("10", "1a", "2" )

— 沃尔特·特罗斯
source

先前的评论指的是我同时删除的答案的一部分（与问题的第二部分有关）

— Walter Tross 2013年

现在将其删除；）还有一个不错的新sort()表，在撰写相关博客文章The Greatest PHP Value时也将其用于实际意义。再次感谢您的回答。

— hakre 2013年

这是否意味着应usort尽可能使用？

— Voitcus

@Voitcus：我想你是说usort($arr, 'strcmp')。这可以工作（当然适用于字符串），但是最好使用sort($arr, SORT_STRING)。

— Walter Tross

@WalterTross我的意思是总是使用您自己的函数（不仅用于字符串）以确保它始终正确

— Voitcus 2013年