Perché alla gente piace la distinzione tra maiuscole e minuscole? [chiuso]

https://stackoverflow.com/questions/165455

03-07-2019
|

Domanda

Ti stai solo chiedendo perché alla gente piace la distinzione tra maiuscole e minuscole in un linguaggio di programmazione? Non sto cercando di iniziare una guerra di fiamme, solo curioso che sia tutto.
Personalmente non mi è mai piaciuto molto perché trovo che la mia produttività diminuisce ogni volta che ho provato un linguaggio che ha la distinzione tra maiuscole e minuscole, sia chiaro che mi sto lentamente riscaldando / abituandomi ora che sto usando C # e F # molto più di allora Prima.

Allora perché ti piace?

Saluti

Soluzione

coerenza. Il codice è più difficile da leggere se "pippo", "pippo", "fOO", e "foo" sono considerati identici.

ALCUNE PERSONE SCRIVONO TUTTO IN TUTTE LE MAIUSCOLE, RENDENDO TUTTO MENO LEGGIBILE.

La distinzione tra maiuscole e minuscole semplifica l'uso dello stesso nome " in diversi modi, secondo una convenzione di capitalizzazione, ad es.

Foo foo = ...  // "Foo" is a type, "foo" is a variable with that type

Altri suggerimenti

Un vantaggio di VB.NET è che sebbene non sia sensibile al maiuscolo / minuscolo, l'IDE riformatta automaticamente tutto in "ufficiale" caso per un identificatore che stai utilizzando, quindi è facile essere coerente, facile da leggere.

Lo svantaggio è che odio la sintassi in stile VB e preferisco di gran lunga operatori in stile C, punteggiatura e sintassi.

In C # trovo che premo sempre Ctrl-Spazio per evitare di dover usare il tipo corretto.

Solo perché puoi nominare cose che differiscono solo per caso non significa che sia una buona idea, perché può portare a fraintendimenti se molto di ciò si perde in ambiti più grandi, quindi ti consiglio di evitarlo all'applicazione o a livello di sottosistema, ma consentendolo solo internamente a una funzione, metodo o classe.

La distinzione tra maiuscole e minuscole non applica stili di codifica o coerenza. Se hai una costante costante, il compilatore non si lamenterà. Ti costringerà semplicemente a digitarlo usando il caso pascal ogni volta che lo usi. Personalmente trovo irritante dover cercare di distinguere tra due elementi che differiscono solo nel caso. È facile da fare in un breve blocco di codice, ma è molto difficile mantenerlo dritto in un blocco di codice molto grande. Si noti inoltre che l'unico modo in cui le persone possono effettivamente utilizzare la distinzione tra maiuscole e minuscole senza impazzire è se tutti seguono rigidamente le stesse convenzioni di denominazione. È la convenzione di denominazione che ha aggiunto il valore, non la distinzione tra maiuscole e minuscole.

Mantengo un compilatore interno per la mia azienda e sono tentato di renderlo un ibrido: puoi usare qualsiasi caso tu voglia per un identificatore e devi fare riferimento ad esso con lo stesso involucro, ma nominando qualcos'altro con il lo stesso nome e un caso diverso causeranno un errore.

Dim abc = 1
Dim y = Abc - 1 ' error, case doesn't match "abc"
Dim ABC = False ' error, can't redeclare variable "abc"

Attualmente non fa distinzione tra maiuscole e minuscole, quindi probabilmente potrei correggere i pochi errori esistenti e nessuno si lamenterebbe troppo ...

Molte persone a cui piace la maiuscole / minuscole sensibilità fraintendono il significato di maiuscole / minuscole in .

VB .NET non distingue tra maiuscole e minuscole. Ciò non significa che puoi dichiarare una variabile come abc, quindi riferirti ad essa come ABC, Abc e aBc. Significa che se lo digiti come uno di quegli altri, l'IDE lo cambierà automaticamente nella forma corretta.

La distinzione tra maiuscole e minuscole significa che è possibile digitare

dim a as string

e VS lo cambieranno automaticamente nel caso corretto

Dim a As String

In pratica, questo significa che non devi quasi mai premere il tasto Maiusc, perché puoi digitare tutte le lettere minuscole e lasciare che l'IDE sia corretto per te.

Ma C # non è poi così male come una volta. Intellisense in C # è molto più aggressivo di quanto non fosse in VS 2002 e 2003, quindi il conteggio dei tasti è leggermente diminuito.

Credo che rafforzi la coerenza, migliorando la leggibilità del codice e lasciando che il tuo occhio analizzi meglio i pezzi.

class Doohickey {

  public void doSomethingWith(string things) {
     print(things);
  }
}

L'uso delle convenzioni del case fa apparire quel codice molto standardizzato per qualsiasi programmatore. Puoi scegliere facilmente classi, tipi e metodi. Sarebbe molto più difficile da fare se qualcuno potesse capitalizzarlo in alcun modo:

Class DOOHICKEY {
  Public Void dosomethingwith(string Things) {
    Print(things);
  }
}

Per non dire che le persone scriverebbero codice brutto, ma molto nel modo in cui le regole di maiuscole e punteggiatura rendono la scrittura più facile da leggere, la distinzione tra maiuscole e minuscole o gli standard del case rendono più facile la lettura del codice.

Credo che sia importante comprendere la differenza tra la sensibilità del case e la leggibilità per rispondere correttamente. Sebbene sia utile avere diverse strategie di involucro, puoi averle in una lingua che non distingue tra maiuscole e minuscole.

Ad esempio foo può essere usato per una variabile e FOO come costante sia in Java che in VB. C'è la piccola differenza che VB ti permetterà di digitare fOo in seguito, ma questa è principalmente una questione di leggibilità e si spera che sia risolta da una qualche forma di completamento del codice.

Ciò che può essere estremamente utile è quando vuoi avere istanze dei tuoi oggetti. Se usi una convenzione di denominazione coerente, può diventare molto facile vedere da dove provengono i tuoi oggetti.

Ad esempio: FooBar fooBar = new FooBar ();

Quando è necessario un solo oggetto di un tipo, la leggibilità aumenta in modo significativo in quanto è immediatamente evidente quale sia l'oggetto. Quando sono necessarie più istanze, dovrai ovviamente scegliere nuovi (nomi che si spera siano significativi), ma in piccole sezioni di codice ha molto senso usare il nome della classe con un primo carattere minuscolo piuttosto che un sistema come myFooBar, x, o qualche altro valore arbitrario che ti dimenticherai di ciò che fa.

Ovviamente tutto questo è una questione di contesto, tuttavia in questo contesto direi 9 volte su 10 che ripaga.

Ci sono molte risposte qui, ma sono sorpreso che nessuno abbia sottolineato l'ovvio esempio che prende in giro anche un concorrente di stackoverflow:

expertSexChange != expertsExchange

Il caso è molto importante quando si usano i nomi delle variabili del caso cammello.

Ti dà più opzioni.

Campana campana BELL

sono tutti diversi.

Inoltre, spinge i neofiti che sono stati appena assunti a cercare di scoprire perché i totali non stanno uscendo nel modo giusto; o)))

Perché ora devi digitare tutto in modo coerente. E poi le cose iniziano improvvisamente a dare un senso.

Se hai un editor decente - uno che presenta IntelliSense o la stessa cosa con un altro nome - non dovresti avere problemi a capire i nomi con distinzione tra maiuscole e minuscole.

La distinzione tra maiuscole e minuscole è una follia! Che tipo di programmatore folle userebbe le variabili denominate foo, foO, fOo e fOO tutte nello stesso ambito? Non mi convincerai mai che esiste una ragione per la distinzione tra maiuscole e minuscole!

Penso che ci sia anche un problema di psicologia coinvolto qui. Siamo programmatori, distinguiamo minuziosamente tra le cose. 'a' non è lo stesso valore ASCII di 'A', e mi sentirei strano se il mio compilatore li considerasse uguali. Ecco perché, quando scrivo

(elenca 'a' b 'c)

in LISP (nella REPL) e risponde con

(A B C)

la mia mente esclama immediatamente "Non è quello che ho detto!". Quando le cose non sono le stesse, sono diverse e devono essere considerate così ...

Di solito passo un po 'di tempo con la programmazione Delphi in vacanza, e la maggior parte delle altre volte uso solo C ++ e MASM. E una cosa è strana: quando sono su Delphi, non mi piace la distinzione tra maiuscole e minuscole, ma quando sono su C ++ - lo faccio. Mi piace la distinzione tra maiuscole e minuscole, perché rende simili parole (funzioni, variabili) simili e mi piace la non-distinzione tra maiuscole e minuscole perché non pone restrizioni eccessive sulla sintassi.

Da Guida per gli sviluppatori di .NET Framework Convenzioni di capitalizzazione , Case-Sensitivity:

Esistono le linee guida per la capitalizzazione   unicamente per facilitare gli identificatori   leggi e riconosci. L'involucro non può essere   usato come mezzo per evitare il nome   collisioni tra elementi della biblioteca.

Non dare per scontato che tutta la programmazione   le lingue fanno distinzione tra maiuscole e minuscole. Loro sono   non. I nomi non possono differire per caso   da solo.

È utile per distinguere i tipi nel codice.

Ad esempio in Java: Se inizia con una lettera maiuscola, probabilmente è una classe. se il suo ALL_CAPS è probabilmente una costante.

Offre maggiore versatilità.

Sembra un modo più professionale di codifica. Non dovrebbe essere necessario il compilatore per capire cosa intendevi.

Mi sentivo allo stesso modo molto tempo fa quando ho usato VB3 / 4 molto di più. Ora lavoro principalmente in C #. Ma ora trovo che gli IDE facciano un ottimo lavoro nel trovare i simboli e nel dare una buona intelligenza ai diversi casi. Mi dà anche maggiore flessibilità nel mio codice in quanto posso avere un significato diverso per gli articoli con casi diversi, cosa che faccio molto ora.

Anche una buona abitudine se lavori in Linux in cui fare riferimento ai nomi dei file fa distinzione tra maiuscole e minuscole. Ho dovuto eseguire il porting di un'applicazione Windows ColdFusion per funzionare in Linux ed è stato un vero incubo. Inoltre, alcuni database hanno attivato la distinzione tra maiuscole e minuscole, immagina la gioia lì.

È una buona abitudine, indipendentemente dalla piattaforma e certamente porta a uno stile di sviluppo più coerente.

IMHO è interamente una questione di abitudine. Qualunque sia la persona a cui sei abituato sembrerà naturale e giusto.

Puoi trovare molte giustificazioni sul perché sia ??buono o cattivo, ma nessuno di loro contiene molta acqua. Ad esempio:

Ottieni più identificatori possibili, ad es. foo vs Foo vs FOO .
Ma avere identificatori che differiscono solo nel caso non sia una buona idea
Puoi codificare informazioni-tipo in un nome (ad es. FooBar = typename, fooBar = function, foo_bar = variabile, foo_bar = macro)
Ma puoi farlo comunque con la notazione ungherese

Perché funziona anche il linguaggio naturale.

Nel programmare c'è qualcosa da dire per la distinzione tra maiuscole e minuscole, ad esempio avere una proprietà pubblica Foo e un corrispondente campo privato / protetto foo. Con IntelliSense non è molto difficile non commettere errori.

Tuttavia, in un sistema operativo, la distinzione tra maiuscole e minuscole è semplicemente pazza. Non voglio davvero avere un file Foo e foo e fOO nella stessa directory. Questo mi fa impazzire ogni volta che faccio cose * nix.

Per me la distinzione tra maiuscole e minuscole è solo un gioco su ambiti come thisValue per un argomento e ThisValue per una proprietà o funzione pubblica.

Più spesso devi usare lo stesso nome di variabile (in quanto rappresenta la stessa cosa) in ambiti diversi e la distinzione tra maiuscole e minuscole ti aiuta a farlo senza ricorrere a prefissi.

Oh, almeno non stiamo più usando la notazione ungherese.

Dopo aver lavorato per molti anni con il codice ASP VBScript legacy, quando siamo passati a .NET abbiamo scelto C # e uno dei motivi principali era la distinzione tra maiuscole e minuscole. Il vecchio codice era illeggibile perché le persone non seguivano nessuna convenzione: il codice era un pasticcio illeggibile (bene, gli IDE VBScript scadenti mi aiutavano in questo).

In C # possiamo definire convenzioni di denominazione e tutti devono seguirle. Se qualcosa non è inserito correttamente, puoi rinominarlo (con refactoring, ma si tratta di una funzione IDE) e non ci saranno problemi perché la classe o la variabile verranno denominate allo stesso modo in tutto il codice.

Infine, penso che sia molto più leggibile se tutto è inserito correttamente. Forse è più veloce scrivere senza distinzione tra maiuscole e minuscole, ma da un punto di revisione e mantenimento del codice non è la cosa migliore perché saltare il codice alla ricerca di qualcosa è più facile. Ad esempio è più facile trovare tutte le stringhe 'foo' in un colpo d'occhio piuttosto che cercare 'foo', 'Foo', 'FOO', 'FOo' ...

I linguaggi senza distinzione tra maiuscole e minuscole non si generalizzano facilmente con set di caratteri non ASCII. La corretta conversione dei casi in una lingua diversa dall'inglese non è un compito semplice e dipende, tra le altre cose, dalle impostazioni locali del sistema.

L'insensibilità al maiuscolo / minuscolo è molto difficile, a meno che non si limiti la sintassi ad ascii (o si applica solo l'insensibilità al maiuscolo / minuscolo ai caratteri ascii) e inoltre è necessario limitare le impostazioni internazionali.

Le regole per determinare i caratteri maiuscoli e minuscoli non sono né ben definite, né senza perdita di dati.

Alcuni personaggi possono avere più di una forma "minuscola". Alcune persone non saranno d'accordo su quale dovrebbe essere la forma maiuscola corretta.

(Alcune lingue e ambienti consentono l'utilizzo di quasi caratteri nei nomi)

Prendi in considerazione In C # qual è la differenza tra ToUpper () e ToUpperInvariant ()?

Autorizzato sotto: CC-BY-SA insieme a attribuzione

Non affiliato a StackOverflow