Gli operatori di incremento e decremento diminuiscono la leggibilità? [chiuso]

La tua domanda

Sì, è del tutto normale utilizzare i++ e --j in una dichiarazione. La maggior parte delle lingue tradizionali li ha adottati.

Sì, è ok usare i++ e --j in espressioni più complesse, quando la precedenza è autoesplicativa:

• o perché è isolato abbastanza come in a[i++] o in --j > 0 ,
• o perché è usato secondo un linguaggio comune come *p++ ( esperto programmatore C / C ++ sa che l'incremento si applica al puntatore / iteratore e non al valore di riferimento ).

Altri consigli

Evitare in caso di dubbi! Preferisci la leggibilità e passaggi più semplici invece di utilizzare le parentesi come per **p[i]++ . Abusare come --(*p++) o 1---j dovrebbe essere veramente proibito, non per l'ambiguità sintattica, ma per l'enorme sforzo che richiede per capire.

Divieto assoluto: non usare mai più di uno di questi effetti collaterali sulla stessa variabile nella stessa espressione di *p++ == *--p o funct(i++, i--) . Ciò potrebbe portare, nel peggiore dei casi, a comportamenti indefiniti, nel migliore dei casi a equivoci, in quanto esistono sottili differenze tra le lingue .

Conclusione e citazione del giorno :

" Debugging is twice as hard as writing a program in the first place. So if you're as clever as you can be when you write it, how will you ever debug it ? "

B.W.Kernighan

Passiamo alla logica:

1. Alcuni sviluppatori junior non comprendono appieno queste affermazioni
2. Quindi evitiamo di utilizzarli e limitiamo la loro esposizione a tali dichiarazioni
3. Alla fine tutti gli sviluppatori incontreranno una tale affermazione
4. Comprendono l'affermazione a causa di # 2

In poche parole, quando le affermazioni vengono evitate perché considerate esoteriche diventano più esoteriche. Il problema è che se queste cose fanno parte della lingua, verranno trovate in codice da qualche parte. Potresti essere in grado di impedirne l'uso in una squadra ma in un modo in cui crei ignoranza nel farlo.

Questo problema è il motivo per cui non sono un grande fan delle lingue "tutto più il lavello della cucina". Più sintassi ci sono, più c'è da capire e se alcuni di essi sono piuttosto crudi o difficili, diventano esoterici e alla fine causano un bug da qualche parte quando viene frainteso. Adottare un tale linguaggio e quindi dichiarare che le persone non dovrebbero usare la sintassi che offre non è davvero ottimale, secondo me. Python non consente ++ i e i ++ e se tu odi queste affermazioni, questo è un vantaggio di quella lingua.

Nelle lingue che consentono queste cose, la mia risposta è "conosci i tuoi strumenti". Queste affermazioni sono ben definite, abbastanza logiche e sono utili in situazioni comuni. Se stai programmando in un linguaggio che consente queste affermazioni e non sai cosa significano, hai bisogno di abilità e non è responsabilità di altri sviluppatori di coccolarti.

Per la domanda 1) - sì, è perfettamente leggibile. Ogni programmatore del pianeta comprende la linea i++ .

Tuttavia , per coerenza, si può prendere in considerazione l'utilizzo di i += 1 . Ha la stessa forma per qualsiasi costante per es. i += 4 , mentre i++ è un bit speciale di sintassi che incrementa esattamente di uno.

Per la domanda 2) - assolutamente no !! Un programmatore non dovrebbe mai avere la precedenza dell'operatore memorizzata per comprendere una riga di codice.

Dai un'occhiata a due piccoli snippet di codice (C # - Non so se C ++ e Java si comportano allo stesso modo di C #):

int i = 0;
int j = i++;

e

int i = 0;
int j = ++i;

Capisci la differenza tra quelle versioni? Quali sono i valori di i e j in questi frammenti?

Se tu - e anche i tuoi colleghi - puoi dirlo senza esitazione, allora tale uso è OK, all'interno della tua squadra. Preferisco scoraggiare questo tipo di utilizzo.

Dipende dalla lingua. In C ci sono alcuni idiomi noti che dipendono dall'uso di incrementi o decrementi come espressioni. Quindi ti aspetteresti che uno sviluppatore C legga il tuo codice per avere familiarità con questi idiomi. Il lettore potrebbe essere sconcertato se scegli una soluzione meno idiomatica.

Java e C # hanno differenti culture e differenti idiomi. Non è comune usare incrementi nelle espressioni. Farlo potrebbe essere considerato "intelligente" o "micro-ottimizzazione". Tuttavia, gli incrementi come affermazioni autonome non sono disapprovate. (Sebbene gli iteratori e simili siano preferiti ai loop con contatori.)

Alcune lingue come Python non hanno affatto operatori di incremento / decremento, nel qual caso non hai molta scelta.

In conclusione: la leggibilità è sempre relativa a un determinato pubblico.