Buraya bir cevap vereceğim, çünkü buradakiler benim için tıklamamıştı.
Perl'in kutsama işlevi, herhangi bir referansı bir paket içindeki tüm işlevlerle ilişkilendirir.
Neden buna ihtiyacımız var?
JavaScript'te bir örnek belirterek başlayalım:
(() => {
'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
})();
Şimdi sınıf yapısını kaldırıp onsuz yapalım:
(() => {
'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);
})();
İşlev, sıralanmamış özelliklerin bir karma tablosunu alır (2016'da dinamik dillerde belirli bir sırayla özellik yazmak zorunda kalmaz) ve bu özelliklere sahip bir karma tablo döndürür veya yeni anahtar kelimeyi koymayı unuttuysanız, tüm global bağlamı döndürür (örn. tarayıcıdaki pencere veya global olarak nodejs).
Perl'de "bu", "yeni" veya "sınıf" yoktur, ancak yine de benzer şekilde davranan bir işlevi olabilir. Bir kurucumuz ya da bir prototipimiz olmayacak, ancak istedikleri zaman yeni hayvanlar yaratabilecek ve bireysel özelliklerini değiştirebileceğiz.
# self contained scope
(sub {
my $Animal = (sub {
return {
'name' => $_[0]{'name'},
'sound' => $_[0]{'sound'}
};
});
my $animal = $Animal->({
'name' => 'Jeff',
'sound' => 'bark'
});
print $animal->{sound};
})->();
Şimdi bir sorunumuz var: Ya hayvanın seslerini basmak yerine sesleri kendileri çalmasını istiyorsak. Yani, bir fonksiyonun gerçekleştirilmesini istiyoruzHayvanın kendi sesini basan ses.
Bunu yapmanın bir yolu, her bir hayvana sesin nasıl yapılacağını öğretmektir. Bu, her Cat'in gerçekleştirmesi için kendi çoğaltma işlevine sahip olduğu anlamına gelir.
# 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'}();
})->();
Bu kötüdür çünkü performSound, bir hayvan her inşa edildiğinde tamamen yeni bir fonksiyon nesnesi olarak konur. 10000 hayvan 10000 performans anlamına gelir. Kendi seslerini arayan ve basan tüm hayvanlar tarafından kullanılan tek bir işleve sahip olmak istiyoruz.
(() => {
'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
})();
İşte Perl'e paralel olarak burada durur.
JavaScript'in yeni işleci isteğe bağlı değildir, onsuz "nesne" içindeki nesne yöntemleri global kapsamı bozar:
(() => {
// '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.
})();
Her hayvan için, yapımda kodlamak yerine o hayvanın kendi sesini arayan bir fonksiyona sahip olmak istiyoruz.
Blessing, bir paketi nesnelerin prototipi olarak kullanmamızı sağlar. Bu şekilde, nesne "başvuruda bulunulan" paketin farkındadır ve paketteki işlevlerin "paket nesnesinin" yapıcısından oluşturulan belirli örneklere "ulaşmasını" sağlayabilir:
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();
Özet / TL; DR :
Perl'in "bu", "sınıf" veya "yeni" yoktur. bir nesneyi bir pakete kutsamak, o nesneye pakete bir başvuru verir ve paketteki işlevleri çağırdığında, argümanları 1 yuva ile dengelenir ve ilk argüman ($ _ [0] veya shift) javascript "bu" dır. Buna karşılık, JavaScript'in prototip modelini biraz taklit edebilirsiniz.
Ne yazık ki, her bir "sınıfın" kendi paketine sahip olması gerektiğinden, çalışma zamanında "yeni sınıflar" oluşturmayı imkansız kılarken, javascript'te "yeni" anahtar kelime olarak hiçbir pakete ihtiyacınız yoktur çalışma zamanında yeni işlevler ekleyebileceğiniz ve işlevleri anında kaldırabileceğiniz bir paket olarak kullanmanız için anonim bir hashmap oluşturur.
Moose gibi ifadede bu sınırlamayı köprülemek için kendi yollarını yaratan bazı Perl kütüphaneleri var.
Neden karışıklık? :
Paketler yüzünden. Sezgimiz bize nesneyi 'prototipini içeren bir hashmap'a bağlamamızı söylüyor. Bu, çalışma zamanında JavaScript'in yapabileceği gibi "paketler" oluşturmamızı sağlar. Perl böyle bir esnekliğe sahip değildir (en azından yerleşik değildir, onu icat etmeniz veya diğer modüllerden almanız gerekir) ve sırayla çalışma zamanı ifadeniz engellenir. Ona “kutsama” deme, pek de iyilik yapmaz.
Ne yapmak istiyoruz :
Bunun gibi bir şey, ancak prototip haritasına özyinelemeli bağlanma var ve bunu açıkça yapmak yerine prototipe dolaylı olarak bağlı olun.
İşte naif bir girişim: sorun "çağrı" bilmiyor "ne denir", bu yüzden de nesnenin yöntemi olup olmadığını kontrol evrensel bir perl işlevi "objectInvokeMethod (nesne, yöntem)" olabilir veya prototipine sahip olur ya da prototipine kadar, sonuna ulaşıp bulana kadar (prototipik miras). Perl'in bunu yapmak için güzel bir değerlendirme büyüsü var ama bunu daha sonra deneyebileceğim bir şey için bırakacağım.
Her neyse, burada fikir:
(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'));
})->();
Neyse umarım birisi bu yazıyı faydalı bulacaktır.