UnityScript versus JavaScript

From Unify Community Wiki
Revision as of 18:10, 10 April 2011 by Ppeterson (Talk | contribs)

Jump to: navigation, search


JavaScript is class-free

JavaScript has no classes. This is because it's a prototypal language, and not a classical one. Inheritance happens with [more dynamic] objects, rather than [unchanging] classes. <javascript>function Machine(x) {

  this.kind = ["bulldozer", "lathe", "car"][x];


var c = new Machine(2); print(typeof c.announce); // "undefined"

Machine.prototype.announce = function() {

  print("I am a "+this.kind+".");


print(typeof c.announce); // "function" c.announce(); // prints "I am a car."</javascript>

As shown above, in JavaScript, a function can create an object, when called with the new keyword. After that happens, the prototype (template) object Machine can be extended to provide additional functionality, and all class instances, past and future, are affected by this extension.

UnityScript has classes, and functions cannot create objects as in JavaScript. Extension is therefore impossible. However, there is the added benefit of being an easier-to-read, more familiar (to most) language.

<javascript>class Machine {

  var kind : String;
  function Machine(x : int) {
     this.kind = ["bulldozer", "lathe", "car"][x];
  function announce() {
     print("I am a "+this.kind+".");


print(typeof Machine.prototype); // undefined

var c = new Machine(2);

c.announce(); // prints "I am a car."</javascript>

No Global Variables

Every top-level variable in JavaScript is global. Additionally, any variable declaration not preceded by the var statement is global. This is not the case in UnityScript, as every object-owned .js file is essentially wrapped in a class JSFileName {...} block. The absent-var behavior is avoided by the language prohibiting missing var keywords.

By extension, there is no global object, so the this keyword will always point to the innermost object's instance, in contrast to JS's this keyword, which will sometimes point to the global object.

Dynamic typing is inefficient

This code is valid in both UnityScript and JavaScript: <javascript>var x; x = 3;</javascript> However, it is inefficient in UnityScript because it causes x to be dynamically typed. For faster runtime execution, use one of the two static typing syntaxes. <javascript>var x = 3; // type `int` is inferred, typed statically</javascript>

<javascript>var x : int; // typed statically x = 3;</javascript>


In JavaScript, privacy is rather unconventional.

<javascript>function Person() { // (this is the *JavaScript* way of doing privacy)

  var secret = "I am a mass murderer."; // private
  this.speak = function() { print("Don't make me tell you my secret! "+secret); }; // prints secret

} var bob = new Person(); print(bob.secret); // undefined bob.speak(); // prints "Don't make me tell you my secret! I am a mass murderer."</javascript>

In UnityScript, it can be more intuitive.

<javascript>class Person { // UnityScript only; impossible in JavaScript

  private var secret : String;
  function Person() {
     secret = "I am a mass murderer.";
  function speak() {
     print("Don't make me tell you my secret! "+secret);


var bob = new Person(); print(bob.secret); // undefined bob.speak(); // prints "Don't make me tell you my secret! I am a mass murderer."</javascript>

No Bling

Dollar signs ($) are not allowed in UnityScript identifiers as they are in JS identifiers. (In JS, the symbol is often used for c-style namespacing or as the name of a do-everything function.)

<javascript>var lib$cosine = 3; // ERROR! in UnityScript</javascript>

No with statement

There is no with statement in UnityScript. This is probably for the best, as JavaScript's with statement causes the whole language to be slower, regardless of whether the statement is used or not. It is also considered harmful.

Personal tools