[PHP] Hoe werkt deze telling?

[Reveller]

In de broncode van Drupal 4.7 (maar ook in latere versies) komt ik het volgende tegen:

PHP:

define('MENU_IS_ROOT', 0x0001);
define('MENU_VISIBLE_IN_TREE', 0x0002);
define('MENU_VISIBLE_IN_BREADCRUMB', 0x0004);
define('MENU_VISIBLE_IF_HAS_CHILDREN', 0x0008);
define('MENU_MODIFIABLE_BY_ADMIN', 0x0010);
define('MENU_MODIFIED_BY_ADMIN', 0x0020);
define('MENU_CREATED_BY_ADMIN', 0x0040);
define('MENU_IS_LOCAL_TASK', 0x0080);
define('MENU_EXPANDED', 0x0100);
define('MENU_LINKS_TO_PARENT', 0x0200);

define('MENU_NORMAL_ITEM', MENU_VISIBLE_IN_TREE | MENU_VISIBLE_IN_BREADCRUMB | MENU_MODIFIABLE_BY_ADMIN);

define('MENU_ITEM_GROUPING', MENU_VISIBLE_IF_HAS_CHILDREN | MENU_VISIBLE_IN_BREADCRUMB | MENU_MODIFIABLE_BY_ADMIN);

MENU_NORMAL_ITEM blijkt een waarde te hebben van 22; MENU_ITEM_GROUPING 28. Ik heb gegoogled op 0x0001, maar vond geen uitleg - slechts berichten als "$software geeft error 0x0001, wat moet ik nu?".

Vandaar twee vragen:

• Wat is de betekenis van 0x0001? Is het een getal? En waarom wordt (in dit geval) MENU_IS_ROOT niet als "1" gedefinieerd?
• Hoe worden de waardes 22 en 28 berekend? Als ik MENU_NORMAL_ITEM als voorbeeld neem: 0x0002 + 0x0004 + 0x0010 = 16; vermendigvuldigen geeft 80

[CyBeR]

Wikipedia: Bit field


[quote]Reveller schreef op zondag 13 februari 2011 @ 18:46:
• Wat is de betekenis van 0x0001? Is het een getal? En waarom wordt (in dit geval) MENU_IS_ROOT niet als "1" gedefinieerd?

Consistentie. 1 had inderdaad ook gekund, da's namelijk hetzelfde.

• Hoe worden de waardes 22 en 28 berekend? Als ik MENU_NORMAL_ITEM als voorbeeld neem: 0x0002 + 0x0004 + 0x0010 = 16; vermendigvuldigen geeft 80

0x16 = 22 in decimaal.

Overigens heb je hier geluk want je kunt niet op een decimale manier, hexadecimale getallen optellen. Maar in dit specifieke geval is de uitkomst toevallig hetzelfde.

[ Voor 102% gewijzigd door CyBeR op 13-02-2011 18:51 ]

[Reveller]

Ik begrijp het niet helemaal, maar nu ik weet waar ik op moet zoeken, kan ik beter onderzoek doen Wat ik ook niet begrijp is, wat de toegevoegde waarde hiervan is. Nu MENU_NORMAL_ITEM een waarde heeft van 22, is dat dan weer terug te herleiden tot "oh, dat is een samentrekking van MENU_VISIBLE_IN_TREE, MENU_VISIBLE_IN_BREADCRUMB en MENU_MODIFIABLE_BY_ADMIN? Dat het een soort unieke samenstelling is die alleen die de combinatie van die 3 constanten gevormd kan worden? En dan nog: wat heb je daar in de praktijk aan?

[significant]

je kunt nu bitwise logica toepassen. Dit is zeer praktische om bv verschillende niveaus te defineren.

Je vergelijkt namelijk of de waarde voorkomt in het bitadres. Zie de PHP manual

Stel je hebt beveleiging niveaus

1, 2, 4 en 8. Stel je wilt alleen 4 en 2 toegang geven en niveau 8 niet. Met bitwise operator kun je dit prima voor elkaar krijgen.

Iets soortgelijks zit verweven in je eigen voorbeeld, maar dat kun je nu zelf wel reverse engineren, leer je ook meer van :-)

[ Voor 49% gewijzigd door significant op 13-02-2011 19:07 ]

[CyBeR]

Reveller schreef op zondag 13 februari 2011 @ 19:02:
Ik begrijp het niet helemaal, maar nu ik weet waar ik op moet zoeken, kan ik beter onderzoek doen Wat ik ook niet begrijp is, wat de toegevoegde waarde hiervan is. Nu MENU_NORMAL_ITEM een waarde heeft van 22, is dat dan weer terug te herleiden tot "oh, dat is een samentrekking van MENU_VISIBLE_IN_TREE, MENU_VISIBLE_IN_BREADCRUMB en MENU_MODIFIABLE_BY_ADMIN?

Juist.

Dat het een soort unieke samenstelling is die alleen die de combinatie van die 3 constanten gevormd kan worden? En dan nog: wat heb je daar in de praktijk aan?

Het is in de basis een manier om 8 booleans in een enkele byte kwijt te kunnen.

[Soultaker]

Reveller schreef op zondag 13 februari 2011 @ 19:02:
Dat het een soort unieke samenstelling is die alleen die de combinatie van die 3 constanten gevormd kan worden? En dan nog: wat heb je daar in de praktijk aan?

Je geeft zelf het antwoord al: het is een eenvoudige manier om een willekeurige deelverzameling van een aantal mogelijke opties in één waarde te representeren, zonder dat je ingewikkelde datastructuren nodig hebt om zo'n verzameling te representeren.

Overigens is het jammer dat PHP geen binaire constanten ondersteunt, anders zou de telling een stuk duidelijker zijn:

PHP:

define('MENU_IS_ROOT',                   0b0000000001);
define('MENU_VISIBLE_IN_TREE',           0b0000000010);
define('MENU_VISIBLE_IN_BREADCRUMB' ,    0b0000000100);
define('MENU_VISIBLE_IF_HAS_CHILDREN',   0b0000001000);
define('MENU_MODIFIABLE_BY_ADMIN',       0b0000010000);
define('MENU_MODIFIED_BY_ADMIN',         0b0000100000);
define('MENU_CREATED_BY_ADMIN',          0b0001000000);
define('MENU_IS_LOCAL_TASK',             0b0010000000);
define('MENU_EXPANDED',                  0b0100000000);
define('MENU_LINKS_TO_PARENT',           0b1000000000);

Het is zo duidelijk dat MENU_NORMAL_ITEM == 22 == 0b0000010110, een combinatie is van
MENU_VISIBLE_IN_TREE, MENU_VISIBLE_IN_BREADCRUMB en MENU_MODIFIABLE_BY_ADMIN (kijk maar naar de positie van de 1-bits).

Je kunt het ook zo schrijven trouwens:

PHP:

define('MENU_IS_ROOT',                   1 << 0);
define('MENU_VISIBLE_IN_TREE',           1 << 1);
define('MENU_VISIBLE_IN_BREADCRUMB' ,    1 << 2);
define('MENU_VISIBLE_IF_HAS_CHILDREN',   1 << 3);
define('MENU_MODIFIABLE_BY_ADMIN',       1 << 4);
define('MENU_MODIFIED_BY_ADMIN',         1 << 5);
define('MENU_CREATED_BY_ADMIN',          1 << 6);
define('MENU_IS_LOCAL_TASK',             1 << 7);
define('MENU_EXPANDED',                  1 << 8);
define('MENU_LINKS_TO_PARENT',           1 << 9);

Dat komt allemaal op hetzelfde neer.

CyBeR schreef op zondag 13 februari 2011 @ 18:47:
Overigens heb je hier geluk want je kunt niet op een decimale manier, hexadecimale getallen optellen. Maar in dit specifieke geval is de uitkomst toevallig hetzelfde.

Hoewel ik denk dat jij wel begrijpt hoe het werkt, kan ik het niet laten om protest aan te tekenen tegen deze terminologie: er is geen "decimale manier" of "hexadecimale manier" om getallen op te tellen (en dus ook geen "binaire manier"). Optellen van bitfields is equivalent aan het gebruik van een logical or, zolang je geen carry introduceert, oftewel: a + b == a | b iff. a & b == 0.

Dit heeft helemaal niets te maken met de representatie van de getallen in de broncode (in het de code hierboven geen ik binaire en decimale representaties van dezelfde getallen als in de oorspronkelijke code; dat maakt verder niets uit).

[ Voor 5% gewijzigd door Soultaker op 14-02-2011 04:54 ]

[CyBeR]

Soultaker schreef op maandag 14 februari 2011 @ 04:53:
[...]


Hoewel ik denk dat jij wel begrijpt hoe het werkt, kan ik het niet laten om protest aan te tekenen tegen deze terminologie: er is geen "decimale manier" of "hexadecimale manier" om getallen op te tellen (en dus ook geen "binaire manier"). Optellen van bitfields is equivalent aan het gebruik van een logical or, zolang je geen carry introduceert, oftewel: a + b == a | b iff. a & b == 0.

Dit heeft helemaal niets te maken met de representatie van de getallen in de broncode (in het de code hierboven geen ik binaire en decimale representaties van dezelfde getallen als in de oorspronkelijke code; dat maakt verder niets uit).

Ik zei ook al dat dat niet uitmaakte. Wat ik bedoelde is dat 2 + 4 + 10 = 16, toevallig ook opgaat voor 0x02 + 0x04 + 0x10 (=0x16). Maar bijvoorbeeld 8 + 9 + 10 (= 27) is niet hetzelfde als 0x8 + 0x9 + 0x10 (=0x21). Zo zijn er nog wel wat combinaties maar hexadecimale getallen optellen alsof 't decimale getallen zijn werkt niet in alle gevallen.

Dat was ook het probleem volgens mij: TS wist niet wat hexadecimale getallen waren (getuige dat 'ie 0x0001 in google geprikt heeft). Maar mischien heeft 'ie wel netjes 0x2 + 0x4 + 0x10 gedaan en zit ik er juist om te zeuren omdat dat toevallig overeen komt met 2 + 4 + 10