---

if (-1 < NULL)
echo 'NULL is smaller';
else
echo '-1 is smaller';

returns '-1 is smaller' as all of us expects.

Please go over the conditions and the echos in this example one more
time.

-- S.

Hi!

Our manual does not have NULL/BOOL type behavior explanations.

It does. I already sent the link, here it is again:

http://www.php.net/manual/en/language.operators.comparison.php

The bug report might be confusing, but it's is not complaining -1 !=
false or like, but it's complaining min() is not following standard PHP
comparison rules.

This is incorrect, it does.

---

if (-1 < NULL)
echo 'NULL is smaller';
else
echo '-1 is smaller';

returns '-1 is smaller' as all of us expects.

Surely, but since in your script the branches are switched, NULL is
actually smaller. Your script just prints "-1 is smaller" when NULL is
smaller. Exactly as described in the manual.

NULL is evaluated as 0 in scalar contexts, but not with min(). NULL wins

I'm not sure what "scalar contexts" are, but NULL is converted to 0 as
integer, however comparisons do not always do integer conversions.
Please see the manual again.

negative values because of the compare_function() in zend_operators.c.
compare_function() treats NULL/BOOL type special way. (i.e Not like
expression in 'if' statement or like)

This is not correct, all these operations treat NULL in the same way.
You are welcome to show an example where it is treated differently, but
I think it's be rather hard as they all use the same compare_function.

I think feasible solution for min() misbehavior is to use new function
that uses standard PHP comparison rule. I'll check PHP functions that

min() already uses standard PHP comparison rules, by calling
compare_function.

uses compare_function() later. There may be other array functions use
it. I'm not sure if there are 'internal' functions that does not perform
comparison(or conversion) non standard way like compare_function().

compare_function is the standard way. That's what comparison operators
use, just look at the code.

--
Stanislav Malyshev, Software Architect
SugarCRM: http://www.sugarcrm.com/
(408)454-6900 ext. 227

I think almost all users are not expecting

min(-10000, -1000, -100, NULL, 100, 1000) returns NULL.

I expect it.

Because, in fact, PHP is not SQL.

It is PHP, and it has its own rules that everybody plays by. They
aren't SQL rules (where NULLs may either be disregarded, as in
aggregates, or quite heavily regarded).

The ecosystem of PHP and SQL is, however, one of the fundamental
reasons you must not make the change you propose. SQL MIN() works
across one column within a rowset, while users often desire a similar
function that works across columns in a row. As they are unable to do
this in pure SQL, they will turn to application code, performing a PHP
min() across columns returned from SQL -- columns that quite commonly
contain PHP NULL if the DB layer supports it. All this time, they have
been getting NULL. You want them to get -10000 for those same rows and
not have that affect their application in a big way. Just... no.

Besides, the manual is not explaining this weird behavior at all.

Sure it is.

-- S.

TRUE only evaluated as 1 otherwise FALSE. FALSE/NULL evaluated as 0
or least.

This is not helping you understand -- you're trying to create rules
and fitting some behavior into them, and then withdrawing your "rules"
when they appear to break.

What you should be doing is using the actual stated rules of the
language.

I realize you're excited about correcting something that has confused
you for a long time, but you are getting ahead of yourself in trying
to say there's something fundamentally wrong with the way PHP works.
Try to slow down and read the comparison rules.

That's what we need in document. IMO.

We absolutely, positively do not need something like this in the
docs.

However, this behavior seems weird.

[yohgaki@dev ~]$ php -r "var_dump((FALSE < -100));"
bool(true)
[yohgaki@dev ~]$ php -r "var_dump((FALSE > -100));"
bool(false)

[yohgaki@dev ~]$ php -r "var_dump((TRUE < -100));"
bool(false)
[yohgaki@dev ~]$ php -r "var_dump((TRUE > -100));"
bool(false)

It's really confusing to me :(

OK, first throw out EVERYTHING you have assumed to date.

Now, realize that PHP has a documented rule of comparing booleans to
integers (this rule is found in the "NULL or boolean - to - anything"
part of the page on comparison).

The rule is: compare as booleans, where FALSE < TRUE.

So take

FALSE < -100

How do we compare them as booleans?

• `FALSE` is already a bool: use `FALSE` 

• cast -100 to bool: use `TRUE` 

So the effective strict comparison is

FALSE < TRUE

By the definition of boolean comparison in PHP, this expression must
be TRUE.

How about

`TRUE` < -100

Compare as booleans?

• `TRUE` is a boolean: use `TRUE` 

• cast -100 to bool: use `TRUE` 

So we've got

TRUE < TRUE

By the definition of non-object comparison in most any language
(including PHP), this expression is FALSE.

-- S.