Utilizzo dei nomi di variabili a carattere singolo per i parametri di funzione? [duplicare]

Nel tuo esempio fattoriale è perfettamente OK.

Un esempio di come non sarebbe OK è:

public int calculateInterest(int x, int y, int z){
      //////
}

Perché per calcolare l'interesse è necessario passare principal, rate e time.

• Il coder dovrebbe passare in quell'ordine asumming x è principal, y è rate e z è time?

Penso di no.

public int calculateInterest(int principal, int rate, int time){
      //////
}

In questa risposta da una domanda simile c'è una lista di casi accettabili per un singolo carattere o due caratteri nomi di variabili.

L'uso di un nome significativo per i parametri di funzione è un modo per rendere il codice auto-documentato e dovresti farlo sempre.

Tuttavia, ci sono alcune situazioni in cui può introdurre verbosità inutili o addirittura confusione. In questi casi è ok usare una singola lettera. Ad esempio:

1. Funzioni puramente aritmetiche che richiedono un singolo numero (in genere x ).
   • OK: factorial(x) , sin(x) , ecc.
   • Non necessario: abs(number)
2. Quando esistono lettere convenzionali.
   • OK: vectorLength(x0, y0, x1, y1) , repeat(something, n) .
   • Ovviamente non OK: dotProduct(vector0horizontalComponent, vector0verticalComponent , vector1horizontalComponent, vector2verticalComponent) ,
   • Inutilmente verboso: repeat(something, numberOfRepetitions)
3. Funzioni banali e piccole espressioni lambda.
   • OK: div(x,y) = x/y , map(u -> u.address.country, users)
   • Inutilmente verboso (ma ok):, div(numerator, denominator) , map(user -> user.address.country, users)
4. Codice altamente generico. Spesso visto nel codice funzionale, specialmente quando si usa la destrutturazione.
   • OK: map(f, [x, xs]) = if xs == [] then [] else [f(x)] + map(f, xs)
   • Inutilmente verbose: map(functionToApply, [firstElementOfList, restOfList]) = ... .

Quando la leggibilità all'interno di una funzione è un problema, ricorda che puoi sempre utilizzare una variabile per rinominarne un'altra localmente, ad esempio:

function getRotationMatrix(angle) {
    var t = angle;
    return new Matrix([
        [+cos(t), -sin(t), 0],
        [+sin(t), +cos(t), 0],
        [0,       0,       1],
    ]);
}

La regola che seguo è quella di mantenere i nomi (per variabili, parametri o anche funzioni / metodi / classi) il più breve possibile pur rimanendo perfettamente chiari nel contesto. Il che significa, tra le altre cose:

• I nomi più lunghi sono inutili se non contengono informazioni utili sulla variabile. E.g: userInstance , TextInput0 , TextInput1
• I nomi più lunghi sono inutili se contengono informazioni ridondanti: E.g. intYear , userList , UrlUtils.getUrlParser(...).parseUrl()
• Evita le abbreviazioni perché non sono quasi mai totalmente ambiguo (eccetto quelle comuni nella lingua o nel dominio)

TLDR: usa nomi purché necessari , non più brevi, non più.