ES3 Specification

The JavaScript Journey Continued

The evolution of the Web and JavaScript continued. After the first standardization step in 1997, the ES1 specification saw the light. In June 1998, the ECMA General Assembly approved the second ECMA specification for ECMAScript ES2. However, I am not going to do any review of the document because according to the TC39 website: ‘Changes between the first and the second edition are editorial in nature.’ It means that the next step in this journey is the third specification of ES3.

ES3 brought new features to the language: regular expressions, improved string handling, new control statements, try/catch style of exception handling, improved definitions of errors, formatting for numeric output and some minor changes in anticipation of future changes of the language. This was a huge leap in the development and evolution of ECMAScript, and a change that broght to the Web another chanper of its history.

After the publication of the third edition of the ES specification, ECMAScript achieved massive adoption and became a widely supported language for the Web because assentially all web browsers supported it. By that time, The Mozilla Project had already been created when the Netscape Navigator went open source in 1998. The scene of a new era of the Web was born. Those moves were necessary to preserve the open nature of the Web, and to harness the creative power of thousands of people allowing free innovation and creativity. All those creative efforts have borne fruit in 2002 when Mozilla released the first version of a new browser to the world: Mozilla 1.0.

In the release note Netscape said that:

A Quick Review of the ES3

As always in the ECMAScript specifications, the first thing is the meaning of conformance: ‘A conforming implementation of ECMAScript must provide and support all the types, values, objects, properties, functions, and program syntax and semantics described in this specification’. One important note in for a conforming implementation is the incorporation of the Unicode Standard version 2.1 or later. It meant that characters must have UTF-16 as its encoding form.

On the other hand, JavaScript preserved its nature as not self-sufficient language, but to be run within a host environment. The language defined as object-based remained the same as the ES1 in 1997. An object-based language is one such that the basic language and host facilities are provided by objects, and a JavaScript program can be interpreted as a cluster of communicating objects. In other words, it is all about objects and object-communication oriented programming.

The list of built-in objects grew since the first specification in 1997. In 1999, ES3 incorporated the following new objects: RegExp, Error, EvalError, RangeError, ReferenceError, SyntaxError, TypeError and URIError object. The list of reserved words or keywords also grew since ES1. New statements were added to the language. For example, selection of paths of executions with the switch-case-default construct; the do-while construct that grants at least one execution is done in a loop; the instanceof operator that allows to test whether the prototype of a Constructor Function appears anywhere in the prototype chain of some object.

Also, a way to throw exceptions an a way to catch them all was incorporated in the language. As written above, new Error objects were incorporated into the language, and a syntactic mechanism for working with them. To catch exceptions, the try/catch/finallly triple was choosen, and the throw expression was the way to raise exceptional behavior in the code.

The new list of keywords in 1999 was:

        break           else            new         var
        case            finally         return      void
        catch           for             switch      while
        continue        function        this        with
        default         if              throw
        delete          in              try
        do              instanceof      typeof

In addition, the ES3 specificaition proposed future extensions of the language through some Future Reserved Words. As you can see in the list below, the object oriented package of keywords were reserved like class, extends, implements, super among others. The future vision of the language at that moment was trying to resemble the object oriented paradigms as JavaScript could allow it. The ES3 complete list of such words is:

        abstract enum int short
        boolean export interface static
        byte extends long super
        char final native synchronized
        class float package throws
        const goto private transient
        debugger implements protected volatile
        double import public

The list of operators also shows some changes in the conception of equality between objects or primitive values. ES3 added the ’===’ and the ’!==’ operators for logical comparison. This new operators where called ‘strict equality’ because they always consider values of different types as not equal.

Photo by Dmitry Spravko on Unsplash

Regular Expression Literals

Other important addition to the language were Regular Expression Literals. As defined by the specification: ‘A regular expression literal is an input element that is converted to a RegExp object when it is scanned’. When the scanner finds a regular expression literal, a new RegExp object is created with such literal expression, and before that piece of code be executed. Evaluation of the literal produces a reference to such object rather than a new one. In addition, a RegExp object can be created using the new operator as the same way as other objects as well as using the RegExp constructor as a function. One important characteristic of RegExp objects is that two objects created with the same literal evaluates false when compared with the strict equality operator ’===’. In general, a literal regular expression is built from a pattern well defined in the specificaition. Below, some examples of the new syntax with a simple regular expression pattern.

        const re = new RegExp("\\w+");
        const lit = /\w+/;
        const other = RegExp("\\w+");

Conclusion

ECMAScript continued its own slow, steady journey; ES3 was just another step further in its evolution. The language had become more suitable for the increasing necessity of innovation and creativity for the Web.