Add a variable to a class instance at runtime: Difference between revisions

{{task|Object oriented}}

Demonstrate how to dynamically add variables to an object (a class instance) at runtime.

 

=={{header|ActionScript}}==

In ActionScript this can be done using an Object object

Or by creating a dynamic class

{

public dynamic class Foo

// ...

}

 

=={{header|Ada}}==

Ada is not a dynamically typed language. Yet it supports mix-in inheritance, run-time inheritance and interfaces. These three allow us to achieve the desired effect, however questionably useful it could be. The example declares an interface of the class (Class). Then a concrete type is created (Base). The object E is an instance of Base. Later, at the run time, a new type Monkey_Patch is created such that it refers to E and implements the class interface per delegation to E. Monkey_Patch has a new integer member Foo and EE is an instance of Monkey_Path. For the user EE appears as E with Foo.

 

procedure Dynamic is

Put_Line (EE.Boo & " with" & Integer'Image (EE.Foo));

end;

Sample output:

<pre>

I am Class with 1

</pre>

=={{header|AutoHotkey}}==

{{works with|AutoHotkey_L}}

 

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

It's not really intended that you should do this, but if you must you can:

REM Create a base class with no members:

IF EVAL("FNassign(" + v$ + "," + n$ + ")")

ENDPROC

 

=={{header|Bracmat}}==

This solution saves the original members and methods in a variable, using pattern matching. Then, using macro expansion, a new object is created with an additional member variable and also an additional method. Because the new object is assigned to the same variable as the original object, the original object ceases to exist.

= (aMember=) (aMethod=.!(its.aMember))

)

& out$("aMember contains:" (object..aMethod)$)

& out$("anotherMember contains:" (object..anotherMethod)$)

Output:

(object=

=(aMember=) (aMethod=.!(its.aMember)));

Call both methods and output their return values.

aMember contains: A value

 

=={{header|C sharp|C#}}==

{{works with|C sharp|C#|4.0}}

//

// Program.cs - DynamicClassVariable

#endregion

}

 

{{out}}

<pre>sampleObj.bar = 1

< Press any key ></pre>

 

=={{header|CoffeeScript}}==

# You can dynamically add attributes to objects.

 

e.yo = -> "baz"

console.log e.foo, e.yo()

 

=={{header|Common Lisp}}==

{{libheader|Closer to MOP}}

 

(change-class instance

(make-instance 'standard-class

:direct-superclasses (list (class-of instance))

 

Example:

 

(new-slots '((:name xenu :initargs (:xenu)))))

(augment-instance-with-slots instance new-slots)

BAR = 42

BAZ = 69

 

The following REPL transcript (from [[LispWorks]]) shows the definition of a class <code>some-class</code> with no slots, and the creation of an instance of the class. The first attempt to access the slot named <code>slot1</code> signals an error as there is no such slot. Then the class is redefined to have such a slot, and with a default value of 23. Attempting to access the slot in the preëxisting instance now gives the default value, since the slot has been added to the instance. This behavior is specified in [http://www.lispworks.com/documentation/HyperSpec/Body/04_cf.htm §4.3.6 Redefining Classes] of the [http://www.lispworks.com/documentation/HyperSpec/Front/index.htm HyperSpec].

 

=={{header|D}}==

private T[string] vars;

 

writeln(d2.a, " ", d2.b, " ", d2.c);

immutable int x = d2.b.get!int;

{{out}}

<pre>10.5 20.2

Hello 11 ['x':2, 'y':4]</pre>

If you want Dynamic to be a class the code is similar. If the attribute names aren't known at compile-time, you have to use a more normal syntax:

 

struct Dyn {

d[attribute_name] = "something";

writeln(d[attribute_name]);

{{out}}

<pre>something</pre>

 

=={{header|Elena}}==

 

{

}

 

 

 

 

{{out}}

<pre>

'''Array:'''

In this example we add a function (which prints out the content of the array) and a new value. While we are not technically adding a "variable", this example is presented to show similar type of functionality.

vect.dump = function ()

for n in [0: self.len()]

end

vect += 'delta'

Output from the above:

1: beta

2: gamma

'''Dictionary:'''

In this example we will add a variable through the use of an object from a bless'ed dictionary. We create a new variable called 'newVar' at runtime and assign a string to it. Additionally we assign an external, to the object, function (sub_func) to the variable 'sub'.

self['prop'] -= value

return self.prop

])

 

 

=={{header|FBSL}}==

FBSL class instances aren't expandable with additional, directly accessible public methods at runtime once the class template is defined in the user code. But FBSL has an extremely powerful feature -- an ExecLine() function -- which permits the user to execute any additional code on the fly either privately (bypassing the main code flow) or publicly (interacting with the main code). ExecLine() can be used for a variety of applications from the fine-tuning of current tasks to designing application plug-ins or completely standalone code debuggers. The following class instance may be stuffed up at runtime with any code from simple variables to executable private methods and properties.

 

CLASS Growable

PRINT Sponge.Yield()

 

'''Output:'''

1234567890

Needs the FMS-SI (single inheritance) library code located here:

http://soton.mpeforth.com/flag/fms/index.html

include FMS-SILib.f

 

:class foo

object-list inst-objects \ a dynamically growable object container

:m add: ( obj -- ) inst-objects add: ;m

:m at: ( idx -- obj ) inst-objects at: ;m

 

main \ => Now is the time 3.14159

 

=={{header|Groovy}}==

 

Any [[Groovy]] class that implements "''Object get(String)''" and "''void set(String, Object)''" will have the '''apparent''' capability to add new properties. However, this capability will only work as expected with an appropriate implementation, backed by a Map object or something very much like a Map.

final x = { it + 25 }

private map = new HashMap()

Object get(String key) { map[key] }

void set(String key, Object value) { map[key] = value }

 

Test:

a.y = 55

a.z = { println (new Date()); Thread.sleep 5000 }

(0..2).each(a.z)

 

 

Output:

Wed Feb 23 21:33:50 CST 2011

null</pre>

 

=={{header|Icon}} and {{header|Unicon}}==

Unicon implements object environments with records and supporting procedures for creation, initialization, and methods. To modify an instance you must create a new record then copy, amend, and replace it. Strictly speaking we can't guarantee the replace as there is no way to modify the existing object and we are creating a new instance with extensions. The procedures ''constructor'' and ''fieldnames'' are needed. This example doesn't do error checking. Here ''extend'' takes three arguments, the class instance, a list of new variable names as strings, and an optional list of new values to be assigned. The new instance is returned and the object is replaced by assignment. The caveat here is that if the object was assigned to anything else we will now have two objects floating around with possible side effects. As written this isn't safe from name collisions - aside from local declarations the use of a fixed constructor name uses the global name space. There is a final caveat that needs to be observed - if future implementations of objects change then this could easily stop working.

 

''Note:'' Unicon can be translated via a command line switch into icon which allows for classes to be shared with Icon code (assuming no other incompatibilities exist).

link ximage

 

x[newvars[i]] := newvals[i] # add new vars = values

return x

 

{{libheader|Icon Programming Library}}

R_tempconstructor_1.d := 9

R_tempconstructor_1.e := 7</pre>

 

=={{header|J}}==

If you assign a value to the name which references a property of a class instance, that name within that instance gets that value.

 

V__C=: 0 NB. ensure the class exists

OBJ1=:conew 'exampleclass' NB. create an instance of our class

0

W__OBJ2 NB. our other instance does not

 

=={{header|JavaScript}}==

This kind of thing is fundamental to JavaScript, as it's a prototype-based language rather than a class-based one.

e.foo = 1

 

=={{header|jq}}==

jq's "+" operator can be used to add a key/value pair (or to add multiple key-value pairs) to an existing object at runtime, but

jq is a functional programming language, and objects themselves cannot be altered. Thus it may be helpful to introduce a variable, since the value of a variable can in effect be updated. For example:

 

# or equivalently:

 

 

 

 

 

 

 

=={{header|Logtalk}}==

The following example uses a prototype for simplicity.

 

% we start by defining an empty object

:- object(foo).

 

:- end_category.

 

We can test our example by compiling and loading the two entities above and then querying the object:

 

| ?- foo::bar(X).

X = 1 ;

X = 3

true

 

=={{header|Lua}}==

 

Mathematica doesn't rally have classes, so it doesn't have class variables. However, many rules can be applied to a single tag, so it has some aspects similar to a class. With that definition, adding a class variable is similar to adding a rule:

f[a]=1;

f[b]=2;

f[a]=3;

Output:

Global`f

 

Here, the two 'variables' can be seen under the single heading 'f'. And of course all of this is done at runtime.

 

=={{header|Morfa}}==

To emulate adding a variable to a class instance, Morfa uses user-defined operators <tt>`</tt> and <tt>&lt;-</tt>.

import morfa.base;

 

}

}

{{out}}

<pre>

30 20

</pre>

 

You can put associative references on any object. You can put multiple ones on the same object. They are indexed by a pointer key (typically the address of some dummy variable). You use the functions <code>objc_getAssociatedObject()</code> and <code>objc_setAssociatedObject</code> to get and set them, respectively.

 

#import <objc/runtime.h>

 

}

return 0;

 

You can also use a selector as the key, since two selectors with the same content are guaranteed to be equal:

#import <objc/runtime.h>

 

}

return 0;

 

=={{header|Octave}}==

Octave is dynamically typed, and can have fields added in two methods:

 

% Given struct "test"

test.b=1;

test = setfield (test, "c", 3);

 

=={{header|ooRexx}}==

===Unknown Method Access===

This example traps unknown method calls, then sets or retrieves the values in an encapsulated directory object.

d = .dynamicvar~new

d~foo = 123

self~init:.dynamicvar

 

 

===Dynamic Method Definitions===

An object may be written that can dynamically add methods to itself. This example is similar to the above example, but the UNKNOWN method attaches a getter/setter pair of methods for the name triggering the UNKNOWN call. On all subsequent calls, the attribute methods will get called.

d = .dynamicvar~new

d~foo = 123

forward to(self) message(messageName) arguments(arguments)

 

 

=={{header|OxygenBasic}}==

Simple implementation for making runtime members - supports integer, float and string types.

'=================

class fleximembers

a.delete

 

=={{header|Oz}}==

It is not possible to add variables to instances in Oz. Every object has exactly one class and this association cannot be changed after object creation. Classes themselves are immutable.

However, classes are also first-class values and are created at runtime. Many of the tasks that are solved with "monkeypatching" in other languages, can be solved by dynamically creating classes in Oz.

 

%% Creates a new class derived from BaseClass

%% with an added feature (==public immutable attribute)

in

{Show Instance.bar} %% inherited feature

 

To add a variable number of features and attributes, you can use [http://www.mozart-oz.org/documentation/base/class.html Class.new].

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

=={{header|PHP}}==

 

$e=new E();

$e->{"foo"} = 1; // using a runtime name

$x = "foo";

 

=={{header|PicoLisp}}==

In general, all instance variables in PicoLisp are dynamically created at

runtime.

-> $385605941

: (put MyObject 'newvar '(some value)) # Set variable

$385605941 (+MyClass)

newvar (some value)

 

=={{header|Pike}}==

Pike does not allow adding variables to existing objects, but we can design a class that allows us to add variables.

{

mapping variables = ([]);

"greeting"

})

 

=={{header|Pop11}}==

it using the 'pop11_compile' procedure.

 

 

define :class foo;

met1(bar) => ;;; default value -- false

"baz" -> met1(bar);

 

=={{header|PowerShell}}==

PowerShell allows extending arbitrary object instances at runtime with the <code>Add-Member</code> cmdlet. The following example adds a property ''Title'' to an integer:

| Add-Member -PassThru `

NoteProperty `

Title `

Now that property can be accessed:

<pre>PS> $x.Title

=={{header|Python}}==

 

pass

 

If the variable (attribute) name is known at "compile" time (hard-coded):

 

 

If the variable name is determined at runtime:

 

'''Note:''' Somewhat counter-intuitively one cannot simply use ''e = object(); e.foo = 1'' because the Python base ''object'' (the ultimate ancestor to all new-style classes) will raise attribute exceptions. However, any normal derivatives of ''object'' can be "monkey patched" at will.

Because functions are first class objects in Python one can not only add variables to instances. One can add or replace functionality to an instance. Doing so is tricky if one wishes to refer back to other instance attributes since there's no "magic" binding back to "self." One trick is to dynamically define the function to be added, nested within the function that applies the patch like so:

 

def __init__(this):

this.foo = "whatever"

patch_empty(e)

e.print_output()

:Note: The name ''self'' is not special; it's merely the pervasive Python convention. In this example I've deliberately used ''this'' in the class definition to underscore this fact. The nested definition could use any name for the "self" object. Because it's nested the value of the object is evaluated at the time that the patch_empty() function is run and thus the function being patched in has a valid reference to the object into which it is being inserted. Other arguments could be passed as necessary. Such techniques are not recommended; however they are possible.

 

=={{header|REBOL}}==

REBOL [

Title: "Add Variables to Class at Runtime"

URL: http://rosettacode.org/wiki/Adding_variables_to_a_class_instance_at_runtime

]

print [crlf "Fighter squadron:"]

foreach pilot squadron [probe pilot]

 

=={{header|Red}}==

name: none

age: none

foreach person people [

print reduce [person/age "year old" person/name "is good at" any [select person 'skill "nothing"]]

 

=={{header|Ring}}==

We can add an attribute (or a group of attributes) to the object state using addattribute() function

addattribute(o1,"x")

addattribute(o1,"y")

addattribute(o1,"z")

see o1 {x=10 y=20 z=30}

{{out}}

<pre>

 

=={{header|Ruby}}==

end

 

f = Empty.new

f.foo = 1 # raises NoMethodError

 

"class << e" uses the ''singleton class'' of "e", which is an automatic subclass of Empty that has only this single instance. Therefore we added the "foo" accessor only to "e", not to other instances of Empty.

Another way of adding a method to a singleton is:

 

def yes_no.not

p yes_no.not # => "No"

p yes_no.not # => "Yes"

 

=={{header|Scala}}==

Since version 2.10 Scala supports dynamic types. Dynamic types have to implement trait ''Dynamic'' and implement methods ''selectDynamic'' and ''updateDynamic''.

 

import scala.collection.mutable.HashMap

 

map(name) = value

}

 

Sample output in the REPL:

 

a: A = A@7b20f29d

 

 

scala> a.foo

 

=={{header|Sidef}}==

var e = Empty(); # create a new class instance

e{:foo} = 42; # add variable 'foo'

 

=={{header|Slate}}==

Slate objects are prototypes:

define: #e -> Empty clone.

 

=={{header|Smalltalk}}==

This preserves object identity. (by the way: if we remember and reuse these temp classes, we get the core of Google's fast JavaScript interpreter implementation ;-)

{{works with|Smalltalk/X}} (should work with all Smalltalks, though)

 

addSlot :=

newObj := anonCls cloneFrom:obj.

obj become:newObj.

create a 2D Point object, add a z slot, change and retrieve the z-value, finally inspect it (and see the slots).

addSlot value:p value:'z'.

p z:30.

p z.

p z:40.

 

The above used a block to perform this operation in privacy. In a real world application, the addSlot code would be added as an extension to the Object class, as in.

 

addSlot: slotName

anonCls compile:('%1:v %1 := v' bindWith:slotName).

newObj := anonCls cloneFrom:self.

then, again create a 2D Point object, add a z slot, change and retrieve the z-value, finally inspect it (and see the slots).

p z:30.

p z.

p z:40.

 

{{incorrect|Smalltalk|It extends the class (adds a new instance var and new method that will exists even in brand new future instances of that class), not only the particular instance. -- The description of the problem must be reworded then, as it

asks for adding variables to the class, not the instance.

 

instanceVariableNames: 'aVar'

classVariableNames: ''

aMonkey setX: 10 .

aMonkey inspect .

 

Output is:

x: 10

10</pre>

 

=={{header|Swift}}==

We can use the same associated object mechanism as in Objective-C:

 

let fooKey = UnsafeMutablePointer<UInt8>.alloc(1)

} else {

print("no associated object")

 

=={{header|Tcl}}==

 

The code below uses the fact that each object is implemented as a namespace, to add a ''time'' variable to an instance of ''summation'':

% oo::class create summation {

constructor {} {

% $s value time

now

An alternative approach is to expose the (normally hidden) <code>varname</code> method on the object so that you can get a handle for an arbitrary variable in the object.

constructor {} {

variable v 0

% # Show that it is only in one object...

% $s2 value time

 

 

 

{{omit from|ALGOL 68}}

{{omit from|AWK}}

{{omit from|Brainf***}}

{{omit from|C++}}

{{omit from|Clojure}}

{{omit from|F Sharp}}

{{omit from|Fortran}}

{{omit from|gnuplot}}

{{omit from|GUISS}}

{{omit from|Haskell}}

{{omit from|Integer BASIC}}

{{omit from|Java}}

{{omit from|Lily}}

{{omit from|M4}}

{{omit from|Maxima}}

{{omit from|ML/I}}

{{omit from|NetRexx}}

{{omit from|OCaml}}

{{omit from|Octave}}

{{omit from|Pascal}}

{{omit from|PlainTeX}}

{{omit from|PureBasic}}

{{omit from|Retro}}

{{omit from|UNIX Shell}}

{{omit from|ZX Spectrum Basic}} <!-- Does not have objects. -->