Udzielę odpowiedzi tutaj, ponieważ te tutaj nie kliknęły dla mnie.
Funkcja błogosławieństwa Perla kojarzy wszelkie odniesienia do wszystkich funkcji wewnątrz pakietu.
Po co nam to?
Zacznijmy od przedstawienia przykładu w 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
})();
Teraz usuńmy konstrukcję klasy i obejdźmy się bez niej:
(() => {
'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);
})();
Funkcja pobiera tablicę skrótów z nieuporządkowanymi właściwościami (ponieważ nie ma sensu pisać właściwości w określonej kolejności w językach dynamicznych w 2016 r.) I zwraca tabelę skrótów z tymi właściwościami lub jeśli zapomniałeś wstawić nowe słowo kluczowe, zwróci cały kontekst globalny (np. okno w przeglądarce lub globalny w nodejs).
Perl nie ma „tego”, „nowego” ani „klasy”, ale nadal może mieć funkcję, która zachowuje się podobnie. Nie będziemy mieli konstruktora ani prototypu, ale będziemy mogli dowolnie tworzyć nowe zwierzęta i modyfikować ich indywidualne właściwości.
# self contained scope
(sub {
my $Animal = (sub {
return {
'name' => $_[0]{'name'},
'sound' => $_[0]{'sound'}
};
});
my $animal = $Animal->({
'name' => 'Jeff',
'sound' => 'bark'
});
print $animal->{sound};
})->();
Teraz mamy problem: co by było, gdybyśmy chcieli, aby zwierzę samodzielnie odtwarzało dźwięki, zamiast drukować, jaki jest ich głos. Oznacza to, że chcemy, aby funkcja performSound wyświetlała dźwięk własnego zwierzęcia.
Jednym ze sposobów jest nauczenie każdego zwierzęcia, jak ma robić to, co słychać. Oznacza to, że każdy kot ma swoją zduplikowaną funkcję do wykonywania dźwięku.
# 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'}();
})->();
Jest to złe, ponieważ performSound jest umieszczany jako zupełnie nowy obiekt funkcji za każdym razem, gdy konstruowane jest zwierzę. 10000 zwierząt to 10000 wykonanych dźwięków. Chcemy, aby jedna funkcja performSound była używana przez wszystkie zwierzęta, które wyszukują własne dźwięki i je drukują.
(() => {
'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
})();
Tutaj kończy się paralela do Perla.
Nowy operator JavaScript nie jest opcjonalny, bez niego „this” wewnątrz metod obiektu psuje globalny zasięg:
(() => {
// '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.
})();
Chcemy mieć jedną funkcję dla każdego zwierzęcia, która wyszukuje własny dźwięk tego zwierzęcia, zamiast zakodować go na sztywno w konstrukcji.
Błogosławieństwo pozwala nam używać pakietu jako prototypu obiektów. W ten sposób obiekt jest świadomy „pakietu”, do którego „się odwołuje”, i z kolei może mieć funkcje w pakiecie „sięgać” do określonych instancji, które zostały utworzone na podstawie konstruktora tego „obiektu pakietu”:
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();
Podsumowanie / TL; DR :
Perl nie ma „tego”, „klasy” ani „nowego”. pobłogosławienie obiektu pakietowi daje temu obiektowi odniesienie do pakietu, a kiedy wywołuje funkcje w pakiecie, ich argumenty zostaną przesunięte o 1 szczelinę, a pierwszy argument ($ _ [0] lub shift) będzie równoważny javascript's „this”. Możesz z kolei nieco symulować prototypowy model JavaScript.
Niestety uniemożliwia to (w moim rozumieniu) tworzenie "nowych klas" w czasie wykonywania, ponieważ każda "klasa" musi mieć swój własny pakiet, podczas gdy w javascript w ogóle nie potrzebujesz pakietów, jako słowo kluczowe "nowe" tworzy anonimowy skrót, którego możesz używać jako pakietu w czasie wykonywania, do którego możesz dodawać nowe funkcje i usuwać funkcje w locie.
Istnieją biblioteki Perla, które tworzą własne sposoby pokonywania tego ograniczenia ekspresji, na przykład Moose.
Dlaczego zamieszanie? :
Z powodu pakietów. Nasza intuicja podpowiada nam, aby związać obiekt z hasmapą zawierającą jego prototyp. To pozwala nam tworzyć „pakiety” w czasie wykonywania, jak JavaScript. Perl nie ma takiej elastyczności (przynajmniej nie jest wbudowany, musisz go wymyślić lub pobrać z innych modułów), co z kolei utrudnia ekspresję w środowisku uruchomieniowym. Nazywanie tego „błogosławieństwem” również nie przynosi zbyt wielu korzyści.
Co chcemy zrobić :
Coś podobnego do tego, ale mają powiązanie z mapą prototypu rekurencyjnie i są niejawnie powiązane z prototypem, zamiast robić to jawnie.
Oto naiwna próba: problem polega na tym, że „call” nie wie „co go wywołało”, więc równie dobrze może to być uniwersalna funkcja perla „objectInvokeMethod (obiekt, metoda)”, która sprawdza, czy obiekt ma metodę , albo ma go jego prototyp, albo ma go jego prototyp, dopóki nie dotrze do końca i go nie znajdzie (dziedziczenie prototypowe). Perl ma do tego niezłą magię ewaluacyjną, ale zostawię to na coś, co będę mógł zrobić później.
Tak czy inaczej, oto pomysł:
(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'));
})->();
Miejmy nadzieję, że ktoś uzna ten post za przydatny.