Je vais fournir une réponse ici car ceux ici n'ont pas tout à fait cliqué pour moi.
La fonction bless de Perl associe toute référence à toutes les fonctions à l'intérieur d'un paquet.
Pourquoi en aurions-nous besoin?
Commençons par exprimer un exemple en 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
})();
Supprimons maintenant la construction de classe et faisons-nous en sans:
(() => {
'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);
})();
La fonction prend une table de hachage de propriétés non ordonnées (car cela n'a aucun sens d'avoir à écrire des propriétés dans un ordre spécifique dans des langages dynamiques en 2016) et renvoie une table de hachage avec ces propriétés, ou si vous avez oublié de mettre le nouveau mot-clé, il retournera tout le contexte global (par exemple, fenêtre dans le navigateur ou global dans nodejs).
Perl n'a ni "this", ni "new" ni "class", mais il peut toujours avoir une fonction qui se comporte de la même manière. Nous n'aurons pas de constructeur ni de prototype, mais nous pourrons créer de nouveaux animaux à volonté et modifier leurs propriétés individuelles.
# self contained scope
(sub {
my $Animal = (sub {
return {
'name' => $_[0]{'name'},
'sound' => $_[0]{'sound'}
};
});
my $animal = $Animal->({
'name' => 'Jeff',
'sound' => 'bark'
});
print $animal->{sound};
})->();
Maintenant, nous avons un problème: que se passe-t-il si nous voulons que l'animal exécute les sons par lui-même au lieu d'imprimer sa voix. Autrement dit, nous voulons une fonction performSound qui imprime le propre son de l'animal.
Une façon de faire est d'apprendre à chaque animal à faire son son. Cela signifie que chaque chat a sa propre fonction de duplication à exécuter.
# 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'}();
})->();
Ceci est mauvais car performSound est mis en tant qu'objet de fonction complètement nouveau à chaque fois qu'un animal est construit. 10000 animaux signifie 10000 performSounds. Nous voulons avoir une seule fonction performSound qui soit utilisée par tous les animaux qui recherchent leur propre son et l'impriment.
(() => {
'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
})();
C'est ici que s'arrête un peu le parallèle avec Perl.
Le nouvel opérateur de JavaScript n'est pas facultatif, sans lui, "this" à l'intérieur des méthodes d'objet corrompt la portée globale:
(() => {
// '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.
})();
Nous voulons avoir une fonction pour chaque animal qui recherche le son de cet animal plutôt que de le coder en dur lors de la construction.
La bénédiction nous permet d'utiliser un package comme prototype d'objets. De cette façon, l'objet est conscient du "package" auquel il est "référencé", et peut à son tour avoir les fonctions du package "atteindre" les instances spécifiques qui ont été créées à partir du constructeur de cet "objet package":
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();
Résumé / TL; DR :
Perl n'a ni "ceci", ni "classe", ni "nouveau". bénir un objet dans un package donne à cet objet une référence au package, et quand il appelle des fonctions dans le package, leurs arguments seront décalés de 1 slot, et le premier argument ($ _ [0] ou shift) sera équivalent à "ceci" de javascript. À son tour, vous pouvez simuler un peu le modèle prototype de JavaScript.
Malheureusement, il est impossible (à ma connaissance) de créer de "nouvelles classes" à l'exécution, car vous avez besoin que chaque "classe" ait son propre package, alors qu'en javascript, vous n'avez pas du tout besoin de packages, en tant que mot-clé "nouveau" constitue un hashmap anonyme que vous pouvez utiliser comme package au moment de l'exécution auquel vous pouvez ajouter de nouvelles fonctions et supprimer des fonctions à la volée.
Certaines bibliothèques Perl créent leurs propres moyens de surmonter cette limitation d'expressivité, comme Moose.
Pourquoi cette confusion? :
À cause des paquets. Notre intuition nous dit de lier l'objet à un hashmap contenant son prototype. Cela nous permet de créer des "packages" au moment de l'exécution comme le peut JavaScript. Perl n'a pas une telle flexibilité (du moins pas intégré, vous devez l'inventer ou l'obtenir à partir d'autres modules), et à son tour votre expressivité d'exécution est entravée. L'appeler "bénir" ne le fait pas non plus.
Ce que nous voulons faire :
Quelque chose comme ça, mais avoir une liaison récursive avec la carte prototype, et être implicitement lié au prototype plutôt que d'avoir à le faire explicitement.
En voici une tentative naïve: le problème est que "call" ne sait pas "comment on l'a appelé", donc cela peut aussi bien être une fonction perl universelle "objectInvokeMethod (object, method)" qui vérifie si l'objet a la méthode , ou son prototype l'a, ou son prototype l'a, jusqu'à ce qu'il atteigne la fin et le trouve ou non (héritage prototypique). Perl a une belle magie eval pour le faire, mais je laisserai cela pour quelque chose que je pourrai essayer de faire plus tard.
Bref, voici l'idée:
(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'));
})->();
Quoi qu'il en soit, j'espère que quelqu'un trouvera cet article utile.