Perché usiamo di solito || oltre |? Qual è la differenza?


219

Mi chiedo solo perché di solito usiamo OR logico ||tra due valori booleani non bit a bit OR |, sebbene entrambi funzionino bene.

Voglio dire, guarda quanto segue:

if(true  | true)  // pass
if(true  | false) // pass
if(false | true)  // pass
if(false | false) // no pass
if(true  || true)  // pass
if(true  || false) // pass
if(false || true)  // pass
if(false || false) // no pass

Possiamo usare |invece di ||? Stessa cosa con &e &&.


16
Molte persone lo dimenticano | è un operatore booleano non in corto circuito oltre ad essere un operatore bit a bit.
John Meagher,

1
I dettagli sulla differenza sono nel JLS. Vedi java.sun.com/docs/books/jls/third_edition/html/…
John Meagher,

64
Non sono gli stessi. Controlla i tutorial su di essi, in particolare per quanto riguarda la valutazione del corto circuito e la valutazione desiderosa . ||e &&corto circuito mentre |e &sono desiderosi.
Hovercraft Full Of Eels,

4
Solo per curiosità, in che caso vorresti effettivamente utilizzare le versioni non in corto circuito? Quasi sempre vedo &&e ||, ma mai & |. Se stai facendo qualcosa che dipende dagli effetti collaterali, non vedo perché dovresti usare qualcosa del genere (a & b | c)poiché qualcuno potrebbe facilmente pensare "Posso ottimizzarlo usando le versioni in cortocircuito".
Mike Bailey,

2
E, naturalmente, hanno una precedenza diversa.
Hot Licks,

Risposte:


349

Se si utilizzano i moduli ||e &&, anziché i moduli |e &di questi operatori, Java non si preoccuperà di valutare da solo l'operando di destra.

È una questione di se si desidera cortocircuitare la valutazione o meno, la maggior parte delle volte che si desidera.

Un buon modo per illustrare i vantaggi del corto circuito sarebbe quello di considerare il seguente esempio.

Boolean b = true;
if(b || foo.timeConsumingCall())
{
   //we entered without calling timeConsumingCall()
}

Un altro vantaggio, come menzionato da Jeremy e Peter, per il corto circuito è il controllo di riferimento null:

if(string != null && string.isEmpty())
{
    //we check for string being null before calling isEmpty()
}

Ulteriori informazioni


115
L'esempio canonico èfoo != null && foo.hasBar()
Jeremy,

1
Se si aggiunge una possibile eccezione di riferimento null utilizzando | dal commento di @ Jeremy, questa è un'ottima risposta.
Peter Kelly,

Ricorda inoltre che && e || indica un'istruzione di diramazione a livello di codice macchina (ricordare che i rami possono causare previsioni errate sui rami), quindi se si è super pedanti sulle prestazioni, utilizzarli solo quando sono effettivamente richiesti ( foo != null && foo.hasBar()) o più veloci ( b || foo.timeConsumingCall()). Tuttavia, il 99% degli sviluppatori non dovrebbe preoccuparsi di questo livello di micro-ottimizzazione.
Jonathan Dickinson,

3
Sono sorpreso che nessuno abbia menzionato quando vuoi usare |. Lo scenario più comune che uso è quando una variabile viene modificata nel controllo come (j> 3 | ++ i> 3) o (++ i> 3 | modifyGlobalAmongOtherThings () = true). Non troppo comune però.
AndSoYouCode

8
Un altro esempio canonico è string == null || string.isEmpty();)
Peter Lawrey,

83

| non esegue la valutazione di cortocircuito nelle espressioni booleane. ||smetterà di valutare se il primo operando è vero, ma |non lo farà.

Inoltre, |può essere utilizzato per eseguire l'operazione OR bit a bit su valori byte / short / int / long. ||non può.


Fornisci una risposta completa e la accetterò. Finora sei il primo a raccoglierne questo aspetto.
John Meagher,

Manca l'aspetto bit per bit di |
John Meagher,

63

Quindi, solo per basarsi sulle altre risposte con un esempio, il corto circuito è cruciale nei seguenti controlli difensivi:

if (foo == null || foo.isClosed()) {
    return;
}

if (bar != null && bar.isBlue()) {
    foo.doSomething();
}

L'uso di |e &invece potrebbe provocare un NullPointerExceptionlancio qui.


Se si applica il modello NullObject non lo farebbe (o piuttosto si annullerebbe la risposta). Inoltre, direi che verificare se il foo è blu è qualcosa di interno al foo. Se è blu, allora qualcosa non dovrebbe fare nulla.
nicodemus13

@ nicodemus13 - buoni punti, sebbene il modello Null Object sia solo a volte desiderabile, e il corpo potrebbe essere qualcosa di diverso da un'altra chiamata a foo. L '"esempio canonico" di Peter Lawrey è il migliore.
Paul Bellora,

@Khan: Sì, ero piuttosto pernicioso, e l'oggetto null non è sempre adatto. Ho semplicemente preso l'abitudine di refactoring subcosciente delle cose. Non c'è nulla di particolarmente sbagliato nella tua risposta.
nicodemus13

39

Logico ||e &&controllare il lato destro solo se necessario. La |e &verificare sia l'ogni lati.

Per esempio:

int i = 12;
if (i == 10 & i < 9) // It will check if i == 10 and if i < 9
...

Riscriverlo:

int i = 12;
if (i == 10 && i < 9) // It will check if i == 10 and stop checking afterward because i != 10
...

Un altro esempio:

int i = 12;
if (i == 12 | i > 10) // It will check if i == 12 and it will check if i > 10
...

Riscriverlo:

int i = 12;
if (i == 12 || i > 10) // It will check if i == 12, it does, so it stops checking and executes what is in the if statement
...

18

Notare anche una trappola comune: gli operatori non pigri hanno la precedenza su quelli pigri, quindi:

boolean a, b, c;
a || b && c; //resolves to a || (b && c)
a | b && c; //resolves to (a | b) && c

Fai attenzione quando li mescoli.


15

Oltre al corto circuito, un'altra cosa da tenere a mente è che fare un'operazione di logica bit a bit su valori che possono essere diversi da 0 o 1 ha un significato molto diverso dalla logica condizionale. Mentre di solito è lo stesso per |e ||, con &e &&ottieni risultati molto diversi (ad es. 2 & 4È 0 / falso mentre 2 && 4è 1 / vero).

Se la cosa che stai ricevendo da una funzione è in realtà un codice di errore e stai testando la non-0-ness, questo può importare molto.

Questo non è un grosso problema in Java in cui devi esplicitamente digitare in booleano o confrontarlo con 0 o simili, ma in altre lingue con sintassi simile (C / C ++ et al) può essere abbastanza confuso.

Inoltre, nota che & e | può essere applicato solo a valori di tipo intero e non a tutto ciò che può essere equivalente a un test booleano. Ancora una volta, in linguaggi non Java, ci sono alcune cose che possono essere usate come booleane con un != 0confronto implicito (puntatori, float, oggetti con un operator bool(), ecc.) E gli operatori bit a bit sono quasi sempre privi di senso in quei contesti.


3
Sono contento che almeno qualcuno abbia menzionato l'intero scopo dell'esistenza di operatori bit per bit.
ulidtko,

9

L'unica volta che vorresti usare |o &invece di ||o &&è quando hai espressioni booleane molto semplici e il costo della scorciatoia (cioè un ramo) è maggiore del tempo che risparmi non valutando le espressioni successive.

Tuttavia, questa è una micro-ottimizzazione che raramente conta tranne nel codice di livello più basso.


1
Sarebbe interessante se il compilatore lo fa automaticamente in alcuni casi.
Starblue,

Forse JIT potrebbe, ma il compilatore tende a gestire solo semplici ottimizzazioni.
Peter Lawrey,

2
Sì, ho visto anche situazioni in cui | è significativamente più veloce dell'overhead del ramo di ||, specialmente su CPU con previsione del ramo assente o limitata. È raro ma non inaudito. Uno dei miei colleghi è entrato in una guerra di ritorno in qualche codice con un appaltatore perché stava (correttamente) usando | e l'appaltatore continuava a pensare che fosse "sbagliato".
soffice

4
@Fluffy, la morale della storia è che se fai qualcosa di complicato, devi commentare il motivo per cui hai fatto questo o i tuoi sforzi potrebbero essere sprecati in seguito. ;)
Peter Lawrey,

1
Sì, alla fine ha aggiunto un commento (su mio suggerimento su come convincere l'appaltatore a smettere di 'ripararlo'), e tutto va bene.
soffice

8

|| è il logico o l'operatore mentre | è bit a bit o operatore.

boolean a = true;
boolean b = false;

if (a || b) {
}

int a = 0x0001;
a = a | 0x0002;

1
Manca quello | è anche un operatore booleano non in corto circuito.
John Meagher,

2
@John Meagher: è implicito, in quanto è bit a bit .
L̲̳o̲̳̳n̲̳̳g̲̳̳p̲̳o̲̳̳k̲̳̳e̲̳̳

@ L̲̳o̲̳̳n̲̳̳g̲̳̳p̲̳o̲̳̳k̲̳̳e̲̳̳ come hai reso il tuo nome diverso stile nel tuo profilo?
UdayKiran Pulipati

8

a | b: valuta b in qualsiasi caso

a || b: valuta b solo se a viene valutato falso


7

Oltre al fatto che | è un operatore bit a bit: || è un operatore di corto circuito - quando un elemento è falso, non controllerà gli altri.

 if(something || someotherthing)
 if(something | someotherthing)

se qualcosa è VERO, || non valuterà altro, mentre | andrà bene. Se le variabili nelle istruzioni if ​​sono effettivamente chiamate di funzione, usando || sta probabilmente risparmiando molte prestazioni.


Perché mai dovresti usare | in un'istruzione if. || è booleano | non lo è | sarebbe booleano solo se stai già lavorando su due valori booleani.
FlySwat,

Questa è la prima risposta per ottenere tutto.
John Meagher,

Questa risposta non è corretta Se qualcosa è FALSO, entrambi gli operatori passeranno all'operando successivo. La differenza sorge solo quando il primo operando è vero.
Michael Myers

Peccato che abbia un esempio assolutamente ridicolo.
FlySwat,

Non ho idea del perché qualcuno dovrebbe usare | o in una dichiarazione if per un semplice confronto booleano, ma è perfettamente legale e ne ho visto degli esempi quando ho iniziato a studiare la programmazione.
Michael Stum

3
| is the binary or operator

|| is the logic or operator

2
Manca quello | è anche un operatore booleano non in corto circuito.
John Meagher,

3

Gli operatori ||e &&sono chiamati operatori condizionali , mentre |e &sono chiamati operatori bit a bit . Servono a scopi diversi.

Gli operatori condizionali funzionano solo con espressioni che valutano staticamente boolean sia sul lato sinistro che sul lato destro.

Gli operatori bit a bit funzionano con qualsiasi operando numerico.

Se si desidera eseguire un confronto logico, è necessario utilizzare operatori condizionali , poiché si aggiungerà una sorta di sicurezza del tipo al codice.


Uhm, |e &sono anche operatori condizionali. Si prega di vedere il link nel mio commento al post originale.
Hovercraft Full Of Eels,

@Hovercraft Full Of Eels: Quel grafico è un po 'fuorviante; si riferisce a loro come operatori condizionali SOLO nel contesto di valori booleani, dove sono matematicamente equivalenti a operatori logici desiderosi. Quando inizi a trattare cose che hanno valori diversi da 0 o 1, o valori in virgola mobile o puntatori o altro, il confronto si interrompe.
soffice

@fluffy: non c'è nulla di fuorviante nel grafico poiché la discussione riguardava solo gli operatori booleani. Che il |e &possa essere usato come operatori bit-saggio è un problema completamente separato.
Hovercraft Full Of Eels,

1
Sarebbe più preciso fare riferimento a loro come operatori bit-saggi usati su valori booleani e non operatori booleani. Accadono solo essere matematicamente equivalenti quando c'è solo un singolo bit.
soffice

2

Una nota a margine: Java ha | = ma non un || =

Un esempio di quando è necessario utilizzare || è quando la prima espressione è un test per vedere se la seconda espressione sarebbe esplosa. ad es. utilizzando un singolo | nel caso seguente potrebbe risultare in un NPE.

public static boolean isNotSet(String text) {
   return text == null || text.length() == 0;
}

2

Le altre risposte hanno fatto un buon lavoro nel coprire la differenza funzionale tra gli operatori, ma le risposte potrebbero applicarsi a quasi ogni singolo linguaggio derivato dal C esistente oggi. La domanda è taggata cone quindi cercherò di rispondere in modo specifico e tecnico per il linguaggio Java.

&e |possono essere operatori Bitwise interi o operatori logici booleani. La sintassi per gli operatori Bitwise e Logical ( §15.22 ) è:

AndExpression:
  EqualityExpression 
  AndExpression & EqualityExpression

ExclusiveOrExpression:
  AndExpression 
  ExclusiveOrExpression ^ AndExpression

InclusiveOrExpression:
  ExclusiveOrExpression 
  InclusiveOrExpression | ExclusiveOrExpression

La sintassi per EqualityExpressionè definita in §15.21 , che richiede RelationalExpressiondefinito in §15.20 , che a sua volta richiede ShiftExpressione ReferenceTypedefinito in §15.19 e §4.3 , rispettivamente. ShiftExpressionrichiede AdditiveExpressiondefinito nel §15.18 , che continua a eseguire il drill down, definendo l'aritmetica di base, gli operatori unari, ecc. ReferenceTypeesegue il drill down in tutti i vari modi per rappresentare un tipo. (Sebbene ReferenceTypenon includa i tipi primitivi, alla fine è necessaria la definizione dei tipi primitivi, poiché potrebbero essere il tipo di dimensione per un array, che è unReferenceType .)

Gli operatori bit a bit e logici hanno le seguenti proprietà:

  • Questi operatori hanno una precedenza diversa, con &la precedenza più alta e| la precedenza più bassa.
  • Ognuno di questi operatori è sintatticamente associativo-sinistro (ogni gruppo da sinistra a destra).
  • Ogni operatore è commutativo se le espressioni degli operandi non hanno effetti collaterali.
  • Ogni operatore è associativo.
  • Gli operatori bit per bit e logici possono essere usati per confrontare due operandi di tipo numerico o due operandi di tipo boolean. Tutti gli altri casi generano un errore in fase di compilazione.

La distinzione tra se l'operatore funge da operatore bit a bit o come operatore logico dipende dal fatto che gli operandi siano "convertibili in un tipo integrale primitivo" ( §4.2 ) o se siano di tipo booleano Boolean( §5.1.8 ).

Se gli operandi sono di tipo integrale, la promozione numerica binaria ( §5.6.2 ) viene eseguita su entrambi gli operandi, lasciandoli entrambi come longs o ints per l'operazione. Il tipo di operazione sarà il tipo di operandi (promossi). A quel punto, &sarà bit a bit AND, ^sarà bit a bit OR esclusivo e |sarà bit a bit OR inclusivo. ( §15.22.1 )

Se gli operandi sono booleano Boolean, gli operandi saranno soggetti a conversione unboxing, se necessario ( §5.1.8 ), e il tipo di operazione sarà boolean. &comporterà truese entrambi gli operandi lo saranno true, ^comporterà truese entrambi gli operandi sono diversi e |comporterà truese entrambi gli operandi lo sono true. ( §15.22.2 )

Al contrario, && è "Operatore condizionale" ( §15.23 ) ed ||è "Operatore condizionale" ( § 15.24 ). La loro sintassi è definita come:

ConditionalAndExpression:
  InclusiveOrExpression 
  ConditionalAndExpression && InclusiveOrExpression

ConditionalOrExpression:
  ConditionalAndExpression 
  ConditionalOrExpression || ConditionalAndExpression

&&è come &, tranne per il fatto che valuta l'operando di destra solo se l'operando di sinistra è true. ||è come |, tranne per il fatto che valuta l'operando di destra solo se l'operando di sinistra èfalse .

Condizionale-E ha le seguenti proprietà:

  • L'operatore condizionale e sintatticamente è associativo a sinistra (raggruppa da sinistra a destra).
  • L'operatore condizionale e l'operatore sono pienamente associativi rispetto agli effetti collaterali e al valore del risultato. Cioè, per qualsiasi espressione a, be la cvalutazione dell'espressione ((a) && (b)) && (c)produce lo stesso risultato, con gli stessi effetti collaterali che si verificano nello stesso ordine, come la valutazione dell'espressione(a) && ((b) && (c)) .
  • Ogni operando dell'operatore condizionale e deve essere di tipo booleanoBoolean , oppure si verifica un errore in fase di compilazione.
  • Il tipo di un condizionale ed espressione è sempre boolean .
  • In fase di esecuzione, l'espressione dell'operando di sinistra viene valutata per prima; se il risultato ha tipo Boolean, è soggetto a conversione unboxing ( §5.1.8 ).
  • Se il valore risultante è false, il valore dell'espressione-condizionale è falsee l'espressione dell'operando di destra non viene valutata.
  • Se il valore dell'operando di sinistra è true, viene valutata l'espressione di destra; se il risultato ha tipo Boolean, è soggetto a conversione unboxing ( §5.1.8 ). Il valore risultante diventa il valore dell'espressione-condizionale.
  • Così, &&calcola lo stesso risultato &su booleanoperandi. Differisce solo dal fatto che l'espressione dell'operando della mano destra viene valutata in modo condizionale piuttosto che sempre.

Condizionale-O ha le seguenti proprietà:

  • L'operatore condizionale o sintatticamente è associativo a sinistra (raggruppa da sinistra a destra).
  • L'operatore condizionale o è completamente associativo rispetto agli effetti collaterali e al valore del risultato. Cioè, per qualsiasi espressione a, be c, la valutazione dell'espressione ((a) || (b)) || (c)produce lo stesso risultato, con gli stessi effetti collaterali che si verificano nello stesso ordine, come la valutazione dell'espressione (a) || ((b) || (c)).
  • Ogni operando del condizionale o dell'operatore deve essere di tipo booleano Boolean, oppure si verifica un errore in fase di compilazione.
  • Il tipo di un condizionale o espressione è sempre boolean .
  • In fase di esecuzione, l'espressione dell'operando di sinistra viene valutata per prima; se il risultato ha tipo Boolean, è soggetto a conversione unboxing ( §5.1.8 ).
  • Se il valore risultante è true, il valore dell'espressione condizionale o è truee l'espressione dell'operando di destra non viene valutata.
  • Se il valore dell'operando di sinistra è false, viene valutata l'espressione di destra; se il risultato ha tipo Boolean, è soggetto a conversione unboxing ( §5.1.8 ). Il valore risultante diventa il valore del condizionale o dell'espressione.
  • Pertanto, ||calcola lo stesso risultato di |on booleano Booleanoperandi. Differisce solo dal fatto che l'espressione dell'operando della mano destra viene valutata in modo condizionale piuttosto che sempre.

In breve, come ha sottolineato più volte @JohnMeagher nei commenti, &e |in realtà sono operatori booleani non in corto circuito nel caso specifico degli operandi che sono booleano Boolean. Con le buone pratiche (ovvero: nessun effetto secondario), questa è una differenza minore. Quando gli operandi non sono booleans o Booleans, tuttavia, gli operatori si comportano molto diversamente: bit a bit e operazioni logiche semplicemente non si confronta bene al livello di programmazione Java.


2

1). (Espressione1 | espressione2), | l'operatore valuterà expression2 indipendentemente dal fatto che il risultato di expression1 sia vero o falso.

Esempio:

class Or 
{
    public static void main(String[] args) 
    {
        boolean b=true;

        if (b | test());
    }

    static boolean test()
    {
        System.out.println("No short circuit!");
        return false;
    }
}

2). (Espressione1 || espressione2), || l'operatore non valuterà expression2 se expression1 è true.

Esempio:

class Or 
{
    public static void main(String[] args) 
    {
        boolean b=true;

        if (b || test())
        {
            System.out.println("short circuit!");
        }
    }

    static boolean test()
    {
        System.out.println("No short circuit!");
        return false;
    }
}

1

|| restituisce un valore booleano inserendo due valori (ecco perché è noto come LOGICO o)

IE:

if (A || B) 

Restituirà vero se A o B sono veri, o falso se sono entrambi falsi.

| è un operatore che esegue un'operazione bit a bit su due valori. Per comprendere meglio le operazioni bit per bit, puoi leggere qui:

http://en.wikipedia.org/wiki/Bitwise_operation


1

Una delle differenze principali è che || e && mostrano "corto circuito", quindi l'RHS sarà valutato solo se necessario.

Per es

if (a || b) {
    path1...
} else {
    path2..
}

Sopra se a è vero, allora b non verrà testato e verrà eseguito path1. Se | è stato utilizzato quindi entrambe le parti sarebbero state valutate anche se 'a' è vero.

Vedi qui e qui , per qualche informazione in più.

Spero che questo ti aiuti.


1

Non corto circuito può essere utile. A volte vuoi assicurarti che due espressioni valutino. Ad esempio, supponiamo di avere un metodo che rimuove un oggetto da due elenchi separati. Potresti voler fare qualcosa del genere:

class foo {

    ArrayList<Bar> list1 = new ArrayList<Bar>();
    ArrayList<Bar> list2 = new ArrayList<Bar>();

    //Returns true if bar is removed from both lists, otherwise false.
    boolean removeBar(Bar bar) {
        return (list1.remove(bar) & list2.remove(bar));
    }
}

Se il metodo utilizzato invece utilizza l'operando condizionale, non rimuove l'oggetto dal secondo elenco se il primo elenco restituisce false.

//Fails to execute the second remove if the first returns false.
boolean removeBar(Bar bar) {
    return (list1.remove(bar) && list2.remove(bar));
}

Non è incredibilmente utile e (come con la maggior parte delle attività di programmazione) potresti raggiungerlo con altri mezzi. Ma è un caso d'uso per operandi bit a bit.


1

La differenza fondamentale tra loro è che | prima converte i valori in binario, quindi esegue il bit o l'operazione. Nel frattempo, || non converte i dati in binari ed esegue semplicemente l'espressione o sul suo stato originale.

int two = -2; int four = -4;
result = two | four; // bitwise OR example

System.out.println(Integer.toBinaryString(two));
System.out.println(Integer.toBinaryString(four));
System.out.println(Integer.toBinaryString(result));

Output:
11111111111111111111111111111110
11111111111111111111111111111100
11111111111111111111111111111110

Per saperne di più: http://javarevisited.blogspot.com/2015/01/difference-between-bitwsie-and-logical.html#ixzz45PCxdQhk


Falso quando gli operandi sono booleani e formattazione stupida.
Marchese di Lorne,

2
Questo mi è stato utile per capire perché Long.valueOf (100 | 200) = 236. Ecco perché: 0 1 1 0 0 1 0 0 | 1 1 0 0 1 0 0 0 = 1 1 1 0 1 1 0 0 = 128 64 32 0 8 4 0 0 = 236
donlys

1

Quando ho avuto questa domanda ho creato un codice di prova per farmi un'idea.

public class HelloWorld{

   public static boolean bool(){
      System.out.println("Bool");
      return true;
   }

   public static void main(String []args){

     boolean a = true;
     boolean b = false;

     if(a||bool())
     {
        System.out.println("If condition executed"); 
     }
     else{
         System.out.println("Else condition executed");
     }

 }
}

In questo caso, cambiamo solo il valore del lato sinistro di if condition aggiungendo a o b.

|| Scenario, quando il lato sinistro è vero [if (a || bool ())]

produzione "If condition executed"

|| Scenario, quando il lato sinistro è falso [if (b || bool ())]

Produzione-

Bool
If condition executed

Conclusion of || Durante l'uso ||, il lato destro controlla solo quando il lato sinistro è falso.

| Scenario, quando il lato sinistro è vero [if (a | bool ())]

Produzione-

Bool
If condition executed

| Scenario, quando il lato sinistro è falso [if (b | bool ())]

Produzione-

Bool
If condition executed

Conclusion of | Durante l'uso |, controllare sia il lato sinistro che quello destro.



0

di solito lo uso quando c'è un operatore pre-incremento e post-incremento. Guarda il seguente codice:

package ocjpPractice;
/**
 * @author tithik
 *
 */
public class Ex1 {

    public static void main(String[] args) {
    int i=10;
    int j=9;
    int x=10;
    int y=9;
    if(i==10 | ++i>j){
        System.out.println("it will print in first if");  
        System.out.println("i is: "+i);
    }

    if(x==10 ||++x>y){
        System.out.println("it will print in second if");   
        System.out.println("x is: "+x);
    }
    }
}

produzione:

stamperà per primo se
sono: 11

stamperà per secondo se
x è: 10

entrambi i ifblocchi sono uguali ma il risultato è diverso. quando c'è |, verranno valutate entrambe le condizioni. Ma se lo è ||, non valuterà la seconda condizione poiché la prima condizione è già vera.


1
Lo trovo molto confuso
NimChimpsky,

0

Ci sono molti casi d'uso che suggeriscono perché dovresti cercare ||piuttosto che |. Alcuni casi d'uso devono usare| operatore per verificare tutte le condizioni.

Ad esempio, se si desidera verificare la convalida del modulo e si desidera mostrare all'utente tutti i campi non validi con testi di errore anziché solo un primo campo non valido.

|| operatore sarebbe,

   if(checkIfEmpty(nameField) || checkIfEmpty(phoneField) || checkIfEmpty(emailField)) {
      // invalid form with one or more empty fields
   }

   private boolean checkIfEmpty(Widget field) {
      if(field.isEmpty()) {
        field.setErrorMessage("Should not be empty!");
        return true;
      }
      return false;
   }

Pertanto, con lo snippet precedente, se l'utente invia il modulo con TUTTI i campi vuoti, SOLO nameFieldverrà visualizzato con un messaggio di errore. Ma, se lo cambi in,

   if(checkIfEmpty(nameField) | checkIfEmpty(phoneField) | checkIfEmpty(emailField)) {
      // invalid form with one or more empty fields
   }

Mostrerà il messaggio di errore corretto su ciascun campo indipendentemente dalle truecondizioni.


0

Dopo aver letto attentamente questo argomento non mi è ancora chiaro se l'utilizzo |come operatore logico è conforme alle pratiche del modello Java.

Di recente ho modificato il codice in una richiesta pull indirizzando un commento in cui

if(function1() | function2()){
  ...
}

doveva essere cambiato in

boolean isChanged = function1();
isChanged |= function2();
if (isChanged){
  ...
}

Qual è la versione effettivamente accettata?

La documentazione Java non viene menzionata |come operatore logico non in corto circuito.

Non sei interessato a un voto, ma piuttosto a scoprire lo standard ?! Entrambe le versioni del codice vengono compilate e funzionano come previsto.





-2

| è un operatore bit a bit. || è un operatore logico.

Uno prenderà due bit e / o loro.

Si determinerà la verità (questo OR quello) Se questo è vero o è vero, allora la risposta è vera.

Oh, e perché le persone rispondono a queste domande velocemente.

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.