PHPの厳密な緩やかな比較

[PHP](https://qiita.com/rana_kualu/items/129b4210ce99e7f50d06) / [JavaScript](https://qiita.com/rana_kualu/items/2a12fc8b9bc1cd647ec5)


# 緩やかな比較…俺なんかが関わって良い世界ではなかった…


`==`による比較の厳密な定義というものが見当たらなかったので調べました。
実用的には[PHP型の比較表](http://php.net/manual/ja/types.comparisons.php)を見ればいいだけなのですがね。

ちなみにJavaScriptでは[言語仕様で明記](https://qiita.com/rana_kualu/items/2a12fc8b9bc1cd647ec5)されています。


# ==の擬似コード

`==`による緩やかな比較は[zend_vm_def.h](https://github.com/php/php-src/blob/php-7.2.10/Zend/zend_vm_def.h#L385)で実装されています。

元コードはもちろんCなのでPHPで完全再現というわけにはいきませんが、以下はPHPっぽく表した擬似コードとなります。
擬似コードは調査時点での最新安定版PHP7.2.10のもので、バージョンによって異なる可能性があります。

```php

/**
* ==の定義
* @param zval 引数1のzval構造体
* @param zval 引数2のzval構造体
* @return boolean 緩やかに同じならtrue、緩やかに異なればfalse
*/
function ==($op1, $op2){
	
	if($op1の型 === integer){
		if($op2の型 === integer){
			return $op1の整数値 === $op2の整数値;
		}else($op2の型 === double){
			return (double)$op1の整数値 === $op2の整数値;
		}
	}elseif($op1の型 === double){
		if($op2の型 === double){
			return $op1の小数値 === $op2の小数値;
		}else(op2の型 === integer){
			return $op1の小数値 === (double)$op2の整数値;
		}
	}elseif($op1の型 === string){
		if($op2の型 === string){
			if($op1のポインタ === $op2のポインタ){
				return true;
			}elseif($op1の1文字目が'9'より大きい || $op2の1文字目が'9'より大きい){
				if($op1の文字長 !== $op2の文字長){
					return false;
				}else{
					return memcmp($op1, $op2) === 0;
				}
			}else{
				return !zendi_smart_strcmp($op1の文字列値, $op2の文字列値);
			}
		}
	}
	
	return !compare_function($op1, $op2);
}
```

ざっくり現すとこんなかんじ。
・両方が数値型であれば数値にして、Cの`==`で比較して返す
・両方が文字列型で、両方の1文字目が数字でなければCのmemcmpで比較して返す
・両方が文字列型ならzendi_smart_strcmpを呼ぶ
・それ以外ならcompare_functionを呼ぶ

高速にさっと比較できるものはさっと調べ、それ以外は別の関数をさらに呼び出す形になっているようです。

`'9'より大きい`というのはchar型の文字コードが'9'より大きいという意味で、PHPで言えば`ord(op1の1文字目) > ord('9')`です。
[memcmp](http://hitorilife.com/memcmp.php)は、ほぼPHPの[strcmp](http://php.net/manual/ja/function.strcmp.php)で、文字列が等しいかを比較します。
zendi_smart_strcmpとcompare_functionはPHPの内部関数です。


## zendi_smart_strcmpの擬似コード

zendi_smart_strcmpは[zend_operators.c](https://github.com/php/php-src/blob/php-7.2.10/Zend/zend_operators.c#L2762)で実装されています。
`==`において、両方の引数が文字列型である場合に呼ばれます。

```php

/**
* 文字列型同士を緩やかに比較して返す
* @param zend_string 文字列1
* @param zend_string 文字列2
* @return int 文字列が緩やかに等しければ0、等しくなければ0以外
*/
function zendi_smart_strcmp($op1, $op2){
	$ret1 = 文字列を数値に変換する($op1); // integerかdoubleか失敗のいずれかになる
	$ret2 = 文字列を数値に変換する($op2);
	
	// 何れかが数値文字列ではなかった
	if( !$ret1 || !$ret2 ){
		return zend_binary_strcmp($op1, $op2);
	}
	
	if(32ビットOSなら){
		if( $ret1がオーバーフローしている
			&& $ret2がオーバーフローしている
			&& $ret1 === $ret2
			&& ( $ret1 > 9007199254740991 || $ret1 < -9007199254740991 )
		){
			return zend_binary_strcmp($op1, $op2);
		}
	}else{
		if( $ret1がオーバーフローしている
			&& $ret2がオーバーフローしている
			&& $ret1 === $ret2
		){
			return zend_binary_strcmp($op1, $op2);
		}
	}
	
	if( $ret1の型 === double || $ret2の型 === double ){
		if( $ret1の型 !== double ){
			$ret1 = (double)$ret1;
		}
		elseif( $ret2の型 !== double ){
			$ret2 = (double)$ret2;
		}elseif($ret1 === $ret2 && $ret1がオーバーフローしている){
			return zend_binary_strcmp($op1, $op2);
		}
		return $ret1 - $ret2;
	}
	
	return $ret1 <=> $ret2;
}

/**
* 文字列型同士を文字列のまま比較して返す
* @param char 文字列1
* @param char 文字列2
* @return int 等しければ0、等しくなければ文字列長の差
*/
function zend_binary_strcmp($op1, $op2){
	if($op1のポインタ === $op2のポインタ){
		return 0;
	}
	return memcmp($op1, $op2);
}
```

1文字目が'A'や'a'であるなど、数値文字列でないことが明らかな場合は`==`内でさっさと比較して返されているので、ここに来るのは数値文字列である可能性がある場合になります。
`文字列を数値に変換する`などの処理内部は華麗にすっ飛ばしていますが、このあたりも[えらいことになっていて](https://github.com/php/php-src/blob/php-7.2.10/Zend/zend_operators.c#L2876)、全てを追っていたら年が明けてまた暮れます。

またオーバーフロー云々は[このあたり](https://hnw.hatenablog.com/entries/2014/08/09)とか[このあたり](https://bugs.php.net/bug.php?id=62097)とかのアドホック修正が積み重なった挙げ句の果てです。
擬似コードではわかりやすく条件分岐していますが、元のコードでは条件文自体を書き換えています。

```c:zend_operators.c
#if ZEND_ULONG_MAX == 0xFFFFFFFF
		if (oflow1 != 0 && oflow1 == oflow2 && dval1 - dval2 == 0. &&
			((oflow1 == 1 && dval1 > 9007199254740991. )
			|| (oflow1 == -1 && dval1 < -9007199254740991.))) {
#else
		if (oflow1 != 0 && oflow1 == oflow2 && dval1 - dval2 == 0.) {
#endif
```

言語実装という現場ではDIやらポリモーフィズムやら言ってる余裕なんてないということでしょう。
しかしそれはいいとしても、ZEND_ENABLE_ZVAL_LONG64やらUINT32_MAXやらを使わず直接`0xFFFFFFFF`なのは何故なのか。


## compare_functionの擬似コード

compare_functionも[zend_operators.c](https://github.com/php/php-src/blob/php-7.2.10/Zend/zend_operators.c#L1904)で実装されています。
こちらは片方が配列だったりオブジェクトだったりといった、ここまでで判定しきれなかった比較が全てやってきます。
つまりは遅いということなので、ここまで来るような比較はあまり書かない方がよいでしょう。
といってもロジックの遅さに比べたら塵芥の差なので気にする必要もないと思いますが。

`[integer, integer]`といった、最初の`==`で弾かれているはずのロジックも書かれていますが、これは`==`以外からも使われているためです。
具体的には[SplHeap](http://php.net/manual/ja/class.splheap.php)や[Collator](http://php.net/manual/ja/class.collator.php)などから呼ばれています。
つまり、これらのソートは緩やかな比較で行われているということです。

```php

/**
* 緩やかに比較して返す
* @param zval 引数1のzval構造体
* @param zval 引数2のzval構造体
* @return int 文字列が緩やかに等しければ0、等しくなければ0以外
*/
function compare_function($op1, $op2){
	
	$converted = false;
	
	start:

	switch([$op1の型, $op2の型]){

	case [integer, integer]:
		return $op1 > $op2 ? 1 : ( $op1 < $op2 ? -1 : 0);
	
	case [double, integer]:
		return ZEND_NORMALIZE_BOOL($op1 - (double)$op2);
	
	case [integer, double]:
		return ZEND_NORMALIZE_BOOL((double)$op1 - $op2);
	
	case [double, double]:
		if($op1 === $op2){ return 0;}
		return ZEND_NORMALIZE_BOOL($op1 - $op2);
	
	case [array, array]:
		return zend_compare_arrays($op1, $op2);
	
	case [null, null]:
	case [null, false]:
	case [false, null]:
	case [false, false]:
	case [true, true]:
		return 0;
	
	case [null, true]:
		return -1;
	case [true, null]:
		return 1;
	
	case [string, string]:
		return $op1 === $op2;
	
	case [null, string]:
		return strlen($op2) === 0 ? 0 : -1;
	case [string, null]:
		return strlen($op1) === 0 ? 0 : 1;
	
	case [object, null]:
		return 1;
	case [null, object]:
		return -1;
	
	default:
		if($op1が参照である){
			$op1 = $op1の参照先;
			goto start;
		}
		if($op2が参照である){
			$op2 = $op2の参照先;
			goto start;
		}
		
		if($op1の型 === object && $op1にcompareハンドラがある){
			return $op1のcompareハンドラ($op1, $op2);
		}
		if($op2の型 === object && $op2にcompareハンドラがある){
			return $op2のcompareハンドラ($op1, $op2);
		}
		
		if($op1の型 === object && $op2の型 === object){
			if($op1のポインタ === $op2のポインタ){
				return 0;
			}
			if($op1のcompare_objectsハンドラのポインタ === $op2のcompare_objectsハンドラのポインタ){
				return $op1のcompare_objectsハンドラ($op1, $op2);
			}
		}
		
		if($op1の型 === object){
			if($op1にgetハンドラがある){
				return compare_function($op1->get(), $op2);
			}elseif($op2の型 !== object && $op1にcast_objectハンドラがある){
				$op1 = $op1->cast_object($op2の型);
				return compare_function($op1, $op2);
			}
		}
		if($op2の型 === object){
			if($op2にgetハンドラがある){
				return compare_function($op1, $op2->get());
			}elseif($op1の型 !== object && $op2にcast_objectハンドラがある){
				$op2 = $op2->cast_object($op1の型);
				return compare_function($op1, $op2);
			}
		}elseif($op1の型 === object){
			return 1;
		}
		
		if(!$converted){
		
			if($op1の型 === null || $op1の型 === false){
				return (bool)$op2 === true ? -1 : 0;
			}elseif($op2の型 === null || $op2の型 === false){
				return (bool)$op1 === true ? -1 : 0;
			}elseif($op1の型 === true){
				return (bool)$op2 === true ? 0 : 1;
			}elseif($op2の型 === true){
				return (bool)$op1 === true ? 0 : -1;
			}else{
				$op1 = (int)$op1;
				$op2 = (int)$op2;
				$converted = true;
				goto start;
			}
		
		}elseif($op1の型 === array){
			return 1;
		}elseif($op2の型 === array){
			return -1;
		}elseif($op1の型 === object){
			return 1;
		}elseif($op2の型 === object){
			return -1;
		}else{
			return 0;
		}
	
	}
}
```

なにこれ。

両方の型がオブジェクトである場合、比較はzend_object_handlers.cで定義されている[compare_objectsハンドラ](https://github.com/php/php-src/blob/php-7.2.10/Zend/zend_object_handlers.c#L1465)で行われます。
同じクラスのインスタンスであり、全てのプロパティの値が同じときにだけtrueを返す、と定義されています。

ただし、これは[任意に書き換えることができる](http://php.net/manual/ja/language.oop5.object-comparison.php)ため、正確な定義はそれぞれの実装を見なければわかりません。
例として、DateTimeでは[時間が同じならtrueを返す](https://github.com/php/php-src/blob/php-7.2.10/ext/date/lib/timelib.c#L72)ようになっています。
時間さえ同じなら[それ以外のプロパティが異なっていてもtrue](https://3v4l.org/N6gnH)です。
普通のオブジェクトでは当然[そんなことはありません](https://3v4l.org/WEgMA)。

compareハンドラについてはよくわかりませんでした。

ZEND_NORMALIZE_BOOLは返り値を0、1、-1の何れかにしてくれる、[宇宙船演算子](https://qiita.com/Hiraku/items/62821d7d0e7af1ac211e)みたいなマクロです。

[zend_compare_arrays](https://github.com/php/php-src/blob/php-7.2.10/Zend/zend_operators.c#L2830)は配列同士を比較する関数で、幾度かのたらい回しを経て、最終的に配列の全要素をcompare_functionで比較して返すという内容になっていました。


ちなみにzend_compare_arraysのすぐ下にある[zend_compare_objects](https://github.com/php/php-src/blob/php-7.2.10/Zend/zend_operators.c#L2836)ですが、いかにもオブジェクト同士を比較してそうな名前ですが全く使われておらず、何故か[unregister_tick_function](http://www.php.net/manual/ja/function.unregister-tick-function.php)だけからしか呼ばれないという謎関数でした。


# ===の擬似コード

参考までに`===`の定義も見てみましょう。

定義は[zend_vm_def.h](https://github.com/php/php-src/blob/php-7.2.10/Zend/zend_vm_def.h#L349)にありますが、たらい回しを経て実態は[zend_is_identical](https://github.com/php/php-src/blob/php-7.2.10/Zend/zend_operators.c#L2112)です。


```php

/**
* ===の定義
* @param zval 引数1のzval構造体
* @param zval 引数2のzval構造体
* @return boolean 厳密に同じならtrue、厳密に異なればfalse
*/
function ===($op1, $op2){
	
	if($op1の型 !== $op2の型){
		return false;
	}
	
	switch($op1の型){

	case null:
	case false:
	case true:
		return true;
	
	case integer:
		return $op1の整数値 === $op2の整数値;
	
	case resource:
		return $op1のポインタ === $op2のポインタ;
	
	case double:
		return $op1の小数値 === $op2の小数値;
	
	case string:
		if($op1のポインタ === $op2のポインタ){
			return true;
		}
		return memcmp($op1, $op2) === 0;
	
	case array:
		if($op1のポインタ === $op2のポインタ){
			return true;
		}
		return zend_hash_compare($op1, $op2);
	
	case object:
		return $op1のポインタ === $op2のポインタ;
	
	default:
		return false;
	}
}
```

`==`に比べると非常にすっきりしていますね。
zend_hash_compareはzend_compare_arraysとだいたい同じで、配列の全要素を`===`で比較するというものです。


# まとめ

`===`を使おう。

プリミティブ型ならまだしも、Object型の緩やかな比較がどうなるかをわかる人は変態だけだと思うのですよ。


# 感想

PHPのソース、マクロだらけ、たらい回しだらけで読むのがとてもつらい。
[Z_OBJ_HANDLER_P](https://github.com/php/php-src/blob/php-7.2.10/Zend/zend_types.h#L603)とか[ZEND_VM_SMART_BRANCH](https://github.com/php/php-src/blob/php-7.2.10/Zend/zend_execute.c#L2937)とかなんなん。
もっとも言語は高速化こそが正義であって、可読性など二の次三の次ということなのでしょうが、おかげで後から見るのがとっても大変です。
こんなの触れる人は本当すごいですわ。