Saya akan memberikan jawaban di sini karena yang di sini tidak cukup klik untuk saya.
Fungsi memberkati Perl menghubungkan referensi apa pun ke semua fungsi di dalam sebuah paket.
Mengapa kita membutuhkan ini?
Mari kita mulai dengan mengungkapkan contoh dalam 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
})();
Sekarang mari kita hapus konstruk kelas dan lakukan tanpa itu:
(() => {
'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);
})();
Fungsi ini mengambil tabel hash dari properti tidak berurutan (karena tidak masuk akal harus menulis properti dalam urutan tertentu dalam bahasa dinamis di 2016) dan mengembalikan tabel hash dengan properti itu, atau jika Anda lupa memasukkan kata kunci baru, itu akan mengembalikan seluruh konteks global (mis. jendela di browser atau global dalam nodejs).
Perl tidak memiliki "ini" atau "baru" atau "kelas", tetapi masih dapat memiliki fungsi yang berperilaku sama. Kami tidak akan memiliki konstruktor atau prototipe, tetapi kami akan dapat membuat hewan baru sesuka hati dan memodifikasi properti masing-masing.
# self contained scope
(sub {
my $Animal = (sub {
return {
'name' => $_[0]{'name'},
'sound' => $_[0]{'sound'}
};
});
my $animal = $Animal->({
'name' => 'Jeff',
'sound' => 'bark'
});
print $animal->{sound};
})->();
Sekarang, kita memiliki masalah: Bagaimana jika kita ingin hewan itu melakukan suara sendiri alih-alih kita mencetak suara mereka. Artinya, kami ingin fungsi performSound yang mencetak suara binatang itu sendiri.
Salah satu cara untuk melakukan ini adalah dengan mengajar masing-masing Hewan bagaimana melakukannya dengan suara. Ini berarti bahwa masing-masing Cat memiliki fungsi duplikat sendiri untuk melakukan Suara.
# 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'}();
})->();
Ini buruk karena performSound diletakkan sebagai objek fungsi yang sama sekali baru setiap kali seekor hewan dikonstruksi. 10.000 hewan berarti 10.000 performSounds. Kami ingin memiliki satu fungsi performSound yang digunakan oleh semua hewan yang mencari suara mereka sendiri dan mencetaknya.
(() => {
'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
})();
Di sinilah paralel ke Perl agak berhenti.
Operator baru JavaScript tidak opsional, tanpa itu, "ini" di dalam metode objek merusak lingkup global:
(() => {
// '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.
})();
Kami ingin memiliki satu fungsi untuk masing-masing Hewan yang mencari suara binatang itu sendiri daripada mengkodekannya saat konstruksi.
Berkat memungkinkan kita menggunakan paket sebagai prototipe objek. Dengan cara ini, objek menyadari "paket" itu "dirujuk", dan pada gilirannya dapat memiliki fungsi dalam paket "menjangkau" contoh spesifik yang dibuat dari konstruktor "objek paket" itu:
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();
Ringkasan / TL; DR :
Perl tidak memiliki "ini", "kelas", atau "baru". memberkati objek ke suatu paket memberikan objek itu referensi ke paket, dan ketika ia memanggil fungsi dalam paket, argumen mereka akan diimbangi dengan 1 slot, dan argumen pertama ($ _ [0] atau shift) akan setara dengan javascript "ini". Pada gilirannya, Anda dapat mensimulasikan model prototipe JavaScript.
Sayangnya itu tidak memungkinkan (untuk pengertian saya) untuk membuat "kelas baru" saat runtime, karena Anda membutuhkan setiap "kelas" untuk memiliki paket sendiri, sedangkan di javascript, Anda tidak perlu paket sama sekali, sebagai kata kunci "baru" membuat hashmap anonim untuk Anda gunakan sebagai paket saat runtime yang Anda dapat menambahkan fungsi baru dan menghapus fungsi dengan cepat.
Ada beberapa perpustakaan Perl menciptakan cara mereka sendiri untuk menjembatani keterbatasan ini dalam ekspresi, seperti Moose.
Kenapa kebingungan? :
Karena paket. Intuisi kita memberitahu kita untuk mengikat objek ke sebuah hashmap yang berisi prototipe. Ini memungkinkan kami membuat "paket" pada saat runtime seperti yang dilakukan JavaScript. Perl tidak memiliki fleksibilitas seperti itu (setidaknya tidak built-in, Anda harus menciptakannya atau mendapatkannya dari modul lain), dan pada gilirannya runtime ekspresivitas Anda terhambat. Menyebutnya "berkah" juga tidak banyak membantu.
Apa yang ingin kita lakukan :
Sesuatu seperti ini, tetapi memiliki ikatan ke prototipe peta rekursif, dan secara implisit terikat pada prototipe daripada harus secara eksplisit melakukannya.
Berikut ini adalah upaya naif untuk itu: masalahnya adalah bahwa "panggilan" tidak tahu "apa yang disebutnya", sehingga mungkin juga menjadi fungsi perl universal "objectInvokeMethod (objek, metode)" yang memeriksa apakah objek memiliki metode , atau prototipe memilikinya, atau prototipe memilikinya, hingga mencapai akhir dan menemukannya atau tidak (pewarisan prototipe). Perl memiliki sihir eval yang bagus untuk melakukannya, tetapi saya akan membiarkannya untuk sesuatu yang bisa saya coba nanti.
Bagaimanapun, inilah idenya:
(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'));
})->();
Pokoknya mudah-mudahan seseorang akan menemukan posting ini bermanfaat.