Attenzione: Questo articolo è rivolto ai programmatori JavaScript. Parens stanno arrivando, ma solo per breve tempo e si può gestire e sarà un bene per voi.
In Struttura e interpretazione di linguaggi di programmazione Second Edition (SICP) a pagina 182, gli autori introducono l'idea del messaggio che passa con il seguente esempio nello schema di una funzione complessa costruzione numero.
(Define (make-da-real-imag xy)
(Define (spedizione op)
(Cond ((eq? Op 'real-parte) x)
((Eq? Op 'imag-parte) y)
(Grandezza (eq? Op ')
(Sqrt (+ (quadrato x) (quadrato y))))
(Angolo (eq? Op ') (atan yx))
(Altrimenti
(Errore "Uknown op - MAKE-DA-REAL-IMAG" op))))
spedizione)La cosa importante da notare qui è che il valore restituito dal
make-da-real-imag funzione di costruzione è in realtà una procedura di spedizione che è possibile chiamare con un argomento del messaggio. È possibile inviare i messaggi per ottenere la parte reale o la grandezza del numero complesso.(C define (make-da-real-imag 3 4))
(C 'real-parte); 3
(C 'imag-parte); 4
(Magnitudine c '); 5
(Angolo c '); 0,927295218001612
(C 'asdf); ERROR: Uknown op - MAKE-DA-REAL-IMAG: asdfVediamo quello che il codice di cui sopra sembra in JavaScript, la nostralingua franca .
funzione makeFromRealImag (x, y) {
funzione di invio (op) {
switch (op) {
case 'realPart': x ritorno;
case 'imagPart': y ritorno;
case 'grandezza':
ritorno Math.sqrt (x * x + y * y);
case 'angolo': return Math.atan2 (y, x);
default:
gettare 'op Unknown - makeFromRealImag:' + op;
}
}
ritorno della spedizione;
}
var c = makeFromRealImag (3, 4);
c ('realPart'); / / 3
c ('imagPart'); / / 4
c ('magnitudo'); / / 5
c ('angolo'); / / 0,9272952180016122
c ('asdf'); / / "op Unknown - makeFromRealImag: asdf"Ora, questo probabilmente non assomiglia a nessun orientato agli oggetti JavaScript che avete visto prima, ma illustra un punto importante. In JavaScript, possiamo rappresentare l'idea di un oggetto in funzione dei suoi messaggi. La funzione restituisce una funzione di costruzione di spedizione che hai scritto, che può inviare qualsiasi messaggio alcun modo che lo si desidera. Questo dà immediatamente Spidermonkey di
__nosuchmethod__, Smalltalk di doesNotUnderstand e Ruby method_missing . Roba potente ma purtroppo il codice JavaScript viene eseguito al di sopra molto lentamente. Siamo in grado di muoversi verso uno stile JavaScript più veloce e più familiare.SICP pagina 223, introduce l'idea di oggetti mutabili, ma il punto più interessante è la variazione della procedura di spedizione.
(Define (make-saldo)
(Define (ritiro importo)
(If (> = saldo dell'importo)
(Begin (set! equilibrio (- importo del saldo))
saldo)
"Fondi insufficienti"))
(Define deposito (importo)
(Set! saldo (saldo + importo))
saldo)
(Define (spedizione m)
(Cond ((eq? M 'recedere) revocare)
(Deposito (eq? M ') deposito)
(Else (errore "Unknown richiesta - MAKE-ACCOUNT"
m))))
spedizione)
(Define account (make-account 10))
((Conto deposito ') 5); 15
((Account 'recedere) 3), 12La conversione di questo JavaScript abbiamo la seguente.
Funzione makeAccount (saldo) {
funzionare prelevare (importo) {
if (saldo> = importo) {
equilibrare = - importo;
restituire equilibrio;
}
di ritorno "fondi insufficienti";
}
funzione di deposito (importo) {
= saldo + importo;
restituire equilibrio;
}
funzione di invio (m) {
Interruttore (m) {
case 'ritiro': return ritirarsi;
caso di 'deposito': deposito di ritorno;
default:
gettare "richiesta Unknown - makeAccount:" + m;
}
}
ritorno della spedizione;
}
var = conto makeAccount (10);
account ('deposito') (5); / / 15
account ('ritiro') (3); / / 12Il modo in cui la
spedizione funzione è disponibile per gli account è molto diversa rispetto al caso dei numeri complessi. Nel caso di numeri complessi, quando un messaggio è stato inviato alla spedizione funzione, eseguita l'operazione associata (cioè il metodo) immediatamente. Al contrario, l'account di spedizione funzione restituisce il metodo associato con il messaggio e che il metodo può quindi essere chiamato.Questo è molto simile al funzionamento di JavaScript
reciever.message (arg) opere sintassi e possiamo passare ad un più familiare stile orientato agli oggetti JavaScript.Funzione makeAccount (saldo) {
funzionare prelevare (importo) {
if (saldo> = importo) {
equilibrare = - importo;
restituire equilibrio;
}
di ritorno "fondi insufficienti";
}
funzione di deposito (importo) {
= saldo + importo;
restituire equilibrio;
}
ritorno {
ritiro: ritirare,
Deposito: deposito
};
}
var = conto makeAccount (10);
account.deposit (5); / / 15
account.withdraw (3); / / 12In questa ultima versione, abbiamo smesso di scrivere la nostra logica propria spedizione e l'uso di JavaScript built-in di ricerca immobiliare.Ciò aumenta notevolmente la velocità. Abbiamo perso la capacità di fare la
__noSuchMethod__ tipo di spedizione quando si utilizzano standard ECMAScript, ma che non sembra essere comunemente utili comunque.Per le buone letture programmatori JavaScript là fuori, si possono riconoscere questa ultima versione, come gli oggetti durevoli dal libro di Douglas Crockford di JavaScript: le parti buone .
Trovo interessante che l '"eredità" la parola non appare nell'indice della SICP anche se il libro va avanti per attuare programmi complessi come interpreti del linguaggio e compilatori in stile message passing. Ciò dimostra questo stile semplice di programmazione object-oriented in grado di portare lontano.
La morale della storia è che i libri antichi sono la pena di leggere e può cambiare il modo in cui si programma oggi.
