== Operatore e operandi

Voglio verificare se un valore è uguale a 1. C’è qualche differenza nelle seguenti righe di codice

Valore valutato == 1

1 == valore valutato

in termini di esecuzione del compilatore

    Nella maggior parte delle lingue è la stessa cosa.

    Le persone spesso fanno 1 == valore valutato perché 1 non è un lvalue. Significa che non puoi accidentalmente svolgere un incarico.

    Esempio:

    if(x = 6)//bug, but no compiling error { } 

    Invece potresti forzare un errore di compilazione invece di un bug:

     if(6 = x)//compiling error { } 

    Ora se x non è di tipo int e stai usando qualcosa come C ++, allora l’utente potrebbe aver creato un operatore == (int) override che porta questa domanda ad un nuovo significato. Il 6 == x non si compilerebbe in quel caso ma lo farebbe x == 6.

    Dipende dal linguaggio di programmazione.

    In Ruby, Smalltalk, Self, Newspeak, Ioke e molti altri linguaggi di programmazione orientati agli oggetti a singola uscita, a == b è in realtà un messaggio di invio. Ad esempio, in Ruby è equivalente a a.==(b) . Ciò significa che quando si scrive a == b , viene eseguito il metodo == nella class di a , ma quando si scrive b == a , viene eseguito il metodo nella class di b . Quindi, ovviamente non è la stessa cosa:

     class A; def ==(other) false end; end class B; def ==(other) true end; end a, b = A.new, B.new pa == b # => false pb == a # => true 

    No, ma la seconda syntax ti darà un errore del compilatore se digiti accidentalmente

     if (1 = evaluatedValue) 

    Nota che oggi qualsiasi compilatore decente ti avviserà se scrivi

     if (evaluatedValue = 1) 

    quindi è per lo più rilevante per ragioni storiche.

    Dipende dalla lingua

    In Prolog o Erlang, == è scritto = ed è un’unificazione piuttosto che un compito (stai affermando che i valori sono uguali, piuttosto che testare che sono uguali o forzarli a essere uguali), quindi puoi usarlo per un’affermazione se il lato sinistro è una costante, come spiegato qui .

    Quindi X = 3 unificerebbe la variabile X e il valore 3 , mentre 3 = X tenterebbe di unificare la costante 3 con il valore corrente di X , ed essere equivalente di assert(x==3) in lingue imperative.

    È la stessa cosa

    In generale, non importa se si utilizza, Valore valutato == 1 OR 1 == valore valutato.

    Usa quello che ti sembra più leggibile. Preferisco se (valore valutato == 1) perché mi sembra più leggibile.

    E ancora, mi piacerebbe citare uno scenario ben noto di confronto delle stringhe in java. Considera uno Str string che devi confrontare con un’altra stringa “SomeString”.

     str = getValueFromSomeRoutine(); 

    Ora in fase di esecuzione, non sei sicuro se str sarebbe NULL. Quindi per evitare un’eccezione scriverai

     if(str!=NULL) { if(str.equals("SomeString") { //do stuff } } 

    per evitare il controllo null esterno si potrebbe semplicemente scrivere

     if ("SomeString".equals(str)) { //do stuff } 

    Anche se questo è meno leggibile che dipende ancora dal contesto, questo ti risparmia un extra se.

    Per questo e per domande simili posso suggerire di scoprirlo da soli scrivendo un piccolo codice, eseguendolo attraverso il compilatore e visualizzando l’output emettitore asembler.

    Ad esempio, per i compilatori GNU, lo fai con il flag -S. Per i compilatori VS, il percorso più comodo è eseguire il programma di test nel debugger e quindi utilizzare la vista del debugger di Assembeler.

    A volte in C ++ fanno cose diverse, se il valore valutato è un tipo di utente e l’operatore == è definito. Male.

    Ma questo è molto raro il motivo per cui chiunque dovrebbe scegliere in un modo o nell’altro: se l’operatore == non è commutativo / simmetrico, incluso se il tipo del valore ha una conversione da int, allora si ha un problema che probabilmente vuole il fixing piuttosto che lavorare in giro. La risposta di Brian R. Bondy, e altri, sono probabilmente sul punto di capire perché qualcuno si preoccupi di ciò in pratica.

    Ma resta il fatto che anche se l’operatore == è commutativo, il compilatore potrebbe non fare esattamente la stessa cosa in ogni caso. Restituirà (per definizione) lo stesso risultato, ma potrebbe fare le cose in un ordine leggermente diverso, o qualsiasi altra cosa.

     if value == 1 if 1 == value 

    È esattamente lo stesso, ma se accidentalmente lo fai

     if value = 1 if 1 = value 

    Il primo funzionerà mentre il secondo produrrà un errore.

    Loro sono la stessa cosa. Alcune persone preferiscono mettere l’1 per primo, per annullare accidentalmente cadere nella trappola della digitazione

      evaluated value = 1 

    che potrebbe essere doloroso se il valore sul lato sinistro è assegnabile. Questo è un modello “difensivo” comune in C, ad esempio.

    Nei linguaggi C è comune inserire prima il numero costante o magico in modo che se si dimentica uno dei “=” del controllo di uguaglianza (==), il compilatore non lo interpreterà come un compito.

    In java, non è ansible eseguire un assegnamento all’interno di un’espressione booleana, e quindi per Java, è irrilevante quale ordine sono scritti gli operandi di uguaglianza; Il compilatore dovrebbe comunque segnalare un errore.