Dynamic variable names: Difference between revisions

{{task|Programming environment operations}}

;Task:

Create a variable with a user-defined name.

*   [[Eval in environment]] is a similar task.

<br><br>

 

=={{header|APL}}==

is←{ t←⍵ ⋄ ⎕this⍎⍺,'←t' } ⍝⍝ the 'Slick Willie' function ;)

'test' is ⍳2 3

1 1 1 2 1 3

2 1 2 2 2 3

 

=={{header|Arturo}}==

 

value: strip input "enter a variable value: "

let name value

 

{{out}}

 

=={{header|AutoHotkey}}==

%Dynamic% = hello

ListVars

 

=={{header|AWK}}==

# syntax: GAWK -f DYNAMIC_VARIABLE_NAMES.AWK

# Variables created in GAWK's internal SYMTAB (symbol table) can only be accessed via SYMTAB[name]

printf("\nsymbol table contains %d names of which %d are arrays\n\n",length(SYMTAB),count)

}

{{out}}

<pre>

{{works with|Beta BASIC|3.0}},

{{works with|SAM BASIC}}

 

=={{header|Batch File}}==

setlocal enableDelayedExpansion

 

 

::Display the value using delayed expansion

 

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

INPUT "Enter a numeric value: " numeric$

dummy% = EVAL("FNassign("+name$+","+numeric$+")")

END

 

=={{header|Bracmat}}==

& get$:?name

& whl

& !numeric:?!name

& put$(str$("Variable " !name " now has the value " !!name \n))

 

{{works with|C sharp|5}}

Not exactly a variable, but ExpandoObject allows adding properties at runtime.

using System.Dynamic;

using System.Collections.Generic;

Console.WriteLine(expando.foo);

}

{{out}}

<pre>

Hello world!

</pre>

 

=={{header|Clojure}}==

 

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

The short answer is this:

(setq var-name (read)) ; reads a name into var-name

(set var-name 1) ; assigns the value 1 to a variable named as entered by the user

 

 

 

Therefore, there are two parts to dynamically creating a variable: we must declare it special, and give it a value. The first part is accomplished by the <code>proclaim</code> function for making declarations at run-time. The second part is simply assigning to the value slot.

"Create a global variable whose name is NAME in the current package and which is bound to INITIAL-VALUE."

(let ((symbol (intern name)))

(proclaim `(special ,symbol))

(setf (symbol-value symbol) initial-value)

GREETING

 

CL-USER> (print greeting)

Things to note:

 

=={{header|Déjà Vu}}==

In Déjà Vu, variable names are idents, which are completely separate from strings, and cannot easily be created from them. The way around that is to invoke the compiler:

local var-name 42

 

#Assuming the user types THISISWEIRD, otherwise this'll error

{{out}}

<pre>Enter a variable name: THISISWEIRD

=={{header|E}}==

In E, there are no global variables, and there is no modification of the local (lexical) environment. However, it is possible to construct a program which binds any given variable name.

 

def dynVarName(name) {

 

? dynVarName("c")

It is also possible to capture the environment object resulting from the evaluation of the constructed program and use it later; this is done by <code>bindX</code> in [[Eval in environment#E]] (except for the program being constant, which is independent).

 

Dynamic variables are not supported by the language. But it is possible to set a dynamic property.

 

import extensions;

 

class TestClass

{

 

constructor()

{

}

function()

{

}

}

 

{{out}}

<pre>

A variable is a symbol. A name can be read from the user as a string and interned to a symbol.

 

 

This example deliberately doesn't use any temporary variables so their names won't clash with what the user might enter. A <code>set</code> like this hits any <code>let</code> dynamic binding or buffer-local setting in the usual way.

 

=={{header|Erlang}}==

This task uses functions from [[Eval_in_environment#Erlang| Runtime evaluation]].

-module( dynamic_variable_names ).

 

Form = runtime_evaluation:form_from_string( erlang:atom_to_list(Variable_name) ++ "." ),

io:fwrite( "~p has value ~p~n", [Variable_name, runtime_evaluation:evaluate_form(Form, {Variable_name, 42})] ).

{{out}}

<pre>

=={{header|Factor}}==

By convention, variable names are usually symbols, but because dynamic variables are implemented via implicit association lists, any object can be used as the key for a value. In this case, we use the string the user enters.

 

=={{header|Forth}}==

." Variable name: " pad 9 + 80 accept

Of course, it is easier for the user to simply type VARIABLE ''name'' at the Forth console.

 

FreeBASIC is a statically typed, compiled language and so it is not possible to create new variables, dynamically, at run time. However, you can make it look to the user like you are doing so with code such as the following. Ideally, a 'map' should be used for an exercise such as this but, as there isn't one built into FB, I've used a dynamic array instead which is searched linearly for the variable name.

 

 

Type DynamicVariable

End If

Loop

 

Sample input/output :

 

=={{header|GAP}}==

Assign := function(var, val)

Read(InputTextString(Concatenation(var, " := ", String(val), ";")));

 

=={{header|Genyris}}==

The intern function creates a symbol from an arbitrary string. Defvar creates a binding. Weird symbols are quoted with pipe characters.

 

=={{header|Go}}==

{{trans|FreeBASIC}}

Go is in the same boat as other statically typed, compiled languages here in that variables cannot be created dynamically at runtime. However, we can use the built-in map type to associate names input at runtime with values which, in practice, is just as good.

 

import (

}

}

 

{{out}}

=={{header|Groovy}}==

Solution:

def value = 42

 

new GroovyShell(this.binding).evaluate("${varname} = ${value}")

 

 

=={{header|Haskell}}==

main = do

putStrLn "please enter you variable name"

vName <- getLine

let var = Var vName 42

 

{{omit cat|Unicon}}

 

=={{header|J}}==

This code was written for J6.02. In J8.04 you will need to replace require'misc' with require'general/misc/prompt'

 

 

(prompt 'Enter variable name: ')=: 0

Enter variable name: FOO

FOO

Or, if the name is defined in the variable 'userDefined'

(userDefined)=: 1

BAR

 

=={{header|Java}}==

Java does not support dynamic naming of variables. Therefore, HashMap has been implemented here. It is similar to an array but allows the searching of values by String keys instead of simply index numbers.

HashMap<String, Integer> vars = new HashMap<String, Integer>();

//The variable name is stored as the String. The var type of the variable can be

System.out.println(vars.get(str));

}

=={{header|JavaScript}}==

var value = 42;

Alternatively, without using eval:

var value = 42;

 

=={{header|jq}}==

jq does not have variables in the usual sense, but in practice the key/value pairs of JSON objects can be used as variable/value bindings. Using this approach, the given task can be accomplished using the following program:

 

(input as $var

| ("Enter a value:" ,

 

''Transcript''

Julia has powerful macros:

 

 

variable = Symbol(readline(STDIN))

@show variable

println("If I named the variable x:")

 

{{out}}

Kotlin is a statically typed, compiled language and so it is not possible to create new variables, dynamically, at run time. However, you can make it look to the user like you are doing so with code such as the following which uses a map:

{{trans|FreeBASIC}}

 

fun main(args: Array<String>) {

else println("It's value is $v")

}

Sample input/output:

{{out}}

 

Which variable do you want to inspect : q

</pre>

 

 

The example below outputs a random decimal that was assigned to the variable name entered as part of the GET params.

if(#thename->size) => {^

var(#thename = math_random)

else

'<a href="?thename=xyz">Please give the variable a name!</a>'

 

=={{header|Lingo}}==

 

-- A new global variable with a user-defined name can be created at runtime like this:

 

-- An new instance variable (object property) with a user-defined name can be created at runtime like this:

 

=={{header|Logo}}==

julie

12

? show :julie

 

=={{header|Logtalk}}==

Logtalk objects can be create or compiled such that new predicates can be added at runtime. A simple example:

| ?- create_object(Id, [], [set_logtalk_flag(dynamic_declarations,allow)], []),

write('Variable name: '), read(Name),

| ?- o1::foo(X).

X = 42.

 

=={{header|Lua}}==

 

=={{header|M2000 Interpreter}}==

Module DynamicVariable {

input "Variable Name:", a$

Keyboard "George"+chr$(13)

DynamicVariable

 

=={{header|M4}}==

define(`inp',esyscmd(`echoinp'))

define(`trim',substr(inp,0,decr(len(inp))))

define(trim,42)

 

DOS batch file echoinp.bat:

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

varvalue = InputString["Enter a value"];

ReleaseHold[ Hold[Set["nameholder", "value"]] /. {"nameholder" -> Symbol[varname], "value" -> varvalue}];

{{out|Example output}}

<pre>-> testvar is now set to 86</pre>

 

=={{header|Maxima}}==

 

=={{header|min}}==

{{works with|min|0.19.3}}

 

=={{header|MUMPS}}==

This is done in immediate mode so you can see the variable is created, although you will have to reference it through the indirection operator, "@".

USER>WRITE ;show all variables and definitions

A="GIBBERISH"

 

=={{header|Nanoquery}}==

name = input()

 

print name + " = "

exec(name + " = 42")

{{out}}

<pre>Enter a variable name: test

 

This solution emulates dynamic variables by mapping a string to a pointer to a variable (using a table).

 

var

 

when isMainModule:

{{out}}

<pre>Enter a var name: varZ

 

=={{header|Octave}}==

value = input ("Enter value: ", "s");

 

=={{header|Oforth}}==

"tvar: " varname + eval ;

 

 

12 myvar put

 

=={{header|PARI/GP}}==

 

=={{header|Pascal}}==

===Free Pascal===

{{works with|Free Pascal|version 3.2.0 }}

PROGRAM ExDynVar;

 

(*)

Free Pascal Compiler version 3.2.0 [2020/06/14] for x86_64

compiles natively to almost any platform, including raspberry PI

(*)

 

 

TYPE

D: Tdict;

 

(*)

If the value is numeric, store it as numeric, otherwise store it as ansistring

(*)

BEGIN

TRY

SetType := StrToFloat ( strVal ) ;

SetType := strVal ;

END;

END;

 

BEGIN

D := TDict.Create;

REPEAT

UNTIL ( strValue = '' ) ;

D.Free;

END.

 

=={{header|Perl}}==

$varname = <STDIN>; # type in "foo" on standard input

chomp($varname);

# treated as a "symbolic reference", where they

# take the string as the name of the variable

If you are operating in a strict environment, this isn't possible. You need to use 'eval' in this case

 

print "Enter a variable name: ";

my $varref = eval('\$' . $varname);

$$varref = 42;

 

=={{header|Phix}}==

=== dictionary ===

In a sense, this is kinda faking it:

 

while 1 do

setd(name,data,globals)

end if

{{Out}}

<pre>

=== dynamic classes ===

{{libheader|Phix/Class}}

class dc dynamic

-- public string fred = "555" -- (predefine some fields if you like)

d[name] = data

end if

Same output as above (for the same input)<br>

Note you would get a fatal crash were that predefined fred not made public, and you entered that, which you could I suppose avoid by testing the result of get_field_flags(d,name) for SF_PRIVATE (and then skipping the prompt and any attempt to store).

 

=={{header|PHP}}==

$varname = rtrim(fgets(STDIN)); # type in "foo" on standard input

$$varname = 42;

echo "$foo\n"; # prints "42"

 

=={{header|PicoLisp}}==

(prin "Enter a variable name: ")

(let Var (line T) # Read transient symbol

(prin "Enter a value: ")

(set Var (read)) # Set symbol's value

{{out}}

<pre>Enter a variable name: Tom

 

=={{header|PowerShell}}==

New-Variable $variableName 'Foo'

 

=={{header|ProDOS}}==

editvar /newvar /value=b /userinput=1 /title=Enter a variable title:

 

=={{header|Python}}==

{{works with|Python|2.x}}

Enter a variable name: X

>>> globals()[name] = 42

>>> X

{{works with|Python|3.x}}

Enter a variable name: X

>>> globals()[name] = 42

>>> X

Note: most of the time when people ask how to do this on newsgroups and other forums, on investigation, it is found that a neater solution is to '''map name to value in a dictionary'''.

 

Quackery does not have variables, but it does have ''ancillary stacks'' which can be used as variables.

 

dup echo$

names find names found iff

$ "[ stack ] is " over join quackery

cr cr

 

{{out}}

 

=={{header|R}}==

varname <- readline("Please name your variable >")

# Make sure the name is valid for a variable

#Check that the value has been assigned ok

ls(pattern=varname)

 

=={{header|Racket}}==

This works on the Racket REPL:

 

-> (begin (printf "Enter some name: ")

(namespace-set-variable-value! (read) 123))

-> bleh

123

 

=={{header|Raku}}==

You can [https://docs.raku.org/language/packages#Interpolating_into_names interpolate strings as variable names]:

 

my $my-var = 'The my var';

 

 

put qq/Var ($name) ends with value ｢{$::('name')}｣/;

 

=={{header|REBOL}}==

Title: "Dynamic Variable Name"

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

; accepts the new word and the string ("Hello!") to be assigned.

 

{{out|Session output}}

<pre>Variable name? glister

 

=={{header|Retro}}==

 

 

=={{header|REXX}}==

:::* &nbsp; check for the minimum number of arguments

:::* &nbsp; check for a legitimate REXX variable name

parse arg newVar newValue

say 'Arguments as they were entered via the command line: ' newVar newValue

call value newVar, newValue

say 'The newly assigned value (as per the VALUE bif)------' newVar value(newVar)

'''output''' &nbsp; for the input: &nbsp; <tt> abc &nbsp; 456 </tt>

<pre>

 

=={{header|Ring}}==

See "Enter the variable name: " give cName eval(cName+"=10")

See "The variable name = " + cName + " and the variable value = " + eval("return "+cName) + nl

Output

Enter the variable name: test

The variable name = test and the variable value = 10

 

=={{header|RLaB}}==

In RLaB all the objects are located in a global list $$. To create a variable dynamically, one writes a new entry into the global list. Consider the following example:

myusername

>> $$.[s] = 10;

>> myusername

 

=={{header|Ruby}}==

x = "@" + gets.chomp!

instance_variable_set x, 42

p "The value of #{x} is #{instance_variable_get x}"

{{out|Example output}}

"Enter a variable name"

 

=={{header|Scheme}}==

(eval `(define ,name ,initial-val) (interaction-environment)))

 

 

=> hello

 

=={{header|Sidef}}==

It is not possible to create a new lexical variable at run-time, but there are other various ways to do something similar.

 

 

class DynamicVar(name, value) {

 

var v = DynamicVar(name, 42); # creates a dynamic variable

 

=={{header|Slate}}==

Slate symbols are objects that name methods and slots. "Variable definition" is like defining a method which holds the value of a slot, and "variable access" is just method-call to get that value back.

define: name -> 42.

 

=={{header|Smalltalk}}==

Set that variable to 42.

Print that variable's name and value.

varName := FillInTheBlankMorph

request: 'Enter a variable name'.

show: ''value of ', varName, ''';

show: '' is '';

the above creates a variable which is visible only inside the evaluated block (which is considered good style). It will not be visible outside.

 

A bad style alternative which creates a globally visible variable in the Smalltalk namespace (and is therefore visible everywhere) is:

varName := Stdin request: 'Enter a global variable name:'.

Smalltalk at:varName asSymbol put:42.

expr := Stdin request:'Enter an expression:'.

(Compiler evaluate:expr) printCR

Be reminded again: this is considered *very very bad style*, and every programmer doing this should be fired.

{{out}}<pre>Enter a global variable name: abc

=={{header|SNOBOL4}}==

Indirect string reference of variables is a basic feature of Snobol, using the $ operator. trim( ) is needed for Snobol4+.

output = 'Enter variable name:'

invar = trim(input)

* Display

output = invar ' == ' $invar

{{out}}

<pre>Enter variable name:

Here a scalar variable is created, but one could create a dataset variable, a matrix... Notice the name of the variable is not "s", but the name stored in the global macro "s".

 

scalar $s=10

 

=={{header|Tcl}}==

gets stdin varname

set $varname 42

Note that it is more normal to use the user's name to index into a Tcl associative array, as the syntax gets easier to work with in that case:

gets stdin elemname

set ary($elemname) [expr int(rand()*100)]

Another common method for working with dynamic variables is to make an alias to the variable with a fixed name:

gets stdin varname

upvar 0 $varname v; # The ‘0’ for “current scope”

set v [expr int(rand()*100)]

 

=={{header|TI-89 BASIC}}==

InputStr "Variable name", varName

Prompt value

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

ASK "Enter variablename": name=""

@name=$value

PRINT @name

Output:

<pre>

 

=={{header|UNIX Shell}}==

declare $name=42

 

=={{header|Wren}}==

 

System.print("Enter three variables:")

for (i in 0..2) {

}

 

System.print("\nYour variables are:\n")

System.print(" %(kv.key) = %(kv.value)")

 

{{out}}

Enter three variables:

 

 

 

 

Your variables are:

wilfred = 5

</pre>

 

=={{header|zkl}}==

zkl doesn't support adding vars to an existing class but can create a new class with new vars:

klass:=Compiler.Compiler.compileText("var %s=123".fmt(vname))(); // compile & run the constructor

klass.vars.println();

klass.foo.println();

{{out}}

<pre>

 

=={{header|Zsh}}==

 

{{omit from|ACL2}}