phphash表

㈠ 在php中使用json如何校验哈希表的格式是否符合要求

获取到的值判断下数据类型，具体的函数名网络搜搜就行了

㈡ php中为什么有的表单会加呃name=“hash”的隐藏域，是做什么用的例如

隐藏域故名思意极为隐藏起来的部分。用于传输一些特定的信息给目标页面。这些信息，目标页面可以接收到，但是网页浏览者在页面上看不到。比如说登陆和注册，我们统一用一个member.action.php来处理。那么，member.action.php怎么知道现在传输过来的数据是用于登陆呢还是注册呢？这时，就用到隐藏域。假定用POST方式传送数据，登陆页隐藏域如下：<input type="hidden" name="action" value="login">注册页如下：：<input type="hidden" name="action" value="register">这样，就可以根据$_POST['action']的值来判断是登陆还是注册了。

㈢ phpcms 如何固定hash数据

phpcms中的pc_hash参数是用于后台安全的一项，想固定它那么就找到它生成的地方然后改掉即可。

打开/phpcms/moles/admin/index.php，在大约第89行有如下代码：

$_SESSION['roleid']=$r['roleid'];
$_SESSION['pc_hash']=random(6,'');
$_SESSION['lock_screen']=0;

修改为：

$_SESSION['roleid']=$r['roleid'];
$_SESSION['pc_hash']=“123456”;//将其修改为你要固定的值
$_SESSION['lock_screen']=0;

仅供参考，pc_hash用于后台安全，为了安全起见建议还是不要更改。

㈣ php hash 是可逆的吗

hash 算法是单向密码体制，是不可逆。 希望能帮到你，我还在后盾网上课学习呢现在没时间，有不会的可以问我，加油吧⁽˙³˙⁾◟(๑•́ ₃ •̀๑)◞⁽˙³˙⁾

㈤ php 登录注册用哈希加密怎么做

//加密

$hash_password = hash_password($password, PASSWORD_DEFAULT);

//验证

if (password_verify($password, $hash_password)) {

//密码正确

} else {

//密码错误

}

㈥ phpredis 怎样区分不同用户的数据

1,hset
描述：将哈希表key中的域field的值设为value。如果key不存在，一个新的哈希表被创建并进行HSET操作。如果域field已经存在于哈希表中，旧值将被覆盖。
参数：key field value
返回值：如果field是哈希表中的一个新建域，并且值设置成功，返回1。如果哈希表中域field已经存在且旧值已被新值覆盖，返回0。
2，hsetnx
描述：将哈希表key中的域field的值设置为value，当且仅当域field不存在。若域field已经存在，该操作无效。如果key不存在，一个新哈希表被创建并执行HSETNX命令。
参数：key field value
返回值：设置成功，返回1。如果给定域已经存在且没有操作被执行，返回0。
3，hget
描述：返回哈希表key中给定域field的值。
参数：key field
返回值：给定域的值。当给定域不存在或是给定key不存在时，返回nil。

㈦ PHP mysql 实现hash分区的问题

当分片索引不是纯整型的字符串时，只接受整型的内置 hash 算法是无法使用的。为此，stringhash 按照用户定义的起点和终点去截取分片索引字段中的部分字符，根据当中每个字符的二进制 unicode 值换算出一个长整型数值，然后就直接调用内置 hash 算法求解分片路由：先求模得到逻辑分片号，再根据逻辑分片号直接映射到物理分片。

• 用户需要在 rule.xml 中定义 partitionLength[] 和 partitionCount[] 两个数组和 hashSlice 二元组。

• 在 DBLE 的启动阶段，点乘两个数组得到模数，也是逻辑分片的数量

• 并且根据两个数组的叉乘，得到各个逻辑分片到物理分片的映射表（物理分片数量由 partitionCount[] 数组的元素值之和）

• 此外根据 hashSlice 二元组，约定把分片索引值中的第 4 字符到第 5 字符（字符串以 0 开始编号，编号 3 到编号 4 等于第 4 字符到第 5 字符）字符串用于 “字符串->整型”的转换

• 在 DBLE 的运行过程中，用户访问使用这个算法的表时，WHERE 子句中的分片索引值会被提取出来，取当中的第 4 个字符到第 5 字符，送入下一步

• 设置一个初始值为 0 的累计值，逐个取字符，把累计值乘以 31，再把这个字符的 unicode 值当成长整型加入到累计值中，如此类推直至处理完截取出来的所有字符，此时的累计值就能够代表用户的分片索引值，完成了 “字符串->整型” 的转换

• 对上一步的累计值进行求模，得到逻辑分片号

• 再根据逻辑分片号，查映射表，直接得到物理分片号

与MyCat的类似分片算法对比

两种算法在string转化为int之后，和 hash 分区算法相同，区别也继承了 hash 算法的区别。

开发注意点

【分片索引】1. 必须是字符串

【分片索引】2. 最大物理分片配置方法是，让 partitionCount[] 数组和等于 2880

例如：

• <property name="partitionLength">1</property><property name="partitionCount">2880</property>



或

• <property name="partitionLength">1,1</property><property name="partitionCount">1440,1440</property>



【分片索引】3. 最小物理分片配置方法是，让 partitionCount[] 数组和等于 1

例如

• <property name="partitionLength">2880</property><property name="partitionCount">1</property>



【分片索引】4. partitionLength 和 partitionCount 被当做两个逗号分隔的一维数组，它们之间的点乘必须在 [1, 2880] 范围内

【分片索引】5. partitionLength 和 partitionCount 的配置对顺序敏感

• <property name="partitionLength">512,256</property><property name="partitionCount">1,2</property>



和

• <property name="partitionLength">256,512</property><property name="partitionCount">2,1</property>



是不同的分片结果

【分片索引】6. 分片索引字段长度小于用户指定的截取长度时，截取长度会安全减少到符合分片索引字段长度

【数据分布】1. 分片索引字段截取越长则越有利于数据均匀分布

【数据分布】2. 分片索引字段的内容重复率越低则越有利于数据均匀分布

运维注意点

【扩容】1. 预先过量分片，并且不改变 partitionCount 和 partitionLength 点乘结果，也不改变截取设置 hashSlice 时，可以避免数据再平衡，只需进行涉及数据的迁移

【扩容】2. 若需要改变 partitionCount 和 partitionLength 点乘结果或改变截取设置 hashSlice 时，需要数据再平衡

【缩容】1. 预先过量分片，并且不改变 partitionCount 和 partitionLength 点乘结果，也不改变截取设置 hashSlice 时，可以避免数据再平衡，只需进行涉及数据的迁移

【缩容】2. 若需要改变 partitionCount 和 partitionLength 点乘结果或改变截取设置 hashSlice 时，需要数据再平衡

配置注意点

【配置项】1. 在 rule.xml 中，可配置项为<property name="partitionLength"> 、<property name="partitionCount"> 和 <property name="hashSlice">

【配置项】2.在 rule.xml 中配置 <property name="partitionLength">标签

内容形式为：<物理分片持有的虚拟分片数>[,<物理分片持有的虚拟分片数>,...<物理分片持有的虚拟分片数>]

物理分片持有的虚拟分片数必须是整型，物理分片持有的虚拟分片数从左到右与同顺序的物理分片数对应，partitionLength 和partitionCount 的点乘结果必须在 [1, 2880] 范围内

【配置项】3. 在 rule.xml 中配置 <property name="partitionCount">标签
内容形式为：<物理分片数>[,<物理分片数>,...<物理分片数>]

其中物理分片数必须是整型，物理分片数按从左到右的顺序与同顺序的物理分片持有的虚拟分片数对应，物理分片的编号从左到右连续递进，partitionLength 和 partitionCount 的点乘结果必须在 [1, 2880] 范围内

【配置项】4. partitionLength 和 partitionCount 的语义是：持有partitionLength[i] 个虚拟分片的物理分片有 partitionCount[i] 个

例如

• <property name="partitionLength">512,256</property><property name="partitionCount">1,2</property>



语义是持有 512 个逻辑分片的物理分片有 1 个，紧随其后，持有 256 个逻辑分片的物理分片有 2 个

【配置项】5.partitionLength 和 partitionCount 都对书写顺序敏感，

例如

• <property name="partitionLength">512,256</property><property name="partitionCount">1,2</property>



分片结果是第一个物理分片持有头512个逻辑分片，第二个物理分片持有紧接着的256个逻辑分片，第三个物理分片持有最后256个逻辑分片，相对的

• <property name="partitionLength">256,512</property><property name="partitionCount">2,1</property>



分片结果则是第一个物理分片持有头 256 个逻辑分片，第二个物理分片持有紧接着的 256 个逻辑分片，第三个物理分片持有最后 512 个逻辑分片

【配置项】6.partitionLength[] 的元素全部为 1 时，这时候partitionCount 数组和等于 partitionLength 和 partitionCount 的点乘，物理分片和逻辑分片就会一一对应，该分片算法等效于直接取余

【配置项】7.在 rule.xml 中配置标签，从分片索引字段的第几个字符开始截取到第几个字符：

• 若希望从首字符开始截取 k 个字符（ k 为正整数），配置的内容形式可以为“ 0 : k ”、“ k ”或“ : k ”；

• 若希望从末字符开始截取 k 个字符（ k 为正整数），则配置的内容形式可以为“ -k : 0 ”、“ -k ”或“ -k : ”；

• 若希望从头第 m 个字符起算截取 n 个字符（ m 和 n 都是正整数），则先计算出 i = m - 1 和 j = i + n - 1，配置的内容形式为“ i : j ”；

• 若希望从尾第 m 个字符起算截取从尾算起的 n 个字符（ m 和 n 都是正整数），则先计算出 i = -m + n - 1，配置的内容形式可以为“ -m : i ”；

• 若希望不截取，则配置的内容形式可以为“ 0 : 0 ”、“ 0 : ”、“ : 0 ”或 “ : ”

㈧ 深入PHP中的HashTable结构详解

深入PHP中的HashTable结构详解

深入PHP中的HashTable结构详解

对php内核有一定了解的人应该都知道php的精髓就是HashTable，HashTable在php的实现中无处不在。包括php的数组、什么全局变量、局部变量的作用域等等，php的hashtable拆开来说就是四部分：

hash函数：用的是time33的散列函数，将一个字符串的key转换成一个数字

一个C数组：用来储存桶(buckets)的

两个双向的链表：第一个双向链表是数组的每个元素（桶bucket）是一个双向链表，这样做是为了解决hash冲突；第二个双向链表是数组将每一个桶(bucket)连接起来，这里要连接的也就是第一个双向链表的链表头，这样做是为了遍历整个hash表用的,鸟哥有篇blog是讲php的foreach的，这里这样设计就是给foreach用的==>《深入理解PHP之数组(遍历顺序)》

我这里不再说hashtable的struct和bucket的`struct了，因为下面的推荐链接几乎都讲了，我不觉得我能描述和说的比他们好，每个人的水平不一样，我就以我现在的技术水平来描述，所以我就只把我整理的一些东西记录一下

下面是php中hash实现的两个文件：zend_hash.c zend_hash.h。这两个文件里面实现了一堆的api，也引申出了一堆的api，下面是实现出来的api的原型

复制代码 代码如下:

ZEND_API ulong zend_hash_func(const char *arKey, uint nKeyLength)

ZEND_API ulong zend_get_hash_value(const char *arKey, uint nKeyLength)

ZEND_API int _zend_hash_init(HashTable *ht, uint nSize, hash_func_t pHashFunction, dtor_func_t pDestructor, zend_bool persistent ZEND_FILE_LINE_DC)

ZEND_API void zend_hash_set_apply_protection(HashTable *ht, zend_bool bApplyProtection)

ZEND_API int _zend_hash_add_or_update(HashTable *ht, const char *arKey, uint nKeyLength, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC)

ZEND_API int _zend_hash_quick_add_or_update(HashTable *ht, const char *arKey, uint nKeyLength, ulong h, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC)

ZEND_API int _zend_hash_index_update_or_next_(HashTable *ht, ulong h, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC)

ZEND_API int zend_hash_rehash(HashTable *ht)

static int zend_hash_do_resize(HashTable *ht)

ZEND_API int zend_hash_del_key_or_index(HashTable *ht, const char *arKey, uint nKeyLength, ulong h, int flag)

ZEND_API void zend_hash_destroy(HashTable *ht)

ZEND_API void zend_hash_clean(HashTable *ht)

static Bucket *zend_hash_apply_r(HashTable *ht, Bucket *p)

ZEND_API void zend_hash_graceful_destroy(HashTable *ht)

ZEND_API void zend_hash_graceful_reverse_destroy(HashTable *ht)

ZEND_API void zend_hash_apply(HashTable *ht, apply_func_t apply_func TSRMLS_DC)

ZEND_API void zend_hash_apply_with_argument(HashTable *ht, apply_func_arg_t apply_func, void *argument TSRMLS_DC)

ZEND_API void zend_hash_apply_with_arguments(HashTable *ht TSRMLS_DC, apply_func_args_t apply_func, int num_args, …)

ZEND_API void zend_hash_reverse_apply(HashTable *ht, apply_func_t apply_func TSRMLS_DC)

ZEND_API void zend_hash_(HashTable *target, HashTable *source, _ctor_func_t pCopyConstructor, void *tmp, uint size)

ZEND_API void _zend_hash_merge(HashTable *target, HashTable *source, _ctor_func_t pCopyConstructor, void *tmp, uint size, int overwrite ZEND_FILE_LINE_DC)

static zend_bool zend_hash_replace_checker_wrapper(HashTable *target, void *source_data, Bucket *p, void *pParam, merge_checker_func_t merge_checker_func)

ZEND_API void zend_hash_merge_ex(HashTable *target, HashTable *source, _ctor_func_t pCopyConstructor, uint size, merge_checker_func_t pMergeSource, void *pParam)

ZEND_API int zend_hash_find(const HashTable *ht, const char *arKey, uint nKeyLength, void **pData)

ZEND_API int zend_hash_quick_find(const HashTable *ht, const char *arKey, uint nKeyLength, ulong h, void **pData)

ZEND_API int zend_hash_exists(const HashTable *ht, const char *arKey, uint nKeyLength)

ZEND_API int zend_hash_quick_exists(const HashTable *ht, const char *arKey, uint nKeyLength, ulong h)

ZEND_API int zend_hash_index_find(const HashTable *ht, ulong h, void **pData)

ZEND_API int zend_hash_index_exists(const HashTable *ht, ulong h)

ZEND_API int zend_hash_num_elements(const HashTable *ht)

ZEND_API int zend_hash_get_pointer(const HashTable *ht, HashPointer *ptr)

ZEND_API int zend_hash_set_pointer(HashTable *ht, const HashPointer *ptr)

ZEND_API void zend_hash_internal_pointer_reset_ex(HashTable *ht, HashPosition *pos)

ZEND_API void zend_hash_internal_pointer_end_ex(HashTable *ht, HashPosition *pos)

ZEND_API int zend_hash_move_forward_ex(HashTable *ht, HashPosition *pos)

ZEND_API int zend_hash_move_backwards_ex(HashTable *ht, HashPosition *pos)

ZEND_API int zend_hash_get_current_key_ex(const HashTable *ht, char **str_index, uint *str_length, ulong *num_index, zend_bool plicate, HashPosition *pos)

ZEND_API int zend_hash_get_current_key_type_ex(HashTable *ht, HashPosition *pos)

ZEND_API int zend_hash_get_current_data_ex(HashTable *ht, void **pData, HashPosition *pos)

ZEND_API int zend_hash_update_current_key_ex(HashTable *ht, int key_type, const char *str_index, uint str_length, ulong num_index, int mode, HashPosition *pos)

ZEND_API int zend_hash_sort(HashTable *ht, sort_func_t sort_func, compare_func_t compar, int renumber TSRMLS_DC)

ZEND_API int zend_hash_compare(HashTable *ht1, HashTable *ht2, compare_func_t compar, zend_bool ordered TSRMLS_DC)

ZEND_API int zend_hash_minmax(const HashTable *ht, compare_func_t compar, int flag, void **pData TSRMLS_DC)

ZEND_API ulong zend_hash_next_free_element(const HashTable *ht)

void zend_hash_display_pListTail(const HashTable *ht)

void zend_hash_display(const HashTable *ht)

;

㈨ php-红黑树、散列表、跳表理解入门

就是把链表的结构稍加改造，这种数据结构叫

为了提升链表的查询效率，怎么让链表支持类似‘数组’那样的‘二分’算法呢

跳表是一个各方面性能都比较优秀的 动态数据结构 ，可以支持快速地插入、删除、查找操作，写起来也不复杂，甚至可以替代红黑树。

Redis 中的有序集合（Sorted Set）就是用跳表来实现的。
那 Redis 为什么会选择用跳表(和散列表)来实现有序集合呢？ 为什么不用红黑树呢？这个问题一会在回答，先看看跳表的数据结构

其实概念很简单，就是在链表上加上了

当我们在不停插入数据，如果我们不更新索引，可能出现某 2 个索引结点之间数据非常多的情况。极端情况下，跳表还会退化成单链表。
红黑树、AVL 树这样平衡二叉树，是通过左右旋的方式保持左右子树的大小平衡，而跳表是通过 随机函数 来维护平衡性。

插入、删除、查找以及迭代输出有序序列这几个操作，红黑树也可以完成，时间复杂度跟跳表是一样的。但是， 按照区间来查找数据这个操作，红黑树的效率没有跳表高。

对于按照区间查找数据这个操作，跳表可以做到 O(logn) 的时间复杂度定位区间的起点，然后在原始链表中顺序往后遍历就可以了。

Redis 键值构建一个散列表，这样按照 key 来删除、查找一个成员对象的时间复杂度就变成了 O(1)。同时，借助跳表结构，其他操作也非常高效。

散列表的英文叫“Hash Table”，我们平时也叫它“哈希表”或者“Hash 表”

散列技术是在记录的存储位置和它的关键字之间建立一个确定的对应关系 f，使得每个关键字 key 对应一个存储位置 f(key)。查找时根据这个对应关系匠互给定的 key 的映射 f(key)

这种关系 f 称为散列函数（又称哈希函数）。散列技术将记录存储在一块连续的存储空间中，这块连续存储空间称为散列表或哈希表。那么关键字对应的记录存储位置称为散列地址。

散列函数的构造方法特点就是：计算简单、散列地址分布均匀

大家一定听说过 hash 碰撞。就是2个不同的 key 对应着不同的 f 关系。但这是几乎不可能的，即便像业界着名的MD5、SHA、CRC等哈希算法，也无法完全避免这种散列冲突。而且，因为数组的存储空间有限，也会加大散列冲突的概率。

我们只能通过其它途径来寻找方法。我们常用的散列冲突解决方法有两类，开放寻址法（open addressing）和链表法（chaining）。

所谓的开放寻址法就是一但发生了冲突，就去寻找下一个空的散地址，只要散列表足够大，空的散列表地址总能找到，并将记录存入。

链地址法又称链表法，其实当发生冲突时存入链表，如下图很容易就可以看明白。此时，已经不存在什么冲突地址的问题，无论有多少冲突，都只是在当前位置给单链表增加结点的问题。

这种不常见，就是把冲突的单独找个地方。

顾名思义，红黑树中的节点，一类被标记为黑色，一类被标记为红色。除此之外，一棵红黑

平衡二叉树 是一种二叉排序树，其中每一个节点的左子树和右子树的高度不能大于 1

红黑树是一种平衡二叉查找树。它是为了解决普通二叉查找树在数据更新的过程中，复杂度退化的问题而产生的。红黑树的高度近似 log2n，所以它是近似平衡，插入、删除、查找操作的时间复杂度都是 O(logn)。

平衡二叉查找树其实有很多，比如，Splay Tree（伸展树）、Treap（树堆）等，但是我们提到平衡二叉查找树，听到的基本都是红黑树。
红黑树在众多里面，表现的最为平衡。
“近似平衡”就等价为性能不会退化得太严重。

一棵红黑树还需要满足这样几个要求：

看到这里你会很头大，什么黑的红的，完全不懂。赋上连接，有时间在看

散列表 ：插入删除查找都是O(1), 是最常用的，但其缺点是不能顺序遍历(存入的数据是无顺序的)以及扩容缩容的性能损耗。适用于那些不需要顺序遍历，数据更新不那么频繁的。
散列表总和链表、跳表一起出现组合使用。

跳表 ：插入删除查找都是O(logn), 并且能顺序遍历。缺点是空间复杂度O(n)。适用于不那么在意内存空间的，其顺序遍历和区间查找非常方便。
跳表还可以和散列表组合让删除、查找一个成员对象操作变为O(1)，也就是说利用了散列表查找速度，跳表的顺序结构

红黑树 ：插入删除查找都是O(logn), 中序遍历即是顺序遍历，稳定。缺点是难以实现，去查找不方便。其实跳表更佳，但红黑树已经用于很多地方了。