Dynamic variable names

From Rosetta Code
Task
Dynamic variable names
You are encouraged to solve this task according to the task description, using any language you may know.
Task

Create a variable with a user-defined name.

The variable name should not be written in the program text, but should be taken from the user dynamically.


See also



APL

      is{ t  ⎕this,'←t' } ⍝⍝ the 'Slick Willie' function ;)
      'test' is 2 3
      test
 1 1  1 2  1 3 
 2 1  2 2  2 3

Arturo

name: strip input "enter a variable name: "
value: strip input "enter a variable value: "
 
let name value
 
print ["the value of variable" name "is:" var name]
Output:
enter a variable name: myvar
enter a variable value: 2021
the value of variable myvar is: 2021 

AutoHotkey

InputBox, Dynamic, Variable Name   
%Dynamic% = hello 
ListVars
MsgBox % %dynamic%  ; says hello

AWK

# syntax: GAWK -f DYNAMIC_VARIABLE_NAMES.AWK
# Variables created in GAWK's internal SYMTAB (symbol table) can only be accessed via SYMTAB[name]
BEGIN {
    PROCINFO["sorted_in"] = "@ind_str_asc"
    show_symbol_table()
    while (1) {
      printf("enter variable name? ")
      getline v_name
      if (v_name in SYMTAB) {
        printf("name already exists with a value of '%s'\n",SYMTAB[v_name])
        continue
      }
      if (v_name ~ /^$/) {
        printf("name is null\n")
        continue
      }
      if (v_name !~ /^[A-Za-z][A-Za-z0-9_]*$/) {
        printf("name illegally constructed\n")
        continue
      }
      break
    }
    printf("enter value? ")
    getline v_value
    SYMTAB[v_name] = v_value
    printf("variable '%s' has been created and assigned the value '%s'\n\n",v_name,v_value)
    show_symbol_table()
    exit(0)
}
function show_symbol_table(  count,i) {
    for (i in SYMTAB) {
      printf("%s ",i)
      if (isarray(SYMTAB[i])) { count++ }
    }
    printf("\nsymbol table contains %d names of which %d are arrays\n\n",length(SYMTAB),count)
}
Output:
ARGC ARGIND ARGV BINMODE CONVFMT ENVIRON ERRNO FIELDWIDTHS FILENAME FNR FPAT FS IGNORECASE LINT NF NR OFMT OFS ORS PREC PROCINFO RLENGTH ROUNDMODE RS RSTART RT SUBSEP TEXTDOMAIN v_name v_value
symbol table contains 30 names of which 3 are arrays

enter variable name? FPAT
name already exists with a value of '[^[:space:]]+'
enter variable name? 0
name illegally constructed
enter variable name?
name is null
enter variable name? animal
enter value? zebra
variable 'animal' has been created and assigned the value 'zebra'

ARGC ARGIND ARGV BINMODE CONVFMT ENVIRON ERRNO FIELDWIDTHS FILENAME FNR FPAT FS IGNORECASE LINT NF NR OFMT OFS ORS PREC PROCINFO RLENGTH ROUNDMODE RS RSTART RT SUBSEP TEXTDOMAIN animal v_name v_value
symbol table contains 31 names of which 3 are arrays

BASIC

Works with: Beta BASIC version 3.0
,
Works with: SAM BASIC
10 INPUT "Enter a variable name", v$
20 KEYIN "LET "+v$+"=42"

Batch File

@echo off
setlocal enableDelayedExpansion

set /p "name=Enter a variable name: "
set /p "value=Enter a value: "

::Create the variable and set its value
set "%name%=%value%"

::Display the value without delayed expansion
call echo %name%=%%%name%%%

::Display the value using delayed expansion
echo %name%=!%name%!

BBC BASIC

      INPUT "Enter a variable name: " name$
      INPUT "Enter a numeric value: " numeric$
      dummy% = EVAL("FNassign("+name$+","+numeric$+")")
      PRINT "Variable " name$ " now has the value "; EVAL(name$)
      END
      
      DEF FNassign(RETURN n, v) : n = v : = 0

Bracmat

( put$"Enter a variable name: "
& get$:?name
&   whl
  ' ( put$"Enter a numeric value: "
    & get$:?numeric:~#
    )
& !numeric:?!name
& put$(str$("Variable " !name " now has the value " !!name \n))
);

C#

Works with: C sharp version 5

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

using System;
using System.Dynamic;
using System.Collections.Generic;

public class Program
{
    public static void Main()
    {
        string varname = Console.ReadLine();
        //Let's pretend the user has entered "foo"
        dynamic expando = new ExpandoObject();
        var map = expando as IDictionary<string, object>;
        map.Add(varname, "Hello world!");
 
        Console.WriteLine(expando.foo);
    }
}
Output:
Hello world!

Clojure

(eval `(def ~(symbol (read)) 42))

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


The academic answer is this:

In Common Lisp, symbol objects name variables; symbols are produced from strings by way of read (general syntax) or intern (specificially retrieving or making a symbol).

Symbols are grouped into packages — roughly namespaces — and any time symbols are created at runtime it is usually good to explicitly specify what package they are created in, outside of user/developer tools for working from the REPL (interactive mode) where the current package *package* is appropriate.

Within the standard, every variable is either lexical or special (dynamic scope). There is no global lexical environment, so in order to "create a variable", we must either create our own mechanism to remember it for lexical binding in a later evaluation, or create a special variable. It is unspecified what happens when a symbol not lexically bound or declared special is used as a variable.

Every symbol has a value slot — a field which, roughly, contains its current value considered as a special variable.

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 proclaim function for making declarations at run-time. The second part is simply assigning to the value slot.

(defun rc-create-variable (name initial-value)
  "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)
    symbol))
CL-USER> (rc-create-variable "GREETING" "hello")
GREETING

CL-USER> (print greeting)
"hello"

Things to note:

  • Once a symbol has been declared special, it cannot be used as a lexical variable. Because of this potentially-surprising behavior, it is conventional to give all symbols naming special variables distinguished names, typically by asterisks as in *greeting*, so that lexical variables will not accidentally be given those names.
  • Some implementations do, to some extent, support global non-special variables; in these, because of the preceding problem, it is better to simply set the value slot and not proclaim it special. However, this may provoke undefined-variable warnings since the compiler or interpreter has no information with which to know the symbol is intended to be a variable.
  • Common Lisp, by default, is case-insensitive; however it accomplishes this by canonicalizing read input to uppercase; there is syntax to denote a lower or mixed-case symbol name, |Foo| or F\o\o. intern does not go through the input path (reader), so we must provide the name in uppercase to make an "ordinary" variable name.

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 !run-blob !compile-string dup concat( ":" !prompt "Enter a variable name: " )
local var-name 42

#Assuming the user types THISISWEIRD, otherwise this'll error
!. THISISWEIRD
Output:
Enter a variable name: THISISWEIRD
42

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 makeNounExpr := <elang:evm.makeNounExpr>

def dynVarName(name) {
    def variable := makeNounExpr(null, name, null)

    return e`{
    
        def a := 1
        def b := 2
        def c := 3
    
        {
            def $variable := "BOO!"
            [a, b, c]
        }
    
    }`.eval(safeScope)
}

? dynVarName("foo")
# value: [1, 2, 3]

? dynVarName("b")
# value: [1, "BOO!", 3]

? dynVarName("c")
# value: [1, 2, "BOO!"]

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 bindX in Eval in environment#E (except for the program being constant, which is independent).

Delphi

See Pascal.

Elena

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

ELENA 6.x :

import system'dynamic;
import extensions;

class TestClass
{
    object variables;

    constructor()
    {
        variables := new DynamicStruct()
    }
    
    function()
    {
        auto prop := new MessageName(console.write("Enter the variable name:").readLine());
        (prop.setPropertyMessage())(variables,42);
        
        console.printLine(prop.toPrintable(),"=",(prop.getPropertyMessage())(variables)).readChar()     
    }
}

public program = new TestClass();

The program should be compiled as a vm-client:

    elena-cli sandbox.l -tvm_console
Output:
Enter the variable name:a
a=42

Emacs Lisp

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

(set (intern (read-string "Enter variable name: ")) 123)

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

Epoxy

The debug library allows you to add, get, and delete variables.

--Add user-defined variable to the stack
const VarName: io.prompt("Input Variable Name: "),
	VarValue: io.prompt("Input Variable Value: ")
	
debug.newvar(VarName,VarValue)

--Outputting the results
log(debug.getvar(VarName))
Output:
Input Variable Name: Test
Input Variable Value: Hello, world!
Hello, world!

Erlang

This task uses functions from Runtime evaluation.

-module( dynamic_variable_names ).

-export( [task/0] ).

task() ->
    {ok,[Variable_name]} = io:fread( "Variable name? ",	"~a" ),
    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})] ).
Output:
12> dynamic_variable_names:task().
Variable name? Asd
'Asd' has value 42

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.

42 readln set

Forth

s" VARIABLE " pad swap move
." Variable name: " pad 9 + 80 accept
pad swap 9 + evaluate

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

FreeBASIC

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.

' FB 1.05.0 Win64

Type DynamicVariable
  As String name
  As String value
End Type

Function FindVariableIndex(a() as DynamicVariable, v as String, nElements As Integer) As Integer
  v = LCase(Trim(v))
  For i As Integer = 1 To nElements
    If a(i).name = v Then Return i
  Next
  Return 0 
End Function

Dim As Integer n, index
Dim As String v
Cls

Do
 Input "How many variables do you want to create (max 5) "; n
Loop Until n > 0 AndAlso n < 6 

Dim a(1 To n) As DynamicVariable
Print
Print "OK, enter the variable names and their values, below"

For i As Integer = 1 to n
  Print
  Print "  Variable"; i
  Input "    Name  : ", a(i).name 
  a(i).name = LCase(Trim(a(i).name)) ' variable names are not case sensitive in FB
  If i > 0 Then
     index = FindVariableIndex(a(), a(i).name, i - 1)
     If index > 0 Then
       Print "  Sorry, you've already created a variable of that name, try again"
       i -= 1
       Continue For
     End If 
  End If
  Input "    Value : ", a(i).value
  a(i).value = LCase(Trim(a(i).value))
Next

Print
Print "Press q to quit"
Do
  Print
  Input "Which variable do you want to inspect "; v
  If v = "q" OrElse v = "Q" Then Exit Do
  index = FindVariableIndex(a(), v, n)
  If index = 0 Then
    Print "Sorry there's no variable of that name, try again"
  Else
    Print "It's value is "; a(index).value
  End If
Loop
End

Sample input/output :

Output:
How many variables do you want to create (max 5) ? 3

OK, enter the variable names and their values, below

  Variable 1
    Name  : a
    Value : 1

  Variable 2
    Name  : b
    Value : 2

  Variable 3
    Name  : b
  Sorry, you've already created a variable of that name, try again

  Variable 3
    Name  : c
    Value : 4

Press q to quit

Which variable do you want to inspect ? b
It's value is 2

Which variable do you want to inspect ? c
It's value is 4

Which variable do you want to inspect ? a
It's value is 1

Which variable do you want to inspect ? q

GAP

# As is, will not work if val is a String
Assign := function(var, val)
	Read(InputTextString(Concatenation(var, " := ", String(val), ";")));
end;

Genyris

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

defvar (intern 'This is not a pipe.') 42
define |<weird>| 2009

Go

Translation of: 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.

package main

import (
    "bufio"
    "fmt"
    "log"
    "os"
    "strconv"
    "strings"
)

func check(err error) {
    if err != nil {
        log.Fatal(err)
    }
}

func main() {
    scanner := bufio.NewScanner(os.Stdin)
    n := 0
    for n < 1 || n > 5 {
        fmt.Print("How many integer variables do you want to create (max 5) : ")
        scanner.Scan()
        n, _ = strconv.Atoi(scanner.Text())
        check(scanner.Err())
    }
    vars := make(map[string]int)
    fmt.Println("OK, enter the variable names and their values, below")
    for i := 1; i <= n; {
        fmt.Println("\n  Variable", i)
        fmt.Print("    Name  : ")
        scanner.Scan()
        name := scanner.Text()
        check(scanner.Err())
        if _, ok := vars[name]; ok {
            fmt.Println("  Sorry, you've already created a variable of that name, try again")
            continue
        }
        var value int
        var err error
        for {
            fmt.Print("    Value : ")
            scanner.Scan()
            value, err = strconv.Atoi(scanner.Text())
            check(scanner.Err())
            if err != nil {
                fmt.Println("  Not a valid integer, try again")
            } else {
                break
            }
        }
        vars[name] = value
        i++
    }
    fmt.Println("\nEnter q to quit")
    for {
        fmt.Print("\nWhich variable do you want to inspect : ")
        scanner.Scan()
        name := scanner.Text()
        check(scanner.Err())
        if s := strings.ToLower(name); s == "q" {
            return
        }
        v, ok := vars[name]
        if !ok {
            fmt.Println("Sorry there's no variable of that name, try again")
        } else {
            fmt.Println("It's value is", v)
        }
    }
}
Output:

Sample input/output:

How many integer variables do you want to create (max 5) : 3
OK, enter the variable names and their values, below

  Variable 1
    Name  : pip
    Value : 1

  Variable 2
    Name  : squeak
    Value : 2

  Variable 3
    Name  : pip
  Sorry, you've already created a variable of that name, try again

  Variable 3
    Name  : wilfred 
    Value : 3

Enter q to quit

Which variable do you want to inspect : squeak
It's value is 2

Which variable do you want to inspect : auntie
Sorry there's no variable of that name, try again

Which variable do you want to inspect : wilfred
It's value is 3

Which variable do you want to inspect : q

Groovy

Solution:

def varname = 'foo'
def value = 42

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

assert foo == 42

Haskell

data Var a = Var String a deriving Show
main = do
    putStrLn "please enter you variable name"
    vName <- getLine
    let var = Var vName 42
    putStrLn $ "this is your variable: " ++ show var

Tasks listed here have been marked as "un-implementable" in Unicon. Solutions may be impossible to do, too complex to be of any valuable instruction in Unicon, or prohibited by the task definition.

But hey; if you think you can prove us wrong, go for it. :-)


Insitux

This first approach creates a function that creates a variable of that name.

(let var-name "hello")
((eval (str "(var " var-name ")")) 123)

This second approach puts the variable value directly in the evaluated string.

(let var-name "hello")
(eval (str "(var " var-name " 123)"))

J

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

require 'misc'
(prompt 'Enter variable name: ')=: 0
For example:
   require 'misc'
   (prompt 'Enter variable name: ')=: 0
Enter variable name: FOO
   FOO
0

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

   userDefined=: 'BAR'
   (userDefined)=: 1
   BAR
1

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.

public static void main(String... args){
        HashMap<String, Integer> vars = new HashMap<String, Integer>();
        //The variable name is stored as the String. The var type of the variable can be
        //changed by changing the second data type mentiones. However, it must be an object
        //or a wrapper class.
        vars.put("Variable name", 3); //declaration of variables
        vars.put("Next variable name", 5);
        Scanner sc = new Scanner(System.in);
        String str = sc.next();
        vars.put(str, sc.nextInt()); //accpeting name and value from user
        
        System.out.println(vars.get("Variable name")); //printing of values
        System.out.println(vars.get(str));
}

JavaScript

var varname = 'foo';  // pretend a user input that
var value = 42;
eval('var ' + varname + '=' + value);

Alternatively, without using eval:

var varname = prompt('Variable name:');
var value = 42;
this[varname] = value;

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:

"Enter a variable name:",
(input as $var
 | ("Enter a value:" ,
    (input as $value | { ($var) : $value })))

Transcript

$ jq -nrR -f program.jq
Enter a variable name:
abracadabra
Enter a value:
magic
{
  "abracadabra": "magic"
}

Julia

Works with: Julia version 0.6

Julia has powerful macros:

print("Insert the variable name: ")

variable   = Symbol(readline(STDIN))
expression = quote
    $variable = 42
    println("Inside quote:")
    @show $variable
end

eval(expression)

println("Outside quote:")
@show variable
println("If I named the variable x:")
@show x
Output:
Insert the variable name: 
x

Inside quote:
x = 42
Outside quote:
variable = :x
x = 42

Kotlin

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:

Translation of: FreeBASIC
// version 1.1.4

fun main(args: Array<String>) {
    var n: Int
    do {
        print("How many integer variables do you want to create (max 5) : ")
        n = readLine()!!.toInt()
    }
    while (n < 1 || n > 5)

    val map = mutableMapOf<String, Int>()
    var name: String
    var value: Int
    var i = 1
    println("OK, enter the variable names and their values, below")
    do {
        println("\n  Variable $i")
        print("    Name  : ")
        name = readLine()!!
        if (map.containsKey(name)) {
            println("  Sorry, you've already created a variable of that name, try again")
            continue
        }
        print("    Value : ")
        value = readLine()!!.toInt()
        map.put(name, value)
        i++
    }
    while (i <= n)

    println("\nEnter q to quit")
    var v: Int?
    while (true) {
        print("\nWhich variable do you want to inspect : ")
        name = readLine()!!
        if (name.toLowerCase() == "q") return
        v = map[name]
        if (v == null) println("Sorry there's no variable of that name, try again")
        else println("It's value is $v")
    }
}

Sample input/output:

Output:
How many integer variables do you want to create (max 5) : 3
OK, enter the variable names and their values, below

  Variable 1
    Name  : faith
    Value : 1

  Variable 2
    Name  : hope
    Value : 2

  Variable 3
    Name  : hope
  Sorry, you've already created a variable of that name, try again

  Variable 3
    Name  : charity
    Value : 3

Enter q to quit

Which variable do you want to inspect : chastity
Sorry there's no variable of that name, try again

Which variable do you want to inspect : charity
It's value is 3

Which variable do you want to inspect : q

Lang

fn.print(Enter a variable name:\s)
$varName = fn.input()
$value = 42

fn.exec(\$$varName = \$value)

fn.println(fn.exec({{{return $}}}$varName))
Output:
Enter a variable name: X
42

Lasso

Thread vars in Lasso 9 can have dynamic names, but local variables cannot.

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

local(thename = web_request->param('thename')->asString)
if(#thename->size) => {^
	var(#thename = math_random)
	var(#thename)
else
	'<a href="?thename=xyz">Please give the variable a name!</a>'
^}

Lingo

-- varName might contain a string that was entered by a user at runtime

-- A new global variable with a user-defined name can be created at runtime like this:
(the globals)[varName] = 23 -- or (the globals).setProp(varName, 23)

-- An new instance variable (object property) with a user-defined name can be created at runtime like this:
obj[varName] = 23 -- or obj.setProp(varName, 23)

? make readword readword
julie
12
? show :julie
12

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),
     write('Variable value: '), read(Value),
     Fact =.. [Name, Value],
     Id::assertz(Fact).

Variable name:  foo.
Variable value: 42.
Id = o1,
Name = foo,
Value =  42,
Fact = foo(42).

?- o1::current_predicate(foo/1).
true.

| ?- o1::foo(X).
X = 42.

Lua

_G[io.read()] = 5 --puts 5 in a global variable named by the user

M2000 Interpreter

Module DynamicVariable {
      input "Variable Name:", a$
      a$=filter$(a$," ,+-*/^~'\({=<>})|!$&"+chr$(9)+chr$(127))
      While a$ ~ "..*"  {a$=mid$(a$, 2)}
      If len(a$)=0 then Error "No name found"
      If chrcode(a$)<65 then Error "Not a Valid name"
      Inline a$+"=1000"
      Print eval(a$)=1000
      \\ use of a$ as pointer to variable
      a$.+=100
      Print eval(a$)=1100
      \\ list of variables
      List
}
Keyboard "George"+chr$(13)
DynamicVariable

M4

Enter foo, please.
define(`inp',esyscmd(`echoinp'))
define(`trim',substr(inp,0,decr(len(inp))))
define(trim,42)
foo

DOS batch file echoinp.bat:

@echo off
set /p Input=
echo %Input%

Mathematica / Wolfram Language

varname = InputString["Enter a variable name"];
varvalue = InputString["Enter a value"];
ReleaseHold[ Hold[Set["nameholder", "value"]] /. {"nameholder" -> Symbol[varname], "value" -> varvalue}];
Print[varname, " is now set to ", Symbol[varname]]
Example output:
-> testvar is now set to 86

Maxima

/* Use :: for indirect assignment */
block([name: read("name?"), x: read("value?")], name :: x);

min

Works with: min version 0.19.3
42 "Enter a variable name" ask define

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>KILL ;Clean up workspace
 
USER>WRITE ;show all variables and definitions
 
USER>READ "Enter a variable name: ",A
Enter a variable name: GIBBERISH
USER>SET @A=3.14159
 
USER>WRITE
 
A="GIBBERISH"
GIBBERISH=3.14159

Nanoquery

print "Enter a variable name: "
name = input()

print name + " = "
exec(name + " = 42")
exec("println " + name)
Output:
Enter a variable name: test
test = 42

Nim

Nim is a compiled language, with powerful Templating and Macros, which are compile-time rather than run-time.

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

import tables

var
  theVar: int = 5
  varMap = initTable[string, pointer]()

proc ptrToInt(p: pointer): int =
  result = cast[ptr int](p)[]

proc main() =
  write(stdout, "Enter a var name: ")
  let sVar = readLine(stdin)
  varMap[$svar] = theVar.addr
  echo "Variable ", sVar, " is ", ptrToInt(varMap[$sVar])

when isMainModule:
  main()
Output:
Enter a var name: varZ
Variable varZ is 5

Octave

varname = input ("Enter variable name: ", "s");
value = input ("Enter value: ", "s");
eval([varname,"=",value]);

Oforth

: createVar(varname)
   "tvar: " varname + eval ;

"myvar" createVar

12 myvar put
myvar at .

PARI/GP

eval(Str(input(), "=34"))

Pascal

Free Pascal

Works with: Free Pascal version version 3.2.0
PROGRAM ExDynVar;

{$IFDEF FPC}
    {$mode objfpc}{$H+}{$J-}{R+}
{$ELSE}
    {$APPTYPE CONSOLE}
{$ENDIF}

(*)
    Free Pascal Compiler version 3.2.0 [2020/06/14] for x86_64
    The free and readable alternative at C/C++ speeds
    compiles natively to almost any platform, including raspberry PI
  
    This demo uses a dictionary because it is compiled: it cannot  make
    dynamic variables at runtime.
(*)

USES
    Generics.Collections,
    SysUtils,
    Variants;

TYPE

    Tdict =
    {$IFDEF FPC}
    specialize
    {$ENDIF}
     TDictionary < ansistring, variant > ;

VAR
    VarName:  ansistring;
    strValue: ansistring;
    VarValue:    variant;
    D:             Tdict;

    FUNCTION SetType ( strVal: ansistring ) : variant ;

    (*)
       If the value is numeric, store it as numeric, otherwise store it as ansistring
    (*)

        BEGIN

            TRY
                SetType := StrToFloat ( strVal ) ;
            EXCEPT
                SetType :=                strVal ;
            END;

        END;

BEGIN

    D := TDict.Create;
    REPEAT
        Write  ( 'Enter variable name : '  ) ;
        ReadLn ( VarName  ) ;
        Write  ( 'Enter variable Value : ' ) ;
        ReadLn ( strValue ) ;
        VarValue :=     SetType ( strValue ) ;
        TRY
            BEGIN
                D.AddOrSetValue ( VarName, VarValue ) ;
                Write                     ( VarName ) ;
                Write                     (  ' = '  ) ;
                WriteLn             ( D [ VarName ] ) ;
            END;
        EXCEPT
            WriteLn ( 'Something went wrong.. Try again' ) ;
        END;
    UNTIL ( strValue = '' ) ;
    D.Free;

END.
JPD 2021/05/13

Perl

print "Enter a variable name: ";
$varname = <STDIN>; # type in "foo" on standard input
chomp($varname);
$$varname = 42; # when you try to dereference a string, it will be
                # treated as a "symbolic reference", where they
                # take the string as the name of the variable
print "$foo\n"; # prints "42"

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

use strict;

print "Enter a variable name: ";
my $foo;
my $varname = <STDIN>; # type in "foo" on standard input
chomp($varname);
my $varref = eval('\$' . $varname);
$$varref = 42;
print "$foo\n"; # prints "42"

Phix

dictionary

In a sense, this is kinda faking it:

constant globals = new_dict()

while 1 do
    string name = prompt_string("Enter name or press Enter to quit:")
    if length(name)=0 then exit end if
    bool bExists = (getd_index(name,globals)!=NULL)
    string prompt = iff(not bExists?"No such name, enter a value:"
                   :sprintf("Already exists, new value[%s]:",{getd(name,globals)}))
    string data = prompt_string(prompt)
    if length(data) then
        setd(name,data,globals)
    end if
end while
Output:
Enter name or press Enter to quit:fred
No such name, enter a value:35
Enter name or press Enter to quit:fred
Already exists, new value[35]:
Enter name or press Enter to quit:james
No such name, enter a value:1
Enter name or press Enter to quit:fred
Already exists, new value[35]:
Enter name or press Enter to quit:james
Already exists, new value[1]:
Enter name or press Enter to quit:

dynamic classes

Library: Phix/Class
requires("0.8.2")
class dc dynamic
--  public string fred = "555" -- (predefine some fields if you like)
end class
dc d = new()

while 1 do
    string name = prompt_string("Enter name or press Enter to quit:")
    if length(name)=0 then exit end if
    bool bExists = (get_field_type(d,name)!=NULL)
--  bool bExists = string(d[name])  -- alt...
    string prompt = iff(not bExists?"No such name, enter a value:"
                   :sprintf("Already exists, new value[%s]:",{d[name]}))
    string data = prompt_string(prompt)
    if length(data) then
        d[name] = data
    end if
end while

Same output as above (for the same input)
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).

PHP

<?php
$varname = rtrim(fgets(STDIN)); # type in "foo" on standard input
$$varname = 42;
echo "$foo\n"; # prints "42"
?>

PicoLisp

(de userVariable ()
   (prin "Enter a variable name: ")
   (let Var (line T)                                  # Read transient symbol
      (prin "Enter a value: ")
      (set Var (read))                                # Set symbol's value
      (println 'Variable Var 'Value (val Var)) ) )    # Print them
Output:
Enter a variable name: Tom
Enter a value: 42
Variable "Tom" Value 42
-> 42

PowerShell

$variableName = Read-Host
New-Variable $variableName 'Foo'
Get-Variable $variableName

ProDOS

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

Prolog

test :- read(Name), atomics_to_string([Name, "= 50, writeln('", Name, "' = " , Name, ")"], String), term_string(Term, String), Term.

Testing:

?- test.
|: "Foo".
Foo = 50.
true.

Python

Works with: Python version 2.x
>>> name = raw_input("Enter a variable name: ")
Enter a variable name: X
>>> globals()[name] = 42
>>> X
42
Works with: Python version 3.x
>>> name = input("Enter a variable name: ")
Enter a variable name: X
>>> globals()[name] = 42
>>> X
42

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

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

  [ say "The word "
    dup echo$ 
    names find names found iff
      [  say " exists." ]
    else 
      [ say " does not exist." ] ]       is exists? ( $ --> )


  [ $ "Please enter a name: " input 
    cr
    dup exists?
    cr cr
    dup say "Creating " echo$
    say "..."
    $ "[ stack ] is " over join quackery
    cr cr 
    exists? cr ]                         is task    (   --> )
Output:

As a dialogue in the Quackery shell.

/O> task
... 
Please enter a name: my-ancillary-stack

The word my-ancillary-stack does not exist.

Creating my-ancillary-stack...

The word my-ancillary-stack exists.

R

# Read the name in from a command prompt
varname <- readline("Please name your variable >")
# Make sure the name is valid for a variable
varname <- make.names(varname)
message(paste("The variable being assigned is '", varname, "'"))
# Assign the variable (with value 42) into the user workspace (global environment)
assign(varname, 42)
#Check that the value has been assigned ok
ls(pattern=varname)
get(varname)

Racket

This works on the Racket REPL:

-> (begin (printf "Enter some name: ")
          (namespace-set-variable-value! (read) 123))
Enter some name: bleh
-> bleh
123

Raku

(formerly Perl 6)

Works with: Rakudo version 2018.03

You can interpolate strings as variable names:

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

my $name  = prompt 'Variable name: ';
my $value = $::('name'); # use the right sigil, etc

put qq/Var ($name) starts with value 「$value」/;

$::('name') = 137;

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

REBOL

REBOL [
	Title: "Dynamic Variable Name"
	URL: http://rosettacode.org/wiki/Dynamic_variable_names
]

; Here, I ask the user for a name, then convert it to a word and
; assign the value "Hello!" to it. To read this phrase, realize that
; REBOL collects terms from right to left, so "Hello!" is stored for
; future use, then the prompt string "Variable name? " is used as the
; argument to ask (prompts user for input). The result of ask is
; converted to a word so it can be an identifier, then the 'set' word
; accepts the new word and the string ("Hello!") to be assigned.

set  to-word  ask "Variable name? "  "Hello!"
Session output:
Variable name? glister
== "Hello!"
>> glister
== "Hello!"

Retro

:newVariable ("-)  s:get var ;

newVariable: foo

REXX

Checks could've been made to:

  •   check for the minimum number of arguments
  •   check for a legitimate REXX variable name
/*REXX program demonstrates the use of dynamic variable names & setting a val.*/
parse arg newVar newValue
say 'Arguments as they were entered via the command line: '   newVar    newValue
say
call value newVar, newValue
say 'The newly assigned value (as per the VALUE bif)------' newVar value(newVar)
                                       /*stick a fork in it,  we're all done. */

output   for the input:   abc   456

Arguments as they were entered via the command line = abc 45678.1

The newly assigned value (as per the VALUE bif)------ abc 45678.1

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

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:

>> s = "myusername"
myusername
>> $$.[s] = 10;
>> myusername
  10

RPL

≪ → uservar
  ≪ 42 uservar STO
     "Value of " uservar →STR + " = " uservar EVAL →STR +
≫ ≫ 'GETVAR' STO
Input:
Xyz GETVAR
Output:
1: "Value of 'Xyz' = 42" 

The variable still exists after execution, until the user deletes it through the PURGE instruction.

Ruby

p "Enter a variable name"
x = "@" + gets.chomp!
instance_variable_set x, 42
p "The value of #{x} is #{instance_variable_get x}"
Example output:
"Enter a variable name"
hello
"The value of @hello is 42"

Scheme

=> (define (create-variable name initial-val)
     (eval `(define ,name ,initial-val) (interaction-environment)))

=> (create-variable (read) 50)
<hello

=> hello
50

Sidef

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

var name = read("Enter a variable name: ", String);     # type in 'foo'

class DynamicVar(name, value) {
    method init {
        DynamicVar.def_method(name, ->(_) { value })
    }
}

var v = DynamicVar(name, 42);       # creates a dynamic variable
say v.foo;                          # retrieves the value

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 -> (query: 'Enter a variable name: ') intern. "X"
define: name -> 42.
X print.

Smalltalk

Works with: Pharo

Define a block-temporary variable with name specified by user input. Set that variable to 42. Print that variable's name and value.

| varName |
varName := FillInTheBlankMorph 
	request: 'Enter a variable name'.
Compiler 
	evaluate:('| ', varName, ' | ', varName, ' := 42. 
	Transcript 
		show: ''value of ', varName, '''; 
		show: '' is '';
		show: ', varName).

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 |
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.

Output:
Enter a global variable name: abc

Enter an expression: abc squared + 5

1769

SNOBOL4

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

*       # Get var name from user        
        output = 'Enter variable name:'
        invar = trim(input)
        
*       # Get value from user, assign        
        output = 'Enter value:'
        $invar = trim(input)

*       Display 
        output = invar ' == ' $invar
end
Output:
Enter variable name:
pi
Enter value:
3.14159
pi == 3.14159

Stata

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".

display "Name?" _request(s)
scalar $s=10
display $s

Tcl

puts "Enter a variable name:"
gets stdin varname
set $varname 42
puts "I have set variable $varname to [set $varname]"

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:

puts -nonewline "Enter an element name: "; flush stdout
gets stdin elemname
set ary($elemname) [expr int(rand()*100)]
puts "I have set element $elemname to $ary($elemname)"

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

puts -nonewline "Enter a variable name: "; flush stdout
gets stdin varname
upvar 0 $varname v; # The ‘0’ for “current scope”
set v [expr int(rand()*100)]
puts "I have set variable $varname to $v (see for yourself: [set $varname])"

TI-89 BASIC

Local varName,value
InputStr "Variable name", varName
Prompt value
value → #varName

TUSCRIPT

$$ MODE TUSCRIPT
ASK "Enter variablename": name=""
ASK "Enter value": value=""
TRACE +@name
@name=$value
PRINT @name

Output:

Enter variablename >test
Enter value >Hello World!
TRACING     Scratch-Datei -*TUSTEP.EDT
   5    00  TRACE +@name
test         = Hello World!
Hello World!

UNIX Shell

read name
declare $name=42
echo "${name}=${!name}"

Wren

Library: Wren-ioutil
Library: Wren-trait

Although Wren is dynamically typed, it is not possible to create new variables at run time. However, we can simulate this using a map which is what the Var class in Wren-trait does under the hood.

import "./ioutil" for Input
import "./trait" for Var

System.print("Enter three variables:")
for (i in 0..2) {
    var name  = Input.text("\n  name  : ")
    var value = Input.text("  value : ")
    Var[name] = Num.fromString(value)
}

System.print("\nYour variables are:\n")
for (kv in Var.entries) {
    System.print("  %(kv.key) = %(kv.value)")
}
Output:

Sample session:

Enter three variables:

  name  : pip
  value : 3

  name  : squeak
  value : 4

  name  : wilfred
  value : 5

Your variables are:

  pip = 3
  squeak = 4
  wilfred = 5

Z80 Assembly

This example is admittedly crude but was made to be as simple as possible. To that end, the variable name was made to be only one letter long. A key press is taken from the user, which is used as an offset into an array of 256 null bytes, and then a value is stored at that offset and retrieved from there. Self-modifying code is used to store the user's input as the offset of the IX register. A more practical implementation would store this value into normal RAM first so that it can be more easily retrieved.

Both the user variable name and the value of that variable are printed. The value is set to 0x42 automatically before printing it.

org &8000
WaitChar equ &BB06  ;Amstrad CPC BIOS call, loops until user presses a key. That key's ASCII value is returned in A.
PrintChar equ &BB5A ;Amstrad CPC BIOS call, A is treated as an ASCII value and is printed to the screen.
	
getInput:
	call WaitChar
	;returns key press in A

	
	or a ;set flags according to accumulator
	jp m,getInput
	;most keyboards aren't capable of going over ascii 127
	;but just in case they can prevent it.
        ;IX/IY offsets are signed, thus a key press outside of 7-bit ASCII would index out of bounds
	
	push af
	call PrintChar          ;prints the user variable name to the screen.
	pop af
	
	call NewLine

	ld (LoadFromUserNamedVariable+2),a ;offset byte is at addr+2
	ld (StoreToUserNamedVariable+2),a  

; This self-modifying code turns both instances of (IX+0) into (IX+varname)
	
	
	ld a,&42 		;set the value of the dynamically named variable
				; to &42
					
	ld ix,ExtraRam          ;storage location of dynamically named variables
	
StoreToUserNamedVariable:
	ld (IX+0),a		;store 42 at the named offset
	                        ;"+0" is overwritten with the dynamic user ram name
	
	xor a
	dec a
	;just to prove that the value is indeed stored where the code
	;   is intending to, set A to 255 so that the next section of
	;   code will show that the variable is indeed retrieved and
	;   is shown to the screen
	
LoadFromUserNamedVariable:
	ld a,(IX+0)	          ;retrieve the value at the stored offset. The "+0" was overwritten with the user-defined offset.
	
	call ShowHex              ;prints to the terminal the value stored at the dynamically named user variable

	
ReturnToBasic
	RET

ShowHex:	                   ;credit to Keith S. of Chibiakumas
	push af
		and %11110000
			rrca
			rrca
			rrca
			rrca
		call PrintHexChar
	pop af
	and %00001111
	;call PrintHexChar
	;execution flows into it naturally.
PrintHexChar:
	or a	;Clear Carry Flag
	daa
	add a,&F0
	adc a,&40
	jp PrintChar
	;ret

NewLine:
	push af
	ld a,13		;Carriage return
	call PrintChar
	ld a,10		;Line Feed 
	call PrintChar
	pop af
	ret


        org &9000
ExtraRam:
       ds 256,0         ;256 bytes of ram, each initialized to zero
Output:
Ready
run"go.bas
s
42
Ready


zkl

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

vname:="foo";  // or vname:=ask("var name = ");
klass:=Compiler.Compiler.compileText("var %s=123".fmt(vname))(); // compile & run the constructor
klass.vars.println();
klass.foo.println();
klass.setVar(vname).println();  // setVar(name,val) sets the var
Output:
L(L("foo",123))
123
123

Zsh

read name
typeset $name=42