Ich werde hier eine Antwort geben, da die hier nicht ganz für mich geklickt haben.
Perls Segensfunktion verknüpft jeden Verweis auf alle Funktionen innerhalb eines Pakets.
Warum brauchen wir das?
Beginnen wir mit einem Beispiel 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
})();
Lassen Sie uns nun das Klassenkonstrukt entfernen und darauf verzichten:
(() => {
'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);
})();
Die Funktion verwendet eine Hash-Tabelle mit ungeordneten Eigenschaften (da es 2016 keinen Sinn macht, Eigenschaften in einer bestimmten Reihenfolge in dynamischen Sprachen schreiben zu müssen) und gibt eine Hash-Tabelle mit diesen Eigenschaften zurück, oder wenn Sie vergessen haben, das neue Schlüsselwort einzugeben gibt den gesamten globalen Kontext zurück (z. B. Fenster im Browser oder global in nodejs).
Perl hat weder "dies" noch "neu" noch "Klasse", kann aber dennoch eine Funktion haben, die sich ähnlich verhält. Wir werden weder einen Konstruktor noch einen Prototyp haben, aber wir werden in der Lage sein, nach Belieben neue Tiere zu erstellen und ihre individuellen Eigenschaften zu ändern.
# self contained scope
(sub {
my $Animal = (sub {
return {
'name' => $_[0]{'name'},
'sound' => $_[0]{'sound'}
};
});
my $animal = $Animal->({
'name' => 'Jeff',
'sound' => 'bark'
});
print $animal->{sound};
})->();
Jetzt haben wir ein Problem: Was ist, wenn wir möchten, dass das Tier die Geräusche selbst ausführt, anstatt dass wir drucken, was ihre Stimme ist? Das heißt, wir möchten eine Funktion performSound, die den eigenen Klang des Tieres druckt.
Eine Möglichkeit, dies zu tun, besteht darin, jedem einzelnen Tier beizubringen, wie es seinen Klang erzeugt. Dies bedeutet, dass jede Katze ihre eigene Duplikatfunktion hat, um Sound auszuführen.
# 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'}();
})->();
Dies ist schlecht, da performSound jedes Mal, wenn ein Tier konstruiert wird, als völlig neues Funktionsobjekt gesetzt wird. 10000 Tiere bedeuten 10000 performSounds. Wir möchten eine einzige Funktion performSound haben, die von allen Tieren verwendet wird, die ihren eigenen Sound nachschlagen und ihn drucken.
(() => {
'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
})();
Hier hört die Parallele zu Perl auf.
Der neue Operator von JavaScript ist nicht optional. Ohne diesen Operator beschädigt "this" innerhalb der Objektmethoden den globalen Bereich:
(() => {
// '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.
})();
Wir möchten eine Funktion für jedes Tier haben, die den eigenen Klang dieses Tieres nachschlägt, anstatt ihn beim Bau fest zu codieren.
Durch den Segen können wir ein Paket als Prototyp von Objekten verwenden. Auf diese Weise kennt das Objekt das "Paket", auf das es "referenziert" ist, und kann wiederum die Funktionen im Paket dazu bringen, in die spezifischen Instanzen zu "greifen", die vom Konstruktor dieses "Paketobjekts" erstellt wurden:
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();
Zusammenfassung / TL; DR :
Perl hat weder "dies", "Klasse" noch "neu". Wenn Sie ein Objekt für ein Paket segnen, erhält dieses Objekt einen Verweis auf das Paket. Wenn es Funktionen im Paket aufruft, werden ihre Argumente um 1 Slot versetzt, und das erste Argument ($ _ [0] oder Shift) entspricht Javascript ist "dies". Im Gegenzug können Sie das Prototypmodell von JavaScript etwas simulieren.
Leider ist es (nach meinem Verständnis) unmöglich, zur Laufzeit "neue Klassen" zu erstellen, da jede "Klasse" ein eigenes Paket haben muss, während Sie in Javascript überhaupt keine Pakete als "neues" Schlüsselwort benötigen erstellt eine anonyme Hashmap, die Sie zur Laufzeit als Paket verwenden können, zu der Sie im laufenden Betrieb neue Funktionen hinzufügen und Funktionen entfernen können.
Es gibt einige Perl-Bibliotheken, die ihre eigenen Methoden entwickeln, um diese Einschränkung der Ausdruckskraft zu überwinden, wie z. B. Moose.
Warum die Verwirrung? ::
Wegen Paketen. Unsere Intuition sagt uns, dass wir das Objekt an eine Hashmap binden sollen, die seinen Prototyp enthält. Auf diese Weise können wir zur Laufzeit "Pakete" erstellen, wie dies JavaScript kann. Perl verfügt nicht über eine solche Flexibilität (zumindest nicht eingebaut, Sie müssen es erfinden oder von anderen Modulen beziehen), und Ihre Laufzeit-Ausdruckskraft wird wiederum beeinträchtigt. Es "Segen" zu nennen, tut ihm auch nicht viel Gutes.
Was wir tun wollen :
So etwas, aber die Bindung an die Prototypkarte ist rekursiv und implizit an den Prototyp gebunden, anstatt dies explizit tun zu müssen.
Hier ist ein naiver Versuch: Das Problem ist, dass "call" nicht weiß, wie es heißt ", also kann es auch eine universelle Perl-Funktion" objectInvokeMethod (object, method) "sein, die prüft, ob das Objekt die Methode hat oder sein Prototyp hat es oder sein Prototyp hat es, bis es das Ende erreicht und es findet oder nicht (prototypische Vererbung). Perl hat eine schöne Eval-Magie, aber ich lasse das für etwas, das ich später versuchen kann.
Jedenfalls ist hier die Idee:
(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'));
})->();
Wie auch immer, hoffentlich findet jemand diesen Beitrag nützlich.