|
Angel,
los artículos de Juanita ewing son sobre Smalltalk/V.
Allí, como ella dice, hay class variables y class instance
variables.
Las class variables, paradójicamente, se "declaran"en la
"definición" de la clase (junto con las de instancia "de las
instancias"), el mensaje
#subclass:instanceVariableNames:classVariableNames:poolDictionaries:.
Las comillas son porque eso no es una declaración, ni una
definición de la clase, sino un mensaje que se envía a un objeto,
en este caso, a una clase.
Las variables de instancia de la clase, se declaran "del lado
class del browser" con otro mensaje que se envía, en este caso, a
una metaclase. Por poner un ejemplo (trivial, porque no tiene
variables de instancia), sería
MessageBox class instanceVariableNames: ''
Las variables de clase se empiezan con mayúscula para indicar
que son compartidas. Compartidas entre la clase y todas sus
instancias, y sus subclases y todas sus instancias.
Las variables de instancia de la clase, son sólo eso. La clase
es un objeto (cada una, una instancia de Metaclass) y puede tener
variables de instancia. Entonces, esas no son compartidas, son
"locales" . Se pueden usar en métodos de clase. Si creás una
subclase, hereda la definición de las variables de instancia (como
pasa con las instancias), pero como es un objeto distinto, tiene
otras variables de instancia, aunque tengan el mismo nombre. Puede
sonar confuso, pero es exactamente igual que lo que pasa con las
instancias.
Pharo tiene una implementación diferente y usa algo que llama,
propiamente, SharedVariables. A grandes rasgos, para las
"variables de clase" es un diccionario en la clase. También lo usa
para los "viejos" PoolDictionaries.
En cuanto al compilador, los que conozco tienen una ristra de
scopes anidados, como cualquier otro. Entonces, una colisión de
nombres (por ejemplo, entre una variable de clase y una "global"
definida en Smalltalk) se resuelve porque primero está el scope
de la clase y más afuera, el del diccionario Smalltalk.
Saludos
PD: La variable Listmenu no te la muestra, porque no da la
"definición " de la clase que está usando, ya que la cambia varias
veces. Pero cuando habla de ella, deja claro que es una class
variable, consecuente con el hecho de que adhiera a la convención
de la mayúscula inicial.
On 17/12/2012 03:36 p.m., Angel Java Lopez wrote:
Hola gente!
Gracias Guillermo por los enlaces, muy interesante.
Segun esa nomenclatura "instance Variable" es lo que se
define en los instanceVariableNames: en general.
Y lo que es "class instance variable" es lo que se define en
los classVariableNames: (y esto es lo que me confunde, lo que se
llama "class instance variable" aparece como
classVariableNames:)
Entiendo instanceVariableNames, classVariableNames y toda
la estructura interna. No diria que una "class instance
variable" o lo que define classVariableNames: es algo similar
a lo estatico en Java o en C++. Y me sigue pareciendo que lo
que los papers (y Valloud) llama "class variables" (insisto,
yo lo hubiera llamado shared variabels), tienen una
implementacion distinta.
PERO, aca viene la duda que persiste, y que en esos papers no
esta dilucidada, hasta donde vi.
En el
pone "How to define Class Instance Variable" y eso lo
entiendo desde principios de los ochenta.
Pero en el
Da como ejemplo de "class variable" a ListMenu. PERO NO
DICE COMO SE DEFINE (no vi en ningun lado un ejemplo que
defina una subclase y en el classVariableNames: venga
ListMenu), simplemente la referencia en el metodo de clase y
con Mayuscula.
ListInterface class
initialize
“Create a menu. Create constants.”
ListMenu :=
Menu labels: #(‘add’ ‘remove’)
menu
“Return the list menu.”
^ListMenu
ListInterface
hasMenu
“Return true if a menu is defined.”
^self class menu notNil
performMenuActivity
“Perform the mouse-based activity for my view.”
self hasMenu
ifTrue: [^self class menu startUp].
Como sabe que
ListMenu es una shared variable, en vez de algo que esta en
Smalltalk???
Valloud habla de Shared Variables, como de algo nuevo (ya
en las secciones anteriores menciono lo de que las clases
tienen "instance variables" definidas en la metaclass). Y que
se accede NO POR class methods, sino como variables
compartidas, directamente accesibles desde cualquier lado de
la jerarquia de ESA CLASE.
Por ejemplo, escribe:
"In addition to instances variables on the instance and
class sides of the browser, there are hybrid entities calles
class variables. Despite the slight difference in their names,
their scope is quite different: a class variable is visible
from the class the class that defines it and also from all the
instances of the class. Moreover, it is also visible by
subclasses of the class in which it is defined, and by
instances of these subclasses as well. This means it is a
global variable whose scope begins at the class that
introduces it. In particular, class variables are accessible
from class instances as well as from emtaclass instances.
Clearly, these are not our everyday instance variables"
Es decir, no veo que sea las que se definen en
classVariableNames:
No veo tampoco que sean las que esten definidas en una
metaclase, de alguna forma especial. Porque dice que se pueden
ver desde las instances, la clase original, y las subclases.
No vi/no entendi que ninguna forma de instanceVariableNames:,
o classVariableNames:, aplicadas a la clase o la metaclase, o
a piruloclase ;-) CONSIGUIERA
SEMEJANTE CONDUCTA de visibilidad.
Como es?
(si existen como se describe en ese texto, yo las hubiera
llamado directamente Shared Variables, como creo recordar que
estan en el libro Smalltalk-80, pero que nunca son usadas o
ejemplificadas en ese libro, hasta donde recuerdo).
Nos leemos!
Angel "Java" Lopez
@ajlopez
gh:ajlopez
2012/12/17 Guillermo Schwarz <[email protected]>
Qué
enredo.
- Eso
estaba desde Smalltalk-80? Estaba explicado en el
libro "clasico" de Smalltalk-80, The language? O
solo nombrado?
Sí.
Existe desde 1980.
- Como se declara que Beta es una class or shared
variable? Por lo que entendi, simplemente se le
asigna un valor en un metodo de una clase. Es asi?
Cuando
se declara una clase se pone la lista de
instaceVariables y de classVariables.
-
Necesita estar en primera letra mayuscula? Me
imagino:
--
Si, el compilador de metodos asi determina que es
Shared
--
No, el compilador de metodos determina que es Shared
si no es Instance, Local, Argument, etc....
En
Smalltalk 80 el lugar para definir las
instaceVariables no es el mismo que para definir las
classVariables:
Smalltalk es una instancia de SystemDictionary y es
donde están definidas las constantes de la aplicación,
en particular las clases están definidas en Smalltalk
como "nombre" -> la clase propiamente tal, con la
salvedad de que en el lenguaje Smalltalk no hay
diferencia entre tiempo de edición, compilación y
ejecución, y por lo tanto tan constantes no son, o si
quieres, son constantes hasta que las cambias y por lo
tanto son variables globales (podrías guardarlo en
cualquier otro dictionary, pero el compilador de
Smalltalk tiene la tendencia a usar Smalltalk como su
dictionary).
La única diferencia entre instanceVariables y
classVariables es que unas están asociadas a las
intancias (son un dictionary que están asociado a cada
instancia), mientras que classVariables están
asociadas a la clase propiamente tal y como tal, todas
las instancias pueden acceder a ellas (si utilizan un
classMethod en vez de un instanceMethod para acceder a
ellas). Para invocar un class method debes hacer self
class <<métdodo>>. ¿Se entiende?
De todas maneras es una trivialidad porque las
clases son objetos. En particular son instancias de la
clase "class", de modo que self class class debiera
ser siempre Class (o MetaClass dependiendo de la
variante de Smalltalk que uses), pero no es así
exactamente. Porque las instanceVariables de Class son
las classVariables de la clase en cuestión (entonces
todas las clases tendrían las mismas classVariables) y
por eso Smalltalk crea una metaclase heredada de Class
o MetaClass para cada clase que se crea, y esa clase
si no me equivoco no está en Smalltalk (el
SystemDictionary) ya que de todas maneras está en
MetaClass subclasses y en cada self class class.
Si conoces C++ o Java, el instanceVariable y el
classVariable es lo mismo que la diferencia entre
atributo normal y atributo estático, uno es propio de
la instancia y el otro es propio de la clase y por eso
se considera "compartido" (shared). Bueno y si no los
conoces, es cosa de ver la implementación que tiene
SystemDictionary y Compiler si al fin y al cabo en
Smalltalk se puede ver todo el código.
"Alpha
dosomething..." => Integer doesNotUnderstand:
#doSomething
El
compilador busca Alpha en Smalltalk y lo reemplaza
por 1 (un Integer), luego le envía el mensaje
dosomething y si no lo entiende... no
sé cómo ser más claro...
Juanita Ewing dice que existen 3 casos:
1. instance variables.
2. Class variables.
3. Class instance variables.
La diferencia entre 2 y 3 es que en el caso 2, se
comparten con las subclases y en el caso 3 no, por lo
tanto argumenta Juanita que es mejor 3.
Saludos,
Guillermo.
--
To post to this group, send email to [email protected]
To unsubscribe from this group, send email to [email protected]
http://www.clubSmalltalk.org
--
To post to this group, send email to
[email protected]
To unsubscribe from this group, send email to
[email protected]
http://www.clubSmalltalk.org
--
To post to this group, send email to [email protected]
To unsubscribe from this group, send email to [email protected]
http://www.clubSmalltalk.org
|
