Tôi sẽ cung cấp câu trả lời ở đây vì những câu hỏi ở đây không phù hợp với tôi.
Chức năng ban phước của Perl liên kết mọi tham chiếu đến tất cả các chức năng trong một gói.
Tại sao chúng ta cần điều này?
Hãy bắt đầu bằng cách thể hiện một ví dụ trong 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
})();
Bây giờ, hãy loại bỏ cấu trúc lớp và thực hiện mà không cần nó:
(() => {
'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);
})();
Hàm lấy một bảng băm của các thuộc tính không có thứ tự (vì sẽ không có nghĩa là phải viết các thuộc tính theo một thứ tự cụ thể trong các ngôn ngữ động trong năm 2016) và trả về một bảng băm với các thuộc tính đó hoặc nếu bạn quên đặt từ khóa mới, nó sẽ không đặt từ khóa mới sẽ trả về toàn bộ bối cảnh toàn cầu (ví dụ: cửa sổ trong trình duyệt hoặc toàn cầu trong nodejs).
Perl không có "cái này" hay "mới" hay "lớp", nhưng nó vẫn có thể có một chức năng hoạt động tương tự. Chúng tôi sẽ không có nhà xây dựng cũng như nguyên mẫu, nhưng chúng tôi sẽ có thể tạo ra các động vật mới theo ý muốn và sửa đổi các thuộc tính riêng lẻ của chúng.
# self contained scope
(sub {
my $Animal = (sub {
return {
'name' => $_[0]{'name'},
'sound' => $_[0]{'sound'}
};
});
my $animal = $Animal->({
'name' => 'Jeff',
'sound' => 'bark'
});
print $animal->{sound};
})->();
Bây giờ, chúng ta có một vấn đề: Điều gì sẽ xảy ra nếu chúng ta muốn con vật tự thực hiện âm thanh thay vì chúng ta in giọng nói của chúng là gì. Đó là, chúng tôi muốn một hàm PerformanceSound in âm thanh của chính con vật.
Một cách để làm điều này là bằng cách dạy cho từng động vật cách phát ra âm thanh. Điều này có nghĩa là mỗi Cat có chức năng trùng lặp riêng để thực hiện.
# 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'}();
})->();
Điều này là xấu vì PerformanceSound được đặt dưới dạng một đối tượng chức năng hoàn toàn mới mỗi khi động vật được xây dựng. 10000 động vật có nghĩa là 10000 biểu diễn. Chúng tôi muốn có một hàm PerformanceSound duy nhất được sử dụng bởi tất cả các động vật tìm kiếm âm thanh của riêng chúng và in nó.
(() => {
'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
})();
Đây là nơi song song với Perl kinda dừng lại.
Toán tử mới của JavaScript không phải là tùy chọn, nếu không có nó, "cái này" bên trong các phương thức đối tượng sẽ làm hỏng phạm vi toàn cầu:
(() => {
// '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.
})();
Chúng tôi muốn có một chức năng cho mỗi Động vật tìm kiếm âm thanh của chính động vật đó thay vì mã hóa nó khi xây dựng.
Blessing cho phép chúng ta sử dụng một gói làm nguyên mẫu của các đối tượng. Theo cách này, đối tượng nhận thức được "gói" mà nó được "tham chiếu đến" và đến lượt nó có thể có các hàm trong gói "tiếp cận" các thể hiện cụ thể được tạo từ hàm tạo của "đối tượng gói" đó:
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();
Tóm tắt / TL; DR :
Perl không có "cái này", "đẳng cấp", cũng không "mới". ban phước cho một đối tượng cho một gói cung cấp cho đối tượng đó một tham chiếu đến gói đó và khi nó gọi các hàm trong gói đó, các đối số của chúng sẽ được bù bởi 1 vị trí và đối số đầu tiên ($ _ [0] hoặc shift) sẽ tương đương với "cái này" của javascript. Đổi lại, bạn có thể mô phỏng phần nào mô hình nguyên mẫu của JavaScript.
Thật không may, theo cách hiểu của tôi, không thể tạo "lớp mới" khi bạn cần mỗi "lớp" để có gói riêng, trong khi trong javascript, bạn không cần gói nào cả, như từ khóa "mới" tạo nên một hashmap ẩn danh để bạn sử dụng như một gói trong thời gian chạy mà bạn có thể thêm các chức năng mới và loại bỏ các chức năng một cách nhanh chóng.
Có một số thư viện Perl tạo ra những cách riêng để bắc cầu giới hạn này trong tính biểu cảm, chẳng hạn như Moose.
Tại sao lại nhầm lẫn? :
Vì gói. Trực giác của chúng ta bảo chúng ta liên kết đối tượng với một hashmap chứa nguyên mẫu của nó. Điều này cho phép chúng tôi tạo "gói" trong thời gian chạy như JavaScript có thể. Perl không có tính linh hoạt như vậy (ít nhất là không được tích hợp sẵn, bạn phải phát minh ra nó hoặc lấy nó từ các mô-đun khác), và đến lượt biểu cảm thời gian chạy của bạn bị cản trở. Gọi nó là "phước lành" cũng không làm điều đó nhiều ủng hộ.
Chúng tôi muốn làm gì :
Một cái gì đó như thế này, nhưng có ràng buộc với đệ quy bản đồ nguyên mẫu, và hoàn toàn bị ràng buộc với nguyên mẫu hơn là phải thực hiện nó một cách rõ ràng.
Đây là một nỗ lực ngây thơ của nó: vấn đề là "cuộc gọi" không biết "cái gì đã gọi nó", vì vậy nó cũng có thể là một hàm perl phổ quát "objectInvokeMethod (object, method)" để kiểm tra xem đối tượng có phương thức không hoặc nguyên mẫu của nó có nó, hoặc nguyên mẫu của nó có nó, cho đến khi nó đi đến tận cùng và tìm thấy nó hoặc không (kế thừa nguyên mẫu). Perl có phép thuật tốt đẹp để làm điều đó nhưng tôi sẽ để nó cho một cái gì đó tôi có thể thử làm sau.
Dù sao đây là ý tưởng:
(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'));
})->();
Dù sao, hy vọng ai đó sẽ tìm thấy bài viết này hữu ích.