Ce n' “|=” signifie? (la pipe de l'égalité de l'opérateur)

J'ai essayé de chercher l'aide de la Recherche Google et de Pile Overflow, mais il n'a pas montré de résultats. J'ai vu cela en open source, le code de bibliothèque:

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

Ce n' "|=" ( pipe equal operator ) signifie?

Je me demande si l'ajout de quelque chose comme pipe equal operator à cette question ou de toute autre documentation sur le sujet ne serait pas aider les gens à la recherche.
êtes-vous les gars de parler de cela docs. Il dit clairement que les docs manque de documentation sur le utilisation de cette.
À moins que tu savais que c'était appelé pipe de l'égalité, il est vraiment difficile de faire des recherches pour les sans demander à quelqu'un.
en effet, passé un certain temps de googler autour de venir avec un terme vertical bar qui finalement m'a conduit ici.
Double Possible de ce n' |= (seul tuyau d'égalité) et &=(seul esperluette égal) moyenne
Je pense qu'ils fournissent à la fois des valeurs différentes pour les différents utilisateurs. Ils doivent cohabiter. Si non, d'après [meta.stackexchange.com/questions/10841/... ](meta post) , l'un avec la meilleure collection de réponses doit le rester. Je dirais qu'il y sont généralement mieux ici.
Double Possible de Ce qui ne l' | opérateur= n'en Java?

InformationsquelleAutor wtsang02 | 2013-01-12

263

|= lit de la même façon que +=.
```
notification.defaults |= Notification.DEFAULT_SOUND;
```
est le même que
```
notification.defaults = notification.defaults | Notification.DEFAULT_SOUND;
```
où | est le bit à bit OU de l'exploitant.

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

Un peu sage opérateur est utilisé parce que, comme c'est fréquent, ces constantes permettent un int pour porter les drapeaux.

Si vous look à ces constantes, vous verrez qu'ils sont dans les puissances 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
```
De sorte que vous pouvez utiliser bit-wise OU pour ajouter des drapeaux
```
int myFlags = DEFAULT_SOUND | DEFAULT_VIBRATE; //same as 001 | 010, producing 011
```
donc
```
myFlags |= DEFAULT_LIGHTS;
```
signifie simplement que nous ajouter un drapeau.

Et symétriquement, nous testons un indicateur est défini à l'aide de & :
```
boolean hasVibrate = (DEFAULT_VIBRATE & myFlags) != 0;
```
- Tout comme j += 1; est le même que j = j + 1;.
- Dans Java 7> int defaults = 0b1001; defaults |= 0b1010; defaults == 0b1011;
- Bien que j += 1 n'est pas exactement le même que j = j + 1.
- Je ne peux pas penser à un contre-exemple en Java (peut-être que si j est volatile?), mais je vais prendre votre parole.
- Voir ceci
- boolean hasVibrate = DEFAULT_VIBRATE & myFlags; - pouvez-vous traduire à partir de int à boolean comme ça en Java? Qui serait valide en C, mais j'ai pensé en Java, il a dû être écrit comme boolean hasVibrate = ((DEFAULT_VIBRATE & myFlags) == DEFAULT_VIBRATE);
- Vous avez raison. J'ai édité pour corriger cette ligne.
- Nice ventilation. +1
- Merci de répondre à la question au lieu de faire comme tout le monde, qui est de recommander à l'auteur de lire l'ensemble de Java Language Specification de comprendre ce que cela signifie
- Wow, que la comparaison avec += enfin fait le tour pour me comprendre. Merci!
InformationsquelleAutor Denys Séguret
34

Vous avez déjà eu suffisamment de réponse pour votre question. Mais peut-être que ma réponse vous aider plus sur |= type d'opérateurs binaires.

Je suis à la table d'écriture pour opérateurs au niveau du bit:

Suivantes sont valides:
```
----------------------------------------------------------------------------------------
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  
----------------------------------------------------------------------------------------
```
note tous les opérateurs sont des opérateurs binaires.

Aussi Remarque: _{(ci-après les points que je voulais ajouter ma réponse)}
- >>> est opérateur au niveau du bit en Java qui est appelé Unsigned maj
  
  ~~mais >>>= pas un opérateur en Java.~~ >>>= opérateur
- ~ est complément bit à bit bits, 0 to 1 and 1 to 0 (opérateur Unaire) mais ~= pas un opérateur.
- En outre, ! Appelé Opérateur Logique not, mais != Vérifie si la valeur de deux opérandes sont égaux ou non, si les valeurs ne sont pas égales puis condition devient vraie. par exemple,(A != B) is true. où que A=!B signifie que si B est true puis A devenir false (et si B est false puis A devenir true).
_{note de côté: | n'est pas appelé pipe, au lieu de son nom OU de, la pipe est shell terminologie de transfert d'un processus à la prochaine..}
- J'étais sous l'impression que le "tuyau" est le nom du personnage, qui est l'endroit où la coquille terme provient de. Mais, en regardant sur Wikipédia, il est en fait appelé une "barre verticale" et de "pipe" est spécifique aux commandes du shell. Je voulais juste dire merci pour l'ajout de cette note de côté!
- googlé ici, grâce à votre vertical bar
InformationsquelleAutor Grijesh Chauhan
13

Je cherchais une réponse sur ce |= n'en Groovy, et bien que les réponses ci-dessus sont à droite, ils n'ont pas de m'aider à comprendre un morceau de code que j'étais en train de regarder.

En particulier, lorsqu'il est appliqué à une variable booléenne "| = "" va le mettre à TRUE la première fois qu'il rencontre un truthy expression sur le côté droit et tiendra sa VRAIE valeur pour tous |= les appels suivants. Comme un loquet.

Voici un exemple simplifié de ce:
```
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 
```
De sortie:
```
false
false
true
true
```
Modifier:
Pourquoi est-ce utile?

Imaginez une situation où vous voulez savoir si quelque chose a changé sur une variété d'objets et de s'informer de l'un des changements. Ainsi, vous souhaitez configurer un hasChanges boolean et mis à |= diff (a,b) et puis |= 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
```
- Yep, la situation est la même en Java. Mais il convient de noter qu'une telle opération OU y|=expr est pas de court-circuit (contrairement à y = y || expr), ce qui signifie que expr toujours évalué. Ce n'était pas évident pour moi, pour la première fois 🙂 Donc, il est important de noter avant de refactoring de remplacement y|=expr ↔ y=y||x est ce n'est pas sémantiquement équivalent dans le cas expr a effectivement des effets secondaires.
- Et, ayant ceci à l'esprit, dans ton cas avec hasChanges il serait probablement mieux préférer y=y||x forme de bénéficier de court-parcours, parce que quand vous avez trouvé tout changement, il n'est pas nécessaire de faire susequent diff parce que vous connaissez déjà la réponse. (Particulièrement important dans la situation de vie réelle lorsque les objets comparés sont compliquées et diffing eux n'est pas assez rapide)
- Merci pour la voix. Oui je suis d'accord avec votre point de vue sur le court-circuitage.
- Merci beaucoup! Mais cet écueil n'est pas mentionné dans standard; est-il de la mise en œuvre de détails?
- bien sûr, pas de détail d'implémentation. Non-court-circuitness n'est pas spécifiquement mentionné à l'endroit que vous l'avez mentionné tout simplement parce que ce n'est pas la particularité - c'est le défaut et le comportement normal pour la plupart des opérateurs. La particularité est en fait le court-circutiness de || et &&, et dans les sections correspondantes 15.23 et 15.24 de la spécification de ce fait est clairement déclarée, et cette différence de | et & est souligné.
- Je pense donc qu'il n'y avait pas besoin de dire quelque chose à propos de ce nouveau ci-dessous dans la section référencés (15.26.2 "Compund opérateurs d'affectation") tout simplement parce que compond les missions sont tout simplement toujours non-court-circuit (il n'y a pas ||= et &&= opérateurs qui enfreindrait la règle et nécessitent une mention spéciale).
InformationsquelleAutor dbrin
12

C'est un raccourcissement de cette:
```
notification.defaults = notification.defaults | Notification.DEFAULT_SOUND;
```
Et | est un peu sage OU.

InformationsquelleAutor Till Helge
8

| est le au niveau du bit-ou opérateur, et elle est appliquée comme +=.

InformationsquelleAutor ford
2

Remarque: ||= n'existe pas. (ou logique)
Vous pouvez utiliser
```
y= y || expr; //expr is NOT evaluated if y==true
```
ou
```
y = expr ? true : y;  //expr is always evaluated.
```
- Pas tout à fait terminée: vous pouvez toujours utiliser y |= expr avec les booléens et ça donne le même résultat sur y que vos variantes avec le important de noter que il n'est pas court-curtuit, ce qui signifie que expr est toujours évalué, même en cas de y==true
InformationsquelleAutor woens

Vous devez vous connecter pour publier un commentaire.