Binär kann im Allgemeinen 32 Zustände darstellen, und jedes Bit kann einen anderen Berechtigungswert darstellen. Angenommen, wir haben vier Berechtigungswerte, nämlich Hinzufügen, Löschen und Ändern:
enum Permission {
Create = 0b0001, // 新增
Delete = 0b0010, // 删除
Update = 0b0100, // 修改
}Nachdem wir die Berechtigungswerte haben, können wir Bitoperationen verwenden, um die Berechtigungswerte zu kombinieren. Wenn das entsprechende Bit 1 ist, bedeutet dies, dass eine Berechtigung vorliegt, und 0 bedeutet, dass keine Berechtigung vorliegt.
Erforderliche Kenntnisse der beteiligten Bitoperationen:
Neue Berechtigungen hinzufügen – bitweise ODER |
Die bitweise ODER-Operation ist alles 0 und eine 1 ist 1. Daher ist das entsprechende Bit 0, wenn keine Berechtigung vorliegt, und das entsprechende Bit ist 1, wenn der Berechtigungswert durch bitweises ODER erhöht wird.
Berechtigungen entfernen – bitweises XOR^
Die bitweise XOR-Operation bedeutet, dass dasselbe Bit 0 und das unterschiedliche Bit 1 ist, sodass die Berechtigung für das entsprechende Bit 1 ist und der zu entfernende Berechtigungswert ebenfalls 1 ist. Wenn die beiden gleich sind, ist das entsprechende Bit gleich 0. Hier führen wir das bitweise ODER ein, aber es gibt keine Verwendung. Es wird ein anderer besserer Weg gewählt, siehe Code
Bestimmen Sie, ob es eine bestimmte Erlaubnis gibt – bitweises UND&
Die bitweise UND-Operation ist alle 1 und eine 0 ist 0. Daher muss das Ergebnis der bitweisen UND-Operation für das entsprechende Bit 1 sein, wenn Sie über die entsprechende Berechtigung verfügen. Wenn das entsprechende Bit 0 ist, ist das Ergebnis 0. Um festzustellen, ob Sie haben nur die Erlaubnis. Überprüfen Sie einfach, ob das Ergebnis ungleich 0 ist
Berechtigungsoperationscode:
enum Permission {
Create = 0b0001,
Delete = 0b0010,
Update = 0b0100,
}
const NotHavePermission = 0 // 没有权限
/**
* @description 组合权限
* @param userPermission 用户的权限散列值
* @param permission 要组合的权限
* @return 如果包含要移除的权限则返回被移除的权限,否则返回null
*/
const combineRolePermissions = (
userPermission: number,
...roleList: Permission[]
): number => {
return roleList.reduce((prev, curr) => {
if (!hasPermission(prev, curr)) {
prev = curr | prev // | 是有一个是0就是0 都为1则为1
}
return prev
}, userPermission)
}
/**
* @description 移除权限
* @param userPermission 权用户的权限散列值
* @param permission 要移除的权限
* @return 如果包含要移除的权限则返回被移除的权限,否则返回null
*/
const removePermission = (
userPermission: number,
targetPermission: Permission
): number | null => {
if (!hasPermission(userPermission, targetPermission)) {
return null
}
// 异或相同为0不同为1 所以都是1则那位变成0就删除了
// return userPermission ^ targetPermission; // 异或可以删除但是得先判断是否有该权限,如果当userPermission为0000时不会删除,所以用第二种方式不会出现这种问题
return (userPermission &= ~targetPermission) // react源码里移除也是这么做的
}
/**
* @description 是否有某个权限
* @param userPermission 权用户的权限散列值
* @param targetPermission 是否包含的权限
* @returns
*/
const hasPermission = (
userPermission: number,
targetPermission: Permission
): boolean => {
return (userPermission & targetPermission) !== NotHavePermission // &就是有一个为1就是1 都为0则为0
}
let userPermission = NotHavePermission // 用户初始化权限是什么都没有就是0
// 后端返回的权限集合
const permissionCollections = [Permission.Create, Permission.Update]
// 组合后端返回的权限
userPermission = combineRolePermissions(
userPermission,
...permissionCollections
)
console.log('用户权限:', userPermission.toString(2)) // 0101
console.log('是否有删除权限', hasPermission(userPermission, Permission.Delete)) // false
userPermission = removePermission(userPermission, Permission.Create) // 移除新增权限
console.log('删除新增后:', userPermission.toString(2)) // 0100
Der Vorteil dieses Designs besteht darin, dass wir Berechtigungswerte beliebig kombinieren können. Beispielsweise können Benutzer sowohl hinzufügen als auch ändern. Die Kombination von Erstellen und Aktualisieren kann dann bedeuten, dass das Hinzufügen und Entfernen sehr flexibel ist, unabhängig davon, ob es sich um die Berechtigungssteuerung verschiedener Vorgangstypen oder Seiten handelt Die Zugriffskontrolle ist sehr praktisch. Eine 32-Bit-Binärdatei kann 32 Seiten darstellen, und ein 64-Bit-System kann 64 Seiten darstellen. Unsere üblichen Anwendungsbits reichen grundsätzlich aus.