Closures pour la confidentialité

Fait partie de la section Programmation orientée objet du Journey Lua de Coddy — leçon 44 sur 70.

Les conventions de nommage signalent l'intention, mais elles n'empêchent pas réellement l'accès. N'importe qui peut toujours écrire player._health = 999 et cela fonctionne. Pour une véritable confidentialité, Lua propose une approche différente : stocker les données dans des variables locales à l'intérieur du constructeur au lieu de self.

L'idée fondamentale est que les variables locales à l'intérieur d'une fonction ne sont accessibles qu'au sein de cette fonction — et de toutes les fonctions définies à l'intérieur de celle-ci. C'est ce qu'on appelle une fermeture (closure) :

local Counter = {}
Counter.__index = Counter

function Counter:new()
    local count = 0  -- Vraiment privé ! Pas sur self.
    
    local obj = {}
    setmetatable(obj, Counter)
    return obj
end

Dans cet exemple, count n'existe qu'à l'intérieur de la fonction :new(). Il n'est pas stocké dans obj, il n'y a donc aucun moyen d'y accéder depuis l'extérieur — myCounter.count renvoie nil, et il n'y a pas de champ préfixé par un trait de soulignement à contourner.

La variable count réside dans la portée de la fermeture (closure). Elle reste complètement cachée du code externe. (Tel qu'écrit, rien ne capture encore count ; dans la prochaine leçon, vous ajouterez des méthodes à l'intérieur du constructeur qui se referment dessus, de sorte qu'elle persiste aussi longtemps que l'objet.) Contrairement à self._count, qui n'est qu'une simple suggestion de courtoisie, cette approche rend les données véritablement inaccessibles.

Bien sûr, les données cachées ne sont pas utiles si vous ne pouvez jamais interagir avec elles. Dans la leçon suivante, vous apprendrez à définir des méthodes à l'intérieur du constructeur capables de lire et de modifier ces variables privées, vous offrant ainsi un accès contrôlé tout en préservant une véritable encapsulation.

Défi

Facile

Construisons une classe SecretKeeper qui démontre une véritable confidentialité des données en utilisant les fermetures (closures) ! Contrairement à la convention de l'underscore de la leçon précédente, cette approche rend les données réellement inaccessibles depuis l'extérieur de l'objet.

Vous organiserez votre code sur deux fichiers :

SecretKeeper.lua : Créez une classe où le secret est stocké dans une variable locale à l'intérieur du constructeur — et non sur self. Le constructeur :new(secretValue) doit stocker le secret dans une variable locale qui n'existe qu'au sein de la fermeture. Pour l'instant, l'objet n'aura aucun moyen d'accéder à ce secret (cela viendra dans la prochaine leçon !), mais vous devez également stocker un champ public name défini sur "Keeper" sur l'instance afin que nous puissions vérifier que l'objet fonctionne.
main.lua : Importez votre module SecretKeeper et lisez une valeur secrète à partir de l'entrée. Créez une instance de SecretKeeper avec ce secret. Démontrez ensuite que le secret est véritablement privé en affichant trois choses :
- Le champ name du keeper (doit afficher Keeper)
- Ce qui se passe lorsque vous essayez d'accéder à keeper.secret (doit être nil)
- Ce qui se passe lorsque vous essayez d'accéder à keeper._secret (doit également être nil)

Vous recevrez une entrée :

La valeur secrète à stocker (par exemple, TopSecret123)

Votre sortie doit comporter trois lignes montrant que, bien que le champ public fonctionne, le secret est complètement caché :

Name: Keeper
secret: nil
_secret: nil

La sortie sera la même quel que soit le secret que vous passez — car il n'y a aucun moyen d'y accéder ! La variable locale à l'intérieur du constructeur est invisible pour le monde extérieur. Cela prouve que la confidentialité basée sur les fermetures est fondamentalement différente de la convention de nommage par underscore.

Par exemple, si l'entrée est MyPassword, la sortie doit toujours être :

Name: Keeper
secret: nil
_secret: nil

Essayez vous-même

-- Requiert le module SecretKeeper
local SecretKeeper = require('SecretKeeper')

-- Lit la valeur secrète depuis l'entrée
local secretValue = io.read()

-- TODO: Créer une instance de SecretKeeper avec la valeur secrète

-- TODO: Afficher le champ name du keeper (format : "Name: <name>")

-- TODO: Afficher ce qu'il se passe lors de l'accès à keeper.secret (format : "secret: <value>")

-- TODO: Afficher ce qu'il se passe lors de l'accès à keeper._secret (format : "_secret: <value>")