TUTORIAL: Why Variables Should Not Be Named Dynamically (eval)

Summary:

Dynamically accessing variable names can negatively impact the readability of your code and can cause it to run slower by preventing MATLAB from optimizing it as well as it could if you used alternate techniques. The most common alternative is to use simple and efficient indexing.

Explanation:

Sometimes beginners (and some self-taught professors) think it would be a good idea to dynamically create or access variable names, the variables are often named something like these:

• matrix1, matrix2, matrix3, matrix4, ...
• test_20kmh, test_50kmh, test_80kmh, ...
• nameA, nameB, nameC, nameD,...

Good reasons why dynamic variable names should be avoided (click the links to jump to the "answers" below):

• Slow
• Buggy
• Security Risk
• Difficult to Work With
• Obfuscated Code Intent
• Confuses Data with Code
• Code Helper Tools do not Work
• Magically Making Variables Appear in a Workspace is Risky

There are much better alternatives to accessing dynamic variable names:

• Indexing into Cell Array or ND-Array
• Non-scalar Structures (with Indexing)
• Dynamic Field-Names in a Structure
• load into a Structure, not into the Workspace
• save the Fields of a Scalar Structure
• Use a table or timetable Array
• Use more Efficient Ways to Pass Variables Between Workspaces

Note that avoiding eval (and assignin, etc.) is not some esoteric MATLAB restriction, it also applies to many other programming languages as well:

• Other Languages: do not use eval!
• PS: The eval function itself is not faulty!

MATLAB Documentation:

If you are not interested in reading the answers below then at least read MATLAB's own documentation on this topic Alternatives to the eval Function, which states "A frequent use of the eval function is to create sets of variables such as A1, A2, ..., An, but this approach does not use the array processing power of MATLAB and is not recommended. The preferred method is to store related data in a single array." Data in a single array can be accessed very efficiently using indexing.

Note that all of these problems and disadvantages also apply to functions load (without an output variable), assignin, evalin, and evalc, and the MATLAB documentation explicitly recommends to "Avoid functions such as eval, evalc, evalin, and feval(fname)".

The official MATLAB blogs explain why eval should be avoided, the better alternatives to eval, and clearly recommend against magically creating variables. Using eval comes out at position number one on this list of Top 10 MATLAB Code Practices That Make Me Cry. Experienced MATLAB users recommend avoiding using eval for trivial code, and have written extensively on this topic.

[Adam]

Now all we need is for Matlab Answers to have a small number of key sticky questions that remain at the top! Not that new users would notice it necessarily, but some would!

[Jan]

@Stephen: Thanks. I've voted for each of your answers. let me suggest to replace the tag "make me cry" by "make us cry". ;-)

[Jan]

This thread has 1100 views this month. Stephen, if perhaps 10% 0r 50% of the readers are encouraged to avoid eval and use one of the mentioned better solutions, this will have a measurable effect on the world-wide-average of the code quality. Thanks again.

[Walter Johnson]

Well I know little about the eval function and I will take it from you that it is something bad to use for this purpose. That said, being able to input the name of an existing file or object that you want to access or read in is not some wacko desire. This is pretty standard with programming languages. There may be reasons why MATLAB does not support this, but it is not a strange or clearly crazy thing to want to do.

[per isakson]

"being able to input the name of an existing file" that's no problem with Matlab.

filespec = 'c:\tmp\the_name_of_my_file.csv';
str = fileread( filespec );

and

fid = fopen( filespec', 'r' );
...

[Stephen Cobeldick]

"...being able to input the name of an existing file..."

... is really easy and does not require magically accessing variable names.

"This is pretty standard with programming languages."

Indeed many languages support string evaluation... and yet interestingly experts and experienced users of most of those languages consider this to be an extremely inefficient and insecure practice that should be avoided. Perhaps you missed reading this thread, which gives links to some of those discussions:

https://www.mathworks.com/matlabcentral/answers/304528-tutorial-why-variables-should-not-be-named-dynamically-eval#answer_236129

"There may be reasons why MATLAB does not support this,.."

MATLAB certainly does support this. Why do you think it does not? In fact the main function that is used for this is currently mentioned 75 times on this thread (and also in the title itself), something that readers of this thread are unlikely miss.

"...but it is not a strange or clearly crazy thing to want to do"

I totally agree: I don't think that it is a strange or crazy thing to want to do. But it is important to note that wanting to do something is not at all synonymous with something being a good way to write code: there are certainly much simpler and more efficient methods of writing better code, which waste less time (coding time, debugging time, run time). The fact that magically accessing variables forces beginners to write slow, complex, buggy code, and is easily avoided by better, simpler code and/or data design, is not changed by how much beginners might want to do it.

We often get questions from beginners who want to calculate all permutations of a set of numbers, or want use some other highly inefficient or numerically unstable algorithm or want to use numerically unstable operations: just because they want to do these things does not mean that their approach is going to be efficient, or produce any sensible output, or even be tractable at all. In these cases we would show them (if at all possible) better ways of solving their problem, just like this thread does. The reality that some code is slower, buggier on average, harder to debug, and much less efficient is not changed by you want.

[Steven Lord]

Stephen, given how long this page has become, I recommend summarizing the discussion in a BLUF at the top of the question to avoid TL;DR syndrome, something along the lines of:

"Bottom line: Numbering variables can negatively impact the readability of your code and can cause it to run slower by preventing MATLAB from optimizing it as well as it could if you used alternate techniques. The most common alternatives are:

[bulleted list with a short description of no more than 3 common alternatives]

For more information, see the longer discussion on the rest of this page."

I know I could do it myself, but you've put a lot of effort into creating and updating this page.

Answer 1

[Stephen Cobeldick]

Some quotes from Steven Lord, responses to inappropriate use of eval and friends:

"DO NOT USE EVAL"

"This is why you SHOULD NOT "poof" variables into the workspace at runtime, whether via EVALIN, ASSIGNIN, EVAL, or LOAD."

"Do NOT use eval, evalc, or any other function in the eval family"

[Cris Luengo]

The 2nd link, to the newsreader, is dead. (Long live the newsreader!)

[Stephen Cobeldick]

@Cris Lengo: you can still access that newsreader thread here:

https://groups.google.com/forum/#!searchin/comp.soft-sys.matlab/subject$3A%22behavior$20of$20assignin%22/comp.soft-sys.matlab/Y-BoQbPqqXQ/Cl7zpUyT5vIJ

The relevant text is:

MATLAB is not lying to you.

When you run your function, MATLAB needs to determine what each identifier

you use is as part of the process of parsing the function. At that time,

there's no indication in your code that debug should be a variable; however,

there is a function named debug. Therefore, MATLAB decides that the

instances of debug in the code should be calls to that function. When the

code is actually executed, a variable named debug is created, and WHICH

reflects that fact -- but at that point, it's too late for MATLAB to "change

its mind" and it tries to call the debug function on the last line. DEBUG

is a script file, though, and so you correctly receive an error.

This is why you SHOULD NOT "poof" variables into the workspace at runtime,

whether via EVALIN, ASSIGNIN, EVAL, or LOAD.

--

Steve Lord

[e-mail]

Answer 2

[Stephen Cobeldick]

Slow

The MATLAB documentation Alternatives to the eval Function explains that code that uses eval is slower because "MATLAB® compiles code the first time you run it to enhance performance for future runs. However, because code in an eval statement can change at run time, it is not compiled".

MATLAB uses JIT acceleration tools that analyze code as it is being executed, and to optimize the code to run more efficiently. When eval is used the JIT optimizations are not effective, because every string has to get compiled and run again on every single iteration! This makes loops with eval very slow. This is also why not just creating variables with dynamic variable names is slow, but also accessing them.

https://www.mathworks.com/products/matlab/matlab-execution-engine.html

https://blogs.mathworks.com/loren/2016/02/12/run-code-faster-with-the-new-matlab-execution-engine/

https://blogs.mathworks.com/loren/2007/08/29/for-versus-while/ (in the comments)

https://www.mathworks.com/matlabcentral/answers/320839-how-bad-is-the-performance-of-run-time-introspection

https://www.mathworks.com/matlabcentral/answers/33284-processor-usage#answer_53297

https://www.mathworks.com/matlabcentral/answers/353349-how-to-make-a-2-files-mat-become-1#comment_478662

https://www.mathworks.com/matlabcentral/answers/105936-how-to-make-dynamic-variable-names-a1-a2-an-with-for-loop-using-eval-num2str#comment_598847

Even the eval hidden inside of str2num can slow down code:

https://www.mathworks.com/matlabcentral/answers/357420-how-to-convert-a-numeric-string-into-a-numeric-range

Answer 3

[Stephen Cobeldick]

Security Risk

eval will evaluate any string at all, no matter what commands it contains. Does that sound secure to you? This string command might be malicious or simply a mistake, but it can do anything at all to your computer. Would you run code which could do anything at all to your computer, without knowing what it was about to do?

For some beginners the surprising answer is "yes please!".

https://www.mathworks.com/matlabcentral/answers/42752-assigning-input-string-as-variable-name#answer_52582

Beginners will happily run code that could do anything at all with their computer. For example, try running this (taken from Jos' answer here):

eval(char('fkur*)Ykvj"GXCN"{qw"pgxgt"mpqy"yjcv"jcrrgpu0"Kv"eqwnf"jcxg"hqtocvvgf"{qwt"jctfftkxg"000)+'-2))

Did you really run it on your computer even though you had no idea what it would do? Every time beginners write code that gets a user input and evaluates it they give that user the ability to run anything at all. Does that sound secure to you?

[Alexander Geldhof]

I'm late to the party, but what does this do?

For the same reasons you mentioned, I'm rather wary from entering this in my Matlab command line.

[Adam Danz]

Hint: the char(str-2) is a caesar-cipher that produces a command that is exectued by eval().

[Steven Lord]

Running the char command is safe, that will just create a char vector you can read. Remove the eval() around the char command and it won't execute the command stored in the char vector.

Answer 4

[Stephen Cobeldick]

Difficult to Work With

Many beginners come here with questions that are basically "I have lots of numbered variables but I cannot figure out how to do this simple operation...", or "my code is very slow/complex/...":

https://www.mathworks.com/matlabcentral/answers/322696-automatically-creating-an-array-of-variables-and-assigning-to-a-function-with-changing-number-of-out

https://www.mathworks.com/matlabcentral/answers/249044-code-fails-to-run-in-function-works-in-command-window-works-in-debug-evaluate-selection

https://www.mathworks.com/matlabcentral/answers/49756-use-eval-statement-to-create-matrices-with-variables

https://www.mathworks.com/matlabcentral/answers/341708-variable-names-in-loop

https://www.mathworks.com/matlabcentral/answers/346695-how-to-save-variables-to-an-array-using-a-for-loop

https://www.mathworks.com/matlabcentral/answers/356673-operation-on-variables-whose-name-contain-a-certain-string

https://www.mathworks.com/matlabcentral/answers/460207-concatenate-structures-select-structures-only-if-not-empty#answer_373564

Even advocates of eval get confused by it, fail to make it work properly, and can't even figure out why, as these two examples clearly show:

https://www.mathworks.com/matlabcentral/answers/158412-how-to-open-txt-files-with-variable-names#answer_154956

https://www.mathworks.com/matlabcentral/answers/272454-how-do-i-iterate-through-multiple-structures#answer_213034

Why can't they figure out why it does not work?:

• Totally obfuscated code. Indirect code evaluation.
• The code helper tools do not work.
• Syntax highlighting does not work.
• Static code checking does not work.
• No useful error messages, etc. ,etc

Answer 5

[Stephen Cobeldick]

Buggy

Using eval makes it really hard to track down bugs, because it obfuscates the code and disables lots of code helper tools. Why would beginners even want to use a tool that makes it harder for them to fix their code?

Here are some examples to illustrate how what should have been simple operations become very difficult to debug because of the choice to use eval:

https://www.mathworks.com/matlabcentral/answers/275439-help-with-code-problem

https://www.mathworks.com/matlabcentral/answers/158412-how-to-open-txt-files-with-variable-names#answer_154956

https://www.mathworks.com/matlabcentral/answers/272454-how-do-i-iterate-through-multiple-structures#answer_213034

https://www.mathworks.com/matlabcentral/answers/349843-getting-an-error-this-statement-is-incomplete

Code that generates variable names dynamically based on imported data or user inputs is also susceptible to the names reaching the name length limit:

https://www.mathworks.com/matlabcentral/answers/498489-clarification-about-using-only-the-first-namelengthmax-characters-of-the-name

This quote sums up debugging eval based code: "I've never even attempted to use it myself, but it seems it would create unreadable, undebuggable code. If you can't read it and can't fix it what good is it?" Note that eval's equally evil siblings evalc, evalin and assignin also make code slow and buggy:

https://www.mathworks.com/matlabcentral/answers/31963-functions-vs-script#answer_40489

https://www.mathworks.com/matlabcentral/answers/372206-use-of-evalc-with-num2str#answer_295604

Answer 6

[Stephen Cobeldick]

Obfuscated Code Intent

What does this code do?:

x1 = [119,101,98,40,39,104,116,116,112,58,47,47,119,119,119];
x2 = [46,121,111,117,116,117,98,101,46,99,111,109,47,119,97];
x3 = [116,99,104,63,118,61,100,81,119,52,119,57,87,103,88];
x4 = [99,81,39,44,39,45,98,114,111,119,115,101,114,39,41];
eval(char([x1,x2,x3,x4]))

Unfortunately eval makes it easy to write code which is hard to understand: it is not clear what it does, or why. If you ran that code without knowing what it does, you should know that it could have deleted all of your data, or sent emails to all of your contacts, or downloaded anything at all from the internet, or worse...

Because eval easily hides the intent of the code many beginners end up writing code that is very hard to follow and understand. This makes the code buggy, and also harder to debug! See these examples:

https://www.mathworks.com/matlabcentral/answers/380551-what-is-the-function-of-sub2ind

Properly written code is clear and understandable. Clear and understandable code is easier to write, to bug-fix, and to maintain. Code is read more times than it is written, so never underestimate the importance of writing code that is clear and understandable: write code comments, write a help section, use consistent formatting and indentation, etc.

[Sean de Wolski]

I remember the newsreader thread you got this from!

[Walter Roberson]

You're never going to give up on this example, are you?

[Walter Roberson]

I just encountered someone using num2str() on a computed variable name, in order to have the effect of an eval() without using eval() directly in the code. This is, needless to say, obscure intent.

Answer 7

[Stephen Cobeldick]

Code Helper Tools do not Work

The MATLAB editor contains many tools that advanced users continuously make use of, and beginners should particularly appreciate when learning to use MATLAB (tip: learn to use them!). However none of these tools work with code that uses eval.

• check the syntax as you type.
• shows warnings and errors on the RHS of the editor. Very very useful!
• Tab completion of function names, filenames, etc.
• variable highlighting shows all locations where a variable is used.
• f1 button to access function help.
• code analyzer prints reports on the code quality: errors, warnings, suggestions on how it could be improved.
• Text search or find-and-replace. Note that with magical variable names it is not even possible to do a simple search for a variable name, because if that variable name is generated dynamically then the name is not defined until the code is executed: how would you imagine searching for where a particular variable is used, if you cannot search for that variable? Ouch!
• text search in multiple files.
• automatically rename all instances of a variable name: very handy!
• and much more...

Note that these do not work when using eval, evalc, etc. to magically create or access variable names. Would you want to disable the tools that help you to write functioning code? Here are examples of how eval hides code errors and makes it hard to debug code:

https://www.mathworks.com/matlabcentral/answers/158412-how-to-open-txt-files-with-variable-names#comment_242698

https://www.mathworks.com/matlabcentral/answers/322696-automatically-creating-an-array-of-variables-and-assigning-to-a-function-with-changing-number-of-out

https://www.mathworks.com/matlabcentral/answers/374023-error-using-eval-function

https://www.mathworks.com/matlabcentral/answers/51946-systematic-do-not-use-global-don-t-use-eval#comment_107637

[Tom Hawkins]

On this topic, it would be great if the Code Analyzer and checkcode would actually flag a warning when eval etc. are used. Perhaps that would cut down the number of questions about them on here?

Answer 8

[Stephen Cobeldick]

Alternative: Indexing into Cell Array or ND-Array

Oftentimes when a user wants to use eval they are trying to create numbered variables, which are effectively an index joined onto a name. So then why not simply turn that pseudo-index into a real index: MATLAB is very fast and efficient when working with indices, and using indices will make code much much simpler than anything involving dynamic variable names:

https://www.mathworks.com/company/newsletters/articles/matrix-indexing-in-matlab.html

https://www.mathworks.com/help/matlab/math/matrix-indexing.html

Using ND-arrays is a particularly efficient way of handling data: many operations can be performed on complete arrays (known as code vectorization), and ND-arrays are easy to get data in and out of, and reduces the chance of bugs:

https://www.mathworks.com/matlabcentral/answers/409279-on-multiple-logical-test-failing-in-if-statement#answer_327952

Or simply put the data into the cells of a cell array:

https://www.mathworks.com/help/matlab/matlab_prog/access-data-in-a-cell-array.html

https://www.mathworks.com/help/matlab/matlab_prog/multilevel-indexing-to-access-parts-of-cells.html

And some real-world examples of where indexing is much simpler than eval:

https://www.mathworks.com/matlabcentral/answers/11981-help-with-find-possibly-inside-of-eval

https://www.mathworks.com/matlabcentral/answers/160310-dynamic-variables-in-loops

Answer 9

[Stephen Cobeldick]

Alternative: Dynamic Field-Names in a Structure

dynamic fieldnames are easy to use, and do not require magically creating variables in the workspace.

https://www.mathworks.com/help/matlab/matlab_prog/access-multiple-elements-of-a-nonscalar-struct-array.html

https://blogs.mathworks.com/loren/2005/12/13/use-dynamic-field-references/

Answer 10

[Stephen Cobeldick]

Alternative: load into a Structure, not into the Workspace

In almost all cases where data is imported programmatically (i.e. not just playing around in the command window) it is advisable to load data into an output argument (which is a structure if the file is a .mat file):

S = load(...);

The fields of the structure can be accessed directly, e.g:

S.X
S.Y

or by using dynamic fieldnames. Note that this is the inverse of saving the fields of a scalar structure.

It is important to note that (contrary to what many beginners seem to think) it is actually much easier within a loop to save and load data when the variable names in the .mat files do not change, as having to process different variable names in each file actually makes saving/loading the files much harder.

Summary: when using a loop, keep all variable names the same!

Here are real-world examples of loading into variables:

https://www.mathworks.com/matlabcentral/answers/429680-how-to-load-a-mat-file-and-make-all-the-variables-from-that-mat-file-to-be-global-variables

https://www.mathworks.com/matlabcentral/answers/302359-access-variables-in-several-mat-files

https://www.mathworks.com/matlabcentral/answers/335253-mat-files-not-loading-correctly#answer_262994

https://www.mathworks.com/matlabcentral/answers/297146-loading-mat-file-into-a-variable

https://www.mathworks.com/matlabcentral/answers/28676-why-use-x-load-myfile-mat#answer_37821

https://www.mathworks.com/matlabcentral/answers/134091-variable-changes-value-after-using-load

https://www.mathworks.com/matlabcentral/answers/29579-decent-way-of-loading-and-saving-variables#answer_37932

https://www.mathworks.com/matlabcentral/answers/485484-using-load-in-a-test-methods-makes-the-test-pass#answer_397441

And finally Steven Lord's comment on load-ing straight into the workspace:

https://www.mathworks.com/matlabcentral/answers/349330-odd-behavior-with-a-simulink-reserved-name-in-a-function

EDIT: No longer active: https://www.mathworks.com/matlabcentral/newsreader/view_thread/244639#628669

Answer 11

[Stephen Cobeldick]

Alternative: Non-Scalar Structure (with Indexing)

Using a non-scalar structure is much simpler than trying to access dynamic variable names. Here are some examples:

https://www.mathworks.com/matlabcentral/answers/79281-create-a-structure-name-based-on-the-string-of-a-variable-create-fieldnames-in-this-structure

https://www.mathworks.com/matlabcentral/answers/128912-concatenating-string-variable-names-and-passing-on-values-of-a-matrix-in-a-for-loop

Answer 12

[Stephen Cobeldick]

Other Languages: do not use eval!

In case you think that avoiding dynamic variable names is just some "weird MATLAB thing", here is the same discussion for some other programming languages, all advising "DO NOT create dynamic variable names":

https://blogs.msdn.microsoft.com/ericlippert/2003/11/01/eval-is-evil-part-one/

https://blogs.msdn.microsoft.com/ericlippert/2003/11/04/eval-is-evil-part-two/

http://nedbatchelder.com/blog/201112/keep_data_out_of_your_variable_names.html

http://www.techrepublic.com/blog/it-security/never-use-dynamic-variable-names/

http://stackoverflow.com/questions/11118486/python-list-as-variable-name

http://www.reddit.com/r/learnpython/comments/2a9o4s/why_is_it_a_bad_idea_to_create_dynamic_variables/

http://stackoverflow.com/questions/1479490/making-a-string-the-name-of-an-instance-object/1480247#1480247

http://stackoverflow.com/questions/25076883/creating-dynamically-named-variables-in-a-function-in-python-3-understanding-e

http://perl.plover.com/varvarname.html

https://24ways.org/2005/dont-be-eval

https://softwareengineering.stackexchange.com/questions/311507/why-are-eval-like-features-considered-evil-in-contrast-to-other-possibly-harmfu/311510

https://stackoverflow.com/questions/2571401/why-exactly-is-eval-evil

Some languages might use, require, or otherwise encourage dynamic variable names. If that is how they work efficiently, then so be it. But what is efficient in one language means nothing about the same method in other languages... if you wish to use MATLAB efficiently, make your code easier to work with, and write in a way that other MATLAB users will appreciate, then you should learn how to use MATLAB features and tools:

https://www.mathworks.com/matlabcentral/answers/320774-looping-over-a-set-of-names-and-creating-a-set-of-variables

Answer 13

[Stephen Cobeldick]

Confuses Data with Code

The inclusion of data and meta-data within variable names (e.g. naming a variable with the user's input, the name of a test subject, or (very commonly) adding an index onto a variable name) is a subtle (but closely related) problem, and it should definitely be avoided.

The problem with including meta-data in variable names is that this breaks the idea of code being generalized, because it mixes the code and data together. In fact data and code should be kept separate to keep the code generalized. Code that is written to be as general as possible is simpler, more robust, more adaptable, easier to write, and easier to fix, which in turn makes code much less buggy. Mixing meta-data into variable names really just makes everything much more complicated, and this in turn makes code slow and buggy.

Read these discussions for an explanation of why it is a poor practice to put data and meta-data in variable names:

https://www.mathworks.com/matlabcentral/answers/56124-eval-is-evil-using-variables-created-dynamically-info-retrieval

https://www.mathworks.com/matlabcentral/answers/225435-save-variable-as-string-from-user-input

https://www.mathworks.com/matlabcentral/answers/12350-variable-name-length-exceeds-63-characters

In many cases that meta-data is just a de-facto index, i.e. a value that proscribes the order of the data. But in that case the de-facto index should be turned into a much more efficient real numeric index:

https://www.mathworks.com/matlabcentral/answers/325569-finding-the-means-of-a-large-number-of-individual-matrices#answer_255199

https://www.mathworks.com/matlabcentral/answers/8337-creating-a-matrix-with-many-numbered-variables

https://www.mathworks.com/matlabcentral/answers/240702-is-there-a-way-to-make-matlab-create-variables-of-any-number-on-its-own#answer_191569

Answer 14

[Stephen Cobeldick]

Alternative: Use more Efficient Ways to Pass Variables between Workspaces (applies to evalin, assignin, etc)

Use nested functions, or pass arguments, or use any of the other efficient ways to pass data between workspaces:

https://www.mathworks.com/help/matlab/matlab_prog/share-data-between-workspaces.html

https://www.mathworks.com/help/matlab/creating_guis/share-data-among-callbacks.html

Answer 15

[Stephen Cobeldick]

Magically Making Variables Appear in a Workspace is Risky

For a start those variables will be overwritten without warning, leading to hard-to-find bugs. But there is also a more serious yet subtle problem, which is caused by the MATLAB parser finding alternative functions/objects/... and calling those instead of using the magically-created variable: basically if the variable does not exist then the parser does it best to find something that matches where the name is called/used later... and it might just find something! For example:

https://www.mathworks.com/matlabcentral/answers/349330-odd-behavior-with-a-simulink-reserved-name-in-a-function

https://www.mathworks.com/matlabcentral/answers/28676-why-use-x-load-myfile-mat

https://www.mathworks.com/matlabcentral/answers/120518-trouble-with-accessing-variable-in-parfor-loop

https://www.mathworks.com/matlabcentral/answers/235119-can-you-explain-this-weird-behavior

https://www.mathworks.com/matlabcentral/newsreader/view_thread/244639#628669

https://www.mathworks.com/matlabcentral/answers/410758-function-call-doesn-t-work-in-script-works-in-command-window#answer_329197

https://www.mathworks.com/matlabcentral/answers/51946-systematic-do-not-use-global-don-t-use-eval#comment_107637

The solution is simple: do not magically "poof" variables into existence: Always load into a structure, and never create variable names dynamically.

[Jonathan]

You seem to imply that this is expected behaviour, but it indicates a (partially?) static name resolution instead of a dynamic one, which is really unexpected for an interpreted language. It is not the job of the parser to interpret the code; and surely if a variable is registered dynamically at runtime, it could overwrite whatever the parser decided previously. Granted, "poofing" variables into existence is a terrible idea, but this should not cause an inconsistent behaviour of name resolution. I think it would be fair to call this a bug, rather than a "gotcha".

[Stephen Cobeldick]

@Jonathan:

"You seem to imply that this is expected behaviour"

I based my answer on various comments of TMW staff members (which I linked to): they are in a much better position than I to make such statements.

"...but it indicates a (partially?) static name resolution instead of a dynamic one, which is really unexpected for an interpreted language."

You assume that MATLAB is interpreted. MATLAB is not really a purely interpreted language: the JIT compiler analyses (static) code and finds ways to optimize it before running it. The TMW blogs state that "MATLAB provides the best of both worlds by compiling MATLAB code on-the-fly, or just-in-time.", distinguishing it from both compiled and interpreted code.

source: https://blogs.mathworks.com/loren/2016/02/12/run-code-faster-with-the-new-matlab-execution-engine/

Describing MATLAB as using "(partially?) static name resolution" is probably reasonable. Ask TMW for more details if you are interested.

"It is not the job of the parser to interpret the code''

Based on the explanations given by TMW staff members in various comments, blogs, and documentation, it appears that the JIT optimization does exactly that.

"if a variable is registered dynamically at runtime, it could overwrite whatever the parser decided previously"

While possible, that would likely be in direct conflict with the JIT parser. Essentially you would slow down (all?) code just to support bad code practices.

Read more:

https://www.mathworks.com/products/matlab/matlab-execution-engine.html

https://www.mathworks.com/matlabcentral/answers/430098-documentation-on-jit-compiler

[Guillaume]

Certainly, mathworks could introduce a construct to automatically resolve dynamic variable name, similar to the $$ construct that PHP uses. And indeed, from a performance point of view, on a purely interpreted language that would have little to no impact. However, as Stephen just pointed out, matlab is not purely interpreted (nowadays no decent programming language is) so anything that changes at runtime does have an impact on performance. If you look at the release notes over the year, you can clearly see that mathworks are constantly optimising variable resolution to take it out of the interpreted stage (hence why poofing variables with load can now fail where it worked before).

From a design point of view, dynamic variable names will always be a nightmare in most cases. PHP is not very well regarded for its security precisely because it allows these constructs.

When you start writing code to generate variable names, you're no longer writing code to process your data, you're writing code to generate the code that will process your data, and the increased complexity of this metaprogramming is always an added risk (of bugs, security issues, etc.)

[Jonathan]

Thanks to both of you for the very prompt responses! :)

I did not know that Matlab was not purely interpreted; knowing this clarifies the issue with dynamic names. Truth be told, I never use dynamic names in my code (because of some of the reasons listed in this thread), and would never recommend that anyone did. But I find edge-cases interesting.

Regarding potential impacts on performance, it seems to me that dynamic names can only ever occur due to an `eval`, `evalin` or `load` operation, is that right? I think it is fair to say that none of these functions should be used in a portion of code that is performance-critical. Though I am not one to give advice about language design, would it be possible to "re-parse" the code following such operations as they occur, in order to update the name resolution? This would badly affect performance when they are used, but would leave other situations unaffected, wouldn't it?

[Guillaume]

assignin and evalc also belong to that list. I can't think of any others right now.

The reparsing that you describe is most likely what was happening is past versions. But at least for load, it's clear that mathworks are moving away from that design and are not interested in supporting implicitly defined variables. I.e.

function myfunc()
    load data.mat   %creates a x variable
    disp(x(:));
end

no longer works (or will no longer work). See R2017a release notes.

I'm fine with that. If the optimiser has to detect whether or not it can optimise or must leave it later to reparse will have an impact on performance for both cases since it must do that detection.

[Walter Roberson]

There is currently some name re-resolution being done whenever the MATLAB path changes, including when you cd() -- which is a reason to avoid cd() in code.

In the past, I put some thought into the kinds of structures you would have to put in place in order to handle that situation efficiency . I did not follow it through, though; just some thought experiments.

Answer 16

[Stephen Cobeldick]

PS: eval is Not Faulty:

Some beginners apparently think that eval (and friends) must be faulty and should be removed from MATLAB altogether. They ask "if eval is so broken, why has it not been removed?"... but it is important to understand that the problem is caused by magically accessing variable names regardless of what tool or operation is used, and that eval (or assignin, or evalin, or load without an output argument, etc.) is simply being used inappropriately because there are much better methods available ( better in the sense faster, neater, simpler, less buggy, etc). Read these discussions for good examples of this confusion:

https://www.mathworks.com/matlabcentral/answers/364851-assignin-and-eval-functions

https://www.mathworks.com/matlabcentral/answers/352237-is-there-the-more-elegant-way-to-do-this

It is important to note that any feature of a language can be used inefficiently or in an inappropriate way, not just eval, and this is not something that can be controlled by the language itself. For example, it is common that someone might solve something with slow loops and without preallocating the output arrays: this does not mean that for loops are "faulty" and need to be removed from MATLAB!

It is up to the programmer to write efficient code.

Answer 17

[Stephen Cobeldick]

Alternative: save the Fields of a Scalar Structure

The save command has an option for saving the fields of a scalar structure as separate variables in a .mat file. For example, given a scalar structure:

S.A = 1;
S.B = [2,3];

this will save variables A and B in the .mat file:

save('myfile.mat','-struct','S')

This is the inverse function of loading into a structure. Some threads showing how this can be used:

https://www.mathworks.com/matlabcentral/answers/456803-how-to-allow-a-gui-user-to-defined-a-variable-name

https://www.mathworks.com/matlabcentral/answers/44175-saving-in-loop-using-eval-or-num2str

https://www.mathworks.com/matlabcentral/answers/314554-saving-function-variables-without-evil-eval#answer_245192

Answer 18

[Steven Lord]

Alternative: Use a table or timetable Array

table (introduced in release R2013b) and timetable (introduced in release R2016b) arrays allow you to store data with row and/or column names with which you can access the data. For example, if you create a table with variables named Age, Gender, Height, Weight, and Smoker and rows named with the last names of the patients:

load patients

patients = table(Age,Gender,Height,Weight,Smoker,...
    'RowNames',LastName);

you can ask for all the ages of the first five patients:

patients(1:5, 'Age')

or all the data for the patients with last names Smith or Jones:

patients({'Smith', 'Jones'}, :)

You can also add new variables to the table, either by hard-coding the name of the variable:

% Indicate if patients are greater than five and a half feet tall
patients.veryTall = patients.Height > 66

or using variable names stored in char or string variables. The code sample below creates new variables named over40 and under35 in the patients table using different indexing techniques.

newname1 = 'over40';
patients.(newname1) = patients.Age > 40;

newname2 = 'under35';
patients{:, newname2} = patients.Age < 35;

patients(1:10, :) % Show the first ten rows

The code sample below selects either Height or Weight and shows the selected variable for the fifth through tenth patients using dynamic names.

if rand > 0.5
    selectedVariable = 'Height';
else
    selectedVariable = 'Weight';
end
patients.(selectedVariable)(5:10)

See this documentation page for more information about techniques you can use to access and manipulate data in a table or timetable array. This documentation page contains information about accessing data in a timetable using the time information associated with the rows.

[Stephen Cobeldick]

Simpler way to generate a table from that .mat file:

S = load('patients.mat');
T = struct2table(S,'RowNames',S.LastName);

Answer 19

[Econstudent]

You discuss at length why we shouldn't A, B or C and you also comment on how we could access certain objects.

Now, suppose we need to import a few time series -- but I can only import those series one at a time. The intention behind creating a sequence of variables inside a loop is often to store those time series in distinct object every time. That is, you want to assign the data to a different object every time and do it considerably more than once...

What other choice do you have besides creating objects within your loop?

[Stephen Cobeldick]

"What other choice do you have besides creating objects within your loop?"

All of the choices that are explained above: cell arrays, structures, ND numeric arrays. And with newer MATLAB versions also tables, strings, datetime, etc. All of these allow you to "import those series one at a time", and use indexing (or fieldnames, etc) to put that data into one variable/object. Simple.

"The intention ... is often to store those time series in distinct object every time"

That is exactly what container arrays are for (e.g. cell array, structure arrays, etc.).

[Jan]

@Econstudent: Did you read this thread carefully? If your "sequence of variables" mean, that the variables are a sequence, they have a relation. Then this relation should be mapped in the code by collecting them in one array. An efficient and logic representation of the data is essential for good code, but it remains the art of programming.

Answer 20

[saul camacho]

How do I get the varibals in the workspace part?

[Adam Danz]

That's not the right question to ask. The question is how those variable ended up in the (base?) workspace to begin with and how that method can change so that they are loaded into the function space or passed as inputs.