Related
In 1995 Netscape created JavaScript, followed by Internet Explorer that also created JScript.
As I understand, so as to avoid the "Best viewed with IE" or "Best viewed with Netscape" and make the life easier for programmers, the ECMAScript standard was developed, and JavaScript was standardised (JScript also adopted the standard).
Taking into account that JavaScript is a trademark of Oracle Corporation, why modern browsers like Chrome or Opera used that old implementation of ECMAScript (JavaScript) in a time where the dominant web programming language was JScript, instead of creating a new implementation also compliant with the ECMAScript specification?
In other words: JavaScript is the Netscape/Mozilla implementation of the ECMA specification, and JScript is Microsoft dialect of ECMAScript. Why Chrome adopted JavaScript and didn't create, for example, ChromeScript or an implementation without trademark?
Why didn't Chrome create its own implementation of ECMAScript?
Chrome did create their own implementation of ECMAScript. The engine that ran their implementation of ECMAScript was and still is called V8 and is still in use today. In fact, it's now used by Chrome, Edge and Node.js (and others).
The public at the time didn't really know the phrase ECMAScript - they mostly just new about Javascript from Firefox and perhaps knew about JScript in IE. When Javascript was taken to a standard's body, they decided they wanted a name that had no trademark affiliation at all. In the words of Brendan Eich (the inventor of the language), the term "ECMAScript" chosen as clearly no trademark association at all and ugly enough that nobody would ever actually use the term in a user-facing product.
ECMAScript was not and still is not something John Q Public would know about (if not a developer). People knew of "Javascript" from the original Netscape days and currently at the time in Firefox/Mozilla. Some people knew that Microsoft's competing implementation that was similar (but not identical) was called JScript. Though even people developing largely for IE at the time would refer to Javascript as the language they were writing.
So, when Google developed their own new implementation of ECMAScript, they referred to it to the public as Javascript. That was just a name used to describe their implementation. That name meant NOTHING at all about its heritage. The V8 Javascript engine was entirely new, not a spin-off from something else.
To summarize, V8 is designed to be ECMAScript compatible and is known to the public in Chrome as a Javascript implementation.
In a note of history, "Javascript" was originally developed at Netscape. "Java" was originally developed at Sun Microsystems. Somehow in the relationship between Netscape and Sun Microsystems, Netscape was allowed to use the term "Javascript", but Sun actually owned the trademark on it. Eventually, the Netscape browser was spun out into the Mozilla foundation and Sun was acquired by Oracle. So, yes Oracle owns the trademark to the term "Javascript", but many are allowed to use it to describe their implementations of ECMAScript. Other companies, at various times, have preferred to stay completely away from any possible trademark issues and that's why others have use JScript, ActionScript, etc... to name their implementations.
You would need a trademark lawyer to go deeper into the legal issues around using the term Javascript.
When Mozilla spun out of AOL/Netscape as an independent company, they had a few firedrills around whether they could continue to use the term "Javascript" in their code and user interface. Some of those are documented in their bug system. I don't know the precise legal dealings that decided it all, but suffice it to say that they are still using the term "Javascript" many, many years later. Sun Microsystems wasn't bothered by that at the time and even a more litigious Oracle who now owns the trademark (by way of its acquisition of Sun) has not tried to stop its use at Mozilla or other places.
Keep in mind that V8 in Chrome implements a language to the ECMAScript standard. Chrome extends ECMAScript as do all browsers by adding their own global objects to the environment such as the window object in the browser. Those global objects in the browser are standardized in different standards efforts that have to do with browsers, not with the actual ECMAScript language.
As it currently stands, this question is not a good fit for our Q&A format. We expect answers to be supported by facts, references, or expertise, but this question will likely solicit debate, arguments, polling, or extended discussion. If you feel that this question can be improved and possibly reopened, visit the help center for guidance.
Closed 10 years ago.
OK, so I'm trying to learn JavaScript properly so that I can write good, clean client-side code, but whenever I think I'm making progress, something stops me dead in my tracks!
I want to know:
What is the different between JavaScript, ECMAScript and JScript?
Which should I focus on learning?
If these are versioned, which version should I be supporting?
Are there any really good references (web / books etc) that are a must have/read?
How do I ensure that what I write will be compliant with all major browsers (IE, FF, Safari, Chrome, Opera etc.) ?
MOST IMPORTANTLY...Is there a reference of the core objects (Array, Number etc) so I know what is implemented already and what I need to do myself?
Thanks.
Javascript is the original name when the language was developed by Netscape.
JScript is Microsoft's name of their own implementation.
ECMAScript is the name of the language standard developed by ECMA, from the original Javascript implementation.
So, it's just one language, with different implementations.
The implementations of Javascript and JScript differ somewhat in what they support, but each version supports what's in the corresponding version of the ECMAScript standard. Generally you just use what's supported a few versions back, so that it works in all the browsers that are still in use.
One reference is the Mozilla Developer Network, as Mozilla is the current developer of Javascript. For each method and property you can find which version it is supported in.
JScript is documented at the Microsoft Developer Network, and has similar information about support. (Note that all Microsoft documentation is there, not only JScript, so for example you would need to search for "jscript array" rather than just "array".)
Using a library like jQuery is useful to avoid dealing with some of the compatibility problems between browsers.
ECMAScript is the scripting language standardized by Ecma International in the ECMA-262 specification and ISO/IEC 16262. The language is widely used for client-side scripting on the web, in the form of several well-known dialects such as JavaScript, JScript, and ActionScript.
Depends on you, but I think most commonly used for web dev is JavaScript
JavaScript was formalized in the ECMAScript language standard and is primarily used in the form of client-side JavaScript
I would recommend this book
By learning more and more about the language itself and writing tests
Look here
It is important to understand, that ECMAScript is a standard, defined in the last century. :D Whereas Javascript is derived from ECMAScript. Derived in a sense, that it implements the standard.
The big difference is, that Javascript actually only exists within the Browser, saying, it is by no means a standard in itself. Every browser can (and a lot do) implement it's own methods.
So, if you seriously want to learn it and write clean code, then IMHO you have to first get familiar with the ECMAScript standard.
To 3: Since Javascript is implemented by the browser, this really depends on what browsers you want to develop code for. Older browser may have to be dealt with trought some seperate handling in your code.
To 5: Again, javascript can check what browser (or what client software in general) requestet the page it is loaded in. Meaning: If bad comes to worse, you can deal with each browser seperately in your code. But most of the time they are pretty compliant (at least the later versions)
On 4 and 6 I'd have to check first for myself.
Hope I could help you out a bit.
Regards
ECMAScript is the language, JavaScript and JScript are dialects
I would, personally, look at and learn JavaScript.
It depends on what browsers you want to support, easily googled.
MDN is a pretty good web source. JavaScript: The Good Parts and JavaScript: The Definitive Guide are both very good books, the first short and concise the latter very detailed.
JavaScript libraries like jQuery is very good for this reason. It all comes down to learning all the quirks of the browsers. Google is your friend.
MDN.
Wikipedia please.
Javascript is a language, this is probably what you want to learn rather than a spec.
Welcome in hell, all. Modernizr and jQuery exists for a reason. Unless you are doing Javascript on the server side with Node.js for example, in this case you can focus on only one JS Engine (V8 for Node).
MDN
Test, Test, Test and re Test. Try never to use too recent features and use libraries.
MDN tells you which browser supports what.
They're one and the same - for an history on JavaScript watch the Douglas Crockford webcasts on YouTube.
http://youtu.be/_DKkVvOt6dk
http://youtu.be/hQVTIJBZook
2,3,4. Start with this http://eloquentjavascript.net/
Libraries like jQuery do a good job in normalising behaviour across browsers.
I think this is what you are looking for http://dochub.io/#javascript/
In Visual Studio when I am setting my script type to JavaScript this comes up as an option in intellisense.
A quick Google search came up with lame results, leading me to believe this isn't terribly popular to use.
What is it?
Does anyone use it? (<script type="text/ecmascript">)
Why?
JavaScript is a subset of ECMAScript. JavaScript is basically ECMAScript at its core but builds upon it. Languages such as ActionScript, JavaScript, JScript all use ECMAScript as its core. As a comparison, AS/JS/JScript are 3 different cars, but they all use the same engine... each of their exteriors is different though, and there have been several modifications done to each to make it unique.
The history is, Brendan Eich created Mocha which became LiveScript, and later JavaScript. Netscape presented JavaScript to Ecma International, which develops standards and it was renamed to ECMA-262 aka ECMAScript.
It's important to note that Brendan Eich's "JavaScript" is not the same JavaScript that is a dialect of ECMAScript. He built the core language which was renamed to ECMAScript, which differs from the JavaScript which browser-vendors implement nowadays.
http://en.wikipedia.org/wiki/ECMAScript
ECMAScript is a standard. JavaScript and ActionScript are well-known implementations of the ECMAScript standard.
http://en.wikipedia.org/wiki/ECMAScript
ECMAScript = ES:
ECMAScript is a Standard for a scripting languages.
Languages like Javascript are based on the ECMAScript standard.
ECMA Standard is based on several originating technologies, the most well known being JavaScript (Netscape) and JScript (Microsoft).
ECMA means European Computer Manufacturer’s Association
On the other side:
JavaScript = JS:
JavaScript is the most popular implementations of the ECMAScript Standard.
The core features of Javascript are based on the ECMAScript standard,
but Javascript also has other additional features that are not in
the ECMA specifications/standard.
ActionScript and JScript are another languages that implements the ECMAScript.
JavaScript was submitted to ECMA for standardization but due to trademark issues with the name Javascript the standard became called ECMAScript.
Every browser has a JavaScript interpreter.
For more details on this checkout my full answer here What is the difference between JavaScript and ECMAScript?
ECMA stands for - European Computer Manufacturer's Association. ECMAScript is a standard for a scripting language. It specifies the core features that a scripting language should provide and how those features should be implemented. Javascript was originally created at Netscape, and they wanted to standardize the language. So, they submitted the language to the European Computer Manufacturer’s Association (ECMA) for standardization. But, there were trademark issues with the name Javascript, and the standard became called ECMAScript, which is the name it holds today as well.
So you can use any scripting language that implements the ECMA standard as the web browsers support the ECMAScript interpretation when you are specifying (<script type="text/ecmascript">).
Here is a different view on this topic. It's more or less from experience, I cannot quote anything.
Any JavaScript validator and everybody who works with JavaScript will tell you that
alert("hello World");
is valid JavaScript. And I'd also agree.
However, a ECMAScript validator will probably tell you it is not valid, because alert() is not part of the ECMAScript, but a typically feature of JavaScript for Browsers.
There are many features of JavaScript, which make only sense in a browser environment, f.i. window.navigator, window.document, WebSocket, navigator.geolocation.
Some would even say, this is not part fo JavaScript, but part of HTML5, which is not true, because HTML5 is just the markup language. However, these fancy new features are often called HTML5, even though they are implemented in JavaScript.
JavaScript can also be used for server side scripting. Then all the geolcation or media apis make no sense. So JavaScript for server side scripting is much closer to ECMAScript again, which doesn't have this typical browser features.
I couldn't really find out, whether the Math object (e.g. Math.sqrt(9)) is part of ECAMScript, or whether ECMAScript really just defines the syntax of the language and has no build in functionality whatsoever. But one ECMAScript validator accepted Math.sqrt(9) as valid ECMAScript, whereas var test=window.document; failed the ECMA validation.
Even though the following link it to a JavaScript documentation, this in my opinion is the build in feature set (objects and functions) of ECMAScript:https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects
So in my opinion JavaScript is very closely tied to browsers, whereas ECMAScript has really only a very basic set of functionality (if at all).
ECMA is the orgranization that standarized JavaScript. They named the language ECMAScript, however the "JavaScript" was the term that won the "name competition"
Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.
We don’t allow questions seeking recommendations for books, tools, software libraries, and more. You can edit the question so it can be answered with facts and citations.
Closed 5 years ago.
Improve this question
I tried to search for a JavaScript reference, but there's none available. The best two suggested sources are MDN (Mozilla Developer Network) and ECMA (https://262.ecma-international.org/12.0/)
Why?
It's not like there is an official JavaScript release. All the browsers have made their own JavaScript engine - some are using the same though. But especially Internet Explorer has its own version that doesn't support a lot of what the other browsers support, making it very difficult to make a general JavaScript reference.
Edit:
While I know there is an official ECMA standard and development team, my point is that it doesn't really matter as long as browsers (Internet Explorer) doesn't live up to it. At the end of the day, clients want JavaScript to work for Internet Explorer too. They won't care about the ECMA standards, they just want it to work. This is where JavaScript libraries come into the picture, but that's another story.
It's the same issues with HTML and CSS, we can't use these tools for active development until:
All browsers support them.
We supply the browsers with code to make them support it.
It's okay it doesn't work in all browsers.
Edit2:
Internet Explorer is getting close to the grave with the new browser project from Microsoft: Edge. This, however, doesn't really change the overall picture. We still have a lot if different browsers we need to support. Developers are constantly trying to push the boundaries of what's possible. This means that we often have this issue, some browser version we want to support doesn't support some feature of the standard (which usually is a bit fluid), which means we need to make some workaround or use frameworks that implement the missing built in features.
You can try with the official ECMAscript site,
http://www.ecmascript.org/
but the useful thing is actually the implementation of each browser.
I like this cheatsheet from Danny Goodman's JavaScript Bible a lot:
http://media.wiley.com/product_ancillary/12/04705269/DOWNLOAD/9780470526910_Appendix_A.pdf
I would say this one is the "official": https://developer.mozilla.org/en/JavaScript
You also have the ECMAScript Language Specification, 5.1 Edition (or as a PDF, the definitive specification).
And from Microsoft: JavaScript Language Reference: "This documentation explains the Microsoft implementation of JavaScript, which is compliant with the ECMAScript 5th Edition language specification. It also provides additional features that are not included in the Ecma Standards."
If you're using ECMAScript for the web (which 99.9% of people are), then beyond the basics syntactics of the language (covered in the ECMA-262 spec mentioned above), what you're probably looking for is a DOM reference - which is the ECMAScript API that's used to interact with web documents.
I'm very surprised noone has mentioned the DOM api sofar. Current W3C DOM standard is here: http://www.w3.org/TR/DOM-Level-2-Core/
(btw, as for the naming confusion - ECMAScript is the name of the official standard, and "Javascript" and "JScript" are Netscape and Microsoft's proprietary "forks")
Wikipedia's quotation:
Beginnings at Netscape
In November 1996, Netscape submitted JavaScript to Ecma
International ...
JavaScript is officially managed by Mozilla Foundation ...
So, in my opinion, the ECMA is the standard and Mozilla is the official one.
It is very difficult to have an "official" reference as long as there are implementations (in all browsers) and there is a specification (ECMAScript) but no conformance tests of implementations against the specifications.
Now though, we have the EMCAScript 5 conformance suite at http://es5conform.codeplex.com/ - and there seems some consensus that ECMAScript implementations will come closer together, making ECMAScript more likely to be the official reference for the language.
There is an official reference, it just isn't in a very convenient format. It is the ECMA-262 specification. It is a single, very large PDF document, instead of a searchable set of HTML pages.
Any revisions of JavaScript pages on MDC by a member of the Mozilla Documentation team (like Eric Shepherd) is official. JavaScript is officially maintained by Mozilla so only documentation by Mozilla is official. The only engines that support JavaScript are currently made by Mozilla and every other engine implements ECMAScript. JavaScript and ECMAScript have quite a few differences (for example, the awesome let statement).
I find the old-school Netscape 4 JavaScript docs very useful for this purpose. Although they're obviously totally outdated, and some of the DOM features in them like Layers are long gone, for the language basics they're really solid.
That's because before the days of IE supremacy and ECMA standardisation, Netscape's JavaScript was the definitive JavaScript. Other browsers pretty much had to implement exactly what you see in those old docs.
They're also much easier to read than the ECMA-262 document, which even by the standards of standards documents is an absolute horror.
By “official”, I think you mean “written by the people responsible for JavaScript”.
Just speculating here really, but the people responsible for JavaScript (the ECMA) don’t directly make any money out of it, and probably don’t have any particular skills in writing reference documentation. So they have neither the incentive nor the ability to write a good reference.
Personally, I like JavaScript: the Definitive Guide from O’Reilly. There’s a sixth edition coming out in November.
I really like Daniel Krook's apidoc, even though it could use some explanations and examples. I would really like to see a krook w3school mashup.
What's the difference between ECMAScript and JavaScript? From what I've deduced, ECMAScript is the standard and JavaScript is the implementation. Is this correct?
I think a little history lesson is due.
JavaScript was originally named Mocha and changed to Livescript but ultimately became JavaScript.
It's important to note that JavaScript came before ECMAscript and the history will tell you why.
To start from the beginning, JavaScript derived its name from Java and initially Brendan Eich (the creator of JS) was asked to develop a language that resembled Java for the web for Netscape.
Eich, however decided that Java was too complicated with all its rules and so set out to create a simpler language that even a beginner could code in. This is evident in such things like the relaxing of the need to have a semicolon.
After the language was complete, the marketing team of Netscape requested Sun to allow them to name it JavaScript as a marketing stunt and hence why most people who have never used JavaScript think it's related to Java.
About a year or two after JavaScript's release in the browser, Microsoft's IE took the language and started making its own implementations such as JScript. At the same time, IE was dominating the market and not long after Netscape had to shut its project.
Before Netscape went down, they decided to start a standard that would guide the path of JavaScript, named ECMAScript.
ECMAScript had a few releases and in 1999 they released their last version (ECMAScript 3) before they went into hibernation for the next 10 years. During this 10 years, Microsoft dominated the scenes but at the same time they weren't improving their product and hence Firefox was born (led by Eich) and a whole heap of other browsers such as Chrome, Opera.
ECMAScript released its 5th Edition in 2009 (the 4th edition was abandoned) with features such as strict mode. Since then, ECMAScript has gained a lot of momentum and is scheduled to release its 6th Edition in a few months from now with the biggest changes its had thus far.
You can use a list of features for ECMAScript 6 here http://kangax.github.io/es5-compat-table/es6/ and also the browser support. You can even start writing Ecmascript 6 like you do with CoffeeScript and use a compiler to compile down to Ecmascript 5.
Whether ECMAScript is the language and JavaScript is a dialect is arguable, but not important. If you continue to think like this it might confuse you. There is no compiler out there that would run ECMAScript, and I believe JavaScript is considered the Language which implements a standard called ECMAScript.
There are also other noticeable languages that implement ECMAScript such as ActionScript (used for Flash)
ECMAScript is the language, whereas JavaScript, JScript, and even ActionScript 3 are called "dialects". Wikipedia sheds some light on this.
ECMAScript = ES:
ECMAScript is a Standard for scripting languages.
Languages like Javascript are based on the ECMAScript standard.
ECMA Standard is based on several originating technologies, the most well known being JavaScript (Netscape) and JScript (Microsoft).
ECMA means European Computer Manufacturer’s Association
JavaScript = JS:
JavaScript is the most popular implementation of the ECMAScript Standard.
The core features of Javascript are based on the ECMAScript standard,
but Javascript also has other additional features that are not in
the ECMA specifications/standard.
ActionScript and JScript are other languages that implement the ECMAScript.
JavaScript was submitted to ECMA for standardization but due to trademark issues with the name Javascript the standard became called ECMAScript.
Every browser has a JavaScript interpreter.
ES5 = ECMAScript 5:
ES5 is a version of the ECMAScript (old/current one).
ES5 is the JavaScript you know and use in the browser today.
ES5 does not require a build step (transpilers) to transform it into something that will run in today's browsers.
ECMAScript version 5 was finished in December 2009,
the latest versions of all major browsers (Chrome, Safari, Firefox, and IE)
have implemented version 5.
Version 5.1 was finished in June, 2011.
ES6 = ECMAScript 6 = ES2015 = ECMAScript 2015:
ES2015 is a version of the ECMAScript (new/future one).
Officially the name ES2015 should be used instead of ES6.
ES6 will tackle many of the core language shortcomings addressed in
TypeScript and CoffeeScript.
ES6 is the next iteration of JavaScript, but it does not run in today's browsers.
There are quite a few transpilers that will export ES5 for running in browsers.
BabelJS:
BabelJS is the most popular transpiler that transforms new JavaScript ES6 to Old JavaScript ES5.
BabelJS makes it possible for writing the next generation of JavaScript today (means ES2015).
BabelJS simply takes ES2015 file and transform it into ES5 file.
Current browsers versions can now understand the new JavaScript code (ES2015), even if they don't yet support it.
TypeScript and CoffeeScript:
Both provides syntactic sugar on top of ES5
and then are transcompiled into ES5 compliant JavaScript.
You write TypeScript or CoffeeScript then the transpiler transforms it into ES5 JavaScript.
The umbrella term:
JavaScript = ECMAScript + DOM + BOM;
ECMAScript® Language Specification defines all logic for creating and editing objects, arrays, numbers, etc...
DOM (Document Object Model) makes it possible to communicate with HTML/XML documents (e.g. document.getElementById('id');).
BOM (Browser Object Model) is the hierarchy of browser objects (e.g. location object, history object, form elements).
History of JavaScript naming:
Mocha ► LiveScript ► JavaScript (the language) ► (part of JS resulted in) ECMA-262 ► ECMAScript ► JavaScript (umbrella term, consisting of ECMAScript + DOM + BOM)
Technically ECMAScript is the language that everyone is using and implementing -- it is the specification created many years ago when Netscape and Microsoft sat down and attempted to standardise the scripting between JavaScript (Netscape's scripting language) and JScript (Microsoft's).
Subsequently all these engines are ostensibly implementing ECMAScript, however JavaScript (the name) now hangs around for both traditional naming reasons, and as a marketing term by Mozilla for their various non-standard extensions (which they want to be able to actually "version")
Various JavaScript versions are implementations of the ECMAScript standard.
In my understanding, ECMAScript is the "Theory" or "Specification", and Javascript is "Practicals" or "Implementation".
i know this is an old post but hopefully this will help someone.
In the 1990’s different versions of js started coming out like javascript from netscape,
Js script from Microsoft. So ecmascript was introduced as a standard. But ecmascript forms only a part of javascript which specifies its core syntax,types,objects etc. Probably that explains the inconsistent implementations of javascript across diff. browsers
Reference - Wrox(Professional Javascript For Web Developers)
JavaScript is a ECMAScript language.
ECMAScript isn't necessarily JavaScript.
Here are my findings:
JavaScript: The Definitive Guide, written by David Flanagan provides a very concise explanation:
JavaScript was created at Netscape in the early days of the Web, and
technically, "JavaScript" is a trademark licensed from Sun
Microsystems (now Oracle) used to describe Netscape's (now Mozilla's)
implementation of the language. Netscape submitted the language for
standardization to ECMA and because of trademark issues, the
standardized version of the language was stuck with the awkward name
"ECMAScript". For the same trademark reasons, Microsoft's version of
the language is formally known as "JScript". In practice, just about
everyone calls the language JavaScript.
A blog post by Microsoft seems to agree with what Flanagan explains by saying..
ECMAScript is the official name for the JavaScript language we all
know and love.
.. which makes me think all occurrences of JavaScript in this reference post (by Microsoft again) must be replaced by ECMASCript. They actually seem to be careful with using ECMAScript only in this, more recent and more technical documentation page.
w3schools.com seems to agree with the definitions above:
JavaScript was invented by Brendan Eich in 1995, and became an ECMA
standard in 1997. ECMA-262 is the official name of the standard.
ECMAScript is the official name of the language.
The key here is: the official name of the language.
If you check Mozilla 's JavaScript version pages, you will encounter the following statement:
Deprecated. The explicit versioning and opt-in of language
features was Mozilla-specific and are in process of being removed.
Firefox 4 was the last version which referred to a JavaScript version
(1.8.5). With new ECMA standards, JavaScript language features are now
often mentioned with their initial definition in ECMA-262 Editions
such as ECMAScript 2015.
and when you see the recent release notes, you will always see reference to ECMAScript standards, such as:
The ES2015 Symbol.toStringTag property has been implemented (bug 1114580).
The ES2015 TypedArray.prototype.toString() and
TypedArray.prototype.toLocaleString() methods have been implemented
(bug 1121938).
Mozilla Web Docs also has a page that explains the difference between ECMAScript and JavaScript:
However, the umbrella term "JavaScript" as understood in a web browser
context contains several very different elements. One of them is the
core language (ECMAScript), another is the collection of the Web APIs,
including the DOM (Document Object Model).
Conclusion
To my understanding, people use the word JavaScript somewhat liberally to refer to the core ECMAScript specification.
I would say, all the modern JavaScript implementations (or JavaScript Engines) are in fact ECMAScript implementations. Check the definition of the V8 Engine from Google, for example:
V8 is Google’s open source high-performance JavaScript engine, written
in C++ and used in Google Chrome, the open source browser from Google,
and in Node.js, among others. It implements ECMAScript as specified in
ECMA-262.
They seem to use the word JavaScript and ECMAScript interchangeably, and I would say it is actually an ECMAScript engine?
So most JavaScript Engines are actually implementing the ECMAScript standard, but instead of calling them ECMAScript engines, they call themselves JavaScript Engines. This answer also supports the way I see the situation.
Existing answers paraphrase the main point quite well.
The main point is that ECMAScript is the bare abstract language, without any domain specific extensions, it's useless in itself. The specification defines only the language and the core objects of it.
While JavaScript and ActionScript and other dialects add the domain specific library to it, so you can use it for something meaningful.
There are many ECMAScript engines, some of them are open source, others are proprietary. You can link them into your program then add your native functions to the global object so your program becomes scriptable. Although most often they are used in browsers.
ECMAScript is a standard for JavaScript, look at these statements from MDN:
JavaScript
JavaScript (JS) is a lightweight interpreted or JIT-compiled
programming language with first-class functions. While it is most
well-known as the scripting language for Web pages, many non-browser
environments also use it, such as node.js, Apache CouchDB and Adobe
Acrobat. JavaScript is a prototype-based, multi-paradigm, dynamic
language, supporting object-oriented, imperative, and declarative
(e.g. functional programming) styles. Read more about JavaScript.
ECMAScript
The standard for JavaScript is ECMAScript. As of 2012, all modern
browsers fully support ECMAScript 5.1. Older browsers support at least
ECMAScript 3. On June 17, 2015, ECMA International published the sixth
major version of ECMAScript, which is officially called ECMAScript
2015, and was initially referred to as ECMAScript 6 or ES6. Since
then, ECMAScript standards are on yearly release cycles. This
documentation refers to the latest draft version, which is currently
ECMAScript 2018.
For more info, visit here
Javascript was the original name, meant to capitalize on the popularity of java. ECMA is the standards body that oversees the standard that was eventually put in place so the names are roughly equivalent.
Implementations have other names, like V8 or Rhino, etc.
I doubt we'd ever use the word "ECMAScript" if not for the fact that the name "JavaScript" is owned by Sun. For all intents and purposes, the language is JavaScript. You don't go to the bookstore looking for ECMAScript books, do you?
It's a bit too simple to say that "JavaScript" is the implementation. JScript is Microsoft's implementation.
JavaScript is one branch of languages formed around the ECMAScript standard. I believe ECMA is the European Computer Manufacturers Association, not that this is really relevant or anything.
Don't forget another popular language formed around the ECMA Script standard is ActionScript, used in Adobe Flash/Flex.