Denominazione di variabili simili [chiuso]

Questo è basato sulla tua domanda aggiornata. Si noti inoltre che ciò non si basa su alcuna misurazione scientifica della leggibilità. Piuttosto, sto presentando i vari fattori che (penso) sono probabilmente per influenzare la leggibilità per il programmatore Joe medio.

Opzione 1 - len1 , len2 , len3

L'unica critica potenziale di questo è che forse non dovresti abbreviare length come len . Ma il contrario è che è probabilmente ovvio dal contesto cosa significa len .

Opzione 2 - lenOne , lenTwo , lenThree

Nessun vantaggio rispetto all'opzione precedente. Gli svantaggi sono:

• questi sono leggermente più difficili da leggere (per la maggior parte delle persone) come parole
• questi sono marginalmente più sforzo per digitare
• il fatto che abbiano lunghezze diverse significa che il codice che le usa si allineerà in modo diverso.

Opzione 3 - lens[0] , lens[1] , lens[2] .

La scelta di lens è errata, perché lens è anche una parola inglese a sé stante.

Altri problemi:

• Marginalmente più difficile da leggere rispetto a una semplice variabile.
• Stai "contando da zero". La maggior parte dei programmatori sa come farlo, ma è in conflitto con ciò che la maggior parte delle persone fa "naturalmente" ¹ . È probabile che renderà len[I] o lens[I] leggermente più difficile da leggere rispetto a lenI
• Questo ha (piccole) prestazioni e costi di utilizzo della memoria.

• Questo introduce potenziali rischi di runtime:

  • Una possibile NullPointerException se dimentichi di inizializzare lens .
  • ArrayIndexOutOfBoundException se si ottiene un indice errato.

Si noti che il compilatore può contrassegnare i rischi sopra indicati come errori o avvisi, ma non in tutti i casi.

Ma il rovescio della medaglia è che questo potenzialmente ti permette di indicizzare l'array lens , che potrebbe semplificare il tuo algoritmo.

Quale è il migliore?

1. È una questione di opinione!
2. La mia opinione è che l'opzione 1 o 3 sia la migliore ... a seconda del contesto .

^{1 - Lo dico senza prove, e noto che ci sono definizioni concorrenti su cosa "numeri naturali" sono. Tuttavia, se chiedi a qualcuno di contare fino a dieci, la maggior parte delle persone inizieranno da zero, non a zero. Il conteggio da uno è radicato nel processo di pensiero della maggior parte delle persone. Se questa è una buona cosa, è fuori questione. La leggibilità riguarda gli schemi di pensiero reali delle persone reali ... non su come l'autore del codice pensa che i lettori del suo codice dovrebbero pensare.}

Assegna un nome alle tue variabili in modo che i loro nomi denotino esattamente qual è il loro scopo. Non chiamarli var0, var1, var2. Presumo che questo var fosse solo un esempio, ma il principio è valido. Sii preciso quando dai il nome alle variabili. Se si scorre due schermate verso il basso e si guarda il codice, si sarebbe in grado di dire quale sia lo scopo della variabile solo dal suo nome? Questo dovrebbe essere il tuo criterio principale.

Se hai bisogno di raggruppare le variabili, quindi crea una classe incapsulante o una struct, ma anche in questo caso fai attenzione a come assegni gli attributi della classe / struct e della classe / struct stessa (vedi il primo paragrafo).

Modifica in base alla domanda modificata

Len o lunghezza è OK. Se hai bisogno di scrivere un algoritmo per un triangolo, allora l'opzione 1 o l'opzione 3 sono entrambi OK, anche se chiamerei le variabili: 1. triangleSideLengthX (X è 1, 2, 3 o addirittura A, B, C) nel primo caso 2. triangleSideLengths (array) nel secondo caso.

In alternativa, vorrei creare una classe come questa:

class TriangleSidesLengths {
    public float sideALength;
    public float sideBLength;
    public float sideCLength;
 }

Tutti dovrebbero sapere esattamente cosa indicano la classe e i suoi membri, poiché i lati del triangolo sono solitamente indicati con lettere in geometria.

Potresti utilizzare lo stesso approccio per N-groviglio.

Modifica

Ho aggiunto la parola "lunghezza" al nome della classe e ai nomi dei suoi attributi, in modo che i nomi fossero più chiari. Tuttavia, potrebbe essere eccessivo, perché anche se i nomi degli attributi di per sé potrebbero essere un po 'ambigui, se accoppiati con il loro tipo, indicano chiaramente una cosa: la lunghezza del lato.

Tutte le tue opzioni sono pessime. I nomi delle variabili dovrebbero riflettere il contenuto della variabile - so già che è una variabile, quindi chiamarla var0 non aggiunge assolutamente nulla a ciò che so già. Se sono cose che sono logicamente una sequenza, quindi inserirle in una matrice, ma denominare l'array in modo appropriato: events o qualsiasi altra cosa. Se non sono logicamente in una sequenza, chiamali solo per quello che sono: startEvent , endEvent e qualsiasi altra cosa ti serva.

Nel codice, la denominazione delle variabili dovrebbe esprimere ciò che stai cercando di fare. Nel contesto dell'utilizzo di tre linee per verificare se creano un triangolo, lo si vorrebbe trasmettere nella denominazione delle variabili.

Le opzioni 1 e 2 sono esattamente le stesse, trasmettono la stessa cosa. Li chiamerei lineLengthA , lineLengthB , lineLengthC , perché:

• len è ambiguo
• non stiamo parlando solo di lunghezze arbitrarie
• stiamo comunicando stiamo parlando di costrutti geometrici, in questo caso segmenti di linea
• sostituendo 1,2,3 con A, B, C convogliamo che non ci interessa l'ordine dei parametri.
• i nomi di auto-documentazione, la gente saprà immediatamente cosa rappresentano questi parametri.

In alternativa puoi chiamare questi lineSegmentLengthX , segmentLengthX o edgeLengthX per ragioni simili.

Questo sembra così:

...
public boolean canCreateValidTriangle(float lineLengthA, float lineLengthB, float lineLengthC){
     ...
}
...

Come per l'opzione del terzo array, questa opzione è preferibile se si ha una lingua in cui è possibile definire i tipi di array a dimensione fissa (come C ++ con std::array<type, size> ), tuttavia non sono consapevole che una tale funzione sia possibile in java, come primitiva i tipi generici non esistono nella lingua AFAIK. Senza questa funzionalità, l'utente del tuo programma non sa come passare correttamente un array alla funzione senza una congettura istruita, guardando all'implementazione o commentando effettivamente che questo è il modo in cui la funzione deve essere utilizzata (che potrebbe cambiare) .

Quindi per java, non avrei passato un array di 3 elementi, a meno che non lo avessi avvolto in un'altra classe (diciamo, " ThreeElementArray<T> "), che solleva altri problemi.

Altre persone hanno suggerito di inserire i tre parametri nella propria classe. Secondo me questo non è un buon modo per fare le cose in questo caso. Se crei una classe POD solo per questa istanza probabilmente non sarai in grado di trovare abbastanza metodi da creare per giustificare la sua esistenza oltre a essere una classe di dati . Quando si crea una classe dati, si finisce per scrivere codice procedurale e non si ottiene alcun beneficio dall'astrazione.

Con un ThreeElementArray<T> potresti essere ingannato nel pensare di non avere una classe Data dato che probabilmente fornirai metodi per l'indicizzazione e le normali operazioni di lunghezza e array, ma quello che stai facendo è solo delegare la stessa funzionalità che esiste già nell'oggetto di matrice incapsulato che contiene per fare la stessa cosa ma direttamente sulla classe come una chiamata di funzione. Non è diverso dal fare Myclass.mymember.mymemberfunction(); . Questo non vuol dire che non dovrebbe fare questo durante la creazione di una classe, ma che dovresti avere altre funzioni che giustificano l'esistenza della classe in primo luogo.

Altri hanno suggerito di usare una "classe Triangolo", ovviamente una classe triangolo avrà funzioni che esulano dall'ambito di un array di tre elementi, quindi è giusto? Il problema con questo metodo è il passaggio di lunghezze della linea non un triangolo . Stai testando se quelle lunghezze di linea potrebbero essere un triangolo, il fatto di passare in un triangolo non ha già senso. Quelle linee non possono formare un triangolo valido e quindi il tuo oggetto triangolo non dovrebbe esistere. Se stai semplicemente usando la classe triangolo per contenere quelle lunghezze di linea che sono estremamente fuorvianti, stai dicendo al programmatore "questo è un triangolo" quando chiaramente non lo è, e potrebbe anche non formarne uno valido. Passare come un triangolo ti impedisce anche di essere in grado di passare a lunghezze di linea arbitrarie, e ricorda, non ci interessa l'ordine delle lunghezze delle linee o da dove provengono.