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

=={{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>

 

=={{header|Io}}==

 

 

=={{header|J}}==

Simple assignment will add variables to classes.

 

 

=={{header|JavaScript}}==

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

 

=={{header|Lua}}==

=={{header|Perl}}==

{{works with|Perl|5.x}}

 

=={{header|PHP}}==

 

=={{header|Pop11}}==

it using the 'pop11_compile' procedure.

 

 

define :class foo;

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

"baz" -> met1(bar);

 

=={{header|PowerShell}}==

=={{header|Python}}==

 

 

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

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:

 

 

 

: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|Ruby}}==

 

 

=={{header|Slate}}==

Slate objects are prototypes:

define: #e -> Empty clone.

 

=={{header|Smalltalk}}==