Fornirò una risposta qui poiché quelli qui non mi hanno cliccato.
La funzione benedica di Perl associa qualsiasi riferimento a tutte le funzioni all'interno di un pacchetto.
Perché dovremmo averne bisogno?
Cominciamo esprimendo un esempio in JavaScript:
(() => {
'use strict';
class Animal {
constructor(args) {
this.name = args.name;
this.sound = args.sound;
}
}
/* [WRONG] (global scope corruption)
* var animal = Animal({
* 'name': 'Jeff',
* 'sound': 'bark'
* });
* console.log(animal.name + ', ' + animal.sound); // seems good
* console.log(window.name); // my window's name is Jeff?
*/
// new is important!
var animal = new Animal(
'name': 'Jeff',
'sound': 'bark'
);
console.log(animal.name + ', ' + animal.sound); // still fine.
console.log(window.name); // undefined
})();
Ora consente di eliminare il costrutto di classe e di farne a meno:
(() => {
'use strict';
var Animal = function(args) {
this.name = args.name;
this.sound = args.sound;
return this; // implicit context hashmap
};
// the "new" causes the Animal to be unbound from global context, and
// rebinds it to an empty hash map before being constructed. The state is
// now bound to animal, not the global scope.
var animal = new Animal({
'name': 'Jeff',
'sound': 'bark'
});
console.log(animal.sound);
})();
La funzione accetta una tabella hash di proprietà non ordinate (dal momento che non ha senso scrivere proprietà in un ordine specifico in linguaggi dinamici nel 2016) e restituisce una tabella hash con quelle proprietà, o se hai dimenticato di inserire la nuova parola chiave, restituirà l'intero contesto globale (ad es. finestra nel browser o globale in nodejs).
Perl non ha "questo" né "nuovo" né "classe", ma può comunque avere una funzione che si comporta in modo simile. Non avremo un costruttore né un prototipo, ma saremo in grado di creare nuovi animali a volontà e modificare le loro proprietà individuali.
# self contained scope
(sub {
my $Animal = (sub {
return {
'name' => $_[0]{'name'},
'sound' => $_[0]{'sound'}
};
});
my $animal = $Animal->({
'name' => 'Jeff',
'sound' => 'bark'
});
print $animal->{sound};
})->();
Ora, abbiamo un problema: che cosa succede se vogliamo che l'animale esegua i suoni da soli invece di stampare la loro voce. Cioè, vogliamo una funzione performSound che stampa il suono dell'animale.
Un modo per farlo è insegnare a ogni singolo animale come fare il suono. Ciò significa che ogni gatto ha la sua funzione duplicata per eseguire SoundSound.
# self contained scope
(sub {
my $Animal = (sub {
$name = $_[0]{'name'};
$sound = $_[0]{'sound'};
return {
'name' => $name,
'sound' => $sound,
'performSound' => sub {
print $sound . "\n";
}
};
});
my $animal = $Animal->({
'name' => 'Jeff',
'sound' => 'bark'
});
$animal->{'performSound'}();
})->();
Ciò è negativo perché performSound viene inserito come un oggetto funzione completamente nuovo ogni volta che viene costruito un animale. 10000 animali significa 10000 performSounds. Vogliamo avere una sola funzione performSound che viene utilizzata da tutti gli animali che cerca il proprio suono e lo stampa.
(() => {
'use strict';
/* a function that creates an Animal constructor which can be used to create animals */
var Animal = (() => {
/* function is important, as fat arrow does not have "this" and will not be bound to Animal. */
var InnerAnimal = function(args) {
this.name = args.name;
this.sound = args.sound;
};
/* defined once and all animals use the same single function call */
InnerAnimal.prototype.performSound = function() {
console.log(this.name);
};
return InnerAnimal;
})();
/* we're gonna create an animal with arguments in different order
because we want to be edgy. */
var animal = new Animal({
'sound': 'bark',
'name': 'Jeff'
});
animal.performSound(); // Jeff
})();
Qui è dove si ferma il parallelo a Perl kinda.
Il nuovo operatore JavaScript non è facoltativo, senza di esso, "questo" all'interno dei metodi degli oggetti corrompe l'ambito globale:
(() => {
// 'use strict'; // uncommenting this prevents corruption and raises an error instead.
var Person = function() {
this.name = "Sam";
};
// var wrong = Person(); // oops! we have overwritten window.name or global.main.
// console.log(window.name); // my window's name is Sam?
var correct = new Person; // person's name is actually stored in the person now.
})();
Vogliamo avere una funzione per ogni Animale che cerca il suono di quell'animale piuttosto che codificarlo alla costruzione.
La benedizione ci consente di utilizzare un pacchetto come prototipo di oggetti. In questo modo, l'oggetto è a conoscenza del "pacchetto" a cui "fa riferimento" e, a sua volta, può avere le funzioni nel pacchetto "raggiungere" le istanze specifiche che sono state create dal costruttore di tale "oggetto pacchetto":
package Animal;
sub new {
my $packageRef = $_[0];
my $name = $_[1]->{'name'};
my $sound = $_[1]->{'sound'};
my $this = {
'name' => $name,
'sound' => $sound
};
bless($this, $packageRef);
return $this;
}
# all animals use the same performSound to look up their sound.
sub performSound {
my $this = shift;
my $sound = $this->{'sound'};
print $sound . "\n";
}
package main;
my $animal = Animal->new({
'name' => 'Cat',
'sound' => 'meow'
});
$animal->performSound();
Riepilogo / TL; DR :
Perl non ha "questo", "classe", né "nuovo". la benedizione di un oggetto in un pacchetto fornisce a tale oggetto un riferimento al pacchetto e quando chiama le funzioni nel pacchetto, i loro argomenti saranno compensati di 1 slot e il primo argomento ($ _ [0] o shift) sarà equivalente a "questo" di javascript. A sua volta, è possibile simulare in qualche modo il modello prototipo di JavaScript.
Sfortunatamente, per la mia comprensione, è impossibile (a mio avviso) creare "nuove classi" in fase di esecuzione, poiché è necessario che ogni "classe" abbia il proprio pacchetto, mentre in javascript non è necessario alcun pacchetto, come "nuova" parola chiave crea una hashmap anonima da utilizzare come pacchetto in fase di esecuzione a cui è possibile aggiungere nuove funzioni e rimuovere funzioni al volo.
Ci sono alcune librerie Perl che creano i propri modi per colmare questa limitazione espressiva, come Moose.
Perché la confusione? :
Per via dei pacchetti. La nostra intuizione ci dice di legare l'oggetto a una hashmap contenente il suo 'prototipo. Questo ci consente di creare "pacchetti" in fase di esecuzione come JavaScript può. Perl non ha una tale flessibilità (almeno non integrata, è necessario inventarla o ottenerla da altri moduli) e, a sua volta, l'espressività del runtime viene ostacolata. Chiamarlo "benedica" non fa neanche molto favore.
Cosa vogliamo fare :
Qualcosa del genere, ma è vincolante per la mappa del prototipo ricorsivo ed è implicitamente legato al prototipo piuttosto che doverlo fare esplicitamente.
Ecco un tentativo ingenuo: il problema è che "call" non sa "come lo ha chiamato", quindi potrebbe anche essere una funzione perl universale "objectInvokeMethod (oggetto, metodo)" che controlla se l'oggetto ha il metodo , o il suo prototipo ce l'ha, o il suo prototipo ce l'ha, fino a quando non raggiunge la fine e la trova o meno (eredità prototipica). Perl ha una bella magia eval da fare, ma lo lascerò per qualcosa che posso provare a fare in seguito.
Comunque ecco l'idea:
(sub {
my $Animal = (sub {
my $AnimalPrototype = {
'performSound' => sub {
return $_[0]->{'sound'};
}
};
my $call = sub {
my $this = $_[0];
my $proc = $_[1];
if (exists $this->{$proc}) {
return $this->{$proc}->();
} else {
return $this->{prototype}->{$proc}->($this, $proc);
}
};
return sub {
my $name = $_[0]->{name};
my $sound = $_[0]->{sound};
my $this = {
'this' => $this,
'name' => $name,
'sound' => $sound,
'prototype' => $AnimalPrototype,
'call' => $call
};
};
})->();
my $animal = $Animal->({
'name' => 'Jeff',
'sound'=> 'bark'
});
print($animal->{call}($animal, 'performSound'));
})->();
Speriamo comunque che qualcuno troverà utile questo post.