SplObjectStorage::getHash
This method calculates an identifier for the objects added to an SplObjectStorage object.
The implementation in SplObjectStorage returns the same value as spl_object_hash() .
The storage object will never contain more than one object with the same identifier. As such, it can be used to implement a set (a collection of unique values) where the quality of an object being unique is determined by the value returned by this function being unique.
Parameters
The object whose identifier is to be calculated.
Return Values
A string with the calculated identifier.
Errors/Exceptions
A RuntimeException is thrown when the returned value is not a string .
Examples
Example #1 SplObjectStorage::getHash() example
class OneSpecimenPerClassStorage extends SplObjectStorage public function getHash ( $o ) return get_class ( $o );
>
>
class A <>
$s = new OneSpecimenPerClassStorage ;
$o1 = new stdClass ;
$o2 = new stdClass ;
$o3 = new A ;
$s [ $o1 ] = 1 ;
//$o2 is considered equal to $o1 so the value is replaced
$s [ $o2 ] = 2 ;
$s [ $o3 ] = 3 ;
//these are considered equal to the objects before
//so they can be used to access the values stored under them
$p1 = new stdClass ;
$p2 = new A ;
echo $s [ $p1 ], «\n» ;
echo $s [ $p2 ], «\n» ;
?>
The above example will output something similar to:
spl_object_id
This function returns a unique identifier for the object. The object id is unique for the lifetime of the object. Once the object is destroyed, its id may be reused for other objects. This behavior is similar to spl_object_hash() .
Parameters
Return Values
An integer identifier that is unique for each currently existing object and is always the same for each object.
Examples
Example #1 A spl_object_id() example
Notes
Note:
When an object is destroyed, its id may be reused for other objects.
User Contributed Notes 1 note
$test1 = new Test ;
$test1_id = spl_object_id ( $test1 );
$test2 = new Test ;
$test2_id = spl_object_id ( $test2 );
var_dump ( $test1_id === $test2_id );
var_dump ( $test1_id );
var_dump ( $test2_id );
?>
Returns
bool(false)
int(5288)
int(5287)
- SPL Functions
- class_implements
- class_parents
- class_uses
- iterator_apply
- iterator_count
- iterator_to_array
- spl_autoload_call
- spl_autoload_extensions
- spl_autoload_functions
- spl_autoload_register
- spl_autoload_unregister
- spl_autoload
- spl_classes
- spl_object_hash
- spl_object_id
spl_object_hash
This function returns a unique identifier for the object. This id can be used as a hash key for storing objects, or for identifying an object, as long as the object is not destroyed. Once the object is destroyed, its hash may be reused for other objects. This behavior is similar to spl_object_id() .
Parameters
Return Values
A string that is unique for each currently existing object and is always the same for each object.
Examples
Example #1 A spl_object_hash() example
Notes
Note:
When an object is destroyed, its hash may be reused for other objects.
See Also
User Contributed Notes 10 notes
Note that the contents (properties) of the object are NOT hashed by the function, merely its internal handle and handler table pointer. This is sufficient to guarantee that any two objects simultaneously co-residing in memory will have different hashes. Uniqueness is not guaranteed between objects that did not reside in memory simultaneously, for example:
var_dump(spl_object_hash(new stdClass()), spl_object_hash(new stdClass()));
Running this alone will usually generate the same hashes, since PHP reuses the internal handle for the first stdClass after it has been dereferenced and destroyed when it creates the second stdClass.
Note that given two different objects spl_object_hash() can return values that look very similar, and in fact both the most significant *and* least significant digits are likely to be identical! e.g. «000000003cc56d770000000007fa48c5» and «000000003cc56d0d0000000007fa48c5».
Therefore (especially if using this function for debugging), you may wish to pass the hash into a cryptographic hash function like md5() to get to facilitate visual comparisons, and make it more likely that the first few or last few digits are unique.
Please note that since PHP 7.2 there’s new function available spl_object_id() which returns int instead of string. It’s (supposed to be) more performant. Due to lack of documentation I recommend you reading the PR https://github.com/php/php-src/pull/2611
For those who believe this function is misnamed, I would like to direct you to https://en.wikipedia.org/wiki/Hash_function . Also, for those who think it’s misnamed and supply a comparison to Python, I would like to direct you to https://docs.python.org/2/library/functions.html#hash which does the same thing as this function. (From Python’s data-model docs: «User-defined classes have __cmp__() and __hash__() methods by default; . x.__hash__() returns a result derived from id(x).» — id(x) returns the memory address of the object.)
The cryptographic hash functions you are familiar with, like MD5 or SHA1, are named hash functions because they have a similar design goal: low chance of collisions.
The «hash» mentioned in the name of this function refers to the storage structure known as a «hash table», not to any sort of «message digest». The string returned by this function is little more than the object’s address in the (hash) table PHP maintains of all existing objects.
Attention when comparing object hashes in PHP >= 8.1
In PHP 8.1 (I think) the output of spl_object_hash() changed (see pull request https://github.com/php/php-src/pull/7010).
This lead to a strange misbehaviour of our application, as we stored object hashes in an array to check, if we processed object already. A simple in_array() check returned true, even though the current object hash was NOT actually in array.Actual problem: New hashes are much more simple and can be something like «0000000000000e600000000000000000» or «0000000000000e490000000000000000», which PHP will interpret as numeric (exponent).
in_array() will compare non type-safe by default and will interpret named hashes as «0».This function is slightly older than spl_object_id. Its output is more complex but doesn’t actually provide any more information than the newer function. It used to be a lot more complex (without being any more informative) but now it’s merely the object’s ID number written in hex with a lot of padding to maintain the old format. spl_object_id just gives the ID number as a plain integer.
You’re probably better off using spl_object_id, and thinking about migrating if you’re already using spl_object_hash; there is a chance this function will be deprecated and subsequently removed in the future.
The «hash» mentioned in this function is used in the sense of the storage structure known as a «hash table», not in the sense of «message digest».
Calling this a hash is very misleading:
1. This function gives an object identifier (ID), which uniquely identifies the object for its whole lifetime. This is similar to the address of an object in C or the id() function in Python. I’m sure other languages have similar constructs.
2. This is not a hash and has nothing to do with it. A hash takes data and algorithmically reduces that data to some kind of scalar value. The only guarantee is that two equal inputs provide the same output, but not that two different inputs provide different outputs (hint: hash collisions). spl_object_hash() guarantees different outputs for non-identical objects though.
3. As someone mentioned already, this does not look at the content of the object. If you consider the difference between equality and identity, it only allows determining identity. If you serialize and unserialize an object, it will not be identical to its former self, but it will be equal, just to give an example. If you want a key to use in a response cache, using this function on the request is not only useless, because equal requests have different IDs, but possibly even harmful, because when a request object is garbage collected, its ID can be reused.php — Unique ID of any value(objects, arrays, scalar)
Lets imagine that we have following:
class Foo < public static $foo; public static $bar; public static $baz; public static $str; public static $arr; >class Bar < public static $foo; public static $bar; public static $baz; public static $str; public static $arr; >class Baz < public static $foo; public static $bar; public static $baz; public static $str; public static $arr; >Foo::$foo = new Foo(); Bar::$foo = Foo::$foo; Baz::$foo = Foo::$foo; Foo::$bar = new Bar(); Bar::$bar = Foo::$bar; Baz::$bar = Foo::$bar; Foo::$baz = new Baz(); Bar::$baz = Foo::$baz; Baz::$baz = Foo::$baz; Foo::$str = 'cat'; Bar::$str = Foo::$str; Baz::$str = Foo::$str; Foo::$arr = [1, 2, 3, 'dog']; Bar::$arr = Foo::$arr; Baz::$arr = Foo::$arr;WHERE:
Foo::$foo , Bar::$foo , Baz::$foo refer same instance of Foo ;
Foo::$bar , Bar::$bar , Baz::$bar refer same instance of Bar ;
Foo::$baz , Bar::$baz , Baz::$baz refer same instance of Baz ;
Foo::$str , Bar::$str , Baz::$str refer same string;
Foo::$arr , Bar::$arr , Baz::$arr refer same array;Is there any way to identify these values? For instance in C++ I could just use a pointer, which would contain same value for Foo::$foo , Bar::$foo and Baz::$foo .
What is it for?
I have a function which iterates all properties of a given classes and writes property values into common array.
Lets imagine we are iterating over Foo’s, Bar’s and Baz’s properties and adding them into array. In final array we’ll have 15 values instead of 5(really different values). If we’ll search and compare these values before adding into array then(if `Foo::$str, Bar::$str and BAZ::$str will be not a refs to same value, but just an equal values) we’ll have only 5 values instead of 7(3 objects, 1 array and 3 strings).
I hope this edit will help to understand me.$a = 1; $b = &$a; $c = 1; ($a == $b) // true ($a == $c) // trueIn both cases result will be true. But how to know that im comparing 2 references of the same value(2 refs that point same memory address) or im comparing 2 different memory addresses and they they are just equal? It will be helpful for solving this problem.
