Wat doet het gebruik van een enkele pijp ‘|’ In een functieargument Doen?

Neem bijvoorbeeld de volgende code:

phpinfo(INFO_MODULES | INFO_ENVIRONMENT | INFO_VARIABLES);

Er wordt een enkel argument gebruikt, maar ik geef een lijst met opties, gescheiden door een enkel pijpsymbool.

• Wat gebeurt er precies met de argumentwaarde in de functie?
• Kan ik hetzelfde gebruiken in mijn eigen functies?
• Is dat zo, en zijn hier voordelen aan ten opzichte van bijvoorbeeld het doorgeven van een array?

Antwoord 1, autoriteit 100%

Bitwise-operators

Bitwise-operators wijzigen de bits van de betrokken waarden. Een bitsgewijze ORvoegt in feite elk bit van zowel het linker- als het rechterargument samen. Bijvoorbeeld:

5 | 2

Zou vertalen naar bits/binair als:

101 | 10

Wat zou resulteren in:

111

Omdat:

1 || 0 = 1
0 || 1 = 1
1 || 0 = 1

En als geheel getal is dat de representatie van 7 en dat is precies wat je krijgt als je:

echo 5 | 2;

In de woorden van Eddie Izzard… Vlag!

Zoals Ignacio stelt, wordt dit het meest gebruikt in PHP (en andere talen) als een manier om meerdere vlaggen te combineren. Elke vlag wordt meestal gedefinieerd als een constante waarvan de waarde normaal is ingesteld op een geheel getal dat slechts één bit vertegenwoordigt op een andere offset:

define('FLAG_A', 1); /// 0001
define('FLAG_B', 2); /// 0010
define('FLAG_C', 4); /// 0100
define('FLAG_D', 8); /// 1000

Als je deze dan samen ORgebruikt, werken ze elk op hun eigen bit-offset en zullen ze nooit botsen:

FLAG_A | FLAG_C

Vertaalt naar:

1 | 100

Dus uiteindelijk schakel je in:

101

Wat staat voor het gehele getal 5.

Het enige wat de code hoeft te doen – de code die zal reageren op de verschillende vlaggen die worden ingesteld – is het volgende (met een bitsgewijze AND):

$combined_flags = FLAG_A | FLAG_C;
if ( $combined_flags & FLAG_A ) {
  /// do something when FLAG_A is set
}
if ( $combined_flags & FLAG_B ) {
  /// this wont be reached with the current value of $combined_flags
}
if ( $combined_flags & FLAG_C ) {
  /// do something when FLAG_C is set
}

Uiteindelijk maakt het dingen alleen maar gemakkelijker te lezen door constanten te noemen, en over het algemeen meer optimaal door te vertrouwen op gehele waarden in plaats van strings of arrays. Een ander voordeel van het gebruik van constanten is dat als ze ooit verkeerd worden getypt wanneer ze worden gebruikt, de compiler in een betere situatie is om te vertellen en een waarschuwing te geven … als een stringwaarde wordt gebruikt, kan hij niet weten dat er iets mis is.

define('MY_FLAG_WITH_EASY_TYPO', 1);
my_function_that_expects_a_flag( MY_FLAG_WITH_EASY_TPYO );
/// if you have strict errors on the above will trigger an error
my_function_that_expects_a_flag( 'my_string_with_easy_tpyo' );
/// the above is just a string, the compiler knows nowt with 
/// regard to it's correctness, so instead you'd have to
/// code your own checks.

Antwoord 2, autoriteit 12%

Je geeft een argument door dat de bitsgewijze OR is van meerdere vlaggen. U kunt de operator overal gebruiken waar u maar wilt.