Perché il segno meno, '-', generalmente non è sovraccaricato allo stesso modo del segno più?

Il segno più +viene usato per l'aggiunta e per la concatenazione di stringhe, ma il suo compagno: il segno meno -, generalmente non viene visto per il taglio di stringhe o altri casi diversi dalla sottrazione. Quale potrebbe essere la ragione o le limitazioni per questo?

Considera il seguente esempio in JavaScript:

var a = "abcdefg";
var b = "efg";

a-b == NaN
// but
a+b == "abcdefgefg"

In breve, non ci sono operazioni simili a sottrazioni particolarmente utili su stringhe con cui le persone hanno voluto scrivere algoritmi.

L' +operatore generalmente indica l'operazione di un monoide additivo , cioè un'operazione associativa con un elemento di identità:

• A + (B + C) = (A + B) + C
• A + 0 = 0 + A = A

Ha senso usare questo operatore per cose come l'aggiunta di numeri interi, la concatenazione di stringhe e l'unione di set perché hanno tutti la stessa struttura algebrica:

1 + (2 + 3) == (1 + 2) + 3
1 + 0 == 0 + 1 == 1

"a" + ("b" + "c") == ("a" + "b") + "c"
"a" + "" == "" + "a" == "a"

E possiamo usarlo per scrivere pratici algoritmi come una concatfunzione che funziona su una sequenza di qualsiasi cosa "concatenabile", ad esempio:

def concat(sequence):
    return sequence.reduce(+, 0)

Quando -viene coinvolta la sottrazione , di solito si parla della struttura di un gruppo , che aggiunge un -A inverso per ogni elemento A, in modo che:

• A + −A = −A + A = 0

E mentre questo ha senso per cose come la sottrazione di numeri interi e in virgola mobile, o addirittura imposta la differenza, non ha molto senso per le stringhe e gli elenchi. Qual è l'inverso di "foo"?

Esiste una struttura chiamata monoid cancellativo , che non ha inversioni, ma ha la proprietà di annullamento , in modo che:

• A - A = 0
• A - 0 = A
• (A + B) - B = A

Questa è la struttura che descrivi, dove "ab" - "b" == "a", ma "ab" - "c"non è definita. È solo che non abbiamo molti algoritmi utili che utilizzano questa struttura. Immagino che se pensi alla concatenazione come serializzazione, la sottrazione potrebbe essere utilizzata per un qualche tipo di analisi.

Perché la concatenazione di due stringhe valide è sempre un'operazione valida, ma non è vero il contrario.

var a = "Hello";
var b = "World";

Cosa dovrebbe a - bessere qui? Non c'è davvero un buon modo per rispondere a questa domanda, perché la domanda stessa non è valida.

Perché l' -operatore per la manipolazione delle stringhe non ha abbastanza "coesione semantica". Gli operatori dovrebbero essere sovraccaricati solo quando è assolutamente chiaro cosa fa il sovraccarico con i suoi operandi e la sottrazione di stringhe non soddisfa quella barra.

Di conseguenza, sono preferite le chiamate di metodo:

public string Remove(string source, string toRemove)
public string Replace(string source, string oldValue, string newValue)

Nel linguaggio C #, usiamo +per la concatenazione di stringhe perché il modulo

var result = string1 + string2 + string3;

invece di

var result = string.Concat(string1, string2, string3);

è conveniente e probabilmente più facile da leggere, anche se una chiamata di funzione è probabilmente più "corretta" da un punto di vista semantico.

L' +operatore può davvero significare solo una cosa in questo contesto. Questo non è altrettanto vero -, poiché la nozione di sottrazione di stringhe è ambigua (la chiamata di funzione Replace(source, oldValue, newValue)con ""come newValueparametro rimuove tutti i dubbi e la funzione può essere utilizzata per modificare le sottostringhe, non solo per rimuoverle).

Il problema, ovviamente, è che il sovraccarico dell'operatore dipende dai tipi che vengono passati all'operatore e se si passa una stringa in cui un numero avrebbe dovuto essere, è possibile che si ottenga un risultato non previsto. Inoltre, per molte concatenazioni (cioè in un ciclo), StringBuilderè preferibile un oggetto, poiché ogni utilizzo di +crea una stringa nuova di zecca e le prestazioni possono risentirne. Quindi l' +operatore non è nemmeno appropriato in tutti i contesti.

Esistono sovraccarichi dell'operatore che hanno una migliore coesione semantica rispetto +all'operatore per la concatenazione di stringhe. Eccone uno che aggiunge due numeri complessi:

public static Complex operator +(Complex c1, Complex c2) 
{
    return new Complex(c1.real + c2.real, c1.imaginary + c2.imaginary);
}

La lingua Groovy consente -:

println('ABC'-'B')

ritorna:

AC

E:

println( 'Hello' - 'World' )

ritorna:

Hello

E:

println('ABABABABAB' - 'B')

ritorna:

AABABABAB

Il segno più probabilmente ha senso contestualmente in più casi, ma un contro-esempio (forse un'eccezione che dimostra la regola) in Python è l'oggetto set, che prevede -ma non +:

>>> set('abc') - set('bcd')
set(['a'])
>>> set('abc') + set('bcd')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'set' and 'set'

Non ha senso usare il +segno perché l'intenzione potrebbe essere ambigua - significa impostare intersezione o unione? Invece, usa |per l'unione e &per l'intersezione:

>>> set('abc') | set('bcd')
set(['a', 'c', 'b', 'd'])
>>> set('abc') & set('bcd')
set(['c', 'b'])

" -" è usato in alcune parole composte (ad esempio "sul posto") per unire le diverse parti nella stessa parola. Perché non utilizziamo " -" per unire stringhe diverse nei linguaggi di programmazione? Penso che avrebbe perfettamente senso! Al diavolo questa +assurdità!

Tuttavia, proviamo a guardare questo da un angolo un po 'più astratto.

Come definiresti l'algebra delle stringhe? Quali operazioni vorresti avere e quali leggi valerebbero per loro? Quali sarebbero le loro relazioni?

Ricorda, potrebbe non esserci assolutamente alcuna ambiguità! Ogni possibile caso deve essere ben definito, anche se ciò significa che non è possibile farlo! Più piccola è la tua algebra, più è facile farlo.

Ad esempio, cosa significa effettivamente aggiungere o sottrarre due stringhe?

Se aggiungi due stringhe (ad esempio, let a = "aa"e b = "bb"), otterrai aabbcome risultato a + b?

Che ne dici b + a? Sarebbe bbaa? Perché no aabb? Cosa succede se sottrai aadal risultato della tua aggiunta? La tua stringa avrebbe un concetto di quantità negativa aain essa?

Ora torna all'inizio di questa risposta e sostituisci spaceshuttleinvece della stringa. In generale, perché viene definita o non definita alcuna operazione per qualsiasi tipo?

Il punto che sto cercando di sottolineare è che non c'è nulla che ti impedisca di creare un'algebra per qualsiasi cosa. Potrebbe essere difficile trovare operazioni significative o persino operazioni utili per questo.

Per quanto riguarda le stringhe, la concatenazione è praticamente l'unica sensata che abbia mai incontrato. Non importa quale simbolo viene utilizzato per rappresentare l'operazione.