PHP string hash function algorithm implementation code

function DJBHash($str) // 0.22
{
$hash = 0;
$n = strlen($str);
for ($i = 0; $i {
$hash += ($hash }
return $hash % 701819;
}

function ELFHash($str) // 0.35
{
$hash = $x = 0;
$n = strlen($str);

for ($i = 0; $i {
$hash = ($hash if(($x = $hash & 0xf0000000) != 0)
{
$hash ^= ($x>> 24);
$hash &= ~$x;
}
}
return $hash % 701819;
}

function JSHash($str) // 0.23
{
$hash = 0;
$n = strlen($str);

for ($i = 0; $i {
$hash ^= (($hash > 2));
}
return $hash % 701819;
}

function SDBMHash($str) // 0.23
{
$hash = 0 ;
$n = strlen($str);

for ($i = 0; $i {
$hash = ord($str[$i]) + ($hash }
return $hash % 701819;
}

function APHash($str) // 0.30
{
$hash = 0 ;
$n = strlen($str);

for ($i = 0; $i {
if (($i & 1 ) == 0 )
{
$hash ^= (($hash > 3 ));
}
else
{
$hash ^= ( ~ (($hash > 5)));
}
}
return $hash % 701819;
}

function DEKHash($str) // 0.23
{
$n = strlen($str);
$hash = $n;

for ($i = 0; $i {
$hash = (($hash > 27)) ^ ord($str[$i]);
}
return $hash % 701819;
}

function FNVHash($str) // 0.31
{
$hash = 0;
$n = strlen($str);

for ($i = 0; $i {
$hash *= 0x811C9DC5;
$hash ^= ord($str[$i]);
}

return $hash % 701819;
}

function PJWHash($str) // 0.33
{
$hash = $test = 0;
$n = strlen($str);

for ($i = 0; $i {
$hash = ($hash
if(($test = $hash & -268435456)  != 0)
{
$hash = (( $hash ^ ($test>> 24)) & (~-268435456));
}
}

return $hash % 701819;
}

function PHPHash($str) // 0.34
{
$hash = 0;
$n = strlen($str);

for ($i = 0; $i {
$hash = ($hash if (($g = ($hash & 0xF0000000)))
{
$hash = $hash ^ ($g>> 24);
$hash = $hash ^ $g;
}
}
return $hash % 701819;
}

function OpenSSLHash($str) // 0.22
{
$hash = 0;
$n = strlen($str);

for ($i = 0; $i {
$hash ^= (ord($str[$i]) }
return $hash % 701819;
}

function MD5Hash($str) // 0.050
{
$hash = md5($str);
$hash = $hash[0] | ($hash[1] return $hash % 701819;
}

Algorithm description: The comment behind the function is the execution speed (unit: s) of 1000 times in my local test. It can be seen that MD5Hash is the fastest, and it is much faster than other functions... But it can also be seen from the algorithm of this function. , it only relies on the first 7 characters of the string after md5. That is to say, if the first 7 characters are the same, the hash value obtained is exactly the same, so in fact, its distribution is not very trustworthy. ....If calculated based on 32 characters, the speed will be far slower than other algorithms...

Except for MD5Hash, other algorithms will be affected by the length of the string. The longer it is, the slower it is. I used 10 characters in English for the test. The final return of each function $hash % 701819; 701819 represents the maximum capacity of the hash, which means that the final number range obtained by these hash functions is 0~701819. This number can be changed. It is generally considered to use a large one. The distribution of prime number results will be relatively even. Several suggested values ​​near 701819 are: 175447, 350899, 1403641, 2807303, 5614657.

What can this be used for...

Why do we need to organize and test these hash algorithms? I am writing a multi-user blog. Well... I also mentioned it in the previous blog. Multi-user blogs generally have a function, which is to use a user name that is a combination of English and numbers. as the blog address (second-level domain name or directory). Then there is a question, how to get the user's ID based on the user name, is there one more query? With the hash function, there is no need. Use the hash function to process the user name, get a number, and then do certain processing on the number (I divided it into hierarchical directories based on 2 digits. The purpose is to prevent too many files in one directory. file (which affects the disk retrieval speed), and then a path is formed, and the corresponding ID is saved in the file under this path (I personally recommend the user name as the file name), so that the user's ID can be obtained directly based on the user name. , no query is required, the user name is used as the file name, so even if the final results are the same, they are in different files, so there is no need to worry about collisions.

Of course...if your system operates entirely based on user names, then I didn't say this before = =b, I quietly criticize SELECT because numbers are faster than strings.

I chose the DJB algorithm. If the MD5 distribution test is acceptable after it goes online, I will consider switching to it.

It can also be seen from here that hashing is actually very useful for distribution. Haha, it can be used for caching, static or other things that require distributed storage.