web-dev-qa-db-fra.com

Que signifie "| ="? (opérateur égal pipe)

J'ai essayé de chercher à l'aide de Google Search et Stack Overflow, mais aucun résultat n'a été affiché. J'ai vu ceci dans le code de la bibliothèque opensource:

Notification notification = new Notification(icon, tickerText, when);
notification.defaults |= Notification.DEFAULT_SOUND;
notification.defaults |= Notification.DEFAULT_VIBRATE;

Que signifie "| =" (pipe equal operator)?

javaandroidoperators
197
wtsang02

|= se lit de la même manière que +=.

notification.defaults |= Notification.DEFAULT_SOUND;

est le même que

notification.defaults = notification.defaults | Notification.DEFAULT_SOUND;

où | représente le bit OR opérateur.

Tous les opérateurs sont référencés ici .

Un opérateur binaire est utilisé car, comme cela est fréquent, ces constantes permettent à un int de porter des drapeaux.

Si vous regardez ces constantes, vous verrez qu'elles ont une puissance de deux:

public static final int DEFAULT_SOUND = 1;
public static final int DEFAULT_VIBRATE = 2; // is the same than 1<<1 or 10 in binary
public static final int DEFAULT_LIGHTS = 4; // is the same than 1<<2 or 100 in binary

Vous pouvez donc utiliser bit par bit OR pour ajouter des drapeaux

int myFlags = DEFAULT_SOUND | DEFAULT_VIBRATE; // same as 001 | 010, producing 011

alors

myFlags |= DEFAULT_LIGHTS;

signifie simplement que nous ajoutons un drapeau.

Et symétriquement, nous testons qu’un drapeau est défini en utilisant &:

boolean hasVibrate = (DEFAULT_VIBRATE & myFlags) != 0;
266
Denys Séguret

Vous avez déjà suffisamment de réponses à votre question. Mais peut-être que ma réponse vous aidera davantage à propos de |= sorte d'opérateurs binaires.

J'écris tableau pour opérateurs au niveau du bit :
Sont valables:

----------------------------------------------------------------------------------------
Operator   Description                                   Example
----------------------------------------------------------------------------------------
|=        bitwise inclusive OR and assignment operator   C |= 2 is same as C = C | 2
^=        bitwise exclusive OR and assignment operator   C ^= 2 is same as C = C ^ 2
&=        Bitwise AND assignment operator                C &= 2 is same as C = C & 2
<<=       Left shift AND assignment operator             C <<= 2 is same as C = C << 2
>>=       Right shift AND assignment operator            C >>= 2 is same as C = C >> 2  
----------------------------------------------------------------------------------------

notez que tous les opérateurs sont des opérateurs binaires.

Aussi Remarque:   (pour les points ci-dessous, je voulais ajouter ma réponse)

  • >>> est un opérateur binaire dans Java appelé décalage signé
    mais >>>= n'est pas un opérateur en Java. >>> = opérateur

  • ~ est un bit au complément, 0 to 1 and 1 to 0 (opérateur unaire) mais ~= n'est pas un opérateur.

  • De plus, ! Appelé opérateur non logique, mais != Vérifie si la valeur de deux opérandes est égale ou non, si les valeurs ne sont pas égales, la condition devient vraie. par exemple. (A != B) is true. où comme A=!B signifie si B est true alors A devient false (et si B est false alors A deviennent true).

note latérale: | n'est pas appelé canal, mais OR, canal est un transfert de terminologie Shell d'un processus à l'autre.

35
Grijesh Chauhan

Je cherchais une réponse à ce que |= fait dans Groovy et bien que les réponses ci-dessus soient exactes, elles ne m'ont pas aidé à comprendre un morceau de code particulier que je cherchais.

En particulier, lorsqu'elle est appliquée à une variable booléenne "| =", elle sera définie sur TRUE la première fois qu'elle rencontre une expression de vérité sur le côté droit et GARDERA sa valeur TRUE pour tous les appels suivants =. Comme un loquet.

Voici un exemple simplifié de ceci:

groovy> boolean result  
groovy> //------------ 
groovy> println result           //<-- False by default
groovy> println result |= false 
groovy> println result |= true   //<-- set to True and latched on to it
groovy> println result |= false

Sortie:

false
false
true
true

Edit: Pourquoi est-ce utile?

Envisagez une situation dans laquelle vous souhaitez savoir si des modifications ont été apportées à divers objets et, le cas échéant, en informer une des modifications. Donc, vous devriez configurer un hasChanges booléen et le régler sur |= diff (a,b) puis sur |= dif(b,c) etc. Voici un bref exemple:

groovy> boolean hasChanges, a, b, c, d 
groovy> diff = {x,y -> x!=y}  
groovy> hasChanges |= diff(a,b) 
groovy> hasChanges |= diff(b,c) 
groovy> hasChanges |= diff(true,false) 
groovy> hasChanges |= diff(c,d) 
groovy> hasChanges 

Result: true
14
dbrin

C'est un raccourcissement pour ceci:

notification.defaults = notification.defaults | Notification.DEFAULT_SOUND;

Et | est un peu sage OU.

12
Till Helge

| est l'opérateur bitwise-or , et il est appliqué comme +=.

8
ford

Remarque: || = n'existe pas. (logique ou) Vous pouvez utiliser

y= y || expr; // expr is NOT evaluated if y==true

ou

y = expr ? true : y;  // expr is always evaluated.
2
woens