Or sometimes even just an array. The first time I thought I wanted to do this was 2003 and I was writing a perl script, and I was trying to loop through some sort of array, and write the outputs of some calculations to $val0 $val1 and so on, and I was neck deep into some horrible dark constructs like ${"val" . $i} before I actually realized that I really just wanted an array, you know, like the one I was already using.

It took me forever to understand map (the metafunction).

It depends. If the variable names are arbitrary, then a map is best. If the variable names are just x_1, x_2, x_3, …, x_n, then a list or dynamic array would be more natural. If n is constant, then a vector or static array is even better.

I’ve just figured out linked lists and I want to call that the solution ¯_(ツ)_/¯

locals()[“x”] = 1

Nah, the locals() or globals() object is much better for this.

In c, nothing and nobody is your friend.

Source: me

In Perl, eval can do similar things, but symbolic references are “better” (I’m fairly sure it’s where PHP got the idea, and the syntax, from.) e.g.

$foo = "bar";
$$foo = "potatoes"; # $$foo = access the variable named in $foo, i.e. $bar
print $bar; # prints potatoes

Reading other responses, it seems like Python’s globals object is not entirely dissimilar, especially if you know how Perl deals with symbolic references under the hood.

But just because you can doesn’t mean you should. If you use strict; in Perl, it will fail to compile most of this nonsense. Use a hash / associative array / dictionary / whatever your language (natural and/or programming) calls them instead.

And I’m pretty sure that even without strict, local variables can’t be accessed at all the symbolic way, which is probably for the best. (NB: local is a subtle thing in Perl. By “local” here, I mean the so-called my variables that aren’t accessible outside their scope. local variables are actually localised globals. Enjoy that thought.)

A common problem (before learning it is impossible/fraught with danger) is categorisation, like sorting of strings.

Say you have a text, and need to count words of different lengths.

One intuitive approach is to pass through it once and add each word to a list for the corresponding length, as well as making lists as needed. No 7 letter words, no 7-letter-word-list, even though there are longer words.

As humans we’re good at sorting things into an unknown number of categories, and we have to unlearn that for programming

I remember wondering this when I was first trying to self learn. It’s because I needed a map (or list + struct or something) and was such a noob I didn’t know what maps were. Whatever material I was learning from wasn’t good enough, especially for winging things. Plus I was trying to learn C++ and maps aren’t quite so built into the language as they are with a better first language like Python.

In lower level languages like C/C++ the reason becomes much more apparent when you learn about memory allocation and management (as a bonus it also really helps to understand how OS’s handle memory). Dynamically declaring variables in a loop would mean you need to allocate a chunk of memory for each variable that’s generated on the fly, most of, if not all of the dynamically declared variables would not even use most of their allocated memory resulting in a ton of extra overhead and wasted space within memory. An array is usually the answer when someone asks how to dynamically define variables. With an array you allocate the space needed in memory and can iterate across it block by block resulting in more control and efficiency within your reserved memory block. Linked lists are also a fun thing to look into when you aren’t sure how big your array needs to be. It’s a hard question to answer in a 100 level class because the answer actually goes pretty deep into low level programming, operating system and hardware principles.

I distinctly remember having the same experience. For some reason I believed dynamic variable naming was a good idea. What was I on??

What are talking about? $$ is the way to go :D

Piiiitchforks! Getcher pitchforks heeeere!

Every time we see this in our legacy code we yell out: dolla-dolla bills 'yall!

Or just use a dictionary/hashmap if it’s all in the same program

Is anyone really?

Everything goes with macros :D

That’s because it makes sense when dynamically creating HTML. HTML is not a programming language, it’s simply markup - so if you want to generate some block of HTML in a loop and later access that block of HTML in JS (e.g. to interact with the UI separate from creating it in the first place), it’s a completely reasonable thing to do.

So long as the ID never repeats, it’s cool

for(var i=0; i \< numLoops; i++){
    globalThis['example'+i] = doStuff(i);
}

Within a loop could be:

for(i in 1:10){
     assign(paste0("listNum", i), list(i, someStringVector[i], i:(i+20), i*value))
}```

And you can also use get() in the same way to dynamically retrieve a variable. 

I've gone so far into coding debauchery that I've dynamically assigned variables from dynamically retrieved ones, and I've done so fairly frequently.

So is that a no?