Rappresentazione di un punto interrogativo in nomi variabili [chiuso]

Questo non sarebbe davvero universalmente compreso, quindi non lo consiglierei.

Inoltre, alcune lingue usano effettivamente ? per verificare se una variabile è definita, quindi se hai chiamato una variabile CompletedP e vuoi controllare se è definita, sarebbe CompletedP? . Questo mi limiterebbe il mal di testa.

In generale, dove penso che questo potrebbe essere appropriato, cambierei semplicemente il nome della variabile in una domanda ovvia. Quindi le seguenti variabili potrebbero essere rinominate:

• TaskACompleted? - > %codice%
• IsTaskACompleted - > %codice%

ecc.

Nelle lingue con una sintassi malleabile come Lisp o Scala, il punto interrogativo è in effetti consentito e viene spesso utilizzato per contrassegnare le funzioni booleane.

Dove non lo è, non ho mai visto una P sostituita a imitare un ? . isValidP() non assomiglia molto a ? per me.

In effetti esiste una certa tradizione di utilizzo di un suffisso di P per contrassegnare predicati (es. funzioni booleane), ma il P indica "predicato", non la forma di ? . (Stranamente, questo è anche prevalente in Lisp, quindi presumo che fosse da un tempo o dal dialetto che non in realtà consentiva ? negli identificatori.)

Molte comunità hanno convenzioni di denominazione per fare sporgere i predicati. In Java, hanno come prefisso has o is ( isEven ), in Ruby e Scheme, sono suffissi con ? ( even? ) e in alcuni altri linguaggi, sono suffissi con p o _p ( evenp , even_p ). A prima vista, ha un odore un po '"cattivo ungherese", ma in realtà trovo che rende il codice più scorrevole.

Haskell non usa alcun marcatore, si fidano dei tipi (tutto ciò che restituisce un Bool è un predicato, ad esempio even :: Integral a ⇒ a → Bool ).

Se la tua comunità utilizza e comprende questa convenzione, dovresti seguirla.

I predicati di denominazione che terminano con p sono in effetti piuttosto comuni, ma ciò non ha nulla a che vedere con l'aspetto della lettera p , è semplicemente un'abbreviazione di "predicato". Ecco un esempio di alcune funzioni della specifica ANSI CommonLISP:

• adjustable-array-p
• alpha-char-p
• alphanumericp
• array-has-fill-pointer-p
• array-in-bounds-p
• arrayp
• bit-vector-p
• both-case-p
• boundp
• char-greaterp
• char-lessp
• char-not-greaterp
• char-not-lessp
• characterp
• compiled-function-p
• complexp
• consp
• constantp
• digit-char-p
• endp
• equalp
• evenp
• fboundp
• floatp
• functionp
• graphic-char-p
• hash-table-p
• input-stream-p
• integerp
• interactive-stream-p
• keywordp
• listp
• logbitp
• lower-case-p
• minusp
• next-method-p
• numberp
• oddp
• open-stream-p
• output-stream-p
• packagep
• pathname-match-p
• pathnamep
• plusp
• random-state-p
• rationalp
• readtablep
• realp
• simple-bit-vector-p
• simple-string-p
• simple-vector-p
• slot-boundp
• slot-exists-p
• special-operator-p
• standard-char-p
• streamp
• string-greaterp
• string-lessp
• string-not-greaterp
• string-not-lessp
• stringp
• subsetp
• subtypep
• symbolp
• tailp
• typep
• upper-case-p
• vectorp
• wild-pathname-p
• y-or-n-p
• yes-or-no-p
• zerop

In Groovy, il punto interrogativo ha alcune funzionalità.

Immagina di avere una società e potrebbe o meno avere una posizione inserita nel sistema. Lo stesso vale per i suoi interi campi di indirizzi. Ora, se voglio ottenere il nome della via, in linguaggi simili come Java, dovrei occuparmi di valori nulli. Non in Groovy!

String streetName = company.getLocation()?.getStreet()?.getStreetName();

Detto ciò, penso che sia una cattiva idea includere ? nel nome di variabili / metodi. Anche P non può sostituirlo, non mi sembra un codice leggibile, sceglierebbe hasButtonChanged () invece di buttonChangedP () ogni volta, giorno e notte.

L'uomo che mi ha insegnato a programmare molti anni fa una volta mi ha detto questo -

"Qualsiasi maledetto idiota può scrivere codice che un computer possa capire. Scrivere un codice che un umano può capire richiede abilità".

In generale, qualsiasi cosa che renda il tuo codice meno leggibile dall'uomo è un'idea davvero pessima. Soprattutto selezionando caratteri arbitrari per sostituire caratteri che potrebbero facilmente essere sfuggiti.