JavaScript

JavaScript (/ˈdʒɑːvəˌskrɪpt/[6]), often

abbreviated as JS, is a high-level,
dynamic, weakly typed, prototype-based,
multi-paradigm, and interpreted
programming language. Alongside HTML
and CSS, JavaScript is one of the three
core technologies of World Wide Web
content production. It is used to make
webpages interactive and provide online
programs, including video games. The
majority of websites employ it, and all
modern web browsers support it without
the need for plug-ins by means of a built-
in JavaScript engine. Each of the many
JavaScript engines represent a different
implementation of JavaScript, all based
on the ECMAScript specification, with
some engines not supporting the spec
fully, and with many engines supporting
additional features beyond ECMA.
JavaScript
Paradigm Multi-paradigm: object-oriented
(prototype-based), imperative,
functional, event-driven[1]

Designed by Brendan Eich

Developer Netscape Communications

Corporation, Mozilla
Foundation, Ecma International

First appeared December 4, 1995[2]

Stable release ECMAScript 2017[3] /

June 2017

Typing dynamic, duck

discipline

Filename .js
extensions

Website Mozilla

Major implementations
 V8, JavaScriptCore, SpiderMonkey, Chakra

Influenced by

Lua, Scheme, Perl, Self, Java, C, Python, AWK,

HyperTalk

Influenced

ActionScript, AtScript, CoffeeScript, Dart,

JScript .NET, LiveScript, Objective-J, Opa, Perl 6,
QML, TypeScript

JavaScript at Wikibooks
JavaScript
Filename .js
extension
Internet application/javascript
media type
text/javascript  (obsolete)
Uniform Type
com.netscape.javascript-source
Identifier (UTI)
[5]

Type of Scripting language

format

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

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.

Although there are strong outward

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.[7]

History
Beginnings at Netscape

In 1993, the National Center for

Supercomputing Applications (NCSA), a
unit of the University of Illinois at Urbana-
Champaign, released NCSA Mosaic, the
first popular graphical Web browser,
which played an important part in
expanding the growth of the nascent
World Wide Web. In 1994, a company
called Mosaic Communications was
founded in Mountain View, California and
employed many of the original NCSA
Mosaic authors to create Mosaic
Netscape. However, it intentionally
shared no code with NCSA Mosaic. The
internal codename for the company's
browser was Mozilla, which stood for
"Mosaic killer", as the company's goal
was to displace NCSA Mosaic as the
world's number one web browser. The
first version of the Web browser, Mosaic
Netscape 0.9, was released in late 1994.
Within four months it had already taken
three-quarters of the browser market and
became the main browser for the
Internet in the 1990s. To avoid trademark
ownership problems with the NCSA, the
browser was subsequently renamed
Netscape Navigator in the same year,
and the company took the name
Netscape Communications. Netscape
Communications realized that the Web
needed to become more dynamic. Marc
Andreessen, the founder of the company
believed that HTML needed a "glue
language" that was easy to use by Web
designers and part-time programmers to
assemble components such as images
and plugins, where the code could be
written directly in the Web page markup.
In 1995, Netscape Communications
recruited Brendan Eich with the goal of
embedding the Scheme programming
language into its Netscape Navigator.[8]
Before he could get started, Netscape
Communications collaborated with Sun
Microsystems to include in Netscape
Navigator Sun's more static
programming language Java, in order to
compete with Microsoft for user
adoption of Web technologies and
platforms.[9] Netscape Communications
then decided that the scripting language
they wanted to create would complement
Java and should have a similar syntax,
which excluded adopting other
languages such as Perl, Python, TCL, or
Scheme. To defend the idea of
JavaScript against competing proposals,
the company needed a prototype. Eich
wrote one in 10 days, in May 1995.

Although it was developed under the

name Mocha, the language was officially
called LiveScript when it first shipped in
beta releases of Netscape Navigator 2.0
in September 1995, but it was renamed
JavaScript[2] when it was deployed in the
Netscape Navigator 2.0 beta 3 in
December.[10] The final choice of name
caused confusion, giving the impression
that the language was a spin-off of the
Java programming language, and the
choice has been characterized as a
marketing ploy by Netscape to give
JavaScript the cachet of what was then
the hot new Web programming language.

There is a common misconception that

JavaScript was influenced by an earlier
Web page scripting language developed
by Nombas named C-- (not to be
confused with the later C-- created in
1997).[11][12] Brendan Eich, however, had
never heard of C-- before he created
LiveScript.[13] Nombas did pitch their
embedded Web page scripting to
Netscape, though Web page scripting
was not a new concept, as shown by the
ViolaWWW Web browser.[14] Nombas
later switched to offering JavaScript
instead of C-- in their ScriptEase product
and was part of the TC39 group that
standardized ECMAScript.[15]

Server-side JavaScript

In December 1995, soon after releasing

JavaScript for browsers, Netscape
introduced an implementation of the
language for server-side scripting with
Netscape Enterprise Server.[16]

Since the mid-2000s, additional server-

side JavaScript implementations have
been introduced, such as Node.js in
2009.[17]

Adoption by Microsoft
Microsoft script technologies including
VBScript and JScript were released in
1996. JScript, a reverse-engineered
implementation of Netscape's
JavaScript, was part of Internet Explorer
3. JScript was also available for server-
side scripting in Internet Information
Server. Internet Explorer 3 also included
Microsoft's first support for CSS and
various extensions to HTML, but in each
case the implementation was noticeably
different to that found in Netscape
Navigator at the time.[18][19] These
differences made it difficult for designers
and programmers to make a single
website work well in both browsers,
leading to the use of "best viewed in
Netscape" and "best viewed in Internet
Explorer" logos that characterized these
early years of the browser wars.[20]
JavaScript began to acquire a reputation
for being one of the roadblocks to a
cross-platform and standards-driven
Web. Some developers took on the
difficult task of trying to make their sites
work in both major browsers, but many
could not afford the time.[18] With the
release of Internet Explorer 4, Microsoft
introduced the concept of Dynamic
HTML, but the differences in language
implementations and the different and
proprietary Document Object Models
remained and were obstacles to
widespread take-up of JavaScript on the
Web.[18]

Standardization

In November 1996, Netscape submitted

JavaScript to Ecma International to carve
out a standard specification, which other
browser vendors could then implement
based on the work done at Netscape.
This led to the official release of the
language specification ECMAScript
published in the first edition of the
ECMA-262 standard in June 1997, with
JavaScript being the most well known of
the implementations. ActionScript and
JScript are other well-known
implementations of ECMAScript.

The standards process continued in

cycles, with the release of ECMAScript 2
in June 1998, which brings some
modifications to conform to the ISO/IEC
16262 international standard. The
release of ECMAScript 3 followed in
December 1999, which is the baseline for
modern day JavaScript. The original
ECMAScript 4 work led by Waldemar
Horwat (then at Netscape, now at
Google) started in 2000 and at first,
Microsoft seemed to participate and
even implemented some of the
proposals in their JScript .NET language.
Over time it was clear though that
Microsoft had no intention of
cooperating or implementing proper
JavaScript in Internet Explorer, even
though they had no competing proposal
and they had a partial (and diverged at
this point) implementation on the .NET
server side. So by 2003, the original
ECMAScript 4 work was mothballed.

The next major event was in 2005, with

two major happenings in JavaScript's
history. First, Brendan Eich and Mozilla
rejoined Ecma International as a not-for-
profit member and work started on
ECMAScript for XML (E4X), the ECMA-
357 standard, which came from ex-
Microsoft employees at BEA Systems
(originally acquired as Crossgain). This
led to working jointly with Macromedia
(later acquired by Adobe Systems), who
were implementing E4X in ActionScript 3
(ActionScript 3 was a fork of original
ECMAScript 4).

So, along with Macromedia, work

restarted on ECMAScript 4 with the goal
of standardizing what was in
ActionScript 3. To this end, Adobe
Systems released the ActionScript
Virtual Machine 2, code named Tamarin,
as an open source project. But Tamarin
and ActionScript 3 were too different
from web JavaScript to converge, as was
realized by the parties in 2007 and 2008.

Alas, there was still turmoil between the

various players; Douglas Crockford—then
at Yahoo!—joined forces with Microsoft
in 2007 to oppose ECMAScript 4, which
led to the ECMAScript 3.1 effort. The
development of ECMAScript 4 was never
completed, but that work influenced
subsequent versions.[21]

While all of this was happening, the open

source and developer communities set to
work to revolutionize what could be done
with JavaScript. This community effort
was sparked in 2005 when Jesse James
Garrett released a white paper in which
he coined the term Ajax, and described a
set of technologies, of which JavaScript
was the backbone, used to create web
applications where data can be loaded in
the background, avoiding the need for full
page reloads and leading to more
dynamic applications. This resulted in a
renaissance period of JavaScript usage
spearheaded by open source libraries
and the communities that formed around
them, with libraries such as Prototype,
jQuery, Dojo Toolkit, MooTools, and
others being released.

In July 2008, the disparate parties on

either side came together in Oslo. This
led to the eventual agreement in early
2009 to rename ECMAScript 3.1 to
ECMAScript 5 and drive the language
forward using an agenda that is known
as Harmony. ECMAScript 5 was finally
released in December 2009.

In June 2011, ECMAScript 5.1 was

released to fully align with the third
edition of the ISO/IEC 16262
international standard. ECMAScript 2015
was released in June 2015. ECMAScript
2016 was released in June 2016. The
current version is ECMAScript 2017,
released in June 2017.[22]

Later developments
JavaScript has become one of the most
popular programming languages on the
Web. Initially, however, many professional
programmers denigrated the language
because, among other reasons, its target
audience consisted of Web authors and
other such "amateurs".[23] The advent of
Ajax returned JavaScript to the spotlight
and brought more professional
programming attention. The result was a
proliferation of comprehensive
frameworks and libraries, improved
JavaScript programming practices, and
increased usage of JavaScript outside
Web browsers, as seen by the
proliferation of server-side JavaScript
platforms.
In January 2009, the CommonJS project
was founded with the goal of specifying
a common standard library mainly for
JavaScript development outside the
browser.[24]

With the rise of single-page applications

and JavaScript-heavy sites, it is
increasingly being used as a compile
target for source-to-source compilers
from both dynamic languages and static
languages.

Trademark
"JavaScript" is a trademark of Oracle
Corporation in the United States.[25] It is
used under license for technology
invented and implemented by Netscape
Communications and current entities
such as the Mozilla Foundation.[26]

Vanilla JavaScript
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.

Features
The following features are common to all
conforming ECMAScript
implementations, unless explicitly
specified otherwise.
Universal support

All modern Web browsers support

JavaScript with built-in interpreters.

Imperative and structured

JavaScript supports much of the

structured programming syntax from C
(e.g., if statements, while loops, switch
statements, do while loops, etc.). One
partial exception is scoping: JavaScript
originally had only function scoping with
var. ECMAScript 2015 added keywords
let and const for block scoping, meaning
JavaScript now has both function and
block scoping. Like C, JavaScript makes
a distinction between expressions and
statements. One syntactic difference
from C is automatic semicolon insertion,
which allows the semicolons that would
normally terminate statements to be
omitted.[27]

Dynamic

Typing
As with most scripting languages,
JavaScript is dynamically typed; a type
is associated with each value, rather
than just with each expression. For
example, a variable that is at one time
bound to a number may later be re-
bound to a string.[28] JavaScript
 supports various ways to test the type
of an object, including duck typing.[29]
Run-time evaluation
JavaScript includes an eval function
that can execute statements provided
as strings at run-time.

Prototype-based (object-
oriented)

JavaScript is almost entirely object-

based. In JavaScript, an object is an
associative array, augmented with a
prototype (see below); each string key
provides the name for an object property,
and there are two syntactical ways to
specify such a name: dot notation
(obj.x = 10) and bracket notation
(obj['x'] = 10). A property may be added,
rebound, or deleted at run-time. Most
properties of an object (and any property
that belongs to an object's prototype
inheritance chain) can be enumerated
using a for...in loop.

JavaScript has a small number of built-in

objects, including Function and Date.

Prototypes
JavaScript uses prototypes where
many other object-oriented languages
use classes for inheritance.[30] It is
possible to simulate many class-based
features with prototypes in
JavaScript.[31]
Functions as object constructors
Functions double as object
constructors, along with their typical
role. Prefixing a function call with new
will create an instance of a prototype,
inheriting properties and methods
from the constructor (including
properties from the Object
prototype).[32] ECMAScript 5 offers the
Object.create method, allowing explicit
creation of an instance without
automatically inheriting from the
Object prototype (older environments
can assign the prototype to null).[33]
The constructor's prototype property
determines the object used for the new
object's internal prototype. New
methods can be added by modifying
the prototype of the function used as a
constructor. JavaScript's built-in
constructors, such as Array or Object,
also have prototypes that can be
modified. While it is possible to modify
the Object prototype, it is generally
considered bad practice because most
objects in JavaScript will inherit
methods and properties from the
Object prototype, and they may not
expect the prototype to be modified.[34]
Functions as methods
Unlike many object-oriented
languages, there is no distinction
between a function definition and a
method definition. Rather, the
distinction occurs during function
 calling; when a function is called as a
method of an object, the function's
local this keyword is bound to that
object for that invocation.

Functional

A function is first-class; a function is

considered to be an object. As such, a
function may have properties and
methods, such as .call() and
.bind().[35] A nested function is a function
defined within another function. It is
created each time the outer function is
invoked. In addition, each nested
function forms a lexical closure: The
lexical scope of the outer function
(including any constant, local variable, or
argument value) becomes part of the
internal state of each inner function
object, even after execution of the outer
function concludes.[36] JavaScript also
supports anonymous functions.

Delegative

JavaScript supports implicit and explicit

delegation.

Functions as roles (Traits and Mixins)

JavaScript natively supports various
function-based implementations of
Role[37] patterns like Traits[38][39] and
Mixins.[40] Such a function defines
additional behavior by at least one
method bound to the this keyword
within its function body. A Role then
has to be delegated explicitly via call or
apply to objects that need to feature
additional behavior that is not shared
via the prototype chain.
Object composition and inheritance
Whereas explicit function-based
delegation does cover composition in
JavaScript, implicit delegation already
happens every time the prototype
chain is walked in order to, e.g., find a
method that might be related to but is
not directly owned by an object. Once
the method is found it gets called
within this object's context. Thus
inheritance in JavaScript is covered by
a delegation automatism that is bound
 to the prototype property of
constructor functions.

Miscellaneous

Run-time environment
JavaScript typically relies on a run-time
environment (e.g., a Web browser) to
provide objects and methods by which
scripts can interact with the
environment (e.g., a webpage DOM). It
also relies on the run-time environment
to provide the ability to include/import
scripts (e.g., HTML <script> elements).
This is not a language feature per se,
but it is common in most JavaScript
implementations.
JavaScript processes messages from
a queue one at a time. Upon loading a
new message, JavaScript calls a
function associated with that
message, which creates a call stack
frame (the function's arguments and
local variables). The call stack shrinks
and grows based on the function's
needs. Upon function completion,
when the stack is empty, JavaScript
proceeds to the next message in the
queue. This is called the event loop,
described as "run to completion"
because each message is fully
processed before the next message is
considered. However, the language's
concurrency model describes the
event loop as non-blocking: program
input/output is performed using events
and callback functions. This means,
for instance, that JavaScript can
process a mouse click while waiting
for a database query to return
information.[41]
Variadic functions
An indefinite number of parameters
can be passed to a function. The
function can access them through
formal parameters and also through
the local arguments object. Variadic
functions can also be created by using
the bind method.
Array and object literals
 Like many scripting languages, arrays
and objects (associative arrays in
other languages) can each be created
with a succinct shortcut syntax. In fact,
these literals form the basis of the
JSON data format.
Regular expressions
JavaScript also supports regular
expressions in a manner similar to
Perl, which provide a concise and
powerful syntax for text manipulation
that is more sophisticated than the
built-in string functions.[42]

Vendor-specific extensions

JavaScript is officially managed by

Mozilla Foundation, and new language
features are added periodically. However,
only some JavaScript engines support
these new features:

property getter and setter functions

(supported by WebKit, Gecko, Opera,[43]
ActionScript, and Rhino)[44]
conditional catch clauses
iterator protocol (adopted from
Python)
shallow generators-coroutines
(adopted from Python)
array comprehensions and generator
expressions (adopted from Python)
proper block scope via the let keyword
 array and object destructuring (limited
form of pattern matching)
concise function expressions
(function(args) expr)
ECMAScript for XML (E4X), an
extension that adds native XML
support to ECMAScript (unsupported
in Firefox since version 21[45])

Syntax
Simple examples

Variables in JavaScript can be defined

using the var keyword:[46]
 var x; // defines the
variable x and assigns to
it the special value
"undefined" (not to be
confused with an undefined
value)
var y = 2; // defines the
variable y and assigns to
it the value 2
var z = "Hello, World!"; //
defines the variable z and
assigns to it a string
entitled "Hello, World!"

Note the comments in the example

above, both of which were preceded with
two forward slashes.

There is no built-in I/O functionality in

JavaScript; the run-time environment
provides that. The ECMAScript
specification in edition 5.1 mentions:[47]

… indeed, there are no

provisions in this specification
for input of external data or
output of computed results.

However, most runtime environments

have a console object[48] that can be
used to print output. Here is a minimalist
Hello World program in JavaScript:
 console.log("Hello
World!");

A simple recursive function:

function factorial(n) {
if (n === 0 || n === 1)
{
return 1; // 0! =
1! = 1
}
return n * factorial(n
- 1);
}

factorial(3); // returns 6
An anonymous function (or lambda):

function counter() {
var count = 0;
return function() {
return ++count;
};
}

var closure = counter();

closure(); // returns 1
closure(); // returns 2
closure(); // returns 3

This example shows that, in JavaScript,

function closures capture their non-local
variables by reference.

In JavaScript, objects are created in the

same way as functions, this is known as
a function object.

Object example:

function Ball(r) {
this.radius = r; //the
radius variable is local to
the ball object
this.area = pi*r**2;
this.show = function(){
//objects can contain
functions
drawCircle(r);
 //references a circle
drawing function
}
}
myBall = new Ball(5);
//creates a new instance of
the ball object with radius
5
myBall.show(); //this
instance of the ball object
has the show function
performed on it

Variadic function demonstration

(arguments is a special variable):[49]
 function sum() {
var x = 0;
for (var i = 0; i <
arguments.length; ++i) {
x += arguments[i];
}
return x;
}
sum(1, 2); // returns 3
sum(1, 2, 3); // returns 6

Immediately-invoked function
expressions are often used to create
modules, as before ECMAScript 2015
there was not built-in construct in the
language. Modules allow gathering
properties and methods in a namespace
and making some of them private:

var counter = (function ()

{
var i = 0; // private
property

return { // public
methods
get: function () {
alert(i);
},
set: function
(value) {
i = value;
},
 increment: function
() {
alert(++i);
}
};
})(); // module

counter.get(); //
shows 0
counter.set(6);
counter.increment(); //
shows 7
counter.increment(); //
shows 8

More advanced example

This sample code displays various
JavaScript features.

/* Finds the lowest common

multiple (LCM) of two
numbers */
function LCMCalculator(x,
y) { // constructor
function
var checkInt =
function(x) { // inner
function
if (x % 1 !== 0) {
throw new TypeError(x
+ "is not an integer"); //
var a = mouseX
};
 return x
}
this.a = checkInt(x)
// semicolons ^^^^
are optional, a newline is
enough
this.b = checkInt(y);

}
// The prototype of object
instances created by a
constructor is
// that constructor's
"prototype" property.
LCMCalculator.prototype = {
// object literal
 constructor:
LCMCalculator, // when
reassigning a prototype,
set the constructor
property appropriately
gcd: function() { //
method that calculates the
greatest common divisor
// Euclidean algorithm:
var a =
Math.abs(this.a),
b = Math.abs(this.b),
t;
if (a < b) {
// swap variables
t = b;
b = a;
 a = t;
}
while (b !== 0) {
t = b;
b = a % b;
a = t;
}
// Only need to
calculate GCD once, so
"redefine" this method.
// (Actually not
redefinition—it's defined
on the instance itself,
// so that this.gcd
refers to this
"redefinition" instead of
LCMCalculator.prototype.gcd
.
// Note that this leads
to a wrong result if the
LCMCalculator object
members "a" and/or "b" are
altered afterwards.)
// Also, 'gcd' ===
"gcd", this['gcd'] ===
this.gcd
this['gcd'] =
function() {
return a;
};
return a;
},
// Object property names
can be specified by strings
delimited by double (") or
single (') quotes.
lcm: function() {
// Variable names don't
collide with object
properties, e.g., |lcm| is
not |this.lcm|.
// not using
|this.a*this.b| to avoid FP
precision issues
var lcm = this.a /
this.gcd() * this.b;
// Only need to
calculate lcm once, so
"redefine" this method.
this.lcm = function() {
return lcm;
 };
return lcm;
},
toString: function() {
return "LCMCalculator:
a = " + this.a + ", b = " +
this.b;
}
};

// Define generic output

function; this
implementation only works
for Web browsers
function output(x) {

document.body.appendChild(d
ocument.createTextNode(x));

document.body.appendChild(d
ocument.createElement('br')
);
}

// Note: Array's map() and

forEach() are defined in
JavaScript 1.6.
// They are used here to
demonstrate JavaScript's
inherent functional nature.
[
[25, 55],
[21, 56],
[22, 58],
 [28, 56]
].map(function(pair) { //
array literal + mapping
function
return new
LCMCalculator(pair[0],
pair[1]);
}).sort((a, b) => a.lcm()
- b.lcm()) // sort with
this comparative function;
=> is a shorthand form of a
function, called "arrow
function"
.forEach(printResult);

function printResult(obj) {
output(obj + ", gcd = " +
 obj.gcd() + ", lcm = " +
obj.lcm());
}

The following output should be displayed

in the browser window.

LCMCalculator: a = 28, b =
56, gcd = 28, lcm = 56
LCMCalculator: a = 21, b =
56, gcd = 7, lcm = 168
LCMCalculator: a = 25, b =
55, gcd = 5, lcm = 275
LCMCalculator: a = 22, b =
58, gcd = 2, lcm = 638

Use in Web pages

As of May 2017 94.5% of 10 million most
popular web pages used JavaScript.[50]
The most common use of JavaScript is
to add client-side behavior to HTML
pages, also known as Dynamic HTML
(DHTML). Scripts are embedded in or
included from HTML pages and interact
with the Document Object Model (DOM)
of the page. Some simple examples of
this usage are:

Loading new page content or

submitting data to the server via Ajax
without reloading the page (for
example, a social network might allow
the user to post status updates
without leaving the page).
 Animation of page elements, fading
them in and out, resizing them, moving
them, etc.
Interactive content, for example
games, and playing audio and video.
Validating input values of a Web form
to make sure that they are acceptable
before being submitted to the server.
Transmitting information about the
user's reading habits and browsing
activities to various websites. Web
pages frequently do this for Web
analytics, ad tracking, personalization
or other purposes.[51]

Because JavaScript code can run locally

in a user's browser (rather than on a
remote server), the browser can respond
to user actions quickly, making an
application more responsive.
Furthermore, JavaScript code can detect
user actions that HTML alone cannot,
such as individual keystrokes.
Applications such as Gmail take
advantage of this: much of the user-
interface logic is written in JavaScript,
and JavaScript dispatches requests for
information (such as the content of an e-
mail message) to the server. The wider
trend of Ajax programming similarly
exploits this strength.

A JavaScript engine (also known as

JavaScript interpreter or JavaScript
implementation) is an interpreter that
interprets JavaScript source code and
executes the script accordingly. The first
JavaScript engine was created by
Brendan Eich at Netscape, for the
Netscape Navigator Web browser. The
engine, code-named SpiderMonkey, is
implemented in C. It has since been
updated (in JavaScript 1.5) to conform to
ECMAScript 3. The Rhino engine, created
primarily by Norris Boyd (formerly at
Netscape, now at Google) is a JavaScript
implementation in Java. Rhino, like
SpiderMonkey, is ECMAScript 3
compliant.
A Web browser is by far the most
common host environment for
JavaScript. Web browsers typically
create "host objects" to represent the
DOM in JavaScript. The Web server is
another common host environment. A
JavaScript Web server would typically
expose host objects representing HTTP
request and response objects, which a
JavaScript program could then
interrogate and manipulate to
dynamically generate Web pages.

Because JavaScript is the only language

that the most popular browsers share
support for, it has become a target
language for many frameworks in other
languages, even though JavaScript was
never intended to be such a language.[52]
Despite the performance limitations
inherent to its dynamic nature, the
increasing speed of JavaScript engines
has made the language a surprisingly
feasible compilation target.

Example script

Below is a minimal example of a

standards-conforming Web page
containing JavaScript (using HTML 5
syntax) and the DOM:

<!DOCTYPE html>
<html>
 <head>
<title>Example</title>
</head>
<body>
<button
id="hellobutton">Hello</but
ton>
<script>

document.getElementById('he
llobutton').onclick =
function() {
alert('Hello
world!');
// Show a dialog
var myTextNode
=
 document.createTextNode('So
me new words.');

document.body.appendChild(m
yTextNode); // Append
"Some new words" to the
page
};
</script>
</body>
</html>

Compatibility considerations

Because JavaScript runs in widely

varying environments, an important part
of testing and debugging is to test and
verify that the JavaScript works across
multiple browsers.

The DOM interfaces for manipulating

Web pages are not part of the
ECMAScript standard, or of JavaScript
itself. Officially, the DOM interfaces are
defined by a separate standardization
effort by the W3C; in practice, browser
implementations differ from the
standards and from each other, and not
all browsers execute JavaScript.

To deal with these differences,

JavaScript authors can attempt to write
standards-compliant code that will also
be executed correctly by most browsers;
failing that, they can write code that
checks for the presence of certain
browser features and behaves differently
if they are not available.[53] In some
cases, two browsers may both
implement a feature but with different
behavior, and authors may find it
practical to detect what browser is
running and change their script's
behavior to match.[54][55] Programmers
may also use libraries or toolkits that
take browser differences into account.

Furthermore, scripts may not work for

some users. For example, a user may:

use an old or rare browser with

incomplete or unusual DOM support;
 use a PDA or mobile phone browser
that cannot execute JavaScript;
have JavaScript execution disabled as
a security precaution;
use a speech browser due to, for
example, a visual disability.

To support these users, Web authors can

try to create pages that degrade
gracefully on user agents (browsers) that
do not support the page's JavaScript. In
particular, the page should remain usable
albeit without the extra features that the
JavaScript would have added. Some
sites use the HTML <noscript> tag, which
contains alt content if JS is disabled. An
alternative approach that many find
preferable is to first author content using
basic technologies that work in all
browsers, then enhance the content for
users that have JavaScript enabled. This
is known as progressive enhancement.

Security
JavaScript and the DOM provide the
potential for malicious authors to deliver
scripts to run on a client computer via
the Web. Browser authors contain this
risk using two restrictions. First, scripts
run in a sandbox in which they can only
perform Web-related actions, not general-
purpose programming tasks like creating
files. Second, scripts are constrained by
the same-origin policy: scripts from one
Web site do not have access to
information such as usernames,
passwords, or cookies sent to another
site. Most JavaScript-related security
bugs are breaches of either the same
origin policy or the sandbox.

There are subsets of general JavaScript

—ADsafe, Secure ECMAScript (SES)—that
provide greater levels of security,
especially on code created by third
parties (such as advertisements).[56][57]
Caja is another project for safe
embedding and isolation of third-party
JavaScript and HTML.
Content Security Policy is the main
intended method of ensuring that only
trusted code is executed on a Web page.

Cross-site vulnerabilities

A common JavaScript-related security

problem is cross-site scripting (XSS), a
violation of the same-origin policy. XSS
vulnerabilities occur when an attacker is
able to cause a target Web site, such as
an online banking website, to include a
malicious script in the webpage
presented to a victim. The script in this
example can then access the banking
application with the privileges of the
victim, potentially disclosing secret
information or transferring money
without the victim's authorization. A
solution to XSS vulnerabilities is to use
HTML escaping whenever displaying
untrusted data.

Some browsers include partial protection

against reflected XSS attacks, in which
the attacker provides a URL including
malicious script. However, even users of
those browsers are vulnerable to other
XSS attacks, such as those where the
malicious code is stored in a database.
Only correct design of Web applications
on the server side can fully prevent XSS.

XSS vulnerabilities can also occur

because of implementation mistakes by
browser authors.[58]

Another cross-site vulnerability is cross-

site request forgery (CSRF). In CSRF,
code on an attacker's site tricks the
victim's browser into taking actions the
user didn't intend at a target site (like
transferring money at a bank). It works
because, if the target site relies only on
cookies to authenticate requests, then
requests initiated by code on the
attacker's site will carry the same
legitimate login credentials as requests
initiated by the user. In general, the
solution to CSRF is to require an
authentication value in a hidden form
field, and not only in the cookies, to
authenticate any request that might have
lasting effects. Checking the HTTP
Referrer header can also help.

"JavaScript hijacking" is a type of CSRF

attack in which a <script> tag on an
attacker's site exploits a page on the
victim's site that returns private
information such as JSON or JavaScript.
Possible solutions include:

requiring an authentication token in the

POST and GET parameters for any
response that returns private
information.

Misplaced trust in the client

Developers of client-server applications
must recognize that untrusted clients
may be under the control of attackers.
The application author cannot assume
that his JavaScript code will run as
intended (or at all) because any secret
embedded in the code could be extracted
by a determined adversary. Some
implications are:

Web site authors cannot perfectly

conceal how their JavaScript operates
because the raw source code must be
sent to the client. The code can be
obfuscated, but obfuscation can be
reverse-engineered.
 JavaScript form validation only
provides convenience for users, not
security. If a site verifies that the user
agreed to its terms of service, or filters
invalid characters out of fields that
should only contain numbers, it must
do so on the server, not only the client.
Scripts can be selectively disabled, so
JavaScript can't be relied on to prevent
operations such as right-clicking on an
image to save it.[59]
It is extremely bad practice to embed
sensitive information such as
passwords in JavaScript because it
can be extracted by an attacker.

Misplaced trust in developers

Package management systems such as
NPM and Bower are popular with
JavaScript developers. Such systems
allow a developer to easily manage their
program's dependencies upon other
developer's program libraries. Developers
trust that the maintainers of the libraries
will keep it secure and up to date, but
that is not always the case. A
vulnerability has emerged because of
this blind trust. Relied upon libraries can
release an update that causes bugs or
vulnerabilities to appear in all programs
that rely upon the library. Inversely, a
library can go unpatched with known
vulnerabilities out in the wild. In a study
done looking over a sample of 133k
websites, researchers found 37% of the
websites included a library with at-least
one known vulnerability.[60] "The median
lag between the oldest library version
used on each website and the newest
available version of that library is 1,177
days in ALEXA, and development of
some libraries still in active use ceased
years ago."[60] Another possibility is that
the maintainer of a library may remove
the library entirely. This occurred in
March 2016 when Azer Koçulu removed
his repository from NPM. This caused all
tens of thousands of programs and
websites depending upon his libraries to
break.[61][62]
Browser and plugin coding
errors

JavaScript provides an interface to a

wide range of browser capabilities, some
of which may have flaws such as buffer
overflows. These flaws can allow
attackers to write scripts that would run
any code they wish on the user's system.
This code is not by any means limited to
another JavaScript application. For
example, a buffer overrun exploit can
allow an attacker to gain access to the
operating system's API with superuser
privileges.

These flaws have affected major

browsers including Firefox,[63] Internet
Explorer,[64] and Safari.[65]

Plugins, such as video players, Adobe

Flash, and the wide range of ActiveX
controls enabled by default in Microsoft
Internet Explorer, may also have flaws
exploitable via JavaScript (such flaws
have been exploited in the past).[66][67]

In Windows Vista, Microsoft has

attempted to contain the risks of bugs
such as buffer overflows by running the
Internet Explorer process with limited
privileges.[68] Google Chrome similarly
confines its page renderers to their own
"sandbox".

Sandbox implementation
errors

Web browsers are capable of running

JavaScript outside the sandbox, with the
privileges necessary to, for example,
create or delete files. Of course, such
privileges aren't meant to be granted to
code from the Web.

Incorrectly granting privileges to

JavaScript from the Web has played a
role in vulnerabilities in both Internet
Explorer[69] and Firefox.[70] In Windows
XP Service Pack 2, Microsoft demoted
JScript's privileges in Internet Explorer.[71]

Microsoft Windows allows JavaScript

source files on a computer's hard drive to
be launched as general-purpose, non-
sandboxed programs (see: Windows
Script Host). This makes JavaScript (like
VBScript) a theoretically viable vector for
a Trojan horse, although JavaScript
Trojan horses are uncommon in
practice.[72]

Hardware vulnerabilities

In 2017 a JavaScript based attack via

browser was demonstrated that could
bypass ASLR. It's called "ASLR⊕Cache"
or AnC.[73][74]

Uses outside Web pages

In addition to Web browsers and servers,
JavaScript interpreters are embedded in
a number of tools. Each of these
applications provides its own object
model that provides access to the host
environment. The core JavaScript
language remains mostly the same in
each application.

Embedded scripting language

Google's Chrome extensions, Opera's

extensions, Apple's Safari 5
extensions, Apple's Dashboard
Widgets, Microsoft's Gadgets, Yahoo!
Widgets, Google Desktop Gadgets, and
Serence Klipfolio are implemented
using JavaScript.
The MongoDB database accepts
queries written in JavaScript.
MongoDB and NodeJS are the core
components of MEAN: a solution stack
for creating Web applications using
just JavaScript.
The Clusterpoint database accept
queries written in JS/SQL, which is a
combination of SQL and JavaScript.
Clusterpoint has built-in computing
engine that allows execution of
JavaScript code right inside the
distributed database.
Adobe's Acrobat and Adobe Reader
support JavaScript in PDF files.[75]
Tools in the Adobe Creative Suite,
including Photoshop, Illustrator,
Dreamweaver, and InDesign, allow
scripting through JavaScript.
OpenOffice.org, an office application
suite, as well as its popular fork
LibreOffice, allows JavaScript to be
used as a scripting language.
The visual programming language
Max, released by Cycling '74, offers a
JavaScript model of its environment
for use by developers. It allows users
to reduce visual clutter by using an
object for a task rather than many.
Apple's Logic Pro X digital audio
workstation (DAW) software can
create custom MIDI effects plugins
using JavaScript.[76]
The Unity game engine supports a
modified version of JavaScript for
scripting via Mono.[77]
DX Studio (3D engine) uses the
SpiderMonkey implementation of
JavaScript for game and simulation
logic.[78]
Maxwell Render (rendering software)
provides an ECMA standard based
scripting engine for tasks
automation.[79]
 Google Apps Script in Google
Spreadsheets and Google Sites allows
users to create custom formulas,
automate repetitive tasks and also
interact with other Google products
such as Gmail.[80]
Many IRC clients, like ChatZilla or
XChat, use JavaScript for their
scripting abilities.[81][82]
RPG Maker MV uses JavaScript as its
scripting language.[83]
The text editor UltraEdit uses
JavaScript 1.7 as internal scripting
language, introduced with version 13 in
2007.

Scripting engine
Microsoft's Active Scripting technology
supports JScript as a scripting
language.[84]
Java introduced the javax.script
package in version 6 that includes a
JavaScript implementation based on
Mozilla Rhino. Thus, Java applications
can host scripts that access the
application's variables and objects,
much like Web browsers host scripts
that access a webpage's Document
Object Model (DOM).[85][86]
The Qt C++ toolkit includes a QtScript
module to interpret JavaScript,
analogous to Java's javax.script
package.[87]
 OS X Yosemite introduced JavaScript
for Automation (JXA), which is built
upon JavaScriptCore and the Open
Scripting Architecture. It features an
Objective-C bridge that enables entire
Cocoa applications to be programmed
in JavaScript.
Late Night Software's JavaScript OSA
(also known as JavaScript for OSA, or
JSOSA) is a freeware alternative to
AppleScript for OS X. It is based on the
Mozilla JavaScript 1.5 implementation,
with the addition of a MacOS object for
interaction with the operating system
and third-party applications.

Application platform
ActionScript, the programming
language used in Adobe Flash, is
another implementation of the
ECMAScript standard.
Adobe AIR (Adobe Integrated Runtime)
is a JavaScript runtime that allows
developers to create desktop
applications.
Electron is an open-source framework
developed by GitHub.
CA Technologies AutoShell cross-
application scripting environment is
built on the SpiderMonkey JavaScript
engine. It contains preprocessor-like
extensions for command definition, as
well as custom classes for various
system-related tasks like file I/O,
operation system command invocation
and redirection, and COM scripting.
Apache Cordova is a mobile
application development framework
Cocos2d is an open source software
framework. It can be used to build
games, apps and other cross platform
GUI based interactive programs
Chromium Embedded Framework
(CEF) is an open source framework for
embedding a web browser engine
based on the Chromium core
RhoMobile Suite is a set of
development tools for creating data-
centric, cross-platform, native mobile
consumer and enterprise applications.
NW.js call all Node.js modules directly
from DOM and enable a new way of
writing applications with all Web
technologies.[88]
GNOME Shell, the shell for the
GNOME 3 desktop environment,[89]
made JavaScript its default
programming language in 2013.[90]
The Mozilla application framework
(XPFE) platform, which underlies
Firefox, Thunderbird, and some other
Web browsers, uses JavaScript to
implement the graphical user interface
(GUI) of its various products.
Qt Quick's markup language (available
since Qt 4.7) uses JavaScript for its
application logic. Its declarative syntax
is also similar to JavaScript.
Ubuntu Touch provides a JavaScript
API for its unified usability interface.
Open webOS is the next generation of
web-centric platforms built to run on a
wide range of form factors.[91]
enyo JS is a framework to develop
apps for all major platforms, from
phones and tablets to PCs and TVs[92]
WinJS provides a special Windows
Library for JavaScript functionality in
Windows 8 that enables the
development of Modern style (formerly
 Metro style) applications in HTML5 and
JavaScript.
NativeScript is an open-source
framework to develop apps on the
Apple iOS and Android platforms.
Weex is a framework for building
Mobile cross-platform UI, created by
China Tech giant Alibaba[93]
XULRunner is packaged version of the
Mozilla platform to enable standalone
desktop application development

Development tools
Within JavaScript, access to a debugger
becomes invaluable when developing
large, non-trivial programs. Because
there can be implementation differences
between the various browsers
(particularly within the DOM), it is useful
to have access to a debugger for each of
the browsers that a Web application
targets.[94]

Script debuggers are integrated within

Internet Explorer, Firefox, Safari, Google
Chrome, Opera and Node.js.[95][96][97]

In addition to the native Internet Explorer

Developer Tools, three debuggers are
available for Internet Explorer: Microsoft
Visual Studio is the richest of the three,
closely followed by Microsoft Script
Editor (a component of Microsoft
Office),[98] and finally the free Microsoft
Script Debugger that is far more basic
than the other two. The free Microsoft
Visual Web Developer Express provides a
limited version of the JavaScript
debugging functionality in Microsoft
Visual Studio. Internet Explorer has
included developer tools since version 8.

In comparison to Internet Explorer,

Firefox has a more comprehensive set of
developer tools, which include a
debugger as well. Old versions of Firefox
without these tools used a Firefox addon
called Firebug, or the older Venkman
debugger. Also, WebKit's Web Inspector
includes a JavaScript debugger,[99] which
is used in Safari. A modified version
called Blink DevTools is used in Google
Chrome. Node.js has Node Inspector, an
interactive debugger that integrates with
the Blink DevTools, available in Google
Chrome. Opera includes a set of tools
called Dragonfly.[100]

In addition to the native computer

software, there are online JavaScript
IDEs, debugging aids that are themselves
written in JavaScript and built to run on
the Web. An example is the program
JSLint, developed by Douglas Crockford
who has written extensively on the
language. JSLint scans JavaScript code
for conformance to a set of standards
and guidelines. Many libraries for
JavaScript, such as three.js, provide links
to demonstration code that can be edited
by users. They are also used as a
pedagogical tool by institutions such as
Khan Academy[101] to allow students to
experience writing code in an
environment where they can see the
output of their programs, without
needing any setup beyond a Web
browser.

Benchmark tools for

developers
Since JavaScript is getting more
important for web development (frontend
overtakes many aspects which were
done in backend before), there is also
more consideration done about
performance. Especially mobile devices
could have problems with rendering and
processing unoptimized complex logic.

A library for doing benchmarks is

benchmark.js . A benchmarking library
that supports high-resolution timers and
returns statistically significant results.

Another tool is jsben.ch . An online

JavaScript benchmarking tool, where
code snippets can be tested against
each other.

Version history
JavaScript was initially developed in
1996 for use in the Netscape Navigator
Web browser. In the same year Microsoft
released an implementation for Internet
Explorer. This implementation was called
JScript due to trademark issues. In 1997
the first standardized version of the
language was released under the name
ECMAScript in the first edition of the
ECMA-252 standard. The explicit
versioning and opt-in of language
features was Mozilla-specific and has
been removed. Firefox 4 was the last
version which referred to a JavaScript
version (1.8.5). With new editions of the
ECMA-262 standard, JavaScript
language features are now often
mentioned with their initial definition in
the ECMA-262 editions.

The following table is based on

information from multiple
sources.[102][103][104]
 Release Netscape Mozilla Internet Google
Version Equivalent to Opera Safari
date Navigator Firefox Explorer Chrome

March
1.0 2.0 3.0
1996

August
1.1 3.0
1996

June
1.2 4.0-4.05 3
1997

October ECMA-262 1st

1.3 4.06-4.7x 4.0 5[105]
1998 + 2nd edition

Netscape
1.4 6
Server

5.5
(JScript
5.5),
6
(JScript
November ECMA-262 3rd 5.6),
1.5 6.0 1.0 7.0 3.0-5 1.0-10.0.666
2000 edition 7
(JScript
5.7),
8
(JScript
5.8)

1.5 + array
extras + array
November
1.6 and string 1.5
2005
generics +
E4X

1.6 + Pythonic
October
1.7 generators + 2.0 28.0.1500.95
2006
iterators + let

1.8 June 1.7 + 3.0 11.50

2008 generator
expressions +
 expression
closures

1.8 + native
JSON support
1.8.1 3.5
+ minor
updates

June 22, 1.8.1 + minor

1.8.2 3.6
2009 updates

1.8.2 + new
features for
July 27,
1.8.5 ECMA-262 5th 4.0
2010
edition
compliance

Related languages and

features
JSON, or JavaScript Object Notation, is a
general-purpose data interchange format
that is defined as a subset of
JavaScript's object literal syntax. Like
much of JavaScript (regexps and
anonymous functions as 1st class
elements, closures, flexible classes, 'use
strict'), JSON, except for replacing Perl's
key-value operator '=>' by an RFC 822[106]
inspired ':', is syntactically pure Perl.

jQuery is a popular JavaScript library

designed to simplify DOM-oriented client-
side HTML scripting along with offering
cross-browser compatibility because
various browsers respond differently to
certain vanilla JavaScript code.

Underscore.js is a utility JavaScript

library for data manipulation that is used
in both client-side and server-side
network applications.

Angular and AngularJS are web

application frameworks to use for
developing single-page applications and
also cross-platform mobile apps.

React (JavaScript library) is an open-

source JavaScript library providing a
views that is rendered using components
specified as custom HTML tags.

Mozilla browsers currently support

LiveConnect, a feature that allows
JavaScript and Java to
intercommunicate on the Web. However,
Mozilla-specific support for LiveConnect
was scheduled to be phased out in the
future in favor of passing on the
LiveConnect handling via NPAPI to the
Java 1.6+ plug-in (not yet supported on
the Mac as of March 2010).[107] Most
browser inspection tools, such as
Firebug in Firefox, include JavaScript
interpreters that can act on the visible
page's DOM.

asm.js is a subset of JavaScript that can

be run in any JavaScript engine or run
faster in an ahead-of-time (AOT)
compiling engine.[108]

JSFuck is an esoteric programming

language. Programs are written using
only six different characters, but are still
valid JavaScript code.

p5.js[109] is an object oriented JavaScript

library designed for artists and
designers. It is based on the ideas of the
Processing project but is for the web.

jsben.ch is an online JavaScript

benchmarking tool, where different code
snippets can be tested against each
other.

CRISP: A Strategy guiding Cloud

Application Development for Beginners
is a strategy proposed by Ayush Sahu to
develop optimized and secure JavaScript
application to be used in mobiles, PC's
and other devices. CRISP (Conversion,
Reformat code, Isolate module, Sandbox,
Partition) strategy has been proposed for
refined conversion of native application
to JavaScript for cloud application
development. JavaScript is chosen as
medium for writing application because
it is mostly used language among
developers and provides rich API
(Application Programming Interface) for
writing applications.[110]

Use as an intermediate
language

As JavaScript is the most widely

supported client-side language that can
run within a Web browser, it has become
an intermediate language for other
languages to target. This has included
both newly created languages and ports
of existing languages. Some of these
include:

OberonScript, a full implementation of

the Oberon programming language
that compiles to high-level
JavaScript.[111]
Objective-J, a superset of JavaScript
that compiles to standard JavaScript.
It adds traditional inheritance and
Smalltalk/Objective-C style dynamic
dispatch and optional pseudo-static
typing to JavaScript.
Processing.js, a JavaScript port of the
Processing programming language
designed to write visualizations,
images, and interactive content. It
allows Web browsers to display
animations, visual applications, games
and other graphical rich content
without the need for a Java applet or
Flash plugin.
CoffeeScript, an alternate syntax for
JavaScript intended to be more
concise and readable. It adds features
like array comprehensions (also
available in JavaScript since version
1.7)[112] and pattern matching. Like
Objective-J, it compiles to JavaScript.
Ruby and Python have been cited as
influential on CoffeeScript syntax.
Google Web Toolkit translates a subset
of Java to JavaScript.
Scala, an object-oriented and
functional programming language, has
a Scala-to-JavaScript compiler.[113]
Pyjs, a port of Google Web Toolkit to
Python translates a subset of Python
to JavaScript.
Google Dart, an all-purpose, open
source language that compiles to
JavaScript.
Whalesong,[114] a Racket-to-JavaScript
compiler.
Emscripten, a LLVM-backend for
porting native libraries to JavaScript,
known as asm.js[115]
Fantom a programming language that
runs on JVM, .NET and JavaScript.
TypeScript, a free and open-source
programming language developed by
Microsoft. It is a superset of
JavaScript, and essentially adds
support for optional type annotations
and some other language extensions
such as classes, interfaces and
modules. A TS-script compiles into
plain JavaScript and can be executed
in any JS host supporting ECMAScript
3 or higher. The compiler is itself
written in TypeScript.
Elm (programming language) is a pure
functional language for web apps.
Unlike handwritten JavaScript, Elm-
generates JavaScript has zero runtime
exceptions, a time-traveling debugger,
and enforced semantic versioning.
Haxe, an open-source high-level
multiplatform programming language
and compiler that can produce
applications and source code for many
different platforms including
JavaScript.
ClojureScript,[116] a compiler for Clojure
that targets JavaScript. It is designed
to emit JavaScript code that is
compatible with the advanced
compilation mode of the Google
Closure optimizing compiler.
SqueakJS , a virtual machine and DOM
environment for the open-source
 Squeak implementation of the
Smalltalk programming language.

As JavaScript has unusual limitations –

such as no explicit integer type, only
double-precision binary floating point –
languages that compile to JavaScript
and do not take care to use the integer-
converting shift and bitwise logical
operators may have slightly different
behavior than in other environments.

JavaScript and Java

A common misconception is that

JavaScript is similar or closely related to
Java. It is true that both have a C-like
syntax (the C language being their most
immediate common ancestor language).
They also are both typically sandboxed
(when used inside a browser), and
JavaScript was designed with Java's
syntax and standard library in mind. In
particular, all Java keywords were
reserved in original JavaScript,
JavaScript's standard library follows
Java's naming conventions, and
JavaScript's Math and Date objects are
based on classes from Java 1.0,[117] but
the similarities end there.

Java and JavaScript both first appeared

on 23 May 1995, but Java was developed
by James Gosling of Sun Microsystems,
and JavaScript by Brendan Eich of
NetScape Communications.

The differences between the two

languages are more prominent than their
similarities. Java has static typing, while
JavaScript's typing is dynamic. Java is
loaded from compiled bytecode, while
JavaScript is loaded as human-readable
source code. Java's objects are class-
based, while JavaScript's are prototype-
based. Finally, Java did not support
functional programming until Java 8,
while JavaScript has done so from the
beginning, being influenced by Scheme.

See also
 WebAssembly

References
1. Flanagan 2011, pp. 1–2.
2. Press release announcing JavaScript ,
"Netscape and Sun announce JavaScript",
PR Newswire, December 4, 1995
3. "Standard ECMA-262" . Ecma
International. 2017-07-03.
4. "RFC 4329" . Apps.ietf.org. Archived
from the original on 2014-03-16.
Retrieved 16 February 2016.
5. "System-Declared Uniform Type
Identifiers" . Mac OS X Reference Library.
Apple Inc. Retrieved 2010-03-05.
6. "JavaScript" . Collins English Dictionary
– Complete & Unabridged 2012 Digital
Edition. William Collins Sons & Co. 2012.
Retrieved 21 August 2015.
7. "ECMAScript Language Overview"
(PDF) . 2007-10-23. p. 4. Retrieved
2009-05-03.
8. "Chapter 4. How JavaScript Was
Created" .
9. Severance, Charles (February 2012).
"JavaScript: Designing a Language in 10
Days" . Computer. IEEE Computer Society.
45 (2): 7–8. doi:10.1109/MC.2012.57 .
Retrieved 23 March 2013.
10. "TechVision: Innovators of the Net:
Brendan Eich and JavaScript" .
web.archive.org. Archived from the
original on 2008-02-08.
11. "The History of Programming
Languages" . oreilly.com. O'Reilly Media.
2004. Retrieved 16 July 2016.
12. "What Is JavaScript?" (PDF).
wiley.com. Wiley. Retrieved 16 July 2016.
13. Noorda, Brent (21 September 2013).
"Brent Noorda's Answers on ECMA" .
quora.com. Retrieved 16 July 2016.
14. Noorda, Brent (24 June 2010). "History
of Nombas" . brent-noorda.com. Retrieved
16 July 2016.
15. Eich, Brendan (21 June 2011). "New
JavaScript Engine Module Owner" .
brendaneich.com. Retrieved 16 July 2016.
16. Netscape Communications
Corporation (11 December 1998). "Server-
Side JavaScript Guide" . oracle.com.
Netscape Communications Corporation.
Retrieved 2016-07-16.
17. Mahemoff, Michael (17 December
2009). "Server-Side JavaScript, Back with
a Vengeance" . readwrite.com. Retrieved
2016-07-16.
18. Champeon, Steve (6 April 2001).
"JavaScript, How Did We Get Here?" .
oreilly.com. Retrieved 16 July 2016.
19. "Microsoft Internet Explorer 3.0 Beta
Now Available" . microsoft.com.
Microsoft. 29 May 1996. Retrieved 16 July
2016.
20. McCracken, Harry (16 September
2010). "The Unwelcome Return of "Best
Viewed with Internet Explorer" " .
technologizer.com. Retrieved 16 July
2016.
21. "Documentation" . ecmascript.org.
Retrieved 16 July 2016.
22. "Standard ECMA-262" . Ecma
International. 2017-07-03.
23. Crockford, Douglas (2001).
"JavaScript, The World's Most
Misunderstood Programming Language" .
crockford.com. Retrieved 16 July 2016.
24. Kowal, Kris (1 December 2009).
"CommonJS Effort Sets JavaScript on
Path for World Domination" .
arstechnica.com. Retrieved 16 July 2016.
25. "USPTO Copyright entry #75026640" .
USPTO.
26. "Sun Trademarks" . Sun
Microsystems. Archived from the original
on 28 May 2010. Retrieved 2007-11-08.
27. Flanagan 2006, p. 16.
28. "JavaScript data types and data
structures - JavaScript | MDN" .
Developer.mozilla.org. 2017-02-16.
Retrieved 2017-02-24.
29. Flanagan 2006, pp. 176–178.
30. "Inheritance and the prototype chain" .
Mozilla Developer Network. Mozilla.
Retrieved 6 April 2013.
31. Herman, David (2013). Effective
JavaScript. Addison-Wesley. p. 83.
ISBN 978-0-321-81218-6.
32. Haverbeke, Marijn (2011). Eloquent
JavaScript. No Starch Press. pp. 95–97.
ISBN 978-1-59327-282-1.
33. Katz, Yehuda. "Understanding
"Prototypes" in JavaScript" . Retrieved
6 April 2013.
34. Herman, David (2013). Effective
JavaScript. Addison-Wesley. pp. 125–127.
ISBN 978-0-321-81218-6.
35. "Properties of the Function Object" .
Es5.github.com. Retrieved 2013-05-26.
36. Flanagan 2006, p. 141.
37. The many talents of JavaScript for
generalizing Role-Oriented Programming
approaches like Traits and Mixins ,
Peterseliger.blogpsot.de, April 11, 2014.
38. Traits for JavaScript , 2010.
39. "Home | CocktailJS" .
Cocktailjs.github.io. Retrieved 2017-02-24.
40. Angus Croll, A fresh look at JavaScript
Mixins , published May 31, 2011.
41. "Concurrency model and Event Loop" .
Mozilla Developer Network. Retrieved
2015-08-28.
42. Haverbeke, Marijn (2011). Eloquent
JavaScript. No Starch Press. pp. 139–149.
ISBN 978-1-59327-282-1.
43. Robert Nyman, Getters And Setters
With JavaScript – Code Samples And
Demos , Robertnyman.com, published 29
May 2009, accessed 2 January 2010.
44. John Resig, JavaScript Getters and
Setters , Ejohn.org, 18 July 2007,
accessed 2 January 2010
45. "E4X – Archive of obsolete content |
MDN" . Mozilla Developer Network.
Mozilla Foundation. Feb 14, 2014.
Retrieved 13 July 2014.
46. "var – JavaScript – MDN" . The
Mozilla Developer Network. Retrieved
22 December 2012.
47. "ECMAScript Language Specification –
ECMA-262 Edition 5.1" . Ecma
International. Retrieved 22 December
2012.
48. "console" . Mozilla Developer Network.
Mozilla. Retrieved 6 April 2013.
49. "arguments" . Mozilla Developer
Network. Mozilla. Retrieved 6 April 2013.
50.
https://w3techs.com/technologies/details
/cp-javascript/all/all
51. "JavaScript tracking – Piwik" . Piwik.
Retrieved 31 March 2012.
52. Hamilton, Naomi (2008-07-31). "The A-
Z of Programming Languages:
JavaScript" . computerworld.com.au.
53. "Javascript - Object detection" .
Quirksmode.org. Retrieved 2017-02-24.
54. Peter-Paul Koch, Mission Impossible –
mouse position
55. "JavaScript - Browser detect" .
Quirksmode.org. Retrieved 2017-02-24.
56. "Making JavaScript Safe for
Advertising" . ADsafe. Retrieved
2013-05-26.
57. "Secure ECMA Script (SES)" .
Code.google.com. Retrieved 2013-05-26.
58. "Mozilla Cross-Site Scripting
Vulnerability Reported and Fixed -
MozillaZine Talkback" . Mozillazine.org.
Retrieved 2017-02-24.
59. "Right-click "protection"? Forget about
it" . 2008-06-17. ISSN 1797-1993 .
Retrieved 2008-06-17.
60. "Thou Shalt Not Depend on Me:
Analysing the Use of Outdated JavaScript
Libraries on the Web" (PDF). 2016-12-21.
Retrieved 2017-02-22.
61. Quartz, How one programmer broke
the internet by deleting a tiny piece of
code
62. SC Magazine UK, Developer's 11 lines
of deleted code 'breaks the internet'
63. Mozilla Corporation, Buffer overflow in
crypto.signText()
64. Festa, Paul (August 19, 1998). "Buffer-
overflow bug in IE" . CNET. Archived from
the original on December 25, 2002.
65. SecurityTracker.com, Apple Safari
JavaScript Buffer Overflow Lets Remote
Users Execute Arbitrary Code and HTTP
Redirect Bug Lets Remote Users Access
Files
66. SecurityFocus, Microsoft
WebViewFolderIcon ActiveX Control
Buffer Overflow Vulnerability
67. Fusion Authority, Macromedia Flash
ActiveX Buffer Overflow
68. "Protected Mode in Vista IE7 –
IEBlog" . Blogs.msdn.com. 2006-02-09.
Retrieved 2017-02-24.
69. US CERT, Vulnerability Note
VU#713878: Microsoft Internet Explorer
does not properly validate source of
redirected frame
70. Mozilla Foundation, Mozilla
Foundation Security Advisory 2005–41:
Privilege escalation via DOM property
overrides
71. Microsoft Corporation, Changes to
Functionality in Microsoft Windows XP
Service Pack 2: Part 5: Enhanced
Browsing Security
72. For one example of a rare JavaScript
Trojan Horse, see Symantec Corporation,
JS.Seeker.K
73. AnC VUSec, 2017
74. New ASLR-busting JavaScript is about
to make drive-by exploits much nastier
Ars Technica, 2017
75. "JavaScript for Acrobat" . Retrieved
2009-08-18.
76. "Logic Pro X" . Apple. Apple, Inc.
Retrieved January 31, 2017.
77. "Unity Scripting" . unity3d.com.
Retrieved 2013-01-29.
78. "Technical Specification" .
dxstudio.com. Retrieved 2009-10-20.
79. THINK! The Maxwell Render Resourcer
Center, Scripting References
80. Google Apps Script, Google Apps
Script
81. "ChatZilla! Frequently Asked Questions
– 4.5. How do I write scripts?" .
Chatzilla.hacksrus.com. Retrieved
11 February 2011.
82. "Xcdscript" . Archived from the
original on 1 May 2011. Retrieved
11 February 2011.
83. "RPG Maker MV | RPG Maker | Make
Your Own Games!" . Retrieved 28 August
2015.
84. "Version Information (JavaScript)" .
Msdn.microsoft.com. Retrieved
2013-05-26.
85. "javax.script release notes" .
Java.sun.com. Retrieved 2009-05-19.
86. Flanagan 2006, pp. 214 et seq.
87. Nokia Corporation, QtScript Module
88. "NW.js" . Nwjs.io. Retrieved
2017-02-24.
89. "Behind the Scenes with Owen
Taylor" . The GNOME Journal. Archived
from the original on 2012-12-21.
Retrieved 2010-01-23.
90. "Answering the question: "How do I
develop an app for GNOME?" " .
91. [1]
92. "Enyo JavaScript Application
Framework" . Enyojs.com. Retrieved
2017-02-24.
93. [2]
94. "Advanced Debugging With
JavaScript" . alistapart.com. 2009-02-03.
Retrieved 2010-05-28.
95. "The JavaScript Debugging Console" .
javascript.about.com. 2010-05-28.
Retrieved 2010-05-28.
96. "SplineTech JavaScript Debugger – an
independent standalone JavaScript
Debugger" . javascript-debugger.com.
2013-08-26. Retrieved 2013-08-26.
97. "Debugging with Node Inspector" .
docs.strongloop.com. Retrieved
2014-05-07.
98. JScript development in Microsoft
Office 11 (MS InfoPath 2003)
99. "Introducing Drosera – Surfin' Safari" .
Webkit.org. 2006-06-28. Retrieved
2009-05-19.
100. "Opera DragonFly" . Opera Software.
101. "Khan Academy Computer Science" .
Retrieved 28 Sep 2012.
102. "New in JavaScript" .
developer.mozilla.org. 2014. Retrieved
2016-07-16.
103. "JavaScript – JScript – ECMAScript
version history" . Webmasterworld.com.
Retrieved 2009-12-17.
104. John Resig. "Versions of
JavaScript" . Ejohn.org. Retrieved
2009-05-19.
105. "What Version of Javascript" .
Javascript.about.com. 2016-02-22.
Retrieved 2017-02-24.
106. "RFC 822 - STANDARD FOR THE
FORMAT OF ARPA INTERNET TEXT
MESSAGES" . Tools.ietf.org. 1982-08-13.
Retrieved 2017-02-24.
107. Release Notes for the Next-
Generation Java™ Plug-In Technology
(introduced in Java SE 6 update 10) .
Java.sun.com. Retrieved on 2013-06-13.
108. "frequently asked questions" .
asm.js. Retrieved 2014-04-13.
109. "Home" . p5.js. 2017-01-21. Retrieved
2017-02-24.
110. "Home" . dspace.thapar.edu:8080.
2016-08-26. Retrieved 2016-08-26.
111. Ralph Sommerer. "Oberon Script. A
Lightweight Compiler and Runtime System
for the Web" . research.microsoft.com.
Retrieved 2015-12-18.
112. "New in JavaScript 1.7" .
Developer.mozilla.org. 2012-12-05.
Retrieved 2013-05-26.
113. Sébastien Doeraene. "Scala.js" .
Lampwww.epfl.ch. Retrieved 2014-04-13.
114. "Whalesong: a Racket to JavaScript
compiler" . Hashcollision.org. Retrieved
2014-04-13.
115. Walton, Zach (2012-04-04). "Easily
Port C++ To HTML5/JavaScript With
Emscripten" . WebProNews. iEntry
Network.
116. "clojure/clojurescript · GitHub" .
Github.com. Retrieved 2014-04-13.
117. Brendan Eich (3 April 2008).
"Popularity" . Retrieved 2012-01-19.

Further reading
Bhangal, Sham; Jankowski, Tomasz
(2003). Foundation Web Design:
Essential HTML, JavaScript, CSS,
PhotoShop, Fireworks, and Flash.
APress L. P. ISBN 1-59059-152-6.
Burns, Joe; Growney, Andree S. (2001).
JavaScript Goodies. Pearson
Education. ISBN 0-7897-2612-2.
Duffy, Scott (2003). How to do
Everything with JavaScript. Osborne.
ISBN 0-07-222887-3.
Flanagan, David (2006). JavaScript:
The Definitive Guide (5th ed.). O'Reilly &
Associates. ISBN 0-596-10199-6.
Flanagan, David (2011). JavaScript:
The Definitive Guide (6th ed.). O'Reilly &
Associates. ISBN 978-0-596-80552-4.
Goodman, Danny; Eich, Brendan
(2001). JavaScript Bible. John Wiley &
Sons. ISBN 0-7645-3342-8.
Goodman, Danny; Markel, Scott (2003).
JavaScript and DHTML Cookbook.
O'Reilly & Associates. ISBN 0-596-
00467-2.
Harris, Andy (2001). JavaScript
Programming for the Absolute Beginner.
Premier Press. ISBN 0-7615-3410-5.
Haverbeke, Marijn (2011). Eloquent
JavaScript. No Starch Press. ISBN 978-
1-59327-282-1.
Heinle, Nick; Koman, Richard (1997).
Designing with JavaScript. O'Reilly &
Associates. ISBN 1-56592-300-6.
Husted, Robert; Kuslich, JJ (1999).
Server-Side JavaScript: Developing
Integrated Web Applications (1st ed.).
Addison-Wesley. ISBN 0-201-43329-X.
McDuffie, Tina Spain (2003).
JavaScript Concepts & Techniques:
Programming Interactive Web Sites.
Franklin, Beedle & Associates. ISBN 1-
887902-69-4.
McFarlane, Nigel (2003). Rapid
Application Development with Mozilla.
Prentice Hall Professional Technical
References. ISBN 0-13-142343-6.
Powell, Thomas A.; Schneider, Fritz
(2001). JavaScript: The Complete
Reference. McGraw-Hill Companies.
ISBN 0-07-219127-9.
Shelly, Gary B.; Cashman, Thomas J.;
Dorin, William J.; Quasney, Jeffrey J.
(2000). JavaScript: Complete Concepts
and Techniques. Cambridge: Course
Technology. ISBN 0-7895-6233-2.
Vander Veer, Emily A. (2004).
JavaScript For Dummies (4th ed.).
Wiley Pub. ISBN 0-7645-7659-3.
Watt, Andrew H.; Watt, Jonathan A.;
Simon, Jinjer L. (2002). Teach Yourself
JavaScript in 21 Days. Pearson
Education. ISBN 0-672-32297-8.
Zakas, Nicholas C. (2012). Professional
JavaScript for Web Developers (3rd
 ed.). Wrox. ISBN 978-1-118-02669-4.

External links
Listen to this article (info/dl)
0:00

This audio file was created from a revision of the article "JavaScript" dated 2013-08-20, and does not reflect subsequent edits to the article. (Audio
help)

More spoken articles

Douglas Crockford's video lectures on
JavaScript
Douglas Crockford's A Survey of the
JavaScript Programming Language
JavaScript at Curlie (based on DMOZ)
List of languages that compile to JS
Retrieved from
"https://en.wikipedia.org/w/index.php?
title=JavaScript&oldid=814040451"

Last edited 2 days ago by CityOfSil…

Content is available under CC BY-SA 3.0 unless

otherwise noted.