Often, when I am initializing something I have to use a temporary variable, for example:

file_str = "path/to/file"
file_file = open(file)

or

regexp_parts = ['foo', 'bar']
regexp       = new RegExp( regexp_parts.join('|') )

However, I like to reduce the scope my variables to the smallest scope possible so there is less places where they can be (mis-)used. For example, I try to use for(var i ...) in C++ so the loop variable is confined to the loop body.

In these initialization cases, if I am using a dynamic language, I am then often tempted to reuse the same variable in order to prevent the initial (and now useless) value from being used latter in the function.

file = "path/to/file"
file = open(file)

regexp = ['...', '...']
regexp = new RegExp( regexp.join('|') )

The idea is that by reducing the number of variables in scope I reduce the chances to misuse them. However this sometimes makes the variable names look a little weird, as in the first example, where "file" refers to a "filename".

I think perhaps this would be a non issue if I could use non-nested scopes

begin scope1
   filename = ...
begin scope2
   file = open(filename)
end scope1
   //use file here
   //can't use filename on accident
end scope2

but I can't think of any programming language that supports this.

What rules of thumb should I use in this situation?

• When is it best to reuse the variable?
• When is it best to create an extra variable?
• What other ways do we solve this scope problem?