I'd like to discuss the addition of the new directive `strict_operators`, which
can be used to disable type juggling when using operators.
---
MOTIVATION
A substantial part of the PHP dev community, including myself, have a strong
dislike of type juggling. It's a common source of issues, while the benefits
over explicit type casting are minimal.
The loose comparison equal (`==`) operator and not equal (`!=`) are a well
known causes of security issues. While to use of these two operators are
discouraged, the issues aren't limited to them but also present in all other
comparison operators as well as arithmetic operators.
Type juggling can be a source of frustration, as it may lead to unexpected
results. An example;
Universal rules of logic state that if `a > b` and `b > c` then `a > c`
<?php
$a = '42';
$b = 10;
$c = '9 dwarfs';
var_export($a > $b); // true
var_export($b > $c); // true
var_export($a > $c); // false ??
---
PROPOSAL
The `strict_operators` directive would work similar to `strict_types`. If
`strict_operators=1` is declared, operators will throw a `TypeError` when an
operator is used with incompatible types.
<?php
declare(strict_operators=1);
$b = 10;
$c = '9 dwarfs';
var_export($b > $c); // TypeError "Type mismatch for greater than ('>')
operator with integer and string"
Including the equals operator;
<?php
declare(strict_operators=1);
$q = 42;
$r = '42';
$s = '42 dwarfs';
var_export($q == $r); // TypeError "Type mismatch for equals ('==') operator
with integer and string"
var_export($q == $s); // TypeError "Type mismatch for equals ('==') operator
with integer and string"
var_export($r == $s); // false
var_export($q === $r); // false
var_export($q == (int)$r); // true
You'd still use `===` to compare values of different types.
The rule also applies to arithmetic operators;
<?php
declare(strict_operators=1);
$b = 10;
$c = '9 dwarfs';
var_export($b + $c); // TypeError "Type mismatch for addition ('+') operator
with integer and string"
var_export($b + (int)$c); // 19
Using operator on a type that doesn't support it, would also throw a
`TypeError`, rather than trigger a notice.
<?php
declare(strict_operators=1);
$s = "foo";
$arr = [];
$b = $s . $arr; // TypeError "Unsupported type for concatenation ('.')
operator, unexpected array"
Last, it would disable type conversion for numeric strings.
<?php
declare(strict_operators=1);
$a = "2.7e1";
$b = "27";
var_dump($a == $b); // false
var_dump((int)$a == (int)$b); // true
---
SCOPE
The directive should only apply to operators and not have other side effects.
For instance; Type casting can still cause similar issues to type juggling,
especially when casting a string to an integer. In other languages like Python,
casting "42 dwarfs" to an int throws a `ValueError`. However, this and similar
issues are outside the scope of this proposal.
---
I believe the directive `strict_operators` fits in the direction PHP is going
with better support for typing, while not affecting backwards compatibility.
Regards,
Arnold Daniels
[Arnold Daniels - Contact Using
Spike](https://www.spikenow.com/?ref=spike-organic-signature&_ts=prm5vi)
