If you’ve been keeping track of this blog, you might have noticed that I am a big fan of JavaScript. Although you can argue about the fundamental features that a language has, there are several reasons why I
consider JavaScript to be one of the hottest languages out there today.
A couple of days ago the organization responsible for the new ECMAScript, version 4 (AKA JavaScript 2) have published a revised version of the language overview. Although this is only a proposal, TG1 is no longer accepting more proposals and has started writing the new specs, so this “overview” is pretty much final.
It is no secret that the new version of JavaScript will be heavily influenced by…. no, not Java 🙂 The new JavaScript will be… Pythonic!
Following you can find some of the coolest features of the next big language.
Note: Some of the following features are already part of current JavaScript specs and are also implemented in Firefox 2 (eg. Generators and Iterators).
Type Annotations
Generally speaking types describe run-time values. In the new JavaScript a type annotation can (optionally) be added to a property, to a function parameter, to a function itself (applying to the function’s return value), to a variable, or to an object or array initializer.
Examples:
var x : String; // declares a string
function f(a : int, b : String, c : Object) : RetType {
// arguments are guaranteed to match types
// return value must convert to or match RetType
}
Classes
Class-based programming is a ubiquitous methodology in the industry. Object-oriented programming as we have known to love it in Java and other languages is supported in ES4 by classes and interfaces. A class describes an object by presenting those properties (fields) of the object that are always present (the fixed properties or fixtures), including variables, constants, and methods. In the JavaScript a class basically defines a named record type derived from another class, or from Object if no supeclass is given, and is immutable.
Example:
class C extends B {
function C(m) { mem = m }
public function getmem() { return mem }
private var mem : Object
}var c : C = new C(new Date)
Interfaces
An interface describes a collection of method properties; a class can declare that it implements an interface and then back that up by providing definitions for the
methods in the interface. Then instances of the class also have the type of the interface. In JavaScript an interface is a named record type, possibly derived from another interface, containing only function declarations with no body. A class may implement one or more interfaces
interface I { function f() }
interface J { function g(n) }
class C implements I, J {
function f() { return "foo" }
function g(n) { return n+2 }
}
Structural Types
Besides classes and interfaces, types can also be renamed or abbreviated by means of special type definitions, which are helpful in giving names to structural types:
type Q = {p: int, q: String}
type R = {p: int, q: String, r: Boolean}
type A = [int, String, Boolean, Object]
type F = function (int, String, Boolean): Object
type G = function (int, Object, Object): Number
Namespaces
Besides the built-ins (public, private, internal, intrinsic) you can declare your own with the namespace directive:
namespace ns = "synodinos.wordpress.com/"class C {
public function frob(): int {...}
public ns function frob(alpha: double): double { ... }
}
Packages
A package is a value comprised of a package name and two namespaces known as the package-internal and the package-public namespaces. The two namespaces are created by the ECMAScript implementation and are not visible to the program, but the package introduces a block scope in which these two namespaces are both open. The definitions in the package are evaluated in this block scope.
Examples:
//Wrap up related code in a first-class way
package org.mozilla.venkman {
class Debugger { . . . }
class Inspector { . . . }
class StackWalker { . . . }
}//Import names from a package…
import org.mozilla.venkman.*
//…or import selectively:
import org.mozilla.venkman.Inspector
let variables
The let directive introduces bindings into the innermost block object. It is considered as a “better var” because var only introduces bindings into the variable object.
Example:
function f(v1: Vec3, v2: Vec3) {
if (cross_product_only) {
let a1 = v1[0], a2 = v1[1], a3 = v1[2]
let b1 = v2[0], b2 = v2[1], b3 = v2[2]
return new Vec3(a2*b3 - a3*b2, a3*b1 - a1*b3, a1*b2 - a2*b1)
}
. . .
}
let variables have block scope and in combination with for loops contain an implicit block:
for (let i = 0; i < n; i++) sum += a[i]
for (let key in obj) print(key, obj[key])
Here is an example of a block statements using let:
//JS1 idiom:
(function (a, b) {
var x = b, y = a
var z = eval(s)
commit(x, y, z)
})(x, y)//With let much better
let (x = y, y = x, z) {
z = eval(s)
commit(x, y, z)
}
Example of Block Expressions using let:
//In the JS1 idiom:
return (function (a, b) {
var x = b, y = a
return commit(x, y, eval(s))
})(x, y)
//With let much much better!
return let (x = y, y = x, z) commit(x, y, eval(s))
Destructuring Assignment
Here are some simple cases of destructuring assignment and bindings:
//Group assignment and return:
// swap, rotate, permute in general
[a, b] = [b, a]
[p, q, r] = [q, r, p]// destructure a triple into fresh vars
var [s, v, o] = db.getTriple()
//Objects:
let {'Title': title, 'Height': height, 'Width': width} = jsonResult//for-in loops:
for (let [key, {'Title':title, 'FileSize':size}] in dict)
print(key, title, size)
Iterators
The iterators in the new JavaScript are similar to those in Python:
Example:
let it = Iterator(["apple", "orange", "banana"])it.next() //returns [0, "apple"]
it.next() //returns [1, "orange"]
it.next() //returns [2, "banana"]
it.next() //throws StopIteration//The for-in loop handles StopIteration:
for (let i in it) print(i)
Generators
When developing code that involves an iterative algorithm (such as iterating over a list, or repeatedly performing computations on the same data set), there are often state variables whose values need to be maintained for the duration of the computation process. Traditionally, you have to use a callback function to obtain the intermediate values of an iterative algorithm. Generators and iterators work together to provide a new, better, way to do this.
A function containing the new keyword yield is a generator: when it is called, it binds its parameters to their values and immediately returns a new generator-iterator object which can be called repeatedly to yield new values:
function count(n : int) {
for (let i = 0; i < n; i++)
yield i
}var gen = count(10)
gen.next() //returns 0; . . .; gen.next() returns 9
gen.next() //throws StopIteration
gen.send(value) //passes value back to yield
gen.throw(exception) //throws exception from yield
Array Comprehensions
Array comprehensions are a use of generators that provides a convenient way to perform powerful initialization of arrays:
let squares = [i * i for (i in count(10))]
print(squares) => "0,1,4,9,...,81"
let odd_squares = [i * i for (i in count(10)) if (i % 2)]
return [i * j for (i in it1) for (j in it2) if (i != j)]
Decimal pragma and type
A pragma is a directive that appears at the beginning of a block and its effect is limited to that block only. For doing math you can use the use decimal pragma, which selects a DecimalContext object containing rounding and precision
settings for decimal arithmetic.
//In JS1…
print(79.49 - 35.99) // => 43.4999999999999
//… but know
{
use decimal
print(79.49 - 35.99) // => 43.50
}
In ECMAScript 3 the type double represents a 64-bit IEEE 754 binary
floating-point number. This is needed for backwards compatibility and is suitable for most computations since it takes advantage of the floating-point hardware on current CPUs. In the new version decimal represent a 128-bit IEEE 754r decimal floating-point number and provides base-10 arithmetic to high precision (34 decimal digits) which is is not yet widely implemented in hardware.
Very excited to blog about the upcoming JHUG Java Day that is organized by the Java Hellenic User Group (JHUG).
At the JavaOne bookstore I got my hands on a 
This year me and my 
It is generally accepted that in every field of IT where a UI is needed there is great benefit from the separation between the 
Dio Synodinos 
