Qual è il punto della parola chiave var?
https://stackoverflow.com/questions/209199
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianDomanda
La parola chiave var elimina la necessità di un esplicito dichiarazione di tipo e ho letto con interesse la discussione SO su quando potrebbe essere . appropriato
Ho anche letto (ma non utilizzato) Boo che sembra prendere le cose un fare un ulteriore passo facoltativo per dichiarare una variabile locale . Con Boo, sia il tipo che la dichiarazione possono essere impliciti.
Il che mi porta a chiedermi, perché i progettisti del linguaggio C # si sono presi la briga di includere una parola chiave var?
Aggiorna : Sì, var supporta i tipi anonimi, ma i tipi anonimi da soli non richiedono la parola chiave var ...
var anon = new { Name = "Terry", Age = 34 };
vs
anon = new { Name = "Terry", Age = 34 };
Soluzione
Aggiornamento: ci sono due domande correlate qui, in realtà: 1. Perché devo dichiarare delle variabili? 2. A che serve " var " in una lingua che ti fa dichiarare variabili?
Le risposte a (1) sono numerose e possono essere trovate altrove per questa domanda. La mia risposta a (2) è di seguito:
Come altri commentatori hanno detto, LINQ lo usa per i suoi tipi anonimi. Tuttavia, LINQ è in realtà un'istanza di un problema più generale in cui il tipo del lato destro di un'espressione non è noto al programmatore o è estremamente dettagliato. Prendere in considerazione:
SomeGeneric<VeryLongTypename<NestedTypename>> thing = new
SomeGeneric<VeryLongTypename<NestedTypename>>();
Verbose e soggetto a errori, giusto? Quindi ora ti permettono di fare questo:
var thing = new SomeGeneric<VeryLongTypename<NestedTypename>>();
Riducendo la duplicazione delle informazioni, gli errori vengono eliminati. Nota che non ci sono solo errori di battitura, qui: è possibile che il tipo dell'espressione per la mano sinistra sia mal digitato in modo tale che il compilatore possa eseguire il cast silenzioso da sinistra a destra, ma il cast in realtà perde alcune proprietà del rvalue. Ciò è ancora più importante quando i tipi restituiti dal valore possono essere sconosciuti o anonimi.
Altri suggerimenti
Senza la parola chiave var diventa possibile creare accidentalmente una nuova variabile quando si intendeva effettivamente utilizzare una variabile già esistente. per es.
name = "fred";
...
Name = "barney"; // whoops! we meant to reuse name
Capisco la necessità di var e serve allo scopo. Non avere parole chiave e definire al volo variabili senza tipo è spaventoso. Fai del male al prossimo che deve mantenere il tuo codice o te stesso se devi rielaborare il codice che non hai toccato da oltre un anno. Non sono sicuro che si tratti di una porta che dovrebbe essere aperta in C # e spero che non lo sia poiché var sta già causando problemi di leggibilità quando viene utilizzato in eccesso quando non è necessario.
Quasi ogni esempio di .net 3.5 che sto vedendo ultimamente ha tutte le variabili definite con var.
L'argomento che sostengo è che sacrifica davvero la leggibilità per salvare le sequenze di tasti quando viene utilizzato in modo eccessivo. Ad esempio:
// What myVar is, is obvious
SomeObject myVar = new SomeObject();
// What myVar is, is obvious here as well
var myVar = new SomeObject();
Il problema che vedo è che le persone lo usano ovunque ... ad esempio:
// WTF is var without really knowing what GetData() returns?
// Now the var shortcut is making me look somewhere else when this should
// just be readable!
var myVar = GetData();
// If the developer would have just done it explicitly it would actually
// be easily readable.
SomeObject myVar = GetData();
Quindi il prossimo argomento sarà, basta dare un nome alla funzione migliore ...
var weight = GetExactWeightOfTheBrownYakInKilograms();
Ancora non so cosa sta tornando. È un oggetto int, decimale, float, peso, cosa? Devo ancora perdere tempo a cercarlo ... ho bisogno della stampella intellisense per salvare la giornata dalla mia programmazione pigra. Forse includere il tipo restituito nel nome della funzione. Buona idea, ora l'utilizzo di var non ci ha salvato nulla se non il fatto che tutte le mie funzioni hanno nomi lunghi reali.
Penso che la gente abbia appena finito di usare var e questo sta portando a una programmazione pigra che a sua volta porta a una lettura del codice più difficile. Ogni volta che scrivi la parola chiave var, dovresti avere una buona ragione per usarla invece di essere esplicita.
Questo è un po 'soggettivo, ma penso che progettare C # 3.0 per avere il "var" la parola chiave per le variabili tipizzate in modo implicito anziché nessuna parola chiave rende il codice più leggibile. Ad esempio, il primo blocco di codice di seguito è più leggibile del secondo:
Ovvio dove viene dichiarata la variabile:
var myVariable = SomeCodeToSetVariableHere;
myVariable = SomeOtherCodeTOSetVariable;
Non ovvio dove viene dichiarata la variabile:
myVariable = SomeCodeToSetVariableHere;
myVariable = SomeOtherCodeTOSetVariable;
Questi sono esempi semplicistici. Penso che tu possa vedere dove va. In situazioni complesse potrebbe essere bello poter trovare il luogo in cui una variabile è effettivamente definita.
Nella tua domanda, var aggiunge valore al codice dicendo al compilatore che la parola anon è ora legale per l'uso ovunque ti aspetti di vedere un elemento del tipo implicito nell'assegnazione. Richiedere l'introduzione di nomi al compilatore in questo modo consente al compilatore di rifiutare le cose che non sono state esplicitamente dichiarate consentite e quindi catturare alcuni tipi di errori in fase di compilazione in modo che non esplodano in fase di esecuzione.
Ad esempio, nella sezione di aggiornamento della tua domanda, hai chiesto informazioni su questo frammento:
anon = new { Name = "Terry", Age = 34 };
Il problema nel permetterlo in questo modo è che trasforma qualsiasi cosa sul lato sinistro di qualsiasi assegnazione in cui il nome non esisteva in precedenza in una dichiarazione variabile, anche se è davvero un errore di battitura. Se più avanti nel programma assegni qualcos'altro a anon e poi ancora di più sul riferimento al nuovo valore, ma l'istruzione centrale ha un errore di battitura, hai un problema che non verrà visualizzato fino al runtime.
La tua risposta è che Boo lo fa, quindi deve essere a posto o almeno possibile. Ma è un'aringa rossa. Stiamo parlando di C #, non di Boo. Uno degli scopi di C # è di avere un linguaggio in cui il compilatore possa catturare quanti più errori possibile. Anche Boo vuole farlo, ma vuole anche essere più simile a Python. Quindi sacrifica un po ' (non tutto) della sicurezza in fase di compilazione di C # in cambio di una sintassi simile a un pitone.
disclaimer: i miei esempi sono Java perché è quello che conosco, ma i concetti dovrebbero essere identici.
Ho votato a favore della risposta che ritengo fondamentale (è troppo facile creare accidentalmente una nuova variabile).
bill=5;
bi11=bill+5
Qual è il valore del conto?
Detto questo, a volte trovo un po 'irritante digitare:
DataOutputStream ds=new DataOutputStream();
Sembra ridondante, ma onestamente non c'è nulla di veramente sbagliato. Non ci vuole più tempo per digitarlo due volte ed è estremamente utile. Ciò che richiede tempo è quando hai domande, quando non sei sicuro di come utilizzare alcune API. Se ti dà davvero fastidio digitare quel tipo di dichiarazione due volte, allora perché stai perdendo tempo qui? Da quando hai iniziato a leggere questo potresti aver digitato 30 o 40 dichiarazioni, sufficienti per ogni dichiarazione che ti servirà per le prossime due settimane.
Immagino che sto dicendo che sebbene comprenda lo stress emotivo che può causare ripetersi, la coerenza, la chiarezza e la capacità di creare strumenti più intelligenti ne valgono la pena.
Un'altra cosa, la maggior parte delle volte il codice non dovrebbe essere come il mio esempio sopra. Quello che dovresti fare è questo:
DataOutput ds=new DataOutputStream();
Ciò nasconde immediatamente il fatto che si sta utilizzando una classe concreta in un modello. Tale modello dovrebbe essere in grado di eseguire tutte le operazioni necessarie sulla tua classe. In seguito, se si desidera sostituire ds con qualche altro tipo di flusso di output, la semplice modifica di quella singola riga lo risolverà. Se stavi utilizzando le funzionalità non disponibili per DataOutput eseguendo il casting su DataOutputStream, l'editor lo capirà facilmente e ti farà sapere.
Per tipi anonimi, che tra l'altro supportano LINQ.
Credo che var (e diverse altre nuove parole chiave) siano state aggiunte specificamente per supportare Linq.
var è la parola chiave utilizzata per creare un tipo anonimo - vedi http: / /msdn.microsoft.com/en-us/library/bb397696.aspx
I tipi anonimi possono essere utilizzati in luoghi diversi da Linq.
var è estremamente utile per Linq. Infatti, secondo un autore esperto, " Senza & # 8216; var & # 8217 ;, LINQ diventa troppo doloroso da usare. "
