Aller au contenu

variable global ou self.xxx ?


Messages recommandés

Posté(e)

Bonjour,

Je me pose la question sur la différence entre un variable globale 

xxx = "variable globale"

et une variable self

self.xxx = "variable self"

merci de vos lumières. 

(je dis vos, mais j'ai un presentiment sur le nom du membre qui va m'expliquer clairement la différence. Quoi que en écrivant, j'ai 3 ou 4 noms qui me viennent en tête)

Posté(e) (modifié)

Joyeuses fêtes de fin d'année :60:

 

EDIT : mais ce n'était peut être pas la réponse attendue :94:

 

Modifié par Lazer
  • Haha 1
Posté(e)

mais justement, c'est suite à la lecture de ce message que j'ai (enfin) posé la question.

Je vais donc le re-re-re-relire.

Posté(e)

 

'self' is a variable passed on to all method calls.

Ex.

function QuickApp:test(x) print(self.name) end

is the same as 

function QuickApp.test(self,x) print(self.name) end

Lua will pass the same 'self' object every time a QuickApp:fun is called

'self' is a Lua table and you can add your own values to self

self.xxx = "variable self"

and later access it when a QuickApp:fun is called

function QuickApp:test2(x) print(self.xxx) end

A global Lua variable is accessible from all functions

xxx = "Lua global"

function QuickApp:test3() print(xxx) end

function test3() print(xxx) end

'self' can be a convenient place to store values as not to pollute the global Lua name space, and you can have values shared privately between QuickApp:funs.

What is faster? Well they are both a table access (table 'self' and table '_G') so without testing I expect them to be similar in efficiency.

 

Note, if you create QuickAppChild objects in your QA they will have their own individual 'self' variables.

  • Like 1
  • Thanks 1
Posté(e) (modifié)

N'hésite pas si tu as une question, pour approfondir la réponse de l'autre topic.

 

EDIT : ah Jang vient de donner des détails complémentaires :)

 

Modifié par Lazer
Posté(e)

ourf, merci à tous les 2 d'essayer de me rendre moins idiot ... mais difficile ???

 

@jang, sorry but you are too expert for me to understand all your points ...

I did used 2 types of variables : local and global (I thing I understand when to use them).

Now I discovered "self.xxx", and I do still not understand the difference with global variable (except perhaps with your last note about Child objects (??) in a QA.

 

@Lazer, le topic auquel tu fais référence, concerne (de ce que j'en ai compris) la gestion des erreurs LUA avec pcall().

Ma question est de comprendre la portée des différents types de variables utilisées par la HC3 (le précis sur les variables concerne la HC2, et il y a de nouveaux types qui sont apparus avec la HC3).

Comme je crois avoir compris ce point (gestion des erreurs avec pcall()). Aurais-tu le courage de faire un sujet similaires pour les variables utilisables en LUA sous HC3 ? :13:

 

 

Posté(e)

Désolé mais je n'ai pas le temps/courage de me lancer dans un nouveau tuto ces temps ci.

Mais ce sont des discussions qu'on a déjà largement abordé en 2020/2021 lorsqu'on est plusieurs à s'être lancé dans le développement de QuickApp suite à la sortie de la HC3, le problème c'est que c'est disséminé un peu partout sur le forum.

 

self désigne l'objet courant.
C'est une notion qui fait référence à la programmation orienté objet.
Même si en réalité, LUA n'est pas un vrai langage orienté objet comme peuvent l'être le C++ ou le Java. Les objets instanciés à partir des classes sont en réalité des variable de type tables au sens LUA. Une table est une variable qui contient n'importe quoi : des fonctions, des string, des boolean, d'autres tables imbriquées, etc.

Fibaro utilise ces notions pour les QA.

Il faut voir QuickApp comme étant une classe, et quickApp (sans la majuscule) comme étant une instance d'objet dérivée de la classe (même si en réalité, d'un point de vue LUA, c'est une table, on l'a dit au-dessus)

self, si utilisé à l'intérieur d'une fonction membre de QuickApp, pointe alors sur l'instance de l'objet quickApp.

self n'est pas utilisable en dehors d'une fonction membre de QuickApp, sauf à le passer explicitement en paramètre lors de l'appel d'une autre fonction (cette autre fonction qui peut être membre d'une autre classe, locale, ou globale, peu importe)

Quand on a plusieurs Child Devices, chaque enfant est une instance objet de la classe QuickAppChild (elle même dérivée de QuickApp). A l'intérieur de chaque enfant, self pointe sur l'objet courant.

 

Bref, il te faut revoir les bases de la programmation orientée objet (pleins de tutos sur le net)

Puis l'implémentation spécifique LUA/Fibaro, pour cela je t'invite à (re)lire l'excellent exposé de Jang sur l'anatomie d'un QuickApp :

 

 

 

 

  • Like 1
Posté(e)
il y a une heure, Lazer a dit :

Désolé mais je n'ai pas le temps/courage de me lancer dans un nouveau tuto ces temps ci.

je m'en doutais, et merci pour toute l'aide que tu apportes malgré tout

 

il y a une heure, Lazer a dit :

Mais ce sont des discussions qu'on a déjà largement abordé en 2020/2021 lorsqu'on est plusieurs à s'être lancé dans le développement de QuickApp suite à la sortie de la HC3, le problème c'est que c'est disséminé un peu partout sur le forum.

Je m'en doute bien, mais comme il m'est physiquement impossible de le parcourir, un résumé comme pour la gestions des erreurs aurait été idéal pour moi. Mais ZERO soucis, je continue (et ça fonctionne) avec les 2 types de variables que je "maitrise".

 

Mais je lis que tu as quand-même donné des éléments de réponse :13:. J'avais commencé à lire les tutos de Jang (tu m'avais donné les liens), mais pas jusqu'au bout (pour les raisons ci-dessus).

Je me souviens d'avoir eu des cours d'initiation à Java il y a 15 ans, mais déjà j'étais largué ...

Posté(e)

Not sure this helps, but....

local myTable = {}
myTable.x = 5
function myTable:test1(x) print(self.x+x) end

Defining a function with ':' is the same as defining

function myTable.test1(self,x) print(self.x+x) end

It inserts a variable 'self' as the first argument (Lua choses the name 'self')

The above function definition is the same as

myTable.test1 = function(self,x) print(self.x+x) end

So the resulting myTable is now

{ x = 5, test1 = function(self,v) print(self.x+x) end }

If we call

myTable:test1(5)

it is transformed to the call myTable.test1(myTable,5), taking the table on the left of ':' and passing it on as the first argument 'self' to the test1 function

myTable.test1(myTable,5)

and we get

>10

If we define our function with '.' we can call 'self' something else...

function myTable.test2(y,x) print(y.x*x) end
myTable:test2(5)
>25

So, 'self' is just a Lua table (object) that is sent around as the first argument to all methods, and representing the object the methods belongs to.
In the common case it's the QuickApp object, but for QuickAppChild classes, it's the child object.

 

We can define our QuickApp functions with '.' instead of ':' but we need to add the first parameter, the 'self'

We can also call our QuickApp functions with '.' instead of ':' but we need to add the first argument, the 'self',  explicitly.
In the below case we call it 'myApp' instead of 'self'

function QuickApp.test3(myApp,x)
  myApp.debug(myApp,myApp.x+x)
end

function QuickApp.onInit(myApp)
  myApp.x = 9
  QuickApp.test3(myApp,8)
end

 

  • Confused 1
×
×
  • Créer...