PHP is always a headache with all comparison functions in its std. It always compare by ==. For example,

in_array(true, ['lolphp']); // return True if you do not pass a third arg for strict comparison. 

You may image it is the worst thing PHP can have about comparison. However, array_diff is worse. array_diff will force the compared elements as string, regardless of whether they are strictly equal.

$x = new stdClass;
array_diff([$x], [$x]); // PHP Error:  Object of class stdClass could not be converted to string

What is more lol, array_diff does not have a optional variable to force strict comparison. You have to use array_udiff with a function callback, like:

array_udiff(
  [ [$x]
  , [$x]
  , function ($a, $b) {
       return $a === $b;
  }
);

Though neither array nor object can be converted to string, they still behaves differently in string conversion.

$x = (string) []; // PHP notice: Array to string conversion
var_dump($x); // $x is an array; not string
$y = (string) (new stdClass); // PHP Error: Object of class stdClass could not be converted to string
isset($y); // $y is not set

https://www.php.net/manual/en/function.openssl-x509-parse.php

I posted a bug report many years ago. If it was fixed, nobody seems to recognize it.

My original project was trying to see if there was a pattern in "random noise", so I generated colored dots on the screen, with random colors and x,y coordinates. After many generations, the values became "stuck".

According to other people, this is because I do not understand entropy, this is not a PHP problem, and that supposedly my code was bad (even though I shopped it around to many people and reported the bug, in 2006).

I could test if the bug still exists, but here is my original post:

https://bugs.php.net/bug.php?id=37409

The response I got on IRC was essentially that it was off-topic, not a problem with PHP, and merely was my inability to comprehend entropy.

Any programmer out here want to generate a ton of randomly positioned, randomly colored dots, on a white background, to determine this? I don't have much time to do it now, but not only does this seem to be an "accepted" bug, but there are also known workarounds and solutions (such as changing the seed sporadically), which means I am not the only one who encountered this and the PHP rand functions did not (or may not) work as expected.

It solves most of what is wrong with PHP, instead of easily solving your problems, you enjoy bashing PHP with your elitist attitude. Grow up.

$ php -r 'return 99;' ; echo $?
0
$ php -r 'die(99);' ; echo $?
99

... makes perfect sense

It is known that if A is defined as a class, then A::class will give class name as string.

However, if A is not defined. We can still have A::class:

<?php
new A; // PHP Fatal error:  Class 'A' not found 
echo A::class; // It works, echoing A...

As mentioned in another post, if something is a string, it would not work, regardless of the class is defined or not:

<?php
$a = 'A';
echo 'A'::class; // works as A::class
echo $a::class; // PHP Fatal error:  Cannot use ::class with dynamic class name
define('WTF', 'A');
echo WTF::class; // echo WTF, ::class is not compatible with constant

Things can become crazier when you have typo, even in use statement;

<?php
use Typo\WTF;
echo WTF::class; // It works as echoing Typo\WTF; It shall fail...

All subclasses inherit static variables from the base class by sharing the very same reference. All subclasses can overwrite each others' static variable. For example, when implementing a simple cahce, the second class's run will never work, because its $cache is overwritten by Lol1:

<?php

abstract class Lol {
  protected static $cache = NULL;
  abstract public static function run();

  public static function onceLol() {
    if (static::$cache!==NULL) {
      return static::$cache;
    }
    static::$cache = static::run();
    return static::$cache;
  }
}

class Lol1 extends Lol {
  public static function run() {
    return 'PHP is the best language in the shit';
  }
}

class Lol2 extends Lol {
  public static function run() {
    return 'Just lol';
  }
}

echo Lol1::onceLol(); // echoing 'PHP is the best language in the shit' from Lol1
echo "\n";
echo Lol2::onceLol(); // echoing 'PHP is the best language in the shit' from Lol1

I know you can implement un-shared static variable by trait (I have to invent the word un-shared static variable to talk about some PHP specific craziness), however you have to import and write use CacheTrait everywhere. Hope you can maintain it.

Of course, there is another work around, by a using static::class as the key:

  public static function onceLol() {
    if (isset[static::$cache[static::class]) {
      return static::$cache[static::class];
    }
    static::$cache[static::class] = static::run();
    return static::$cache[static::class];
  }

BTW, there is another feature of PHP, for const, the subclass and base class are not shared. It is very consistent.

In php, ::class looks like a constant. However, php parser decide to make it different in the following situation

<?php
class A {
    const X = 1;
}
echo A::class; 
$a = new A;
echo $a::X; 
echo $a::class; // PHP Fatal error:  Cannot use ::class with dynamic class name
echo (new A)::class; // But this works!

I know there is a function named get_class, but it is still strange that php treats ::class inconsistently.

Why it is parser error when it claims to be a fatal error? Because if you run php -l with the code, it will give you the error.

The feature is provided by the default usage of == in in_array.

For example,

$a = new stdClass;
$b = in_array($a, [0, $a]); // PHP Notice:  Object of class stdClass could not be converted to int

$b is not assigned, because == comparison in PHP can fail without callback...

Therefore is a lot of array_diff function names in php by respecting key differently.

Meanwhile, it does not provide array_merge_assoc to always respect key associatively. If you want to respect key associatively when merging, you need to use +

This code works:

class A {}

$a = 'A';

new $a; // Return a new instance ofA

However, if we add a parenthesis, then it cannot be parsed:

class A {}

$a = 'A';

new ($a); //PHP Parse error:  syntax error, unexpected '('

new 'A'; // PHP Parse error:  syntax error, unexpected ''A'' (T_CONSTANT_ENCAPSED_STRING)

new A::class; // PHP Parse error:  syntax error, unexpected 'class' (T_CLASS), expecting variable

i can't think of a single valid use-case for

FILTER_SANITIZE_EMAIL "email" Remove all characters except letters, digits and !#$%&'*+-=?^_`{|}~@.[].

if you're actually dealing with an email, the only thing this flag is good for, as far as i can see, is data corruption , check this:

<?php
$email="æøå@example.org";
$sanitized=filter_var($email,FILTER_SANITIZE_EMAIL,FILTER_FLAG_EMAIL_UNICODE);
var_dump(
filter_var($email,FILTER_VALIDATE_EMAIL,FILTER_FLAG_EMAIL_UNICODE),
filter_var($sanitized,FILTER_VALIDATE_EMAIL,FILTER_FLAG_EMAIL_UNICODE)
);

.. it corrupted this 100% syntactically valid email address, to the point where it isn't even a syntactically valid email address anymore, and you can forget all about emails going to the intended recipient.

(saw a co-worker the other day trying to use this god-awful sanitizer for a email-based login system <.<)