Although JavaScript and Java sound and look similar they are very different in their details and philosophies. Here I try to compare the two languages regardless of their libraries and frameworks. The goal is that you as a Java developer get an understanding of what JavaScript is and how it differs from Java. One hint: you can use jsfiddle.net to try out some of the snippets here or any JavaScript.
Note: right now this document discusses JavaScript 1.4, if enough interest is there I try to update it to a newer version (preferable ES5).
Primitives
Java – char, boolean, byte, short, int, long, float, double
JavaScript – none
Primitives are elements of the language which aren’t objects and therefore have no methods defined on them. JavaScript has no primitives.
Immutable types
Java – String (16bit), Character, Boolean, Byte, Short, Integer, Long, Float, Double, BigDecimal, BigInteger
JavaScript – String (16bit), Number(double, 64bit floating point), Boolean, RegExp
The next special kind of object are immutable objects, objects which represent values and cannot be changed.
JavaScript has four value objects: String (16bit like in Java), Number (64bit floating point like a double in Java), Boolean (like in Java) and RegExp (similar to Java). Java differences the number types further and introduces a Character.
Strings in JavaScript can be in single or double quotes and the sign to escape is the backslash (‘\’) just like in Java.
A regexp can be created via new RegExp or with ‘/’ like:
/a*/
Arrays
Java – special
JavaScript – normal object
Another base type in every language is the array. In Java the array is treated as a special kind of object it has a length property and is the only object which has the bracket ‘[]’ operator. In Java you create and access an array in the following way:
// creation
String[] empty = new String[2]; // an empty array with length 2
String[] array = new String[] {"1", "2"};
// read
empty[0]; // => null
empty[5]; // => ArrayIndexOutOfBoundsException
// write
empty[0] = "Test"; // empty is now ["Test", null]
empty[2] = "Test"; // => ArrayIndexOutOfBoundsException
JavaScript handles creation and access in a different way:
// creation
var empty = new Array(2); // an empty array with length 2
var array = ["1", "2"];
// read
empty[0]; // => undefined
empty[5]; // => undefined
// write
empty[0] = "Test"; // empty is now ["Test", undefined]
empty[2] = "Test"; // empty is now ["Test", undefined, "Test"]
The reason for the strange patterns is that an array in JavaScript is just an object with the indexes as properties and reading an undefined property returns undefined whereas setting an undefined property creates the property on the object. More on this under objects.
Comments
Java – // and /**/
JavaScript – // and /**/
Both languages allow the line ‘//’ and the block ‘/* */’ comments whereas the line comment is preferred in JavaScript because commenting out a regular expression can lead to syntax errors:
/a*/
Commenting out this regular expression with the block comment would result in
/* /a*/ */
which is a syntax error.
Boolean Truth
Java – true: true, false: false
JavaScript – false: false, null, undefined, ”, 0, NaN, true: all other values
Another stumbling block for Java developers is the handling of expressions in a boolean context. JavaScript not just treats false as false but also defines null, undefined, the empty string, 0, NaN as falsy values. All other values are evaluated to true.
Literals
Java – “, ‘, numbers, booleans
JavaScript – “, ‘, [], {}, /, numbers, booleans
Literals are a short hand for constructing objects inside the language. Java only supports string, number and boolean creation with literals everything else needs a new operator. In JavaScript you can create strings, numbers, booleans, arrays, objects and regular expressions:
"A string";
'Another string';
var number = 5;
var whatif = true;
var array = [];
var object = {};
var regexp = /a*b+/;
Operators
Java – postfix (expr++ expr–), unary (++expr –expr +expr -expr ~ !), multiplicative (* / %), additive (+ -), shift (<> >>>), relational ( = instanceof), equality (== !=), bitwise AND (&), bitwise exclusive OR (^),, bitwise inclusive OR (|), logical AND (&&), logical OR (||), ternary (?:), assignment (= += -= *= /= %= &= ^= |= <>= >>>=)
JavaScript – object creation (new), function call (()), increment/decrement (++ –), unary (+expr -expr ~ !), typeof, void, delete, multiplicative (* / %), additive (+ -), shift (<> >>>), relational ( = in instanceof), equality (== != === !==), bitwise AND (&), bitwise exclusive OR (^),, bitwise inclusive OR (|), logical AND (&&), logical OR (||), ternary (?:), assignment (= += -= *= /= %= &= ^= |= <>= >>>=)
Java and JavaScript have many operators in common. JavaScript has some additional ones. ‘void’ is an operator to return undefined and rarely useful. ‘delete’ removes properties from objects and hence also elements from arrays. ‘in’ tests for a property of an object but does not work for literal strings and numbers.
var string = "A string";
"length" in string // => error
var another = new String('Another string');
"length" in another // => true
The unary operators ‘+’ and ‘-‘ try to convert their operands to numbers and if the conversion fails they return NaN:
+'5' // => 5
-'2' // => 2
-'a' // => NaN
Typeof returns the type of its operand as a string. Beware the difference between literal creation and creation via new for numbers and strings.
typeof undefined // => "undefined"
typeof null // => "object"
typeof true // => "boolean"
typeof 5 // => "number"
typeof new Number(5) // => "object"
typeof 'a' // => "string"
typeof new String('a') // => "object"
typeof document // => Implementation-dependent
typeof function() {} // => "function"
typeof {} // => "object"
typeof [] // => "object"
All host environment specific objects like window or the html elements in a browser have implementation dependent return values.
Note that for an array it also returns “object” if you need to distinguish an array you must dig deeper.
Object.prototype.toString.call([]) // => "[object Array]"
The two pairs of equality operators (== != and === !==) behave differently. The shorter ones ‘==’ and ‘!=’ use type coercion which produces strange results and breaks transitivity:
'' == '0' // => false
0 == '' // => true
0 == '0' // => true
‘===’ and ‘!==’ works as expected if both operands are of the same type and have the same value they are true. The same value means either they are the same object or if they are a literal string, a literal number or a literal boolean have the same value regardless of length or precision.
5 === 5 // => true
5 === 5.0 // => true
'a' === "a" // => true
5 === '5' // => false
[5] === [5] // => false
new Number(5) === new Number(5) // => false
var a = new Number(5);
a === a // => true
false === false // => true
Declaration
Java – type
JavaScript – var
Since JavaScript is a dynamically typed language you do not specify types when declaring parameters, fields or local variables you just use var:
var a = new Number(5);
Scope
Java – block
JavaScript – function
Scope is a common pitfall in JavaScript. Scope defines the code area in which a variable is valid and defined. Java has block scope which means a variable is defined and valid inside any block.
int a = 2;
int b = 1;
if (a > b) {
int number = 5;
}
// no number defined here
JavaScript on the other hand has function scope which can lead to some confusion for developers coming from block scoped languages.
var f = function() {
var a = 2;
var b = 1;
if (a > b) {
var number = 5;
}
alert(number); // number is valid here
};
// but not here
One thing to remember is that closures have a reference not a copy of their variables from an outer scope.
for (var i = 0; i < 3; i++) {
setTimeout(function() {
i; // => always 3
}, 200);
}
How can you fix this? You need to add a wrapper function and pass the values you need.
for (var i = 0; i < 3; i++) {
(function(i) {
setTimeout(function() {
i; // => 0, 1, 2
}, 200);
})(i);
}
Statements
Java – conditional (switch, if/else), loop (while, do/while, for), branch (return, break, continue), exception (throw, try/catch/finally)
JavaScript – conditional (switch (uses ===), if/else), loop (while, do/while, for, for in (beware of protoype chain)), branch (break, continue, return), exception (throw, try/catch/finally), with
The statements which can be used in Java and JavaScript are largely the same but since JavaScript is dynamically typed you can use them with any types. See the section about boolean truth for the statements which need an expression to evaluate to false or true. Switch uses the ‘===’ operator to match the cases and has the same fall through pitfall like Java. ‘For in’ iterates over the names of all properties of an object including those which are inherited via the prototype chain. ‘With’ can be used to shorten the access to objects.
with (object) {
a = b
}
The problem here is you don’t know from looking at the code if a and/or b is a property of object or a global variable. Because of this ambiguity ‘with’ should be avoided
Object creation
Java – new
JavaScript – new or functional creation / module pattern
In Java you just declare your class
public class Person {
private final String name;
public Person(String name) {
this.name = name;
}
public String getName() {
return this.name;
}
}
and instantiate it via new.
Person john = new Person("John");
In JavaScript there is no class keyword but you can create objects via ‘{}’ or ‘new’. Let’s take a look at the functional approach first. The so called module pattern supports encapsulation (read: private members).
var person = function(name) {
var private_name = name;
return {
get_name: function() {
return private_name;
}
};
};
Now person holds a reference to a factory method and calling it will create a new person.
var john = person('John');
Another more classical and familiar way is to use ‘new’.
var Person = function(name) {
this.name = name;
};
Person.prototype.get_name = function() {
return this.name;
};
var john = new Person('John');
But what happens when we leave out the new?
var john = Person('John'); // bad idea!
Now this is bound to window (the global context) and a name property is defined on window but we can avoid this:
var Person = function(name) {
if (!(this instanceof Person)) {
return new Person(name);
}
this.name = name;
};
Now you can call Person with or without new and both behave the same. If you don’t want to repeat this for every class you can use the following pattern (adapted from John Resig to make it ES5 strict compatible).
// adapted from makeClass - By John Resig (MIT Licensed) - http://ejohn.org/blog/simple-class-instantiation/
var makeClass = function() {
var internal = false;
var create = function(args) {
if (this instanceof create) {
if (typeof this.init == "function") {
this.init.apply(this, internal ? args : arguments);
}
} else {
internal = true;
return new create(arguments);
}
};
return create;
};
This creates a function which can create classes. You can use it similar to the classical pattern.
var Person = makeClass();
Person.prototype.init = function(name) {
this.name = name;
};
Person.prototype.get_name = function() {
return this.name;
};
var john = new Person('John');
But name is now a public member of Person what if we want it to be private? If we take another look at the functional pattern above we can use the same mechanism.
var Person = function(name) {
if (!(this instanceof Person)) {
return new Person(name);
}
var private_name = name;
this.get_name = function() {
return private_name;
};
this.set_name = function(new_name) {
private_name = new_name;
};
};
Now name is also a private member of the Person class. Using makeClass you can achieve it in the following way.
var Person = makeClass();
Person.prototype.init = function(name) {
var private_name = name;
this.get_name = function() {
return private_name;
};
};
var john = new Person('John');
Encapsulation
Java – visibility modifiers (public, package, protected, private)
JavaScript – public or private (via closures)
As we have seen in the previous section we can have private variables and also methods via the encapsulation of a closure. All other variables and members are public.
Accessing properties
Java – .
JavaScript – . or []
Besides the dot you can also use an object like a hash.
var a = {b: 1};
a.b = 3;
a['b'] = 5;
Accessing non existing properties
Java – prevented by the compiler
JavaScript – get returns undefined, set creates
In Java accessing a property or method of an object which does not exists is prevented by the compiler. In JavaScript the following compiles and runs fine.
var a = {};
a.b;
a.b = 5;
When you access non existing members of an object you get undefined in return. Setting the non existing property creates it on the object.
Invocation and this
Java – method
JavaScript – method, function, constructor, apply
JavaScript knows four kinds of invocations: method, function, constructor and apply. A function on an object is called method and calling it will bound this to the object.
var john = {
name: "John",
get_name: function() {
return this.name; // => this is bound to john
}
};
john.get_name(); // => John
But there is a potential pitfall: it doesn’t matter which method you call but how! This problem can be worked around with the apply/call pattern below.
var john = {
name: "John",
get_name: function() {
return this.name; // => this is bound to the global context
}
};
var fn = john.get_name;
fn(); // => NOT John
A function which is not a property of an object is just a function and this is bound to the global context (in a browser the global context is the window object).
var get_name = function() {
return this.name; // this is bound to the global context
};
get_name();
Calling a function with ‘new’ constructs a new object and bounds this to it.
var Person = function(name) {
this.name = name; // => this is bound to john
};
var john = new Person("John");
john.name; // => John
JavaScript is a functional language (some call it even Lisp in C’s clothing) and therefore functions have methods, too. ‘Apply’ and ‘call’ are both methods to call a function with binding ‘this’ explicit.
var john = {
name: "John"
};
var get_name = function() {
return this.name; // this is bound to the john
};
get_name.apply(john); // => John
get_name.call(john); // => John
The difference between ‘apply’ and ‘call’ is just how they take their additional parameters: ‘apply’ needs an array whereas ‘call’ takes them explicitly.
var john = {
name: "John"
};
var set_name = function(name) {
this.name = name; // this is bound to the john
};
set_name.apply(john, ["Jack"]); // => Jack
set_name.call(john, "John"); // => John
Variable arguments
Java – …
JavaScript – arguments
In Java you can use variable argument lists via ‘…’. In JavaScript you do not need to declare them. All parameters of a function call are available via arguments regardless of what parameters are declared.
var sum = function() {
var result = 0;
for (var i = 0; i < arguments.length; i++) {
result += arguments[i];
}
return result;
};
sum(1); // => 1
sum(1, 2); // => 3
Also arguments looks like an array it isn’t one and if you need an array of arguments you can use slice to convert it.
var array = Array().slice.call(arguments);
Inheritance
Java – extends, implements
JavaScript – prototype chain
Java can easily inherit types or implementation via implements or extends. JavaScript has no classes and uses another approach called the prototype chain. If you want to create a new object User which inherits from Person you use the prototype attribute.
var Person = function(name) {
this.name = name;
};
var User = function(username) {
Person.call(this, username); // emulating call to super
this.username = username;
};
User.prototype = new Person();
var john = new User('John');
john.name; // => John
john.username; // => John
If I left something out or got something wrong please leave a comment. Also if you think a topic discussed here should be explored in more depth feel free to comment.
Schneide Blog 