Costanti di stringa private per chiavi di mappa

Question

Costanti di stringa private per chiavi di mappa

#1 da (7 voti)
#2 da (2 voti)
#3 da (2 voti)

2

È buona prassi definire stringhe costanti private che hanno lo stesso nome dei loro valori? Prendi ad esempio il seguente codice.

public class Example {

    private static final String FIRST_KEY = "firstKey";
    private static final String SECOND_KEY = "secondKey";
    private static final String THIRD_KEY = "thirdKey";
    private static final String SOME_KEY = "someKey";
    private static final String SOME_OTHER_KEY = "someOtherKey";
    private static final String BLAH = "blah";

    public Map<String, Object> createMap() {
        Map<String, Object> map = new HashMap<>();
        map.put(FIRST_KEY, getFromDB());
        map.put(SECOND_KEY, computeValue2());
        map.put(THIRD_KEY, computeValue3());
        map.put(SOME_KEY, "any value");
        map.put(SOME_OTHER_KEY, new Object());
        map.put(BLAH, new Object());
        return map;
    }

    ...

}

Credo che questo non aggiunga alcun valore quando sono usati una sola volta (o forse anche due volte). Sono sicuramente più difficili da leggere quando controllo alcuni contenuti generati da JSON dalla mappa. Devo passare alla definizione costante per assicurarmi che la chiave JSON e la chiave della mappa siano effettivamente le stesse. Questa convenzione è stata utilizzata in molti progetti su cui ho lavorato e non ho ancora capito perché. Il refactoring più semplice non dovrebbe essere il motivo se le chiavi non vengono utilizzate troppe volte. A mio avviso, è un uso eccessivo delle costanti di stringa. Le costanti di stringa private sono utili, quando i loro nomi spiegano veramente il contenuto ma in questo esempio non lo fanno (e sono fondamentalmente solo copie).

clean-code

posta Karol Lewandowski 25.03.2016 - 14:31

fonte

3 risposte

Leggi altre domande sui tag clean-code

E 'possibile che un sistema di computer abbia un carico costante / zero della CPU? Come posso spiegare perché il controllo della versione è una buona idea? [chiuso]

score 7 · Answer 1

Le costanti di stringa sono ridondanti, se le utilizzi una sola volta. Ma non appena hai due usi (anche nella stessa classe), è meglio avere una costante di stringa.

Se la costante di stringa viene utilizzata solo una volta, ma è necessario identificare la stringa nel codice per possibili usi futuri, allora è meglio mantenere costante la stringa.

Se quelle stringhe verranno utilizzate solo per definire la mappa, direi "no". Basta metterli sulla mappa, direttamente. Ad esempio, potresti eseguire il mapping a una tabella in un database e potrebbe non dover mai fare riferimento alla mappa direttamente nel codice.

Se le stringhe verranno utilizzate altrove nel programma per cercare elementi dalla mappa, allora sì, hai bisogno di costanti di stringa. Ma poi devono essere definiti pubblicamente, in modo che il resto del codice possa accedervi.

score 2 · Answer 2

Direi che const string è migliore di un letterale stringa, ma nella maggior parte dei casi non sono particolarmente buoni.

Se si dispone di un insieme discreto di nomi correlati che sono logicamente intercambiabili, utilizzare il sistema di tipi. Se un nuovo tipo completo è eccessivo, utilizzare almeno un'enumerazione. Le dimensioni delle immagini, ad esempio, sarebbero meglio modellate come imo di enumerazione.

Un'altra prospettiva è l'ambito. Certo, non è molto bello se una classe inizia con 20 righe di dichiarazioni const (a meno che non si tratti di una classe che è effettivamente pensata per la memorizzazione di alcuni valori costanti), ma questo potrebbe benissimo essere un problema di scoping. A meno che i valori non vengano utilizzati globalmente, trascinali in privato. A meno che non vengano utilizzati nell'intera classe, trascinali in un ambito locale o incapsulali nel loro tipo che può essere referenziato / trasferito dove è necessario.

Sicuramente penso che il tuo codice di esempio sia orribile, ma questo non è dovuto alle costanti. È perché ha una coesione abissale. Non c'è attenzione e non è chiaro a cosa serve la classe, quindi è difficile dire come dovrebbe "guardare".

score 2 · Answer 3

Se accidentalmente digiti in modo errato una stringa letterale, il tuo codice verrà compilato felicemente e non lo sarà fino al momento dell'esecuzione quando inizia a comportarsi in modo irregolare. Se invece avessi usato costanti con nome, avresti ottenuto un errore in fase di compilazione che ti indirizza esattamente all'errore di battitura. Naturalmente, si può ancora scrivere in modo errato la definizione costante, ma almeno, sarà quindi errata in modo coerente.

Come Robert Harvey parla , se hai bisogno solo della costante una volta, non viene ottenuto nulla dall'uso della costante nominata. Ma attenzione alle future aggiunte al codice. Vorrei aggiungere che in un linguaggio dinamico (uno che non viene controllato sintatticamente staticamente) i benefici sono ridotti, ma è ancora meglio ottenere un errore di run-time che dice che una variabile viene usata prima della definizione rispetto al fatto che il codice si comporta in modo errato. / p>