What is "native JavaScript"?

Question

Is there anything called "Native JavaScript"? I have seen this term in a job description I am going to be interviewing.

Is regular JavaScript is same as Native JavaScript?

• p.campbell: Likely they mean JavaScript, rather than JS libraries like jQuery, Dojo and others.
• Frank Conijn - Support Ukraine: I agree with @p.campbell. It’s the Javascript that browsers understand by themselves, natively. For jQuery lines, browsers need an ‘interpreter’, the jQuery file in the head section. Otherwise they will throw errors.

Answer 1

The term "native" is very overused in JavaScript.

• Colloquially, it is used as in Johan's answer: no JQuery, Moo, Dojo.

• Analogous to the JNI for Java, Google's GWT and similar I-compile-down-to-JavaScript talks about the underlying implementation as being native.

• The original use of native in JS, I believe, refers to objects built and defined in ECMAScript as opposed to the environment. JavaScript, as an ECMAScript language, is not intended to be self-sufficient; it is embedded in a host environment such as a Web browser, Photoshop, Acroread, etc. When you write a web client program, you will use objects such as Math, Function, Array, Window, and Button. The first three are native (independent of host environment), while the last two are non-native (supplied by the host environment). This is kind of the opposite of cdhowie's answer, which is a good answer BTW. Just interesting, though!

I'm sure there are other interpretations. My guess is that if you see this in a job description, it's probably not the last one: that definition is too academic. :)

Here is the official definition from the ECMAScript-262 Standard, Fifth Edition:

4.3.6 native object --- object in an ECMAScript implementation 
whose semantics are fully defined by this specification rather 
than by the host environment. NOTE Standard native objects are 
defined in this specification. Some native objects are built-in; 
others may be constructed during the course of execution of an 
ECMAScript program.

In other words the built-ins like Math, Object, String, RegExp are native, as are any objects I make with object literals or function definitions. But host objects are the opposite. Sorry for the ramble.

• RobG: The built–ins are are a subset of native. Part of the confusion is the common use of JavaScript or javascript as a synonym for ECMAScript. It isn't. Libraries like jQuery might be said to be native JavaScript, but they are not native ECMAScript due to their dependency on host DOM objects. However, libraries like moment.js are native ECMAScript as they rely only on built–in objects, not host objects (noting of course the ECMAScript is dependent on a host to provide an environment to run in). :-)

Answer 2

Native JS, I think, it's example below:

$=~[];$={___:++,ドル$$$$:(![]+"")[$],__$:++,ドル$_$_:(![]+"")[$],_$_:++,ドル$_$$:
({}+"")[$],$$_$:($[$]+"")[$],_$$:++,ドル$$$_:(!""+"")[$],$__:++,ドル$_$:
++,ドル$$__:({}+"")[$],$$_:++,ドル$$$:++,ドル$___:++,ドル$__$:++$};$.$_=
($.$_=$+"")[$.$_$]+($._$=$.$_[$.__$])+($.$$=($.$+"")[$.__$])+
((!$)+"")[$._$$]+($.__=$.$_[$.$$_])+($.$=(!""+"")[$.__$])+
($._=(!""+"")[$._$_])+$.$_[$.$_$]+$.__+$._$+$.$;$.$$=$.$+
(!""+"")[$._$$]+$.__+$._+$.$+$.$$;$.$=($.___)[$.$_][$.$_];
$.$($.$($.$$+"\""+$.$$_$+$._$+$.$$__+$._+"\\"+$.__$+$.$_$+$.$_$+
$.$$$_+"\\"+$.__$+$.$_$+$.$$_+$.__+".\\"+$.__$+$.$$_+$.$$$+
"\\"+$.__$+$.$$_+$._$_+"\\"+$.__$+$.$_$+$.__$+$.__+$.$$$_+
"(\\\"\\"+$.__$+$.__$+$.___+$.$$$_+(![]+"")[$._$_]+(![]+"")[$._$_]+
$._$+", \\"+$.__$+$.$$_+$.$$$+$._$+"\\"+$.__$+$.$$_+$._$_+
(![]+"")[$._$_]+$.$$_$+"!\\\")\\"+$.$$$+$._$$+"\"")())();

• evolutionxbox: Wat... Mind = blown.
• user985399: No, it is called minified or random pattern
• Mark Lopez: From reading it quickly, this code looks like it will just append "Hello World" to the DOM. But when trying it out I get the error: VM46:8 Uncaught EvalError: Refused to evaluate a string as JavaScript because 'unsafe-eval' is not an allowed source of script in the following Content Security Policy directive: "script-src chrome://resources chrome://test 'self' 'unsafe-inline' https:".
• degr: try harder, you can run it

Answer 3

Native JavaScript is the JavaScript implemented in the browser.

Browser implementation is followed by ECMA standard and some extra method. For example, if you familiar with jQuery and want to select element by ID

$('#myId')

Native JavaScript will be

document.getElementById('myId')

Now, if you need to do some simple tasks. You might not or should not load a huge jQuery Library and execute all its functionality. Rather 10 lines of native Javascript will do the job instead of 5 lines of jQuery code

Answer 4

I belief native Javascript reveres to 'vanilla' javascript, so no jQuery, MooTools, etc. Just plain old javascript

Answer 5

Not to complicate things too much more as @Ray's answer is correct, but a new JavaScript framework for building mobile applications has emerged called NativeScript https://www.nativescript.org/ If not confusing enough, this framework allows you to write pure "vanilla" JavaScript, but call Native (iOS/Android/WindowsPhone) APIs.

It is almost like writing a "Native" app (think Objective-C/Java/C#) but using a single language (JavaScript) which is interpreted at run-time on the device.

I suspect as this library's popularity grows "Native JavaScript" may be used as a label to describe code using this framework (esp. since that's how I got to this question via Google)

Answer 6

Native JavaScript is all JavaScript code . Not any kind of framework codes. It's faster and loads in the browser. You can use for simple browser task, that does not require any database interface, or any back-end large computation work. Using framework makes codes larger and makes browser slow.

• Timusan: Your answer seems to only tell part of the story. Native (vanilla) JavaScript can do anything a JavaScript library can or to put it in reverse: a library can not do more then the native code's capabilities. The main thing libraries add is abstraction so you can do some things easier with more readable and concise code. This, indeed, can come at the cost of extra computation and extra bytes over the wire.

Answer 7

The only context I know for the term "native JavaScript" involves writing JavaScript objects and/or functions that are implemented by the JavaScript provider and not written in JavaScript itself. For example, many of the functions you call on the window object are implemented by the browser in its native language (C++ for Firefox/Mozilla, etc.). This might be what they mean...

They might also mean vanilla/pure JavaScript (without frameworks like jQuery or Prototype). Consider contacting them and asking for clarification.

• Tim Down: That's exactly the wrong way round. Native objects are pure JavaScript objects, while objects that are provided by the environment (for example, DOM nodes in browsers) are known as host objects.

Answer 8

It is the same, perhaps just wondering if you've done more than just jayesh etc.

Answer 9

No , Native Javascript to me means 3rd party js functions that can do things that regular js cant , kind of like the Java-JNI relationship . Google JNEXT and JSNI for more info.

Again , I do not know the real context of the question , If i were you , I'd ask for clarification.