ECMAScript

ECMAScript (or ES)[1] is a scripting-language specification standardized by Ecma International in ECMA-262 and ISO/IEC 16262. It was created to standardize JavaScript, so as to foster multiple independent implementations. JavaScript has remained the best-known implementation of ECMAScript since the standard was first published, with other well-known implementations including JScript and ActionScript.[2] ECMAScript is commonly used for client-side scripting on the World Wide Web, and it is increasingly being used for writing server applications and services using Node.js.

ECMAScript
ParadigmMulti-paradigm: prototype-based, functional, imperative
Designed byBrendan Eich, Ecma International
First appeared1997
Typing disciplineweak, dynamic
Websitewww.ecma-international.org
Major implementations
JavaScript, SpiderMonkey, V8, ActionScript, JScript, QtScript, InScript, Google Apps Script
Influenced by
Self, HyperTalk, AWK, C, CoffeeScript, Perl, Python, Java, Scheme
ECMAScript
Crystal source
Filename extensions.es
Internet media typeapplication/ecmascript
Developed bySun Microsystems,
Ecma International
Initial releaseJune 1997
Latest release
Edition 9
(June 2018)
Type of formatScripting language
WebsiteECMA-262, ECMA-290,
ECMA-327, ECMA-357,
ECMA-402

History

The ECMAScript specification is a standardized specification of a scripting language developed by Brendan Eich of Netscape; initially it was named Mocha, later LiveScript, and finally JavaScript.[3] In December 1995, Sun Microsystems and Netscape announced JavaScript in a press release.[4] The first edition of ECMA-262 was adopted by the Ecma General Assembly in June 1997. Several editions of the language standard have been published since then. The name "ECMAScript" was a compromise between the organizations involved in standardizing the language, especially Netscape and Microsoft, whose disputes dominated the early standards sessions. Each commented that "ECMAScript was always an unwanted trade name that sounds like a skin disease."[5]

While both JavaScript and JScript aim to be compatible with ECMAScript, they also provide additional features not described in the ECMA specifications.[6]

Versions

There are nine editions of ECMA-262 published. Work on version 9 of the standard was finalized in June 2018.[7]

Edition Date published Name Changes from prior edition Editor
1 June 1997 First edition Guy L. Steele Jr.
2 June 1998 Editorial changes to keep the specification fully aligned with ISO/IEC 16262 international standard Mike Cowlishaw
3 December 1999 Added regular expressions, better string handling, new control statements, try/catch exception handling, tighter definition of errors, formatting for numeric output and other enhancements Mike Cowlishaw
4 Abandoned Fourth Edition was abandoned, due to political differences concerning language complexity. Many features proposed for the Fourth Edition have been completely dropped; some were incorporated into the sixth edition.
5 December 2009 Adds "strict mode," a subset intended to provide more thorough error checking and avoid error-prone constructs. Clarifies many ambiguities in the 3rd edition specification, and accommodates behaviour of real-world implementations that differed consistently from that specification. Adds some new features, such as getters and setters, library support for JSON, and more complete reflection on object properties.[8] Pratap Lakshman, Allen Wirfs-Brock
5.1 June 2011 This edition 5.1 of the ECMAScript standard is fully aligned with third edition of the international standard ISO/IEC 16262:2011. Pratap Lakshman, Allen Wirfs-Brock
6 June 2015[9] ECMAScript 2015 (ES2015) The sixth edition, initially known as ECMAScript 6 (ES6) and later renamed to ECMAScript 2015 (ES2015)[9] adds significant new syntax for writing complex applications, including classes and modules, but defines them semantically in the same terms as ECMAScript 5 strict mode. Other new features include iterators and for/of loops, Python-style generators and generator expressions, arrow functions, binary data, typed arrays, collections (maps, sets and weak maps), promises, number and math enhancements, reflection, and proxies (metaprogramming for virtual objects and wrappers). As the first "ECMAScript Harmony" specification, it is also known as "ES6 Harmony." Allen Wirfs-Brock
7 June 2016[10] ECMAScript 2016 (ES2016) ECMAScript 2016 (ES2016)[10], the seventh edition, intended to continue the themes of language reform, code isolation, control of effects and library/tool enabling from ES2015, includes two new features: the exponentiation operator (**) and Array.prototype.includes. Brian Terlson
8 June 2017[11] ECMAScript 2017 (ES2017) ECMAScript 2017 (ES2017), the eighth edition, includes features for concurrency and atomics, syntactic integration with promises (async/await).[12][11] Brian Terlson
9 June 2018[7] ECMAScript 2018 (ES2018) ECMAScript 2018 (ES2018), the ninth edition, includes features for asynchronous iteration and generators, new regular expression features and rest/spread parameters.[7] Brian Terlson

In June 2004, Ecma International published ECMA-357 standard, defining an extension to ECMAScript, known as ECMAScript for XML (E4X). Ecma also defined a "Compact Profile" for ECMAScript – known as ES-CP, or ECMA 327 – that was designed for resource-constrained devices, which was withdrawn in 2015.[13]

4th Edition (abandoned)

The proposed fourth edition of ECMA-262 (ECMAScript 4 or ES4) would have been the first major update to ECMAScript since the third edition was published in 1999. The specification (along with a reference implementation) was originally targeted for completion by October 2008.[14] An overview of the language was released by the working group on October 23, 2007.[15]

By August 2008, the ECMAScript 4th edition proposal had been scaled back into a project codenamed ECMAScript Harmony. Features under discussion for Harmony at the time included

Intent of these features was partly to better support programming in the large, and to allow sacrificing some of the script's ability to be dynamic to improve performance. For example, Tamarin – the virtual machine for ActionScript, developed and open sourced by Adobe – has just-in-time compilation (JIT) support for certain classes of scripts.

In addition to introducing new features, some ES3 bugs were proposed to be fixed in edition 4.[16][17] These fixes and others, and support for JSON encoding/decoding, have been folded into the ECMAScript, 5th Edition specification.[18]

Work started on Edition 4 after the ES-CP (Compact Profile) specification was completed, and continued for approximately 18 months where slow progress was made balancing the theory of Netscape's JavaScript 2 specification with the implementation experience of Microsoft's JScript .NET. After some time, the focus shifted to the ECMAScript for XML (E4X) standard. The update has not been without controversy. In late 2007, a debate between Eich, later the Mozilla Foundation's CTO, and Chris Wilson, Microsoft's platform architect for Internet Explorer, became public on a number of blogs. Wilson cautioned that because the proposed changes to ECMAScript made it backwards incompatible in some respects to earlier versions of the language, the update amounted to "breaking the Web,"[19] and that stakeholders who opposed the changes were being "hidden from view".[20] Eich responded by stating that Wilson seemed to be "repeating falsehoods in blogs" and denied that there was attempt to suppress dissent and challenged critics to give specific examples of incompatibility.[21] He pointed out that Microsoft Silverlight and Adobe AIR rely on C# and ActionScript 3 respectively, both of which are larger and more complex than ECMAScript Edition 3.[22]

5th Edition

Yahoo, Microsoft, Google, and other 4th edition dissenters formed their own subcommittee to design a less ambitious update of ECMAScript 3, tentatively named ECMAScript 3.1. This edition would focus on security and library updates with a large emphasis on compatibility. After the aforementioned public sparring, the ECMAScript 3.1 and ECMAScript 4 teams agreed on a compromise: the two editions would be worked on, in parallel, with coordination between the teams to ensure that ECMAScript 3.1 remains a strict subset of ECMAScript 4 in both semantics and syntax.

However, the differing philosophies in each team resulted in repeated breakages of the subset rule, and it remained doubtful that the ECMAScript 4 dissenters would ever support or implement ECMAScript 4 in the future. After over a year since the disagreement over the future of ECMAScript within the Ecma Technical Committee 39, the two teams reached a new compromise in July 2008: Brendan Eich announced that Ecma TC39 would focus work on the ECMAScript 3.1 (later renamed to ECMAScript, 5th Edition) project with full collaboration of all parties, and vendors would target at least two interoperable implementations by early 2009.[23][24] In April 2009, Ecma TC39 published the "final" draft of the 5th edition and announced that testing of interoperable implementations was expected to be completed by mid-July.[25] On December 3, 2009, ECMA-262 5th edition was published.[26]

6th Edition - ECMAScript 2015

The 6th edition, officially known as ECMAScript 2015, was finalized in June 2015.[9][27] This update adds significant new syntax for writing complex applications, including classes and modules, but defines them semantically in the same terms as ECMAScript 5 strict mode. Other new features include iterators and for/of loops, Python-style generators, arrow functions, binary data, typed arrays, collections (maps, sets and weak maps), promises, number and math enhancements, reflection, proxies (metaprogramming for virtual objects and wrappers) and template literals.[28][29] The complete list is extensive.[30]

7th Edition - ECMAScript 2016

The 7th edition, officially known as ECMAScript 2016, was finalized in June 2016.[10] New features include the exponentiation operator (**), Array.prototype.includes.

8th Edition - ECMAScript 2017

The 8th edition, officially known as ECMAScript 2017, was finalized in June 2017.[11] Includes async/await, which works using generators and promises. [12]

9th Edition - ECMAScript 2018

The 9th edition, officially known as ECMAScript 2018, was finalized in June 2018.[7] New features include rest/spread properties, asynchronous iteration, Promise.prototype.finally() and additions to RegExp.[7]

ES.Next

ES.Next is a dynamic name that refers to whatever the next version is at time of writing. ES.Next features are more correctly called proposals, because, by definition, the specification has not been finalized yet.

Features

The ECMAScript language includes structured, dynamic, functional, and prototype-based features.[31]

Concise syntax

ES6 brought with it a new mode of defining functions, so called "arrow functions."[32] In ES5, a function would be defined as such:

var readWikiArticle = function(content) {
    // Read it!
}

Whereas in ES6, using the new concise arrow function syntax:

var readWikiArticle = (content) => {
    //Read article!
}

Arrow functions also improve variable binding between functions.

Transpiling

Since ES 2015, transpiling JavaScript has become very common. Transpilation is a source to source compilation in which the newer versions of JavaScript are used in the user's source code and the transpiler rewrites them so that they are compliant with the current specification.[33] Usually, transpilers transpile down to ES3 to maintain compatibility with all versions of browsers. The settings to transpiling to a specific version can be configured according to need. Transpiling adds an extra step to the build process and sometimes to avoid that polyfills can be used as well. Polyfills allow adding extra functionalities by including another JavaScript file which adds those specific functionalities.

Conformance

In 2010, Ecma International started developing a standards test for Ecma 262 ECMAScript.[34] Test262 is an ECMAScript conformance test suite that can be used to check how closely a JavaScript implementation follows the ECMAScript 5th Edition Specification. The test suite contains thousands of individual tests, each of which tests some specific requirements of the ECMAScript specification.

Development of test262 is a project of Ecma Technical Committee 39 (TC39). The testing framework and individual tests are created by member organizations of TC39 and contributed to Ecma for use in Test262.

Important contributions were made by Google (Sputnik testsuite) and Microsoft who both contributed thousands of tests. The Test262 testsuite already contains more than 11,000 tests and is being developed further as of 2013.

ECMAScript specifications through ES7 are well-supported in major web browsers. The table below shows the conformance rate for current versions of software with respect to the most recent editions of ECMAScript.

Scripting engine Reference application(s) Conformance[35]
ES5[36] ES6[37] ES7[38] Newer (2016+)[38][39]
Chakra Microsoft Edge 18 100% 96% 100% 58%
SpiderMonkey Firefox 63 100% 98% 100% 78%
Chrome V8 Google Chrome 70, Opera 57 100% 98% 100% 100%
JavaScriptCore (Nitro) Safari 12 99% 99% 100% 90%

See also

References

  1. ^ Stefanov, Stoyan (2010). JavaScript Patterns. O'Reilly Media, Inc. p. 5. ISBN 9781449396947. Retrieved 2016-01-12. The core JavaScript programming language [...] is based on the ECMAScript standard, or ES for short.
  2. ^ "A Short History of JavaScript". W3C. Retrieved 31 March 2017.
  3. ^ Krill, Paul (2008-06-23). "JavaScript creator ponders past, future". InfoWorld. Retrieved 2013-10-31.
  4. ^ "Industry Leaders to Advance Standardization of Netscape's JavaScript at Standards Body Meeting". Netscape. November 15, 1996. Archived from the original on 1998-12-03. Retrieved 2013-10-31.
  5. ^ "Will there be a suggested file suffix for es4?". Mail.mozilla.org. 2006-10-03. Retrieved 2013-10-31.
  6. ^ "JScript VS JavaScript". About.com. 2015-11-25.
  7. ^ a b c d e "ECMAScript 2018 Language Specification". Ecma International. June 2018.
  8. ^ "Changes to JavaScript, Part 1: EcmaScript 5". YouTube. 2009-05-18. Retrieved 2013-10-31.
  9. ^ a b c "ECMAScript 2015 Language Specification". Ecma International. June 2015.
  10. ^ a b c "ECMAScript 2016 Language Specification". Ecma International. June 2016.
  11. ^ a b c "ECMAScript 2017 Language Specification". Ecma International. June 2017.
  12. ^ a b "ECMAScript 2017 (ES8): the final feature set". 2ality. Retrieved 2018-04-23.
  13. ^ 2015-03-24 Meeting Notes. ESDiscuss. Also see Ecma withdrawn Standards. ECMA.
  14. ^ "ES4 overview paper released". Mail.mozilla.org. Retrieved 2013-10-31.
  15. ^ "Proposed ECMAScript 4th Edition – Language Overview" (PDF). ecmascript.org. 23 October 2007. Archived from the original (PDF) on 13 July 2010.
  16. ^ John Resig. "John Resig – Bug Fixes in JavaScript 2". Ejohn.org. Retrieved 2013-10-31.
  17. ^ "Compatibility Between ES3 and Proposed ES4" (PDF). Ecmascript.org. Retrieved 2013-10-31.
  18. ^ "Wayback Machine" (PDF). 2009-04-19. Retrieved 2018-03-19.
  19. ^ "ECMAScript 3 and Beyond – IEBlog – Site Home – MSDN Blogs". Blogs.msdn.com. 2007-10-30. Retrieved 2013-10-31.
  20. ^ "What I think about ES4. - Albatross! - Site Home – MSDN Blogs". Blogs.msdn.com. 2007-10-31. Retrieved 2013-10-31.
  21. ^ "Open letter to Chris Wilson". Brendan Eich. 2007-10-31. Retrieved 2013-10-31.
  22. ^ "JavaScript 2 and the Open Web". 2007-11-20. Retrieved 2014-01-20.
  23. ^ "ECMAScript Harmony". Mail.mozilla.org. Retrieved 2013-10-31.
  24. ^ "A Major Milestone in JavaScript Standardization – JScript Blog – Site Home – MSDN Blogs". Blogs.msdn.com. 2009-04-09. Retrieved 2013-10-31.
  25. ^ "Ecma International finalises major revision of ECMAScript". Ecma International. 2009-04-09. Retrieved 2009-05-22.
  26. ^ "Ecma latest news". Ecma-international.org. Retrieved 2013-10-31.
  27. ^ Krill, Paul. "It's official: ECMAScript 6 is approved". InfoWorld. Retrieved 2018-03-19.
  28. ^ "5 Great Features in EcmaScript 6 (ES6 Harmony) - Wintellect". Wintellect. 2014-03-24. Retrieved 2018-03-19.
  29. ^ "ECMAScript 6 (ES6): What's New In The Next Version Of JavaScript". Smashing Magazine. 2015-10-28. Retrieved 2018-03-19.
  30. ^ "ECMAScript 6: New Features: Overview and Comparison". es6-features.org. Retrieved 2018-03-19.
  31. ^ "About". ECMAScript. Archived from the original on 2012-08-02. Retrieved 2009-12-17.
  32. ^ "Arrow Functions: Fat and Concise Syntax in JavaScript". SitePoint. 2018-04-09. Retrieved 2018-11-21.
  33. ^ "Using ES2015 today". Wisdom Geek. 2016-05-12. Retrieved 2018-08-29.
  34. ^ "ECMAScript Language – test262". Test262.ecmascript.org. Archived from the original on 2011-05-14. Retrieved 2013-10-31.
  35. ^ ES5 is the baseline for this test suite. The conformance rate for other editions reflects support for new features only, not a comprehensive score.
  36. ^ "ECMAScript 5 compatibility table". kangax.github.io. Retrieved 2018-11-08.
  37. ^ "ECMAScript 6 compatibility table". kangax.github.io. Retrieved 2018-11-08.
  38. ^ a b "ECMAScript 2016+ compatibility table". kangax.github.io. Retrieved 2018-11-08.
  39. ^ Composite score that includes new features from ES7 through next edition drafts

External links

ISO Standard
Ecma Standards
ActionScript

ActionScript is an object-oriented programming language originally developed by Macromedia Inc. (later acquired by Adobe Systems). It is a derivation of HyperTalk, the scripting language for HyperCard. It is now a dialect of ECMAScript (meaning it is a superset of the syntax and semantics of the language more widely known as JavaScript), though it originally arose as a sibling, both being influenced by HyperTalk.

ActionScript is used primarily for the development of websites and software targeting the Adobe Flash Player platform, used on Web pages in the form of embedded SWF files.

ActionScript 3 is also used with Adobe AIR system for the development of desktop and mobile applications. The language itself is open-source in that its specification is offered free of charge and both an open source compiler (as part of Apache Flex) and open source virtual machine (Mozilla Tamarin) are available.

ActionScript is also used with Scaleform GFx for the development of 3D video game user interfaces and HUDs.

Caja project

Caja (pronounced KAH-hah) is a Google project and a JavaScript implementation for "virtual iframes" based on the principles of object-capabilities. Caja takes JavaScript (technically, ECMAScript 5 strict mode code), HTML, and CSS input and rewrites it into a safe subset of HTML and CSS, plus a single JavaScript function with no free variables. That means the only way such a function can modify an object is if it is given a reference to the object by the host page. Instead of giving direct references to DOM objects, the host page typically gives references to wrappers that sanitize HTML, proxy URLs, and prevent redirecting the page; this allows Caja to prevent certain phishing attacks, prevent cross-site scripting attacks, and prevent downloading malware. Also, since all rewritten programs run in the same frame, the host page can allow one program to export an object reference to another program; then inter-frame communication is simply method invocation.

The word "caja" is Spanish for "box" or "safe" (as in a bank), the idea being that Caja can safely contain JavaScript programs as well as being a capabilities-based JavaScript.

Caja is currently used by Google in its Google Sites and Google Apps Script products; in 2008 MySpace and Yahoo! and Allianz had both deployed a very early version of Caja but later abandoned it.

Comparison of JavaScript engines

The following tables compare standards support for some notable JavaScript engines used in web browsers.

ECMAScript for XML

ECMAScript for XML (E4X) is the standard ISO/IEC 22537:2006 [1] programming language extension that adds native XML support to ECMAScript (which includes ActionScript, JavaScript, and JScript). The goal is to provide an alternative to DOM interfaces that uses a simpler syntax for accessing XML documents. It also offers a new way of making XML visible. Before the release of E4X, XML was always accessed at an object level. E4X instead treats XML as a primitive (like characters, integers, and booleans). This implies faster access, better support, and acceptance as a building block (data structure) of a program.

E4X is standardized by Ecma International in the ECMA-357 standard. The first edition was published in June 2004, the second edition in December 2005.

The E4X standard was deprecated by the Mozilla Foundation in 2014.

InScript (JavaScript engine)

InScript is a software library providing an ECMAScript engine for ECMA-262 3ed, written in C++, and some Java classes for LiveConnect. It was used by the web browser iCab 2 and 3. ICab 4 uses the WebKit Web browser engine with the ECMAScript engine JavaScriptCore. It is proprietary software, closed-source.

JScript

JScript is Microsoft's dialect of the ECMAScript standard that is used in Microsoft's Internet Explorer.

JScript is implemented as an Active Scripting engine. This means that it can be "plugged in" to OLE Automation applications that support Active Scripting, such as Internet Explorer, Active Server Pages, and Windows Script Host. It also means such applications can use multiple Active Scripting languages, e.g., JScript, VBScript or PerlScript.

JScript was first supported in the Internet Explorer 3.0 browser released in August 1996. Its most recent version is JScript 9.0, included in Internet Explorer 9.

JScript 10.0 is a separate dialect, also known as JScript .NET, which adds several new features from the abandoned fourth edition of the ECMAScript standard. It must be compiled for .NET Framework version 2 or version 4, but static type annotations are optional.

JavaScript

JavaScript (), often abbreviated as JS, is a high-level, interpreted programming language that conforms to the ECMAScript specification. It is a programming language that is characterized as dynamic, weakly typed, prototype-based and multi-paradigm.

Alongside HTML and CSS, JavaScript is one of the core technologies of the World Wide Web. JavaScript enables interactive web pages and is an essential part of web applications. The vast majority of websites use it, and major web browsers have a dedicated JavaScript engine to execute it.

As a multi-paradigm language, JavaScript supports event-driven, functional, and imperative (including object-oriented and prototype-based) programming styles. It has APIs for working with text, arrays, dates, regular expressions, and the DOM, but the language itself does not include any I/O, such as networking, storage, or graphics facilities. It relies upon the host environment in which it is embedded to provide these features.

Initially only implemented client-side in web browsers, JavaScript engines are now embedded in many other types of host software, including server-side in web servers and databases, and in non-web programs such as word processors and PDF software, and in runtime environments that make JavaScript available for writing mobile and desktop applications, including desktop widgets.

The terms Vanilla JavaScript and Vanilla JS refer to JavaScript not extended by any frameworks or additional libraries. Scripts written in Vanilla JS are plain JavaScript code.Although there are similarities between JavaScript and Java, including language name, syntax, and respective standard libraries, the two languages are distinct and differ greatly in design. JavaScript was influenced by programming languages such as Self and Scheme.

JavaScript engine

A JavaScript engine is a computer program that executes JavaScript (JS) code. The first JS engines were mere interpreters, but all relevant modern engines utilize just-in-time compilation for improved performance.JS engines are developed by web browser vendors, and every major browser has one. In a browser, the JS engine runs in concert with the rendering engine via the Document Object Model (DOM).

The use of JS engines is not limited to browsers. For example, the Chrome V8 engine is a core component of the popular Node.js runtime system.

KJS (software)

KJS is KDE's ECMAScript-JavaScript engine that was originally developed for the KDE project's Konqueror web browser by Harri Porten in 2000.

On June 13, 2002, Maciej Stachowiak announced on a mailing list that Apple was releasing JavaScriptCore, a framework for Mac OS X that was based on KJS. Through the WebKit project, JavaScriptCore has since evolved into SquirrelFish Extreme, a JavaScript engine that compiles JavaScript into native machine code.

List of ECMAScript engines

An ECMAScript engine is a program that executes source code written in a version of the ECMAScript language standard, for example, JavaScript.

These are new generation ECMAScript engines for web browsers, all implementing just-in-time compilation (JIT) or variations of that idea. The performance benefits for just-in-time compilation make it much more suitable for web applications written in JavaScript.

Carakan: A JavaScript engine developed by Opera Software ASA, included in the 10.50 release of the Opera web browser, until switching to V8 with Opera 15 (released in 2013).

Chakra (JScript9): A JScript engine used in Internet Explorer. It was first previewed at MIX 10 as part of the Internet Explorer 9 Platform Preview.

Chakra: A JavaScript engine used in Microsoft Edge.

SpiderMonkey: A JavaScript engine in Mozilla Gecko applications, including Firefox. The engine currently includes the IonMonkey compiler and OdinMonkey optimization module, has previously included the TraceMonkey compiler (first javascript JIT) and JägerMonkey.

JavaScriptCore: A JavaScript interpreter and JIT originally derived from KJS. It is used in the WebKit project and applications such as Safari. Also known as Nitro, SquirrelFish and SquirrelFish Extreme.

Tamarin: An ActionScript and ECMAScript engine used in Adobe Flash.

V8: A JavaScript engine used in Google Chrome, Node.js, and V8.NET.

Nashorn: A JavaScript engine used in Oracle Java Development Kit (JDK) since version 8.

iv, ECMAScript Lexer / Parser / Interpreter / VM / method JIT written in C++

CL-JavaScript: Can compile JavaScript to machine language on Common Lisp implementations that compile to machine languageThe following engines use runtime interpreters, which do not compile into native machine code and generally run more slowly:

Continuum: A self-interpreter that supports older drafts of the ECMAScript 2015 specification. Uniquely, the engine is implemented in ECMAScript 3, which made it possible to run ES2015 in browsers as old as IE6.

Futhark: The ECMAScript engine of the Opera web browser versions 9.50 to 10.10.

InScript: An obsolete proprietary library used for iCab 2 and 3.

JScript: The engine that is used in Internet Explorer for versions up to IE9, and one component of the Trident layout engine.

KJS: The engine used in Konqueror, and one component of KHTML, a predecessor to JavaScriptCore.

Linear B: The ECMAScript engine of the Opera web browser versions 7.0 to 9.50, exclusive.

Narcissus: JavaScript implemented in JavaScript (a meta-circular evaluator), intended to run in another JavaScript engine, of theoretical and educational nature only.

JS-Interpreter A lightweight JavaScript interpreter implemented in JavaScript with step-by-step execution.

QtScript: Originally developed by Trolltech, now owned by The Qt Company. It provides QObject integration with JavaScriptCore.

Rhino: One of several JavaScript engines from Mozilla, using the Java platform.

YAJI: An ECMAScript engine based on the FESI implementation by Jean-Marc Lugrin in 1999, using the Java platform, currently being developed to support the latest standards (ECMAScript spec. 262, v5.1).

Duktape: A small footprint, easily embeddable Ecmascript E5/E5.1 engine.

The Kinoma Platform, an ECMAScript 6 runtime environment and framework. This is one of the first runtimes to correctly implement almost all of the ECMAScript 6 specification, currently unmaintained.

Moddable successor of Kinoma Platform, currently active project and aims to support more recent versions of ECMAScript.

Jsish: A JavaScript interpreter with builtin SQLite, JSON, WebSocket, and ZVFS support.

Websocket.js: An embeddable Javascript engine with HTTP/Websocket support.

Espruino: A very small footprint interpreter specifically for microcontrollers. Can run in less than 8 kB of RAM by executing from source (rather than bytecode).

MuJS: A lightweight ECMAScript interpreter library, designed for embedding in other software to extend them with scripting capabilities. Originally developed for MuPDF.

V7: Part of the Smart.js platform; claims to be the world's smallest JavaScript engine.

Tiny-JS: A minimal JavaScript interpreter written in C++.

JerryScript: A lightweight JavaScript engine by Samsung for microcontrollers with less than 64 KB RAM.

GNU Guile features an ECMAScript interpreter as of version 1.9

njs: A lightweight JavaScript interpreter optimized for web server scripting and fastest VM context creation; used in nginx.

Presto (browser engine)

Presto was the browser engine of the Opera web browser from the release of Opera 7 on 28 January 2003 until the release of Opera 15 on 2 July 2013, at which time Opera switched to using the Blink engine that was originally created for Chromium. Presto was also used to power the Opera Mini and Opera Mobile browsers.

Presto is a dynamic engine. Web pages can be re-rendered completely or partially in response to DOM events. Its releases saw a number of bug fixes and optimizations to improve the speed of the ECMAScript (JavaScript) engine. It is proprietary and only available as a part of the Opera browsers.

QtScript

QtScript is a scripting engine that has been part of the Qt cross-platform application framework since version 4.3.0.

The scripting language is based on the ECMAScript standard with a few extensions, such as QObject-style signal and slot connections. The library contains the engine, and a C++ API for evaluating QtScript code and exposing custom QObject-derived C++ classes to QtScript.

The QtScript Binding Generator provides bindings for the Qt API to access directly from ECMAScript. QtScript and the binding generator are used for Amarok 2's scripting system.

The current (as of Qt 4.7) implementation uses JavaScriptCore and will not be further developed. The module is deprecated as of Qt 5.5.

SVG animation

Animation of Scalable Vector Graphics, an open XML-based standard vector graphics format, is possible through various means:

Scripting: ECMAScript is a primary means of creating animations and interactive user interfaces within SVG.

Styling: Since 2008, the development of CSS Animations as a feature in WebKit has made possible stylesheet-driven implicit animation of SVG files from within the Document Object Model (DOM).

SMIL: Synchronized Multimedia Integration Language, a recommended means of animating SVG-based hypermedia, supported by the Amaya (2003) Opera (2006), Mozilla Firefox (2011), Google Chrome (2016) and Safari (2017) web browsers, and any browser that aims to pass the Acid3 web standards test of 2008 (i.e. before the test's "simplification" in 2011) as this requires SMIL support for tests 75 and 76.Libraries have also been written as a shim to give current SVG-enabled browsers SMIL support. This method is also known as SVG+Time.Because SVG supports PNG and JPEG raster images, it can be used to animate such images as an alternative to APNG and MNG.

Scripting language

A scripting or script language is a programming language that supports scripts — programs written for a special run-time environment that automates the execution of tasks that could alternatively be executed one-by-one by a human operator. Scripting languages are often interpreted (rather than compiled). Primitives are usually the elementary tasks or API calls, and the language allows them to be combined into more complex programs. Environments that can be automated through scripting include software applications, web pages within a web browser, usage of the shells of operating systems (OS), embedded systems, as well as numerous games. A scripting language can be viewed as a domain-specific language for a particular environment; in the case of scripting an application, it is also known as an extension language. Scripting languages are also sometimes referred to as very high-level programming languages, as they operate at a high level of abstraction, or as control languages, particularly for job control languages on mainframes.

The term "scripting language" is also used loosely to refer to dynamic high-level general-purpose languages, such as Perl, PowerShell, Python, and Tcl with the term "script" often used for small programs (up to a few thousand lines of code) in such languages, or in domain-specific languages such as the text-processing languages sed and AWK. Some of these languages were originally developed for use within a particular environment, and later developed into portable domain-specific or general-purpose languages.

Conversely, many general-purpose languages have dialects that are used as scripting languages. This article discusses scripting languages in the narrow sense of languages for a specific environment.

The spectrum of scripting languages ranges from very small and highly domain-specific languages to general-purpose programming languages used for scripting. Standard examples of scripting languages for specific environments include: Bash, for the Unix or Unix-like operating systems; ECMAScript (JavaScript), for web browsers; and Visual Basic for Applications, for Microsoft Office applications. Lua is a language designed and widely used as an extension language. Python is a general-purpose language that is also commonly used as an extension language, while ECMAScript is still primarily a scripting language for web browsers, but is also used as a general-purpose language. The Emacs Lisp dialect of Lisp (for the Emacs editor) and the Visual Basic for Applications dialect of Visual Basic are examples of scripting language dialects of general-purpose languages. Some game systems, notably the Second Life virtual world and the Trainz franchise of Railroad simulators have been extensively extended in functionality by scripting extensions (Linden Scripting Language and TrainzScript). In other games like Wesnoth, the variety of actual games played by players are scripts written by other users.

Speech Recognition Grammar Specification

Speech Recognition Grammar Specification (SRGS) is a W3C standard for how speech recognition grammars are specified. A speech recognition grammar is a set of word patterns, and tells a speech recognition system what to expect a human to say. For instance, if you call an auto-attendant application, it will prompt you for the name of a person (with the expectation that your call will be transferred to that person's phone). It will then start up a speech recognizer, giving it a speech recognition grammar. This grammar contains the names of the people in the auto attendant's directory and a collection of sentence patterns that are the typical responses from callers to the prompt.

SRGS specifies two alternate but equivalent syntaxes, one based on XML, and one using augmented BNF format. In practice, the XML syntax is used more frequently.

Both the ABNF and XML form have the expressive power of a context-free grammar. A grammar processor that does not support recursive grammars has the expressive power of a finite state machine or regular expression language.

If the speech recognizer returned just a string containing the actual words spoken by the user, the voice application would have to do the tedious job of extracting the semantic meaning from those words. For this reason, SRGS grammars can be decorated with tag elements, which when executed, build up the semantic result. SRGS does not specify the contents of the tag elements: this is done in a companion W3C standard, Semantic Interpretation for Speech Recognition (SISR). SISR is based on ECMAScript, and ECMAScript statements inside the SRGS tags build up an ECMAScript semantic result object that is easy for the voice application to process.

Both SRGS and SISR are W3C Recommendations, the final stage of the W3C standards track. The W3C VoiceXML standard, which defines how voice dialogs are specified, depends heavily on SRGS and SISR.

Sputnik (JavaScript conformance test)

Sputnik was a JavaScript conformance test suite. The purpose of the test suite was to determine how well a JavaScript implementation adheres to the ECMA-262 specification, 5th edition, looking only at those features that were also present in the 3rd edition. It contained over 5000 tests that touched all aspects of the JavaScript language.The test was created in Russia for testing the conformance of the V8 JavaScript engine used in Google Chrome.As part of phasing out Google Labs, Google has shut down Sputnik. All current Sputnik tests have been incorporated into ECMA's Test262 test suite.

Tamarin (software)

Tamarin is a free software virtual machine with just-in-time compilation (JIT) support intended to implement the 4th edition of the ECMAScript (ES4) language standard. Tamarin source code originates from ActionScript Virtual Machine 2 (AVM2) developed by Adobe Systems, as introduced within Adobe Flash Player 9, which implements ActionScript 3 scripting language. ActionScript Virtual Machine 2 was donated as open-source to Mozilla Foundation on November 7, 2006, to develop Tamarin as a high-performance virtual machine, with the support from broad Mozilla community, to be used by Mozilla and Adobe Systems in the next generation of their JavaScript and ActionScript engines with the ultimate aim to unify the scripting languages across web browsers and Adobe Flash platform and ease the development of rich better performing web applications.

TypeScript

TypeScript is an open-source programming language developed and maintained by Microsoft. It is a strict syntactical superset of JavaScript, and adds optional static typing to the language.

TypeScript is designed for development of large applications and transcompiles to JavaScript. As TypeScript is a superset of JavaScript, existing JavaScript programs are also valid TypeScript programs. TypeScript may be used to develop JavaScript applications for both client-side and server-side (Node.js) execution.

For the transcompilation process, there are multiple options available. You can use the default TypeScript Checker to do so, or you can rely on Babel for converting your TypeScript to JavaScriptTypeScript supports definition files that can contain type information of existing JavaScript libraries, much like C++ header files can describe the structure of existing object files. This enables other programs to use the values defined in the files as if they were statically typed TypeScript entities. There are third-party header files for popular libraries such as jQuery, MongoDB, and D3.js. TypeScript headers for the Node.js basic modules are also available, allowing development of Node.js programs within TypeScript.The TypeScript compiler is itself written in TypeScript and compiled to JavaScript. It is licensed under the Apache 2.0 License.

TypeScript is included as a first-class programming language in Microsoft Visual Studio 2013 Update 2 and later, beside C# and other Microsoft languages. An official extension allows Visual Studio 2012 to support TypeScript as well.Anders Hejlsberg, lead architect of C# and creator of Delphi and Turbo Pascal, has worked on the development of TypeScript.

WMLScript

WMLScript is a procedural programming language and dialect of JavaScript used for WML pages and is part of the Wireless Application Protocol (WAP).

WMLScript is a client-side scripting language and is similar to JavaScript. Just like JavaScript WMLScript is used for tasks such as user input validation, generation of error message and other Dialog boxes etc.

WMLScript is based on ECMAScript (European Computer Manufacturers Association Script), which is JavaScript's standardized version. Thus the syntax of WMLScript is similar to JavaScript but not fully compatible.Despite the syntactical similarities, they are two different languages. WMLScript does not have objects or array, which JavaScript has. On the other hand, it allows you to declare and include external functions from other scripts. WMLScript is optimised for low power devices, and is a compiled language.

ECMAScript
Dialects
Engines
(comparison)
Frameworks
People
Other
Standards of Ecma International
Application interfaces
File systems (tape)
File systems (disk)
Graphics
Programming languages
Radio link interfaces
Other
ISO standards by standard number
1–9999
10000–19999
20000+
IEC standards
ISO/IEC standards
Related

This page is based on a Wikipedia article written by authors (here).
Text is available under the CC BY-SA 3.0 license; additional terms may apply.
Images, videos and audio are available under their respective licenses.