+- JeuWeb - Crée ton jeu par navigateur (https://jeuweb.org)
+-- Forum : Discussions, Aide, Ressources... (https://jeuweb.org/forumdisplay.php?fid=38)
+--- Forum : Programmation, infrastructure (https://jeuweb.org/forumdisplay.php?fid=51)
+--- Sujet : Retour aux sources : du binaire pour la gestion des droits (/showthread.php?tid=6535)
Retour aux sources : du binaire pour la gestion des droits - JWHSmith - 24-12-2012
-----
RE: Retour aux sources : du binaire pour la gestion des droits - srm - 24-12-2012
A noter que ça s'applique pas que pour les droits, mais pour tout ce qui a un grand nombre de paramètre du type booléen.
RE: Retour aux sources : du binaire pour la gestion des droits - Talus - 25-01-2013
les masques binaire (le nom de cette technique) est très utiliser lorsque que tu fait de la programmation système en C (surtout sous linux)
mais tu n'est pas obliger d'utiliser une écriture en hexa pour tes constante tu les mettre en décimal ça marche tout aussi bien
RE: Retour aux sources : du binaire pour la gestion des droits - Xenos - 25-01-2013
Je les ai déjà vu appelés "flags", ces masques binaires.
Au lieu de 0x002, 0x004 etc, qui sont certes très classes pour l'obfuscation mais qui sont très peu pratiques pour la lecture et la maintenance, on peut utiliser (suivant les langages), la syntaxe
1<<N
où << est l'opérateur de décalage binaire. En d'autres termes, le mot binaire (ex: 010101101) sera décalé de N bits vers la gauche, le trou étant complété par des 0 et les N premiers bits étant perdus (010101101 << 5 --> 010101101 00000 --> 01010 110100000 --> 110100000).
Donc, 1<<N correspond à la mise à 1 de tous les bits d'un mot, sauf le N ème, ce qui permet d'écrire:
can_do_this = (1 << 1); //Droit déterminé par le "flag" 1, aka, le bit 1
can_do_that = (1 << 2); //Droit déterminé par le "flag" 2, aka, le bit 2
can_do_this2 = (1 << 3); //Droit déterminé par le "flag" 3, aka, le bit 3
can_do_thattoo = (1 << 4); //Droit déterminé par le "flag" 4, aka, le bit 4
Il devient alors plus facile de savoir quel bit gère quoi et on évite des erreurs de calcul.
@Thalus
En hexadécimal, on a:
0x01 0x02 0x04 0x08 0x10 0x20...
En décimal
1 2 4 8 16 32 64
Pour les grands nombres, cela sera donc plus facile d'entrer l'hexa que le décimal:
128 256 512 1024 2048 4096 8192 16384 32768 65536 ... mais après, c'est dur de les connaitre par coeur!
0x0080 0x0100 0x0200 0x0400 0x0800 0x1000 0x2000 0x4000 0x8000...
Facile de compléter les nombres, sans même connaitre la valeur décimale par coeur
En binaire, on peut le faire également, mais c'est long (b1 b10 b100 b1000...)
D'où mon conseil: pour définir qu'une constante C est le mot binaire où tous les bits sont à 0 sauf le N-eme, utilisez "1<<N".
----
Note: certains SGDB résolvent peut-être d'eux même ce problème: si plusieurs colonnes de type "bool" se suivent, leur valeur est peut-être stockée dans un seul "champ" binaire (aka, si j'ai 8 colonnes de type "bool", cela ne prend qu'un octet de donnée dans la BDD, alors que si j'ai 9 colonnes, cela prend 2 octets car tout octet entamé est complété).
RE: Retour aux sources : du binaire pour la gestion des droits - niahoo - 25-01-2013
J'utilise souvent cette technique, par contre je ne comprends pas vos remarques :
Pourquoi initialiser les constantes avec des hexadécimaux. Vous devez être balaises pour retenir toutes ces puissances de 2 en hexa. Par contre en notation normale je sais aller juqu'à 4096 (pas terrible :S mais je n'ai jamais eu besoin d'autant de valeurs)
Je comprends pas l'utilisation de la rotation. Chez moi (1 << 1) ça fait 2 du coup c'est pas du tout opti côté mnémotechnique.
>>> Pour les grands nombres, cela sera donc plus facile d'entrer l'hexa que le décimal:
Ben oui mais bon, si on utilise des constantes c'est justement pour pas retenir les chiffres de toute façon.
Citation :Donc, 1<<N correspond à la mise à 1 de tous les bits d'un mot, sauf le N ème
non plus, ça décale juste ...
En fait loin de moi l'idée d'être antipathique, mais ton post c'est n'importe quoi en fait.
RE: Retour aux sources : du binaire pour la gestion des droits - Xenos - 25-01-2013
*<<N décale les bits de * à gauche de N bits, en paddant le trou avec des zéros.
1 est le nombre entier 1, codé en binaire 000....01
Donc, 1<<N est le décalage de 000...001 de N bits à gauche, donc, 0.000100..00 avec N zéros à la fin. C'est donc bien la mise à 1 du N-ème bit (je compte comme les informaticiens: en partant de zéro, aka le bit 0 est le bit le plus à droite).
D'où la remarque "initialiser avec des hexadécimaux? C'est peu pratique. Initialiser avec l'opérateur de décalage de bit est plus souple".
"ton post": de quel message parles-tu?
-----
Au fait
Code PHP :
<?php
return (!((int)$right & $this->operator)) ? false : true;
C'est assez moche (mais juste). Je préfère
Code PHP :
<?php
return ((bool)($right & $this->operator))
Note que l'on peut tester qu'un utilisateur possède deux droits à la fois:
Code PHP :
<?php
($droits & (1<<3 | 1<<4))==(1<<3 | 1<<4)
1<<4 = 10000b = 16
Le i-eme bit de (x|y) vaut 1 si le i-eme bit de x vaut 1 OU si le i-eme dit de y vaut 1. Donc:
(1<<3 | 1<<4) = (1000b | 10000b) = 11000b
Le i-eme bit de (x & y) vaut 1 si et seulement si le i-eme bit de x vaut 1 et le y-ieme bit de y aussi, donc:
Si $droits = 10000 alors le résultat est (10000b)==11000b donc false
Si $droits = 11000 alors le résultat est (11000b)==11000b donc true
Si $droits = 00100 alors le résultat est (00000b)==11000b donc false
On peut donc modifier la méthode hasRight pour qu'elle accepte des droits multiples:
Code PHP :
<?php
public function hasRight($right) {
return (($this->operator & $right)==$right);
}
S'utilise via:
Code PHP :
<?php
$rights->hasRight(binaryRightsOperator::EDIT_USERS | binaryRightsOperator::EDIT_PARAMETERS);
Qui renvoie "true" si l'utilisateur a le droit "EDIT_USERS" ET le droit "EDIT_PARAMETERS".
RE: Retour aux sources : du binaire pour la gestion des droits - niahoo - 25-01-2013
C'est ton post qui dit n'importe quoi. Mais peut-être que je me trompe, ça ne me choquerais pas.
Citation :"Donc, 1<<N correspond à la mise à 1 de tous les bits d'un mot, sauf le N ème"
Erreur. 1 << 3 ça fait '1000' en binaire, donc c'est pas le 3eme qui est à '1', c'est le N+1.
Citation :can_do_this = (1 << 1); //Droit déterminé par le "flag" 1, aka, le bit 1
Erreur, 1 << 1 ça fait deux, soit '10' en binaire, c'est le flag 2, le bit 2.
Citation :1<<N correspond à la mise à 1 de tous les bits d'un mot, sauf le N ème, ce qui permet d'écrire ...
Erreur, ça ne mets pas tous les bits à 1 sauf le Nième, ça ne fait que décaler de N bits.
Voilà mais peut-être que dans d'autres langages ça se comporte comme tu le dis. J'ai cependant de gros doutes.
RE: Retour aux sources : du binaire pour la gestion des droits - niahoo - 26-01-2013
Ah j'ai relu et je vois que tu comptes les bits en partant de l'indice 0. Du coup on peut parler du Nième bit effectivement, mais ça embrouille plus qu'autre chose. Mais là c'est une histoire de goûts
RE: Retour aux sources : du binaire pour la gestion des droits - Xenos - 26-01-2013
Eyuup, tout viens du fait que je démarre de 0
sauf peut-être le "1<<N correspond à la mise à 1 de tous les bits d'un mot" où mon "d'un mot", est de trop...
Oui, * << N décale tous les bits d'un mot de N rangs, ca, t'as raison (j'ai jamais pensé le contraire, j'espère ne pas l'avoir dit), mais si *=1, alors 1<<N revient à mettre tous les bits à 1 sauf le N-eme (ou N+1 eme), puisque le "mot" est composé que de zéros, sauf le 0eme bit.
RE: Retour aux sources : du binaire pour la gestion des droits - archANJS - 26-01-2013
http://i.imgur.com/oo35Z.gif