When declaring variables in JavaScript, especially when coming from a Java background, there are a few  things to be aware of. Here are a few notes I took.

JavaScript is a recent enough adopter of the const keyword, its version of a constant, when it was introduced with ES2015. The Let keyword was also introduced. But first let us look at the standard way to declare a variable.

JavaScript is not strongly typed, and there are several ways to make a declaration. In general it is best to use the var keyword as follows:

var number = 1;

You don’t have to do so, the following would work also:

number = 1;

However, there is a big difference between the two examples. Take a look at the following example to see if you can spot what happens to the outerScope variable.

function multiply() {
	var innerScope = 10;
	outerScope = 35;
	console.log( innerScope * outerScope )
}
multiply();
  350

innerScope;
  Uncaught ReferenceError: innerScope is not defined
      at <anonymous>:1:1
  (anonymous) @ VM555:1

outerScope;
  35

The first variable declared in the function, innerScope, behaves as we would expect from a Java background; it is only visible within the scope that it has been declared in. However, without the var keyword, the outerScope variable behaves differently. It is available to a global scope.

As you can imagine this can lead to unintended consequences if the behaviour is not understood correctly. It can lead to multiple parts of the codebase updating the same, global variables without the others knowing and should be avoided. Always use the var keyword when declaring variables.

Constants

One thing that irks many non-Java developers is that it can be overly verbose. A pet hate of mine is that constant declarations require two modifiers, static and final. And because default visibility is package in Java, we usually add either the public or private modifier leading to overly wordy declarations.

JavaScript began life without any constants, but when they were finally introduced, at least the designers had the good sense to do so with a short keyword, const. Once declared and set, any attempt to update a constant will produce an error:

const c = 10;
c = 11;
VM371:2 Uncaught TypeError: Assignment to constant variable.
    at <anonymous>:2:3
(anonymous) @ VM371:2

Let it Be

In Java, tight scoping rules mean that when a variable name is reused, clear rules separate access to the variable. Take for example this method, where the use of the variable within the for loop does not affect the static class variable with the same name.

public class TestScope {
	private static int number = 17;
	public static void main (String [] args) {
		for ( int i = 0; i < 5; i++ ) {
			// redeclare and change the number variable
			int number = i * 10;
			System.out.println("Inner number is: " + number);
		}
		System.out.println("Outer number is: " + number);
	}
}

When run this will produce:

Inner number is: 0
Inner number is: 10
Inner number is: 20
Inner number is: 30
Inner number is: 40
Outer number is: 17

JavaScript behaves a little differently. This simple example illustrates the difference:

var number = 100;
console.log(number);
{
  var number = 75;
  console.log(number);
}
console.log(number);
  100
  75
  75

The second declaration of the number variable affects the first and there is no compiler or runtime warning that this is happening. I’m not sure whether this is a feature for some reason, but there is a way around it using the keyword let should a variable name need to be reused.

var number = 100;
console.log(number);
{
  let number = 75;
  console.log(number);
}
console.log(number);

  100
  75
  100

Just another thing to be aware of when transitioning from Java to JavaScript. I’ll continue this series of short articles, which can be found under Tech Shorts, as I come across interesting differences.