JavaScript Interview Questions
JavaScript Interview Questions
Table of Contents
No. Questions
24 What is memoization?
25 What is Hoisting?
34 What is IndexedDB?
37 What is a cookie?
41 What are the differences between cookie, local storage and session storage?
51 What is a promise?
64 What is promise.all
75 What is eval?
79 What is isNaN?
92 What are the tools or techniques used for debugging JavaScript code?
141 What is the way to find the number of parameters expected by a function?
150 Can you write a random integers function to print integers with in a range?
No. Questions
168 How do you get the image width and height using JS?
175 What are the ways to execute javascript after page load?
186 What happens if you do not use rest parameter as a last argument?
190 How do you determine two values same or not using object?
197 What are the differences between freeze and seal methods?
200 What is the main difference between Object.values and Object.entries method?
201 How can you get the list of keys of any object?
No. Questions
215 What is the precedence order between local and global variables?
222 What are the conventions to be followed for the usage of swtich case?
228 What are the different error names from error object?
233 How do you perform language specific date and time formatting?
245 How do you find min and max values without Math functions?
255 What happens if you write constructor more than once in a class?
273 What are the DOM methods available for constraint validation?
284 How do you check whether an array includes a particular value or not?
291 How do you invoke javascript code in an iframe from parent page?
294 What are the different methods to find HTML elements in DOM?
325 What are the problems with postmessage target origin as wildcard?
339 What are the list of cases error thrown from non-strict mode to strict mode?
346 How do you return all matching strings against a regular expression?
1. Object constructor:
The simplest way to create an empty object is using Object constructor. Currently this approach is
not recommended.
The create method of Object creates a new object by passing the prototype object as a parameter
3. Object literal syntax: The object literal syntax is equivalent to create method when it passes
null as parameter
var object = {};
4. Function constructor: Create any function and apply the new operator to create object
instances,
function Person(name){
var object = {};
object.name=name;
object.age=21;
return object;
}
var object = new Person("Sudheer");
5. Function constructor with prototype: This is similar to function constructor but it uses
prototype for their properties and methods,
function Person(){}
Person.prototype.name = "Sudheer";
var object = new Person();
This is equivalent to an instance created with an object create method with a function prototype and
then call that function with an instance and parameters as arguments.
**(OR)**
// If the result is a non-null object then use it otherwise just use the new
instance.
console.log(result && typeof result === 'object' ? result : newInstance);
6. ES6 Class syntax: ES6 introduces class feature to create the objects
class Person {
constructor(name) {
this.name = name;
}
}
7. Singleton pattern: A Singleton is an object which can only be instantiated one time.
Repeated calls to its constructor return the same instance and this way one can ensure that
they don't accidentally create multiple instances.
var object = new function(){
this.name = "Sudheer";
}
⬆ Back to Top
Prototype chaining is used to build new types of objects based on existing ones. It is similar to
inheritance in a class based language. The prototype on object instance is available through
Object.getPrototypeOf(object) or proto property whereas prototype on constructors function is
available through object.prototype.
⬆ Back to Top
The difference between Call, Apply and Bind can be explained with below examples, Call: The call()
method invokes a function with a given this value and arguments provided one by one
var employee1 = {firstName: 'John', lastName: 'Rodson'};
var employee2 = {firstName: 'Jimmy', lastName: 'Baily'};
invite.call(employee1, 'Hello', 'How are you?'); // Hello John Rodson, How are you?
invite.call(employee2, 'Hello', 'How are you?'); // Hello Jimmy Baily, How are you?
Apply: Invokes the function and allows you to pass in arguments as an array
invite.apply(employee1, ['Hello', 'How are you?']); // Hello John Rodson, How are
you?
invite.apply(employee2, ['Hello', 'How are you?']); // Hello Jimmy Baily, How are
you?
bind: returns a new function, allowing you to pass in an array and any number of arguments
Call and apply are pretty interchangeable. Both execute the current function immediately. You need
to decide whether it’s easier to send in an array or a comma separated list of arguments. You can
remember by treating Call is for comma (separated list) and Apply is for Array. Whereas Bind creates
a new function that will have this set to the first parameter passed to bind().
⬆ Back to Top
JSON is a text-based data format following JavaScript object syntax, which was popularized by
Douglas Crockford. It is useful when you want to transmit data across a network and it is basically
just a text file with an extension of .json, and a MIME type of application/json Parsing: **Converting a
string to a native object
JSON.parse(text)
Stringification: **converting a native object to a string so it can be transmitted across the network
JSON.stringify(object)
⬆ Back to Top
The slice() method returns the selected elements in an array as a new array object. It selects the
elements starting at the given start argument, and ends at the given optional end argument without
including the last element. If you omit the second argument then it selects till the end. Some of the
examples of this method are,
Note: Slice method won't mutate the original array but it returns the subset as new array.
⬆ Back to Top
Note: Splice method modifies the original array and returns the deleted array.
⬆ Back to Top
Slice Splice
Returns the subset of original array Returns the deleted elements as array
Used to pick the elements from array Used to insert or delete elements to/from arra
⬆ Back to Top
Objects are similar to Maps in that both let you set keys to values, retrieve those values, delete keys,
and detect whether something is stored at a key. Due to this reason, Objects have been used as
Maps historically. But there are important differences that make using a Map preferable in certain
cases.
1. The keys of an Object are Strings and Symbols, whereas they can be any value for a Map,
including functions, objects, and any primitive.
2. The keys in Map are ordered while keys added to object are not. Thus, when iterating over it,
a Map object returns keys in order of insertion.
3. You can get the size of a Map easily with the size property, while the number of properties in
an Object must be determined manually.
4. A Map is an iterable and can thus be directly iterated, whereas iterating over an Object
requires obtaining its keys in some fashion and iterating over them.
5. An Object has a prototype, so there are default keys in the map that could collide with your
keys if you're not careful. As of ES5 this can be bypassed by using map = Object.create(null),
but this is seldom done.
6. A Map may perform better in scenarios involving frequent addition and removal of key pairs.
⬆ Back to Top
JavaScript provides both strict(===, !==) and type-converting(==, !=) equality comparison. The strict
operators takes type of variable in consideration, while non-strict operators make type
correction/conversion based upon values of variables. The strict operators follow the below
conditions for different types,
1. Two strings are strictly equal when they have the same sequence of characters, same length,
and same characters in corresponding positions.
2. Two numbers are strictly equal when they are numerically equal. i.e, Having the same number
value. There are two special cases in this,
i. NaN is not equal to anything, including NaN.
ii. Positive and negative zeros are equal to one another.
3. Two Boolean operands are strictly equal if both are true or both are false.
4. Two objects are strictly equal if they refer to the same Object.
5. Null and Undefined types are not equal with ===, but equal with ==. i.e, null===undefined -
-> false but null==undefined --> true
0 == false // true
0 === false // false
1 == "1" // true
1 === "1" // false
null == undefined // true
null === undefined // false
'0' == false // true
'0' === false // false
[]==[] or []===[] //false, refer different objects in memory
{}=={} or {}==={} //false, refer different objects in memory
⬆ Back to Top
⬆ Back to Top
In Javascript, functions are first class objects. First-class functions means when functions in that
language are treated like any other variable. For example, in such a language, a function can be
passed as an argument to other functions, can be returned by another function and can be assigned
as a value to a variable. For example, in the below example, handler functions assigned to a listener
⬆ Back to Top
First-order function is a function that doesn’t accept other function as an argument and doesn’t
return a function as its return value.
⬆ Back to Top
Higher-order function is a function that accepts other function as an argument or returns a function
as a return value.
⬆ Back to Top
Unary function (i.e. monadic) is a function that accepts exactly one argument. Let us take an example
of unary function. It stands for single argument accepted by a function.
const unaryFunction = a => console.log (a + 10); //Add 10 to the given argument and
display the value
⬆ Back to Top
15. What is currying function?
Currying is the process of taking a function with multiple arguments and turning it into a sequence
of functions each with only a single argument. Currying is named after a mathematician Haskell
Curry. By applying currying, a n-ary function turns it into a unary function. Let's take an example of n-
ary function and how it turns into a currying function
Curried functions are great to improve code re-usability and functional composition.
⬆ Back to Top
A Pure function is a function where the return value is only determined by its arguments without
any side effects. i.e, If you call a function with the same arguments 'n' number of times and 'n'
number of places in the application then it will always return the same value. Let's take an example
to see the difference between pure and impure functions,
//Impure
let numberArray = [];
const impureAddNumber = number => numberArray.push (number);
//Pure
const pureAddNumber = number => argNumberArray =>
argNumberArray.concat ([number]);
As per above code snippets, Push function is impure itself by altering the array and returning an
push number index which is independent of parameter value. Whereas Concat on the other hand
takes the array and concatenates it with the other array producing a whole new array without side
effects. Also, the return value is a concatenation of previous array. Remember that Pure functions are
important as they simplify unit testing without any side effects and no need for dependency
injection. They also avoid tight coupling and makes harder to break your application by not having
any side effects. These principles are coming together with Immutability concept of ES6 by giving
preference to const over let usage.
⬆ Back to Top
⬆ Back to Top
var let
function userDetails(username) {
if(username) {
console.log(salary); // undefined(due to hoisting)
console.log(age); // error: age is not defined
let age = 30;
var salary = 10000;
}
console.log(salary); //10000 (accessible to due function scope)
console.log(age); //error: age is not defined(due to block scope)
}
⬆ Back to Top
Let is a mathematical statement that was adopted by early programming languages like
Scheme and Basic. It has been borrowed from dozens of other languages that use let already
as a traditional keyword as close to var as possible.
⬆ Back to Top
If you try to redeclare variables in a switch block then it will cause errors because there is
only one block. For example, the below code block throws a syntax error as below,
let counter = 1;
switch(x) {
case 0:
let name;
break;
case 1:
let name; // SyntaxError for redeclaration.
break;
}
To avoid this error, you can create a nested block inside a case clause will create a new block
scoped lexical environment.
let counter = 1;
switch(x) {
case 0: {
let name;
break;
}
case 1: {
let name; // No SyntaxError for redeclaration.
break;
}
}
⬆ Back to Top
The Temporal Dead Zone is a behavior in JavaScript that occurs when declaring a variable
with the let and const keywords, but not with var. In ECMAScript 6, accessing a let or const
variable before its declaration (within its scope) causes a ReferenceError. The time span when
that happens, between the creation of a variable’s binding and its declaration, is called the
temporal dead zone. Let's see this behavior with an example,
function somemethod() {
console.log(counter1); // undefined
console.log(counter2); // ReferenceError
var counter1 = 1;
let counter2 = 2;
}
⬆ Back to Top
IIFE (Immediately Invoked Function Expression) is a JavaScript function that runs as soon as it
is defined. The signature of it would be as below,
(function ()
{
// logic here
}
)
();
The primary reason to use an IIFE is to obtain data privacy because any variables declared
within the IIFE cannot be accessed by the outside world. i.e, If you try to access variables with
IIFE then it throws an error as below,
(function ()
{
var message = "IIFE";
console.log(message);
}
)
();
console.log(message); //Error: message is not defined
⬆ Back to Top
There are a lot of benefits to using modules in favour of a sprawling. Some of the benefits
are,
i. Maintainablity
ii. Reusability
iii. Namespacing
⬆ Back to Top
⬆ Back to Top
Hoisting is a JavaScript mechanism where variables and function declarations are moved to
the top of their scope before code execution. Remember that JavaScript only hoists
declarations, not initialisation. Let's take a simple example of variable hoisting,
var message;
console.log(message);
message = ’The variable Has been hoisted’;
⬆ Back to Top
In ES6, Javascript classes are primarily syntactical sugar over JavaScript’s existing prototype-
based inheritance. For example, the prototype based inheritance written in function
expression as below,
function Bike(model,color) {
this.model = model;
this.color = color;
}
Bike.prototype.getDetails = function() {
return this.model+ ' bike has' + this.color+ ' color';
};
class Bike{
constructor(color, model) {
this.color= color;
this.model= model;
}
}
⬆ Back to Top
A closure is the combination of a function and the lexical environment within which that
function was declared. i.e, It is an inner function that has access to the outer or enclosing
function’s variables. The closure has three scope chains
function Welcome(name){
var greetingInfo = function(message){
console.log(message+' '+name);
}
return greetingInfo;
}
var myFunction = Welcome('John');
myFunction('Welcome '); //Output: Welcome John
myFunction('Hello Mr.'); //output: Hello Mr.John
As per the above code, the inner function(greetingInfo) has access to the variables in the
outer function scope(Welcome) even after outer function has returned.
⬆ Back to Top
Modules refers small units of independent, reusable code and also act as foundation of many
JavaScript design patterns. Most of the JavaScript modules export an object literal, a function,
or a constructor
⬆ Back to Top
29. Why do you need modules?
i. Maintainablity
ii. Reusability
iii. Namespacing
⬆ Back to Top
Scope is the accessibility of variables, functions, and objects in some particular part of your
code during runtime. In other words, scope determines the visibility of variables and other
resources in areas of your code.
⬆ Back to Top
A Service worker is basically a script (JavaScript file) that runs in background, separate from a
web page and provide features that don't need a web page or user interaction. Some of the
major features of service workers are Rich offline experiences(offline first web application
development), periodic background syncs, push notifications, intercept and handle network
requests and programmatically managing a cache of responses.
⬆ Back to Top
Service worker can't access the DOM directly. But it can communicate with the pages it
controls by responding to messages sent via the postMessage interface, and those pages can
manipulate the DOM.
⬆ Back to Top
The problem with service worker is that it get terminated when not in use, and restarted
when it's next needed, so you cannot rely on global state within a service
worker's onfetch and onmessage handlers. In this case, service workers will have access to
IndexedDB API in order to persist and reuse across restarts.
⬆ Back to Top
34. What is IndexedDB?
IndexedDB is a low-level API for client-side storage of larger amounts of structured data,
including files/blobs. This API uses indexes to enable high-performance searches of this data.
⬆ Back to Top
Web storage is an API that provides a mechanism by which browsers can store key/value
pairs locally within the user's browser, in a much more intuitive fashion than using cookies.
The web storage provides two mechanisms for storing data on the client.
i. Local storage: It stores data for current origin with no expiration date.
ii. Session storage: It stores data for one session and the data is lost when the browser
tab is closed.
⬆ Back to Top
⬆ Back to Top
A cookie is a piece of data that is stored on your computer to be accessed by your browser.
Cookies are saved as key/value pairs. For example, you can create a cookie named username
as below,
document.cookie = "username=John";
⬆ Back to Top
Cookies are used to remember information about the user profile(such as username). It
basically involves two steps,
i. When a user visits a web page, user profile can be stored in a cookie.
ii. Next time the user visits the page, the cookie remembers user profile.
⬆ Back to Top
i. By default, the cookie is deleted when the browser is closed but you can change this
behavior by setting expiry date (in UTC time).
ii. By default, the cookie belongs to a current page. But you can tell the browser what
path the cookie belongs to using a path parameter.
⬆ Back to Top
You can delete a cookie by setting the expiry date as a passed date. You don't need to
specify a cookie value in this case. For example, you can delete a username cookie in the
current page as below.
Note: You should define the cookie path option to ensure that you delete the right cookie.
Some browsers doesn't allow to delete a cookie unless you specify a path parameter.
⬆ Back to Top
41. What are the differences between cookie, local storage and
session storage?
Below are some of the differences between cookie, local storage and session storage,
Local Session
Feature Cookie
storage storage
Not
SSL support Supported Not supported
supported
⬆ Back to Top
LocalStorage is same as SessionStorage but it persists the data even when the browser is
closed and reopened(i.e it has no expiration time) whereas in sessionStorage data gets
cleared when the page session ends.
⬆ Back to Top
⬆ Back to Top
The session storage provided methods for reading, writing and clearing the session data
⬆ Back to Top
The StorageEvent is an event that fires when a storage area has been changed in the context
of another document. Whereas onstorage property is an EventHandler for processing storage
events. The syntax would be as below
window.onstorage = functionRef;
Let's take the example usage of onstorage event handler which logs the storage key and it's
values
window.onstorage = function(e) {
console.log('The ' + e.key +
' key has been changed from ' + e.oldValue +
' to ' + e.newValue + '.');
};
⬆ Back to Top
Web storage is more secure, and large amounts of data can be stored locally, without
affecting website performance. Also, the information is never transferred to the server. Hence
this is recommended approach than Cookies.
⬆ Back to Top
You need to check browser support for localStorage and sessionStorage before using web
storage,
⬆ Back to Top
48. How do you check web workers browser support?
You need to check browser support for web workers before using it
⬆ Back to Top
You need to follow below steps to start using web workers for counting example
ii. Create a Web Worker File: You need to write a script to increment the count value.
Let's name it as counter.js
let i = 0;
function timedCount() {
i = i + 1;
postMessage(i);
setTimeout("timedCount()",500);
}
timedCount();
Here postMessage() method is used to post a message back to the HTML page 2. Create a
Web Worker Object: You can create a web worker object by checking for browser support.
Let's name this file as web_worker_example.js
if (typeof(w) == "undefined") {
w = new Worker("counter.js");
}
w.onmessage = function(event){
document.getElementById("message").innerHTML = event.data;
};
iii. Terminate a Web Worker: Web workers will continue to listen for messages (even
after the external script is finished) until it is terminated. You can use terminate()
method to terminate listening the messages.
w.terminate();
iv. Reuse the Web Worker: If you set the worker variable to undefined you can reuse the
code
w = undefined;
⬆ Back to Top
WebWorkers don't have access to below javascript objects since they are defined in an
external files
⬆ Back to Top
A promise is an object that may produce a single value some time in the future with either a
resolved value or a reason that it’s not resolved(for example, network error). It will be in one
of the 3 possible states: fulfilled, rejected, or pending. The syntax of promise would be as
below
⬆ Back to Top
Promises are used to handle asynchronous operations. They provide an alternative approach
for callbacks by reducing the callback hell and writing the cleaner code.
⬆ Back to Top
⬆ Back to Top
A callback function is a function passed into another function as an argument. This function
is invoked inside the outer function to complete an action. Let's take a simple example of
how to use callback function
function callbackFunction(name) {
console.log('Hello ' + name);
}
function outerFunction(callback) {
let name = prompt('Please enter your name.');
callback(name);
}
outerFunction(callbackFunction);
⬆ Back to Top
The callbacks are needed because javascript is a event driven language. That means instead
of waiting for a response javascript will keep executing while listening for other events. Let's
take an example with first function invoking an API call(simulated by setTimeout) and next
function which logs the message.
function firstFunction(){
// Simulate a code delay
setTimeout( function(){
console.log('First function called');
}, 1000 );
}
function secondFunction(){
console.log('Second function called');
}
firstFunction();
secondFunction();
Output
// Second function called
// First function called
As observed from the output, javascript didn't wait for the response of first function and
remaining code block get executed. So callbacks used in a way to make sure that certain
code doesn’t execute until other code finished execution.
⬆ Back to Top
Callback Hell is an anti-pattern with multiple nested callbacks which makes code hard to read
and debug when dealing with asynchronous logic. The callback hell looks like below,
async1(function(){
async2(function(){
async3(function(){
async4(function(){
....
});
});
});
});
⬆ Back to Top
Server-sent events (SSE) is a server push technology enabling a browser to receive automatic
updates from a server via HTTP connection without resorting to polling. These are a one way
communications channel - events flow from server to client only. This is been used in
Facebook/Twitter updates, stock price updates, news feeds etc.
⬆ Back to Top
The EventSource object is used to receive server-sent event notifications. For example, you
can receive messages from server as below,
⬆ Back to Top
You can perform browser support for server-sent events before using it as below,
⬆ Back to Top
60. What are the events available for server sent events?
Below are the list of events available for server sent events | Event | Description | |---- | -------
-- | onopen | It is used when a connection to the server is opened | | onmessage | This event
is used when a message is received | | onerror | It happens when an error occurs|
⬆ Back to Top
⬆ Back to Top
You can nest one callback inside in another callback to execute the actions sequentially one
by one. This is known as callbacks in callbacks.
loadScript('/script1.js', function(script) {
console.log('first script is loaded');
loadScript('/script2.js', function(script) {
loadScript('/script3.js', function(script) {
})
});
⬆ Back to Top
The process of executing a sequence of asynchronous tasks one after another using promises
is known as Promise chaining. Let's take an example of promise chaining for calculating the
final result,
}).then(function(result) {
console.log(result); // 1
return result * 2;
}).then(function(result) {
console.log(result); // 2
return result * 3;
}).then(function(result) {
console.log(result); // 6
return result * 4;
});
In the above handlers, the result is passed to the chain of .then() handlers with the below
work flow,
⬆ Back to Top
Promise.all is a promise that takes an array of promises as an input (an iterable), and it gets
resolved when all the promises get resolved or any one of them gets rejected. For example,
the syntax of promise.all method is below,
Promise.all([Promise1, Promise2, Promise3]) .then(result) => {
console.log(result) }) .catch(error => console.log(`Error in promises
${error}`))
Note: Remember that the order of the promises(output the result) is maintained as per input
order.
⬆ Back to Top
Promise.race() method will return the promise instance which is firstly resolved or rejected.
Let's take an example of race() method where promise2 is resolved first
Promise.race([promise1, promise2]).then(function(value) {
console.log(value); // "two" // Both promises will resolve, but promise2 is
faster
});
⬆ Back to Top
Strict Mode is a new feature in ECMAScript 5 that allows you to place a program, or a
function, in a “strict” operating context. This way it prevents certain actions from being taken
and throws more exceptions. The literal expression “use strict”; instructs the browser to
use the javascript code in the Strict mode.
⬆ Back to Top
Strict mode is useful to write "secure" JavaScript by notifying "bad syntax" into real errors. For
example, it eliminates accidentally creating a global variable by throwing an error and also
throws an error for assignment to a non-writable property, a getter-only property, a non-
existing property, a non-existing variable, or a non-existing object.
⬆ Back to Top
"use strict";
x = 3.14; // This will cause an error because x is not declared
function myFunction() {
"use strict";
y = 3.14; // This will cause an error
}
⬆ Back to Top
The double exclamation or negation(!!) ensures the resulting type is a boolean. If it was falsey
(e.g. 0, null, undefined, etc.), it will be false, otherwise, true. For example, you can test IE
version using this expression as below,
If you don't use this expression then it returns the original value.
⬆ Back to Top
The delete keyword is used to delete the property as well as its value.
⬆ Back to Top
⬆ Back to Top
The undefined property indicates that a variable has not been assigned a value, or not
declared at all. The type of undefined value is undefined too.
user = undefined
⬆ Back to Top
The value null represents the intentional absence of any object value. It is one of JavaScript's
primitive values. The type of null value is object. You can empty the variable by setting the
value to null.
⬆ Back to Top
Null Undefined
It is an assignment value which indicates that variable It is not an assignment value where a varia
points to no object. but has not yet been assigned a value.
The null value is a primitive value that represents the null, The undefined value is a primitive value u
Null Undefined
Indicates the absence of a value for a variable Indicates absence of variable itself
⬆ Back to Top
The eval() function evaluates JavaScript code represented as a string. The string can be a
JavaScript expression, variable, statement, or sequence of statements.
console.log(eval('1 + 2')); // 3
⬆ Back to Top
Window Document
It has methods like alert(), confirm() and properties It provides methods like getElementById, getEle
like document, location createElement etc
⬆ Back to Top
function goBack() {
window.history.back()
}
function goForward() {
window.history.forward()
}
⬆ Back to Top
. Number
i. String
ii. Boolean
iii. Object
iv. Undefined
⬆ Back to Top
The isNaN() function is used to determine whether a value is an illegal number (Not-a-
Number) or not. i.e, This function returns true if the value equates to NaN. Otherwise it
returns false.
isNaN('Hello') //true
isNaN('100') //false
⬆ Back to Top
Below are the major differences between undeclared and undefined variables,
undeclared undefined
undeclared undefined
If you try to read the value of an undeclared variable, then a If you try to read the value of an und
runtime error is encountered undefined value is returned.
⬆ Back to Top
Global variables are those that are available throughout the length of the code without any
scope. The var keyword is used to declare a local variable but if you omit it then it will
become global variable
⬆ Back to Top
The problem with global variables is the conflict of variable names of local and global scope.
It is also difficult to debug and test the code that relies on global variables.
⬆ Back to Top
The NaN property is a global property that represents "Not-a-Number" value. i.e, It indicates
that a value is not a legal number. It is very rare to use NaN in a program but it can be used
as return value for few cases
Math.sqrt(-1)
parseInt("Hello")
⬆ Back to Top
The isFinite() function is used to determine whether a number is a finite, legal number. It
returns false if the value is +infinity, -infinity, or NaN (Not-a-Number), otherwise it returns
true.
isFinite(Infinity); // false
isFinite(NaN); // false
isFinite(-Infinity); // false
isFinite(100); // true
⬆ Back to Top
Event flow is the order in which event is received on the web page. When you click an
element that is nested in various other elements, before your click actually reaches its
destination, or target element, it must trigger the click event each of its parent elements first,
starting at the top with the global window object. There are two ways of event flow
⬆ Back to Top
Event bubbling is a type of event propagation where the event first triggers on the innermost
target element, and then successively triggers on the ancestors (parents) of the target
element in the same nesting hierarchy till it reaches the outermost DOM element.
⬆ Back to Top
Event bubbling is a type of event propagation where the event is first captured by the
outermost element and , and then successively triggers on the descendants (children) of the
target element in the same nesting hierarchy till it reaches the inner DOM element.
⬆ Back to Top
You can submit a form using JavaScript use document.form[0].submit(). All the form input's
information is submitted using onsubmit event handler
function submit() {
document.form[0].submit();
}
⬆ Back to Top
89. How do you find operating system details?
The window.navigator object contains information about the visitor's browser os details.
Some of the OS properties are avaialble under platform property,
console.log(navigator.platform);
⬆ Back to Top
The DOMContentLoaded event is fired when the initial HTML document has been completely
loaded and parsed, without waiting for assets(stylesheets, images, and subframes) to finish
loading. Whereas The load event is fired when the whole page has loaded, including all
dependent resources(stylesheets, images).
⬆ Back to Top
91. What is the difference between native, host and user objects?
Native objects are objects that are part of the JavaScript language defined by the
ECMAScript specification. For example, String, Math, RegExp, Object, Function etc core
objects defined in the ECMAScript spec. Host objects are objects provided by the browser
or runtime environment (Node). For example, window, XmlHttpRequest, DOM nodes etc
considered as host objects. User objects are objects defined in the javascript code. For
example, User object created for profile information.
⬆ Back to Top
92. What are the tools or techniques used for debugging JavaScript
code?
. Chrome Devtools
i. debugger statement
ii. Good old console.log statement
⬆ Back to Top
93. What are the pros and cons of promises over callbacks?
Below are the list of pros and cons of promises over callbacks, Pros:
. It avoids callback hell which is unreadable
i. Easy to write sequential asynchronous code with .then()
ii. Easy to write parallel asynchronous code with Promise.all()
iii. Solves some of the common problems of callbacks(call the callback too late, too
early, many times and swallow errors/exceptions)
Cons:
⬆ Back to Top
Attributes are defined on the HTML markup whereas properties are defined on the DOM. For
example, the below HTML element has 2 attributes type and value,
And after you change the value of the text field to "Good evening", it becomes like
⬆ Back to Top
The same-origin policy is a policy that prevents JavaScript from making requests across
domain boundaries. An origin is defined as a combination of URI scheme, hostname, and
port number. If you enable this policy then it prevents a malicious script on one page from
obtaining access to sensitive data on another web page using Document Object
Model(DOM).
⬆ Back to Top
⬆ Back to Top
⬆ Back to Top
Yes, JavaScript is a case sensitive language. The language keywords, variables, function &
object names, and any other identifiers must always be typed with a consistent capitalization
of letters.
⬆ Back to Top
No, they are entirely two different programming languages and has nothing to do with each
other. But both of them are Object Oriented Programming languages and like many other
languages, they follow similar syntax for basic features(if, else, for, switch, break, continue
etc).
⬆ Back to Top
Events are "things" that happen to HTML elements. When JavaScript is used in HTML pages,
JavaScript can react on these events. Some of the examples of HTML events are,
<!doctype html>
<html>
<head>
<script>
function greeting() {
alert('Hello! Good morning');
}
</script>
</head>
<body>
<button type="button" onclick="greeting()">Click me</button>
</body>
</html>
⬆ Back to Top
JavaScript was created by Brendan Eich in 1995 during his time at Netscape Communications.
Initially it was developed under the name Mocha, but later the language was officially
called LiveScript when it first shipped in beta releases of Netscape.
⬆ Back to Top
The preventDefault() method cancels the event if it is cancelable, meaning that the default
action or behaviour that belongs to the event will not occur. For example, prevent form
submission when clicking on submit button and prevent opening the page URL when clicking
on hyper link are some common usecases.
document.getElementById("link").addEventListener("click", function(event){
event.preventDefault();
});
⬆ Back to Top
The stopPropagation method is used to stop the event from bubbling up the event chain. For
example, the below nested divs with stopPropagation method prevents default event
propagation when clicking on nested div(Div1)
<script>
function firstFunc(event) {
alert("DIV 1");
event.stopPropagation();
}
function secondFunc() {
alert("DIV 2");
}
</script>
⬆ Back to Top
The return false statement in event handlers performs the below steps,
⬆ Back to Top
The Browser Object Model (BOM) allows JavaScript to "talk to" the browser. It consists of the
objects navigator, history, screen, location and document which are children of window. The
Browser Object Model is not standardized and can change based on different browsers.
⬆ Back to Top
⬆ Back to Top
⬆ Back to Top
JavaScript is a single-threaded language. Because the language specification does not allow
the programmer to write code so that the interpreter can run parts of it in parallel in multiple
threads or processes. Whereas languages like java, go, C++ can make multi-threaded and
multi-process programs.
⬆ Back to Top
Event delegation is a technique for listening to events where you delegate a parent element
as the listener for all of the events that happen inside it. For example, if you wanted to detect
field changes in inside a specific form, you can use event delegation technique,
}, false);
⬆ Back to Top
ECMAScript is the scripting language that forms the basis of JavaScript. ECMAScript
standardized by the ECMA International standards organization in the ECMA-262 and ECMA-
402 specifications. The first edition of ECMAScript was released in 1997.
⬆ Back to Top
JSON (JavaScript Object Notation) is a lightweight format that is used for data interchanging.
It is based on a subset of JavaScript language in the way objects are built in JavaScript.
⬆ Back to Top
⬆ Back to Top
When sending data to a web server, the data has to be in a string format. You can achieve
this by converting JSON object into a string using stringify() method.
⬆ Back to Top
When receiving the data from a web server, the data is always in a string format. But you can
convert this string value to javascript object using parse() method.
⬆ Back to Top
When exchanging data between a browser and a server, the data can only be text. Since
JSON is text only, it can easily be sent to and from a server, and used as a data format by any
programming language.
⬆ Back to Top
⬆ Back to Top
The clearTimeout() function is used in javascript to clear the timeout which has been set by
setTimeout()function before that. i.e, The return value of setTimeout() function is stored in a
variable and it’s passed into the clearTimeout() function to clear the timer. For example, the
below setTimeout method is used to display the message after 3 seconds. This timeout can
be cleared by clearTimeout() method.
<script>
var msg;
function greeting() {
alert('Good morning');
}
function start() {
msg =setTimeout(greeting, 3000);
function stop() {
clearTimeout(msg);
}
</script>
⬆ Back to Top
The clearInterval() function is used in javascript to clear the interval which has been set by
setInterval() function. i.e, The return value returned by setInterval() function is stored in a
variable and it’s passed into the clearInterval() function to clear the interval. For example, the
below setInterval method is used to display the message for every 3 seconds. This interval
can be cleared by clearInterval() method.
<script>
var msg;
function greeting() {
alert('Good morning');
}
function start() {
msg = setInterval(greeting, 3000);
function stop() {
clearInterval(msg);
}
</script>
⬆ Back to Top
In vanilla javascript, you can redirect to a new page using location property of window
object. The syntax would be as follows,
function redirect() {
window.location.href = 'newPage.html';
}
⬆ Back to Top
There are 3 possible ways to check whether a string contains a substring or not,
iii. Using RegEx: The advanced solution is using Regular expression's test
method(RegExp.test), which allows for testing for against regular expressions
⬆ Back to Top
⬆ Back to Top
You can use window.location.href expression to get the current url path and you can use
the same expression for updating the URL too. You can also use document.URL for read-only
purpose but this solution has issues in FF.
console.log('location.href', window.location.href); // Returns full URL
⬆ Back to Top
The below Location object properties can be used to access URL components of the page,
⬆ Back to Top
You can use URLSearchParams to get query string values in javascript. Let's see an example
to get the client code value from URL query string,
⬆ Back to Top
125. How do you check if a key exists in an object?
You can check whether a key exists in an object or not using two approaches,
. ** Using in operator:** You can use the in operator whether a key exists in an object
or not
"key" in obj
and If you want to check if a key doesn't exist, remember to use parenthesis,
!("key" in obj)
ii. ** Using hasOwnProperty method:** You can use hasOwnProperty to particularly test
for properties of the object instance (and not inherited properties)
obj.hasOwnProperty("key") // true
⬆ Back to Top
You can use the for-in loop to loop through javascript object. You can also make sure that
the key you get is an actual property of an object, and doesn't come from the prototype
using hasOwnProperty method.
var object = {
"k1": "value1",
"k2": "value2",
"k3": "value3"
};
⬆ Back to Top
ii. Using Object entries(ECMA 7+): You can use object entries length along with
constructor type.
iii. Using for-in with hasOwnProperty(Pre-ECMA 5): You can use for-in loop along
with hasOwnProperty.
function isEmpty(obj) {
for(var prop in obj) {
if(obj.hasOwnProperty(prop)) {
return false;
}
}
⬆ Back to Top
The arguments object is an Array-like object accessible inside functions that contains the
values of the arguments passed to that function. For example, let's see how to use arguments
object inside sum function,
function sum() {
var total = 0;
for (var i = 0, len = arguments.length; i < len; ++i) {
total += arguments[i];
}
return total;
}
sum(1, 2, 3) // returns 6
⬆ Back to Top
You can create a function which uses chain of string methods such as charAt, toUpperCase
and slice methods to generate a string with first letter in uppercase.
function capitalizeFirstLetter(string) {
return string.charAt(0).toUpperCase() + string.slice(1);
}
⬆ Back to Top
130. What are the pros and cons of for loop?
The for-loop is a commonly used iteration syntax in javascript. It has both pros and cons Pros
⬆ Back to Top
You can use new Date() to generate a new Date object containing the current date and time.
For example, let's display the current date in mm/dd/yyyy
var today = new Date();
var dd = String(today.getDate()).padStart(2, '0');
var mm = String(today.getMonth() + 1).padStart(2, '0'); //January is 0!
var yyyy = today.getFullYear();
⬆ Back to Top
You need to use use date.getTime() method to compare date values instead comparision
operators (==, !=, ===, and !== operators)
⬆ Back to Top
JavaScript provided a trim method on string types to trim any whitespaces present at the
begining or ending of the string.
If your browser(<IE9) doesn't support this method then you can use below polyfill.
if (!String.prototype.trim) {
(function() {
// Make sure we trim BOM and NBSP
var rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g;
String.prototype.trim = function() {
return this.replace(rtrim, '');
};
})();
}
⬆ Back to Top
There are two possible solutions to add new properties to an object. Let's take a simple
object to explain these solutions.
var object = {
key1: value1,
key2: value2
};
. Using dot notation: This solution is useful when you know the name of the property
object.key3 = "value3";
ii. Using square bracket notation: This solution is useful when the name of the
property is dynamically determined.
obj["key3"] = "value3";
⬆ Back to Top
No,that's not a special operator. But it is a combination of 2 standard operators one after the
other,
ii. A logical not (!)
iii. A prefix decrement (--)
At first, the value decremented by one and then tested to see if it is equal to zero or not for
determining the truthy/falsy value.
⬆ Back to Top
You can use the logical or operator || in an assignment expression to provide a default
value. The syntax looks like as below,
var a = b || c;
As per the above expression, variable 'a 'will get the value of 'c' only if 'b' is falsy (if is null,
false, undefined, 0, empty string, or NaN), otherwise 'a' will get the value of 'b'.
⬆ Back to Top
You can define multiline string literals using '' character followed by line terminator.
But if you have a space after the '' character, the code will look exactly the same, but it will
raise a SyntaxError.
⬆ Back to Top
An application shell (or app shell) architecture is one way to build a Progressive Web App
that reliably and instantly loads on your users' screens, similar to what you see in native
applications. It is useful for getting some initial HTML to the screen fast without a network.
⬆ Back to Top
Yes, We can define properties for functions because functions are also objects.
fn = function(x) {
//Function code goes here
}
fn.name = "John";
fn.profile = function(y) {
//Profile code goes here
}
⬆ Back to Top
You can use function.length syntax to find the number of parameters expected by a
function. Let's take an example of sum function to calculate the sum of numbers,
function sum(num1, num2, num3, num4){
return num1 + num2 + num3 + num4;
}
sum.length // 4 is the number of parameters expected.
⬆ Back to Top
A polyfill is a piece of JS code used to provide modern functionality on older browsers that
do not natively support it. For example, Silverlight plugin polyfill can be used to mimic the
functionality of an HTML Canvas element on Microsoft Internet Explorer 7.
⬆ Back to Top
The break statement is used to "jumps out" of a loop. i.e, It breaks the loop and continues
executing the code after the loop.
The continue statement is used to "jumps over" one iteration in the loop. i.e, It breaks one
iteration (in the loop), if a specified condition occurs, and continues with the next iteration in
the loop.
The label statement allows us to name loops and blocks in JavaScript. We can then use these
labels to refer back to the code later. For example, the below code with labels avoids printing
the numbers when they are same,
var i, j;
loop1:
for (i = 0; i < 3; i++) {
loop2:
for (j = 0; j < 3; j++) {
if (i === j) {
continue loop1;
}
console.log('i = ' + i + ', j = ' + j);
}
}
// Output is:
// "i = 1, j = 0"
// "i = 2, j = 0"
// "i = 2, j = 1"
⬆ Back to Top
It is recommended to keep all declarations at the top of each script or function. The benefits
of doing this are,
⬆ Back to Top
It is recommended to avoid creating new objects using new Object(). Instead you can
initialize values based on it's type to create the objects.
var v1 = {};
var v2 = "";
var v3 = 0;
var v4 = false;
var v5 = [];
var v6 = /()/;
var v7 = function(){};
⬆ Back to Top
JSON arrays are written inside square brackets and array contain javascript objects. For
example, the JSON array of users would be as below,
"users":[
{"firstName":"John", "lastName":"Abrahm"},
{"firstName":"Anna", "lastName":"Smith"},
{"firstName":"Shane", "lastName":"Warn"}
]
⬆ Back to Top
You can use Math.random() with Math.floor() to return random integers. For example, if you
want generate random integers between 1 to 10, the multiplication factor should be 10,
Math.floor(Math.random() * 10) + 1; // returns a random integer from 1 to
10
Math.floor(Math.random() * 100) + 1; // returns a random integer from 1 to
100
⬆ Back to Top
150. Can you write a random integers function to print integers with
in a range?
Yes, you can create a proper random function to return a random number between min and
max (both included)
⬆ Back to Top
Tree shaking is a form of dead code elimination. It means that unused modules will not be
included in the bundle during the build process and for that it relies on the static structure of
ES2015 module syntax,( i.e. import and export). Initially this has been popularized by the
ES2015 module bundler rollup.
⬆ Back to Top
Tree Shaking can significantly reduce the code size in any application. i.e, The less code we
send over the wire the more performant the application will be. For example, if we just want
to create a “Hello World” Application using SPA frameworks then it will take around few MBs,
but by tree shaking it can bring down the size to just few hundred KBs. Tree shaking is been
implemented in Rollup and Webpack bundlers.
⬆ Back to Top
⬆ Back to Top
A regular expression is a sequence of characters that forms a search pattern. You can use this
search pattern for searching data in a text. These can be used to perform all types of text
search and text replace operations. Let's see the syntax format now,
/pattern/modifiers;
For example, the regular expression or search pattern with case-insensitive username would
be,
/John/i
⬆ Back to Top
Regular Expressions has two string methods: search() and replace(). The search() method uses
an expression to search for a match, and returns the position of the match.
The replace() method is used return a modified string where the pattern is replaced.
⬆ Back to Top
Modifiers can be used to perform case-insensitive and global searches. Let's list down some
of the modifiers,
Modifier Description
Regular Expressions provided group of patterns in order to match characters. Basically they
are categorized into 3 types,
i. Brackets: These are used to find a range of characters. For example, below are some
use cases,
a. [abc]: Used to find any of the characters between the brackets(a,b,c)
b. [0-9]: Used to find any of the digits between the brackets
c. (a|b): Used to find any of the alternatives separated with |
ii. Metacharacters: These are characters with a special meaning For example, below are
some use cases,
a. \d: Used to find a digit
b. \s: Used to find a whitespace character
c. \b: Used to find a match at the beginning or ending of a word
iii. Quantifiers: These are useful to define quantities For example, below are some use
cases,
a. n+: Used to find matches for any string that contains at least one n
b. n*: Used to find matches for any string that contains zero or more
occurrences of n
c. n?: Used to find matches for any string that contains zero or one occurrences
of n
⬆ Back to Top
RegExp object is a regular expression object with predefined properties and methods. Let's
see the simple usage of RegExp object,
var regexp = new RegExp('\\w+');
console.log(regexp);
// expected output: /\w+/
⬆ Back to Top
You can use test() method of regular expression in order to search a string for a pattern, and
returns true or false depending on the result.
⬆ Back to Top
The purpose of exec method is similar to test method but it returns a founded text as an
object instead of returning true/false.
⬆ Back to Top
You can change inline style or classname of a HTML element using javascript
i. ** Using style property:** You can modify inline style using style property
document.getElementById("title").style.fontSize = "30px";
ii. ** Using ClassName property:** It is easy to modify element class using className
property
document.getElementById("title").style.className = "custom-title";
⬆ Back to Top
The output is going to be 33. Since 1 and 2 are numeric values, the result of first two digits is
going to be a numeric value 3. The next digit is a string type value because of that the
addition of numeric value 3 and string type value 3 is just going to be a concatenation
value 33.
⬆ Back to Top
The debugger statement invokes any available debugging functionality, such as setting a
breakpoint. If no debugging functionality is available, this statement has no effect. For
example, in the below function a debugger statement has been inserted. So execution is
paused at the debugger statement just like a breakpoint in the script source.
function getProfile() {
// code goes here
debugger;
// code goes here
}
⬆ Back to Top
You can set breakpoints in the javascript code once the debugger statement is executed and
debugger window pops up. At each breakpoint, javascript will stop executing, and let you
examine the JavaScript values. After examining values, you can resume the execution of code
using play button.
⬆ Back to Top
No, you cannot use the reserved words as variables, labels, object or function names. Let's
see one simple example,
⬆ Back to Top
You can use regex which returns a true or false value depending on whether or not the user
is browsing with a mobile.
window.mobilecheck = function() {
var mobileCheck = false;
(function(a){if(/(android|bb\d+|meego).+mobile|avantgo|bada\/|blackberry|blaze
r|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge
|maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm(
os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series(4|6)0|symbian|treo|up\.(brows
er|link)|vodafone|wap|windows
ce|xda|xiino/i.test(a)||/1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a
wa|abac|ac(er|oo|s\-
)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di
|\-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br(e|v)w|bumb|bw\-
(n|u)|c55\/|capi|ccwa|cdm\-|cell|chtm|cldc|cmd\-
|co(mp|nd)|craw|da(it|ll|ng)|dbte|dc\-s|devi|dica|dmob|do(c|p)o|ds(12|\-
d)|el(49|ai)|em(l2|ul)|er(ic|k0)|esl8|ez([4-7]0|os|wa|ze)|fetc|fly(\-|_)|g1
u|g560|gene|gf\-5|g\-mo|go(\.w|od)|gr(ad|un)|haie|hcit|hd\-(m|p|t)|hei\-
|hi(pt|ta)|hp( i|ip)|hs\-c|ht(c(\-| |_|a|g|p|s|t)|tp)|hu(aw|tc)|i\-
(20|go|ma)|i230|iac( |\-
|\/)|ibro|idea|ig01|ikom|im1k|inno|ipaq|iris|ja(t|v)a|jbro|jemu|jigs|kddi|keji
|kgt( |\/)|klon|kpt |kwc\-|kyo(c|k)|le(no|xi)|lg( g|\/(k|l|u)|50|54|\-[a-
w])|libw|lynx|m1\-w|m3ga|m50\/|ma(te|ui|xo)|mc(01|21|ca)|m\-
cr|me(rc|ri)|mi(o8|oa|ts)|mmef|mo(01|02|bi|de|do|t(\-| |o|v)|zz)|mt(50|p1|v
)|mwbp|mywa|n10[0-2]|n20[2-3]|n30(0|2)|n50(0|2|5)|n7(0(0|1)|10)|ne((c|m)\-
|on|tf|wf|wg|wt)|nok(6|i)|nzph|o2im|op(ti|wv)|oran|owg1|p800|pan(a|d|t)|pdxg|p
g(13|\-([1-8]|c))|phil|pire|pl(ay|uc)|pn\-2|po(ck|rt|se)|prox|psio|pt\-g|qa\-
a|qc(07|12|21|32|60|\-[2-7]|i\-
)|qtek|r380|r600|raks|rim9|ro(ve|zo)|s55\/|sa(ge|ma|mm|ms|ny|va)|sc(01|h\-
|oo|p\-)|sdk\/|se(c(\-|0|1)|47|mc|nd|ri)|sgh\-|shar|sie(\-|m)|sk\-
0|sl(45|id)|sm(al|ar|b3|it|t5)|so(ft|ny)|sp(01|h\-|v\-|v
)|sy(01|mb)|t2(18|50)|t6(00|10|18)|ta(gt|lk)|tcl\-|tdg\-|tel(i|m)|tim\-|t\-
mo|to(pl|sh)|ts(70|m\-|m3|m5)|tx\-
9|up(\.b|g1|si)|utst|v400|v750|veri|vi(rg|te)|vk(40|5[0-3]|\-
v)|vm40|voda|vulc|vx(52|53|60|61|70|80|81|83|85|98)|w3c(\-| )|webc|whit|wi(g
|nc|nw)|wmlb|wonu|x700|yas\-|your|zeto|zte\-/i.test(a.substr(0,4)))
mobileCheck = true;})(navigator.userAgent||navigator.vendor||window.opera);
return mobileCheck;
};
⬆ Back to Top
You can detect mobile browser by simply running through a list of devices and checking if
the useragent matches anything. This is an alternative solution for RegExp usage,
function detectmob() {
if( navigator.userAgent.match(/Android/i)
|| navigator.userAgent.match(/webOS/i)
|| navigator.userAgent.match(/iPhone/i)
|| navigator.userAgent.match(/iPad/i)
|| navigator.userAgent.match(/iPod/i)
|| navigator.userAgent.match(/BlackBerry/i)
|| navigator.userAgent.match(/Windows Phone/i)
){
return true;
}
else {
return false;
}
}
⬆ Back to Top
168. How do you get the image width and height using JS?
You can programmatically get the image and check the dimensions(width and height) using
Javascript.
⬆ Back to Top
Browsers provide an XMLHttpRequest object which can be used to make synchronous HTTP
requests from JavaScript
function httpGet(theUrl)
{
var xmlHttpReq = new XMLHttpRequest();
xmlHttpReq.open( "GET", theUrl, false ); // false for synchronous request
xmlHttpReq.send( null );
return xmlHttpReq.responseText;
}
⬆ Back to Top
Browsers provide an XMLHttpRequest object which can be used to make asynchronous HTTP
requests from JavaScript by passing 3rd parameter as true.
⬆ Back to Top
⬆ Back to Top
⬆ Back to Top
The conditional (ternary) operator is the only JavaScript operator that takes three operands
which acts as a shortcut for if statement.
⬆ Back to Top
Yes, you can apply chaining on conditional operator similar to if … else if … else if … else
chain. The syntax is going to be as below,
function traceValue(someParam) {
return condition1 ? value1
: condition2 ? value2
: condition3 ? value3
: value4;
}
⬆ Back to Top
175. What are the ways to execute javascript after page load?
You can execute javascript after page load in many different ways,
ii. ** window.onload:**
ii. document.onload:
<body onload="script();">
⬆ Back to Top
The __proto__ object is the actual object that is used in the lookup chain to resolve
methods, etc. Whereas prototype is the object that is used to build __proto__ when you
create an object with new
( new Employee ).__proto__ === Employee.prototype;
( new Employee ).prototype === undefined;
⬆ Back to Top
It is recommended to use semicolons after every statement in JavaScript. For example, in the
below case it throws an error ".. is not a function" at runtime due to missing semicolon.
// define a function
var fn = function () {
//...
} // semicolon missing at this line
var fn = function () {
//...
}(function () {
//...
})();
In this case, we are passing second function as an argument to the first function and then
trying to call the result of the first function call as a function. Hence, the second function will
fail with a "... is not a function" error at runtime.
⬆ Back to Top
The freeze() method is used to freeze an object. Freezing an object does'nt allow adding new
properties to an object,prevents from removing and prevents changing the enumerability,
configurability, or writability of existing properties. i.e, It returns the passed object and does
not create a frozen copy.
const obj = {
prop: 100
};
Object.freeze(obj);
obj.prop = 200; // Throws an error in strict mode
console.log(obj.prop); //100
⬆ Back to Top
⬆ Back to Top
⬆ Back to Top
You can use navigator object to detect a browser language preference as below,
console.log(language);
⬆ Back to Top
Title case means that the first letter of each word is capitalized. You can convert a string to
title case using the below function,
function toTitleCase(str) {
return str.replace(
/\w\S*/g,
function(txt) {
return txt.charAt(0).toUpperCase() +
txt.substr(1).toLowerCase();
}
);
}
toTitleCase("good morning john"); // Good Morning John
⬆ Back to Top
You can use <noscript> tag to detect javascript disabled or not. The code block
inside <noscript> get executed when JavaScript is disabled, and are typically used to display
alternative content when the page generated in JavaScript.
<script type="javascript">
// JS related code goes here
</script>
<noscript>
<a href="next_page.html?noJS=true">JavaScript is disabled in the apge.
Please click Next Page</a>
</noscript>
⬆ Back to Top
⬆ Back to Top
For example, let's take a sum example to calculate on dynamic number of parameters,
function total(…args){
let sum = 0;
for(let i of args){
sum+=i;
}
return sum;
}
console.log(fun(1,2)); //3
console.log(fun(1,2,3)); //6
console.log(fun(1,2,3,4)); //13
console.log(fun(1,2,3,4,5)); //15
⬆ Back to Top
186. What happens if you do not use rest parameter as a last
argument?
The rest parameter should be the last argument, as its job is to collect all the remaining
arguments into an array. For example, if you define a function like below it doesn’t make any
sense and will throw an error.
function someFunc(a,…b,c){
//You code goes here
return;
}
⬆ Back to Top
⬆ Back to Top
Spread operator allows iterables( arrays / objects / strings ) to be expanded into single
arguments/elements. Let's take an example to see this behavior,
function calculateSum(x, y, z) {
return x + y + z;
}
console.log(calculateSum(...numbers)); // 6
⬆ Back to Top
. If it is not extensible.
i. If all of its properties are non-configurable.
ii. If all its data properties are non-writable. The usage is going to be as follows,
const object = {
property: 'Welcome JS world'
};
Object.freeze(object);
console.log(Object.isFrozen(object));
⬆ Back to Top
190. How do you determine two values same or not using object?
The Object.is() method determines whether two values are the same value. For example, the
usage with different types of values would be,
. both undefined
i. both null
ii. both true or both false
iii. both strings of the same length with the same characters in the same order
iv. both the same object (means both object have same reference)
v. both numbers and both +0 both -0 both NaN both non-zero and both not NaN and
both have the same value.
⬆ Back to Top
You can use Object.assign() method which is used to copy the values and properties from
one or more source objects to a target object. It returns the target object which has
properties and values copied from the target object. The syntax would be as below,
Object.assign(target, ...sources)
Let's take exampple with one source and one target object,
const target = { a: 1, b: 2 };
const source = { b: 3, c: 4 };
console.log(target); // { a: 1, b: 3, c: 5 }
console.log(returnedTarget); // { a: 1, b: 3, c: 5 }
As observed in the above code, there is a common property(b) from source to target so it's
value is been overwritten.
⬆ Back to Top
⬆ Back to Top
The Proxy object is used to define custom behavior for fundamental operations such as
property lookup, assignment, enumeration, function invocation, etc. The syntax would be as
follows,
var handler = {
get: function(obj, prop) {
return prop in obj ?
obj[prop] :
100;
}
};
In the above code, it uses get handler which define the behavior of the proxy when an
operation is performed on it
⬆ Back to Top
The Object.seal() method is used seal an object, by preventing new properties from being
added to it and marking all existing properties as non-configurable. But values of present
properties can still be changed as long as they are writable. Let's see the below example to
understand more about seal() method
const object = {
property: 'Welcome JS world'
};
Object.seal(object);
object.property = 'Welcome to object world';
console.log(Object.isSealed(object)); // Welcome to object world
delete object.property; // You cannot delete when sealed
console.log(object.property); //Welcome to object world
⬆ Back to Top
⬆ Back to Top
197. What are the differences between freeze and seal methods?
If an object is frozen using the Object.freeze() method then its properties become immutable
and no changes can be made in them whereas if an object is sealed using the Object.seal()
method then the changes can be made in the existing properties of the object.
⬆ Back to Top
. If it is not extensible.
i. If all of its properties are non-configurable.
ii. If it is not removable (but not necessarily non-writable). Let's see it in the action
const object = {
property: 'Hello, Good morning'
};
⬆ Back to Top
The Object.entries() method is used to return an array of a given object's own enumerable
string-keyed property [key, value] pairs, in the same order as that provided by a for...in loop.
Let's see the functionality of object.entries() method in an example,
const object = {
a: 'Good morning',
b: 100
};
⬆ Back to Top
200. What is the main difference between Object.values and
Object.entries method?
const object = {
a: 'Good morning',
b: 100
};
⬆ Back to Top
201. How can you get the list of keys of any object?
You can use Object.keys() method which is used return an array of a given object's own
property names, in the same order as we get with a normal loop. For example, you can get
the keys of a user object,
const user = {
name: 'John',
gender: 'male',
age: 40
};
⬆ Back to Top
The Object.create() method is used to create a new object with the specified prototype object
and properties. i.e, It uses existing object as the prototype of the newly created object. It
returns a new object with the specified prototype object and properties.
const user = {
name: 'John',
printInfo: function () {
console.log(`My name is ${this.name}.`);
}
};
⬆ Back to Top
WeakSet is used to store a collection of weakly(weak references) held objects. The syntax
would be as follows,
new WeakSet([iterable]);
⬆ Back to Top
The main difference is that references to objects in Set are strong while references to objects
in WeakSet are weak. i.e, An object in WeakSet can be garbage collected if there is no other
reference to it. Other differences are,
. Sets can store any value Whereas WeakSets can store only collections of objects
i. WeakSet does not have size property unlike Set
ii. WeakSet does not have methods such as clear, keys, values, entries, forEach.
iii. WeakSet is not iterable.
⬆ Back to Top
. add(value): A new object is appended with the given value to the weakset
i. delete(value): Deletes the value from the WeakSet collection.
ii. has(value): It returns true if the value is present in the WeakSet Collection, otherwise
it returns false.
iii. length(): It returns the length of weakSetObject Let's see the functionality of all the
above methods in an example,
var weakSetObject = new WeakSet();
var firstObject = {};
var secondObject = {};
// add(value)
weakSetObject.add(firstObject);
weakSetObject.add(secondObject);
console.log(weakSetObject.has(firstObject)); //true
console.log(weakSetObject.length()); //2
weakSetObject.delete(secondObject);
⬆ Back to Top
The WeakMap object is a collection of key/value pairs in which the keys are weakly
referenced. In this case, keys must be objects and the values can be arbitrary values. The
syntax is looking like as below,
new WeakMap([iterable])
⬆ Back to Top
The main difference is that references to key objects in Map are strong while references to
key objects in WeakMap are weak. i.e, A key object in WeakMap can be garbage collected if
there is no other reference to it. Other differences are,
. Maps can store any key type Whereas WeakMaps can store only collections of key
objects
i. WeakMap does not have size property unlike Map
ii. WeakMap does not have methods such as clear, keys, values, entries, forEach.
iii. WeakMap is not iterable.
⬆ Back to Top
. set(key, value): Sets the value for the key in the WeakMap object. Returns the
WeakMap object.
i. delete(key): Removes any value associated to the key.
ii. has(key): Returns a Boolean asserting whether a value has been associated to the key
in the WeakMap object or not.
iii. get(key): Returns the value associated to the key, or undefined if there is none. Let's
see the functionality of all the above methods in an example,
⬆ Back to Top
The uneval() is an inbuilt function which is used to create a string representation of the
source code of an Object. It is a top-level function and is not associated with any object. Let's
see the below example to know more about it's functionality,
var a = 1;
uneval(a); // returns a String containing 1
uneval(function user() {}); // returns "(function user(){})"
⬆ Back to Top
The encodeURI() function is used to encode complete URI which has special characters
except (, / ? : @ & = + $ #) characters.
⬆ Back to Top
⬆ Back to Top
The window object provided print() method which is used to prints the contents of the
current window. It opens Print dialog box which lets you choose between various printing
options. Let's see the usage of print method in an example,
Note: In most browsers, it will block while the print dialog is open.
⬆ Back to Top
The uneval function returns the source of a given object; whereas the eval function does the
opposite, by evaluating that source code in a different memory area. Let's see an example to
clarify the difference,
var msg = uneval(function greeting() { return 'Hello, Good morning'; });
var greeting = eval(msg);
greeting(); // returns "Hello, Good morning"
⬆ Back to Top
function (optionalParameters) {
//do something
}
⬆ Back to Top
A local variable takes precedence over a global variable with the same name. Let's see this
behavior in an example.
⬆ Back to Top
⬆ Back to Top
217. How do you define property on Object constructor?
Object.defineProperty(newObject, 'newProperty', {
value: 100,
writable: false
});
console.log(newObject.newProperty); // 100
⬆ Back to Top
Both has similar results until unless you use classes. If you use get the property will be
defined on the prototype of the object whereas using Object.defineProperty() the
property will be defined on the instance it is applied to.
⬆ Back to Top
⬆ Back to Top
Yes, You can use Object.defineProperty() method to add Getters and Setters. For
example, the below counter object uses increment, decrement, add and substract properties,
var counterObj = {counter : 0};
// Define getters
Object.defineProperty(obj, "increment", {
get : function () {this.counter++;}
});
Object.defineProperty(obj, "decrement", {
get : function () {this.counter--;}
});
// Define setters
Object.defineProperty(obj, "add", {
set : function (value) {this.counter += value;}
});
Object.defineProperty(obj, "subtract", {
set : function (value) {this.counter -= value;}
});
obj.add = 10;
obj.subtract = 5;
console.log(obj.increment); //6
console.log(obj.decrement); //5
⬆ Back to Top
The switch case statement in JavaScript is used for decision making purposes. In few cases,
using the switch case statement is going to be more convenient than if-else statements. The
syntax would be as below,
switch (expression)
{
case value1:
statement1;
break;
case value2:
statement2;
break;
.
.
case valueN:
statementN;
break;
default:
statementDefault;
}
The above multi-way branch statement provides an easy way to dispatch execution to
different parts of code based on the value of the expression.
⬆ Back to Top
222. What are the conventions to be followed for the usage of switch
case?
⬆ Back to Top
A primitive data type is data that has a primitive value (which has no properties or methods).
There are 5 types of primitive data types.
. string
i. number
ii. boolean
iii. null
iv. undefined
⬆ Back to Top
objectName.property
ii. Square brackets notation: It uses square brackets for property access
objectName["property"]
objectName[expression]
⬆ Back to Top
iii. The function definitions do not specify data types for parameters.
iv. Do not perform type checking on the passed arguments.
v. Do not check the number of arguments received. i.e, The below function follows the
above rules,
⬆ Back to Top
An error object is a built in error object that provides error information when an error occurs.
It has two properties: name and message. For example, the below function logs error details,
try {
greeting("Welcome");
}
catch(err) {
console.log(err.name + "<br>" + err.message);
}
⬆ Back to Top
A SyntaxError is thrown if you try to evaluate code with a syntax error. For example, the
below missing quote for the function parameter throws a syntax error
try {
eval("greeting('welcome)"); // Missing ' will produce an error
}
catch(err) {
console.log(err.name);
}
⬆ Back to Top
228. What are the different error names from error object?
There are 6 different types of error names returned from error object, | Error Name |
Description | |---- | --------- | EvalError | An error has occurred in the eval() function | |
RangeError | An error has occurred with a number "out of range" | | ReferenceError | An error
due to an illegal reference| | SyntaxError | An error due to a syntax error| | TypeError | An error
due to a type error | | URIError | An error due to encodeURI() |
⬆ Back to Top
⬆ Back to Top
. Entry Controlled loops: In this kind of loop type, the test condition is tested before
entering the loop body. For example, For Loop and While Loop comes under this
category.
i. Exit Controlled Loops: In this kind of loop typpe, the test condition is tested or
evaluated at the end of loop body. i.e, the loop body will execute atleast once
irrespective of test condition true or false. For example, do-while loop comes under
this category.
⬆ Back to Top
Node.js is a server-side platform built on Chrome's JavaScript runtime for easily building fast
and scalable network applications. It is an event-based, non-blocking, asynchronous I/O
runtime that uses Google's V8 JavaScript engine and libuv library.
⬆ Back to Top
⬆ Back to Top
You can use Intl.DateTimeFormat object which is constructor for objects that enable
language-sensitive date and time formatting. Let's see this behavior with an example,
var date = new Date(Date.UTC(2019, 07, 07, 3, 0, 0));
console.log(new Intl.DateTimeFormat('en-GB').format(date)); // 07/08/2019
console.log(new Intl.DateTimeFormat('en-AU').format(date)); // 07/08/2019
⬆ Back to Top
An iterator is an object which defines a sequence and a return value upon its termination. It
implements the Iterator protocol with a next() method which returns an object with two
properties: value (the next value in the sequence) and done (which is true if the last value in
the sequence has been consumed).
⬆ Back to Top
The Event Loop is a queue of callback functions. When an async function executes, the
callback function is pushed into the queue. The JavaScript engine doesn't start processing
the event loop until async function has finished executing the code. Note: It allows Node.js
to perform non-blocking I/O operations eventhough JavaScript is single-threaded.
⬆ Back to Top
⬆ Back to Top
⬆ Back to Top
function admin(isAdmin) {
return function(target) {
target.isAdmin = isAdmin;
}
}
@admin(true)
class User() {
}
console.log(User.isAdmin); //true
@admin(false)
class User() {
}
console.log(User.isAdmin); //false
⬆ Back to Top
. Collator: These are the objects that enable language-sensitive string comparison.
i. DateTimeFormat: These are the objects that enable language-sensitive date and
time formatting.
ii. ListFormat: These are the objects that enable language-sensitive list formatting.
iii. NumberFormat: Objects that enable language-sensitive number formatting.
iv. PluralRules: Objects that enable plural-sensitive formatting and language-specific
rules for plurals.
v. RelativeTimeFormat: Objects that enable language-sensitive relative time
formatting.
⬆ Back to Top
The unary(+) operator is used to convert a variable to a number.If the variable cannot be
converted, it will still become a number but with the value NaN. Let's see this behavior in an
action.
var x = "100";
var y = + x;
console.log(typeof x, typeof y); // string, number
var a = "Hello";
var b = + a;
console.log(typeof a, typeof b, b); // string, number, NaN
⬆ Back to Top
The sort() method is used to sort the elements of an array in place and returns the sorted
array. The example usage would be as below,
⬆ Back to Top
The compareFunction is used to define the sort order. If omitted, the array elements are
converted to strings, then sorted according to each character's Unicode code point value.
Let's take an example to see the usage of compareFunction,
⬆ Back to Top
You can use reverse() method is used reverse the elements in an array. This method is useful
to sort an array in descending order. Let's see the usage of reverse() method in an example,
⬆ Back to Top
You can use Math.min and Math.max methods on array variable to find the minimum and
maximum elements with in an array. Let's create two functions to find the min and max value
with in an array,
var marks = [50, 20, 70, 60, 45, 30];
function findMin(arr) {
return Math.min.apply(null, arr);
}
function findMax(arr) {
return Math.max.apply(null, arr);
}
console.log(findMin(marks));
console.log(findMax(marks));
⬆ Back to Top
245. How do you find min and max values without Math functions?
You can write functions which loops through an array comparing each value with the lowest
value or highest value to find the min and max values. Let's create those functions to find
min an max values,
function findMax(arr) {
var length = arr.length
var max = -Infinity;
while (len--) {
if (arr[length] > max) {
max = arr[length];
}
}
return max;
}
console.log(findMin(marks));
console.log(findMax(marks));
⬆ Back to Top
The empty statement is a semicolon (;) indicating that no statement will be executed, even if
JavaScript syntax requires one. Since there is no action with an empty statement you might
think that it's usage is quite less, but the empty statement is occasionally useful when you
want to create a loop that has an empty body. For example, you can initialize an array with
zero values as below,
// Initialize an array a
for(int i=0; i < a.length; a[i++] = 0) ;
⬆ Back to Top
You can use import.meta object which is a meta-property exposing context-specific meta
data to a JavaScript module. It contains information about the current module, such as
module's URL. In browser, you might get different meta data than NodeJS.
<script type="module" src="welcome-module.js"></script>
console.log(import.meta); // { url: "file:///home/user/welcome-module.js" }
⬆ Back to Top
The comma operator is used to evaluate each of its operands from left to right and returns
the value of the last operand. This is totally different from comma usage within arrays,
objects, and function arguments and parameters. For example, the usage for numeric
expressions would be as below,
var x = 1;
x = (x++, x);
console.log(x); // 2
⬆ Back to Top
You can also use the comma operator in a return statement where it process before
returning.
function myFunction() {
var a = 1;
return (a += 10, a); // 11
}
⬆ Back to Top
document.body.innerHTML = greeting(user);
```
The greeting method allows only string type as argument.
⬆ Back to Top
⬆ Back to Top
i. TypeScript is able to find compile time errors at the development time only and it
make sures less runtime errors. Whereas javascript is interpreted language.
ii. TypeScript is is strongly-typed or supports static typing which allows for checking
type correctness at compile time. This is not available in javascript.
iii. TypeScript compiler can compile the .ts files into ES3,ES4 and ES5 unlike ES6 features
of javascript which may not be supported in some browsers.
⬆ Back to Top
An object initializer is an expression that describes the initialization of an Object. The syntax
for this expression is represented as a comma-delimited list of zero or more pairs of property
names and associated values of an object, enclosed in curly braces ({}). This is also known as
literal notation. It is one of the ways to create an object.
console.log(initObject.a); // John
⬆ Back to Top
The constructor method is a special method for creating and initializing an object created
within a class. If you do not specify a constructor method, a default constructor is used. The
example usage of constructor would be as below,
class Employee {
constructor() {
this.name = "John";
}
}
console.log(employeeObject.name); // John
⬆ Back to Top
console.log(employeeObject.name);
⬆ Back to Top
You can use super keyword to call the constructor of a parent class. Remember
that super() must be called before using 'this' reference. Otherwise it will cause a reference
error. Let's the usage of it,
class Square extends Rectangle {
constructor(length) {
super(length, length);
this.name = 'Square';
}
get area() {
return this.width * this.height;
}
set area(value) {
this.area = value;
}
}
⬆ Back to Top
You can use Object.getPrototypeOf(obj) method is used to return the prototype of the
specified object. i.e. The value of the internal prototype property. If there are no inherited
properties then null value is returned.
const newPrototype = {};
const newObject = Object.create(newPrototype);
In ES5, it will throw a TypeError exception if the obj parameter isn't an object. Whereas in
ES2015, the parameter will be coerced to an Object.
// ES5
Object.getPrototypeOf('James'); // TypeError: "James" is not an object
// ES2015
Object.getPrototypeOf('James'); // String.prototype
⬆ Back to Top
You can use Object.setPrototypeOf() method that sets the prototype (i.e., the
internal Prototype property) of a specified object to another object or null. For example, if
you want to set prototype of a square object to rectangle object would be as follows,
Object.setPrototypeOf(Square.prototype, Rectangle.prototype);
Object.setPrototypeOf({}, null);
⬆ Back to Top
Note: By default, all the objects are extendable. i.e, The new properties can added or
modified.
⬆ Back to Top
try {
Object.defineProperty(newObject, 'newProperty', { // Adding new property
value: 100
});
} catch (e) {
console.log(e); // TypeError: Cannot define property newProperty, object is
not extensible
}
⬆ Back to Top
i. Object.preventExtensions
ii. Object.seal
iii. Object.freeze
⬆ Back to Top
Object.defineProperties(newObject, {
newProperty1: {
value: 'John',
writable: true
},
newProperty2: {}
});
⬆ Back to Top
⬆ Back to Top
function greeeting() {
console.log('Hello, welcome to JS world');
}
eval(function(p,a,c,k,e,d){e=function(c){return
c};if(!''.replace(/^/,String)){while(c--){d[c]=k[c]||c}k=[function(e){return
d[e]}];e=function(){return'\\w+'};c=1};while(c--){if(k[c]){p=p.replace(new
RegExp('\\b'+e(c)+'\\b','g'),k[c])}}return p}('2 1(){0.3(\'4, 7 6 5
8\')}',9,9,'console|greeeting|function|log|Hello|JS|to|welcome|world'.split('|
'),0,{}))
⬆ Back to Top
i. The Code size will be reduced. So data transfers between server and client will be
fast.
ii. It hides the business logic from outside world and protects the code from others
iii. Reverse engineering is highly difficult
iv. The download time will be reduced
⬆ Back to Top
Normally it is recommend to use minification for heavy traffic and intensive requirements of
resources. It reduces file sizes with below benefits,
⬆ Back to Top
Changing the form of any data in any Changing the form of information to a
Definition
other form using a key
Target data
It will be converted to a complex form Converted into an unreadable format
format
⬆ Back to Top
⬆ Back to Top
271. How do you perform form validation using javascript?
JavaScript can be used to perform HTML form validation. For example, if form field is empty,
the function needs to notify, and return false, to prevent the form being submitted. Lets'
perform user login in an html form,
function validateForm() {
var x = document.forms["myForm"]["uname"].value;
if (x == "") {
alert("The username shouldn't be empty");
return false;
}
}
⬆ Back to Top
You can perform HTML form validation automatically without using javascript. The validation
enabled by applying required attribute to prevent form submission when the input is empty.
<form method="post">
<input type="text" name="uname" required>
<input type="submit" value="Submit">
</form>
Note: Automatic form validation does not work in Internet Explorer 9 or earlier.
⬆ Back to Top
273. What are the DOM methods available for constraint validation?
The below DOM methods are available for constraint validation on an invalid input,
function myFunction() {
var userName = document.getElementById("uname");
if (!userName.checkValidity()) {
document.getElementById("message").innerHTML = userName.validationMessage;
} else {
document.getElementById("message").innerHTML = "Entered a valid username";
}
}
⬆ Back to Top
Below are the list of some of the constraint validation DOM properties available,
⬆ Back to Top
The validity property of an input element provides a set of properties related to the validity
of data.
⬆ Back to Top
If an element's value is greater than its max attribute then rangeOverflow property returns
true. For example, the below form submission throws an error if the value is more than 100,
⬆ Back to Top
No, javascript does not natively support enums. But there are different kind of solutions to
simulate them even though they may not provide exact equivalent. For example, you can use
freeze or seal on object,
⬆ Back to Top
An enum is a type restricting variables to one value from a predefined set of constants.
JavaScript has no enums but typescript provides built-in enum support.
enum Color {
RED, GREEN, BLUE
}
⬆ Back to Top
⬆ Back to Top
You can use Object.getOwnPropertyDescriptors() method which returns all own property
descriptors of a given object. The example usage of this method is below,
const newObject = {
a: 1,
b: 2,
c: 3
};
const descriptorsObject = Object.getOwnPropertyDescriptors(newObject);
console.log(descriptorsObject.a.writable); //true
console.log(descriptorsObject.a.configurable); //true
console.log(descriptorsObject.a.enumerable); //true
console.log(descriptorsObject.a.value); // 1
⬆ Back to Top
⬆ Back to Top
get area() {
return this.width * this.height;
}
set area(value) {
this.area = value;
}
}
⬆ Back to Top
The window.localtion.url property will be helpful to modify the url but it reloads the page.
HTML5 introduced the history.pushState() and history.replaceState() methods, which
allow you to add and modify history entries, respectively. For example, you can use pushState
as below,
window.history.pushState('page2', 'Title', '/page2.html');
⬆ Back to Top
⬆ Back to Top
You can use length and every methods of arrays to compare two scalar(compared directly
using ===) arrays. The combination of these expressions can give the expected result,
If you would like to compare arrays irrespective of order then you should sort them before,
The new URL() object accepts url string and searchParams property of this object can be
used to access the get parameters. Remember that you may need to use polyfill
or window.location to access the URL in older browsers(including IE).
let urlString = "http://www.some-domain.com/about.html?x=1&y=2&z=3";
//window.location.href
let url = new URL(urlString);
let parameterZ = url.searchParams.get("z");
console.log(parameterZ); // 3
⬆ Back to Top
console.log(convertToThousandFormat(12345.6789));
⬆ Back to Top
Both are totally unrelated programming languages and no relation between them. Java is
statically typed, compiled, runs on its own VM. Whereas Javascript is dynamically typed,
interpreted, and runs in a browser and nodejs environments. Let's see the major differences
in a tabular format, | Feature | Java | JavaScript | |---- | --------- | Typed | It's a strongly typed
language | It's a dynamic typed language | | Paradigm | Object oriented programming |
Prototype based programming | | Scoping | Block scoped | Function-scoped | | Concurrency |
Thread based | event based | | Memory | Uses more memory | Uses less memory. Hence it will
be used for web pages |
⬆ Back to Top
}
function func1() {
console.log("This is a second definition");
}
func1(); // This is a second definition
It always calls the second function definition. In this case, namespace will solve the name
collision problem.
⬆ Back to Top
Even though JavaScript lack namespaces, we can use Objects , IIFE to create namespaces.
i. Using Object Literal Notation: Let's wrap variables and function inside Object literal
which act as a namespace. After that you can access them using object notation
var namespaceOne = {
function func1() {
console.log("This is a first definition");
}
}
var namespaceTwo = {
function func1() {
console.log("This is a second definition");
}
}
namespaceOne.func1(); // This is a first definition
namespaceTwo.func1(); // This is a second definition
ii. Using IIFE (Immediately invoked function expression): The outer pair of
parenthesis of IIFE creates a local scope for all the code inside of it and makes the
anonymous function a function expression. Due to that, you can create same function
in two different function expressions to act as namespace.
(function() {
function fun1(){
console.log("This is a first definition");
} fun1();
}());
(function() {
function fun1(){
console.log("This is a second definition");
} fun1();
}());
iii. Using a block and a let/const declaration: In ECMAScript 6, you can simply use a
block and a let declaration to restrict the scope of a variable to a block.
{
let myFunction= function fun1(){
console.log("This is a first definition");
}
myFunction();
}
//myFunction(): ReferenceError: myFunction is not defined.
{
let myFunction= function fun1(){
console.log("This is a second definition");
}
myFunction();
}
//myFunction(): ReferenceError: myFunction is not defined.
⬆ Back to Top
⬆ Back to Top
You can use getTimezoneOffset method of date object. This method returns the time zone
difference, in minutes, from current locale (host system settings) to UTC
var offset = new Date().getTimezoneOffset();
console.log(offset); // -480
⬆ Back to Top
You can create both link and script elements in the DOM and append them as child to head
tag. Let's create a function to add script and style resources as below,
⬆ Back to Top
294. What are the different methods to find HTML elements in DOM?
If you want to access any element in an HTML page, you need to start with accessing the
document object. Later you can use any of the below methods to find the HTML element,
⬆ Back to Top
jQuery is a popular cross-browser JavaScript library that provides Document Object Model
(DOM) traversal, event handling, animations and AJAX interactions by minimizing the
discrepancies across browsers. It is widely famous with its philosophy of “Write less, do
more”. For example, you can display welcome message on the page load using jQuery as
below,
Note: You can download it from jquery official site or install it from CDNs, like google.
⬆ Back to Top
⬆ Back to Top
JavaScript is a loosely typed or a dynamic language because variables in JavaScript are not
directly associated with any particular value type, and any variable can be assigned/re-
assigned with values of all types.
⬆ Back to Top
The void operator evaluates the given expression and then returns undefined(i.e, without
returning value). The syntax would be as below,
void (expression)
void expression
Note: This operator is often used to obtain the undefined primitive value, using "void(0)".
⬆ Back to Top
The cursor can be set to wait in JavaScript by using the property "cursor". Let's perform this
behavior on page load using the below function.
function myFunction() {
window.document.body.style.cursor = "wait";
}
<body onload="myFunction()">
⬆ Back to Top
300. How do you create an infinite loop?
You can create infinite loop using for and while loops without using any expressions. The for
loop construct or syntax is better approach in terms of ESLint and code optimizer tools,
for (;;) {}
while(true) {
}
⬆ Back to Top
JavaScript's with statement was intended to provide a shorthand for writing recurring
accesses to objects. So it can help reduce file size by reducing the need to repeat a lengthy
object reference without performance penalty. Let's take an example where it is used to
avoid redundancy when accessing an object several times.
a.b.c.greeting = 'welcome';
a.b.c.age = 32;
But this with statement creates performance problems since one cannot predict whether
argument will refer to a real variable or to a property inside the with argument.
⬆ Back to Top
The output of the above for loops is 4 4 4 4 and 0 1 2 3 Explanation: Due to event loop of
javascript, the setTimeout callback function is called after the loop has been executed. Since
the variable i is declared with var keyword it became a global variable and the value was
equal to 4 using iteration when the time setTimeout function is invoked. Hence, the output of
the first loop is 4 4 4 4. Whereas in the second loop, the variable i is declared
as let keyword it became a block scoped variable and it holds a new value(0, 1 ,2 3) for each
iteration. Hence, the output of the first loop is 0 1 2 3.
⬆ Back to Top
⬆ Back to Top
ES6 is the sixth edition of the javascript language and it was released on June 2015. It was
initially known as ECMAScript 6 (ES6) and later renamed to ECMAScript 2015. Almost all the
modern browsers support ES6 but for the old browsers there are many transpilers, like
Babel.js etc.
⬆ Back to Top
No, you cannot redeclare let and const variables. If you do, it throws below error
Explanation: The variable declaration with var keyword refers to a function scope and the
variable is treated as if it were declared at the top of the enclosing scope due to hoisting
feature. So all the multiple declarations contributing to the same hoisted variable without any
error. Let's take an example of re-declaring variables in the same scope for both var and
let/const variables.
var name = 'John';
function myFunc() {
var name = 'Nick';
var name = 'Abraham'; // Re-assigned in the same function block
alert(name); // Abraham
}
myFunc();
alert(name); // John
myFunc();
alert(name);
⬆ Back to Top
No, the const variable doesn't make the value immutable. But it disallows subsequent
assignments(i.e, You can declare with assignment but can't assign another value later)
⬆ Back to Top
//ES5
var calculateArea = function(height, width) {
height = height || 50;
width = width || 60;
//ES6
var calculateArea = function(height = 50, width = 60) {
return width * height;
}
console.log(calculateArea()); //300
⬆ Back to Top
Template literals or template strings are string literals allowing embedded expressions. These
are enclosed by the back-tick ( ) character instead of double or single quotes. In E6, this
feature enables using dynamic expressions as below,
var greeting = `Welcome to JS World, Mr. ${firstName} ${lastName}.`
var greeting = 'Welcome to JS World, Mr. ' + firstName + ' ' + lastName.`
Note: You can use multi-line strings and string interpolation features with template literals.
⬆ Back to Top
In ES5, you would have to use newline escape character('\n') and concatenation symbol(+) in
order to get multi-line strings.
Whereas in ES6, You don't need to mention any newline sequence character,
⬆ Back to Top
The nesting templates is a feature supported with in template literals syntax to allow inner
backticks inside a placeholder ${ } within the template. For example, the below nesting
template is used to display the icons based on user permissions whereas outer template
checks for platform type,
⬆ Back to Top
Tagged templates are the advanced form of templates in which tags allow you to parse
template literals with a function. The tag function accepts first parameter as array of strings
and remaining parameters as expressions. This function can also return manipulated string
based on parameters. Let's see the usage of this tagged template behavior of an IT
professional skill set in an organization,
var expertiseStr;
if (experienceExp > 10){
expertiseStr = 'expert developer';
} else if(skillExp > 5 && skillExp <= 10) {
expertiseStr = 'senior developer';
} else {
expertiseStr = 'junior developer';
}
return `${str0}${userExp}${str1}${experienceExp}{str3}`;
}
⬆ Back to Top
318. What are raw strings?
ES6 provides raw strings feature using String.raw() method which is used to get the raw
string form of template strings. This feature allows you to access the raw strings as they were
entered, without processing escape sequences. For example, the usage would be as below,
var calculationString = String.raw `The sum of numbers is \n${1+2+3+4}!`;
console.log(calculationString); // The sum of numbers is 10
If you don't use raw strings, the newline character sequence will be processed by displaying
the output in multiple lines
Also, the raw property is available on the first argument to the tag function
function tag(strings) {
console.log(strings.raw[0]);
}
⬆ Back to Top
console.log(one); // "JAN"
console.log(two); // "FEB"
console.log(three); // "MARCH"
and you can get user properties of an object using destructuring assignment,
console.log(name); // John
console.log(age); // 32
⬆ Back to Top
A variable can be assigned a default value when the value unpacked from the array or object
is undefined during destructuring assignment. It helps to avoid setting default values
separately for each assignment. Let's take an example for both arrays and object
usecases, Arrays destructuring:
var x, y, z;
Objects destructuring:
console.log(x); // 10
console.log(y); // 4
console.log(z); // 6
⬆ Back to Top
If you don't use destructuring assignment, swapping two values requires a temporary
variable. Whereas using destructuring feature, two variables values can be swapped in one
destructuring expression. Let's swap two number variables in array destructuring assignment,
⬆ Back to Top
Object literals make it easy to quickly create objects with properties inside the curly braces.
For example, it provides shorter syntax for common object property definition as below.
//ES6
var x = 10, y = 20
obj = { x, y }
console.log(obj); // {x: 10, y:20}
//ES5
var x = 10, y = 20
obj = { x : x, y : y}
console.log(obj); // {x: 10, y:20}
⬆ Back to Top
323. What are dynamic imports?
The dynamic imports using import() function syntax allows us to load modules on demand
by using promises or the async/await syntax. Currently this features is in stage4
proposal(https://github.com/tc39/proposal-dynamic-import). The main advantage of
dynamic imports is reduction of our bundle's sizes, the size/payload response of our requests
and overall improvements in the user experience. The syntax of dynamic imports would be as
below,
import('./Module').then(Module => Module.method());
⬆ Back to Top
Below are some of the use cases of using dynamic imports over static imports,
if (isLegacyBrowser()) {
import(···)
.then(···);
}
ii. Compute the module specifier at runtime. For example, you can use it for
internationalization.
import(`messages_${getLocale()}.js`).then(···);
⬆ Back to Top
Typed arrays are array-like objects from ECMAScript 6 API for handling binary data.
JavaScript provides 8 Typed array types,
For example, you can create an array of 8-bit signed integers as below
⬆ Back to Top
. Dynamic loading
i. State isolation
ii. Global namespace isolation
iii. Compilation hooks
iv. Nested virtualization
⬆ Back to Top
Collation is used for sorting a set of strings and searching within a set of strings. It is
parameterized by locale and aware of Unicode. Let's take comparision and sorting features,
. Comparison:
var list = [ "ä", "a", "z" ]; // In German, "ä" sorts with "a" Whereas in
Swedish, "ä" sorts after "z"
var l10nDE = new Intl.Collator("de");
var l10nSV = new Intl.Collator("sv");
console.log(l10nDE.compare("ä", "z") === -1); // true
console.log(l10nSV.compare("ä", "z") === +1); // true
ii. Sorting:
var list = [ "ä", "a", "z" ]; // In German, "ä" sorts with "a" Whereas in
Swedish, "ä" sorts after "z"
var l10nDE = new Intl.Collator("de");
var l10nSV = new Intl.Collator("sv");
console.log(list.sort(l10nDE.compare)) // [ "a", "ä", "z" ]
console.log(list.sort(l10nSV.compare)) // [ "a", "z", "ä" ]
⬆ Back to Top
328. What is for...of statement?
The for...of statement creates a loop iterating over iterable objects or elements such as built-
in String, Array, Array-like objects (like arguments or NodeList), TypedArray, Map, Set, and
user-defined iterables. The basic usage of for...of statement on arrays would be as below,
⬆ Back to Top
The output of the array is ['J', 'o', 'h', 'n', '', 'R', 'e', 's', 'i', 'g'] Explanation: The string is an
iterable type and the spread operator with in an array maps every character of an iterable to
one element. Hence, each character of a string becomes an element within an Array.
⬆ Back to Top
⬆ Back to Top
The second argument of postMessage method specifies which origin is allowed to receive
the message. If you use the wildcard “*” as an argument then any origin is allowed to receive
the message. In this case, there is no way for the sender window to know if the target
window is at the target origin when sending the message. If the target window has been
navigated to another origin, the other origin would receive the data. Hence, this may lead to
XSS vulnerabilities.
targetWindow.postMessage(message, '*');
⬆ Back to Top
332. How do you avoid receiving postMessages from attackers?
Since the listener listens for any message, an attacker can trick the application by sending a
message from the attacker’s origin, which gives an impression that the receiver received the
message from the actual sender’s window. You can avoid this issue by validating the origin of
the message on the receiver's end using “message.origin” attribute. For examples, let's check
the sender's origin(http://www.some-sender.com) on receiver side(www.some-receiver.com),
//Listener on http://www.some-receiver.com/
window.addEventListener("message", function(message){
if(/^http://www\.some-sender\.com$/.test(message.origin)){
console.log('You recieved the data from valid sender', message.data);
}
});
⬆ Back to Top
You cannot avoid using postMessages completely(or 100%). Even though your application
doesn’t use postMessage considering the risks, a lot of third party scripts use postMessage
to communicate with the third party service. So your application might be using
postMessage without your knowledge.
⬆ Back to Top
The postMessages are synchronous in IE8 browser but they are asynchronous in IE9 and all
other modern browsers (i.e, IE9+, Firefox, Chrome, Safari).Due to this asynchronous
behaviour, we use a callback mechanism when the postMessage is returned.
⬆ Back to Top
⬆ Back to Top
Internal JavaScript: It is the source code with in the script tag. External JavaScript: The
source code is stored in an external file(stored with .js extension) and referred with in the tag.
⬆ Back to Top
Yes, JavaScript is than server side script. Because JavaScript is a client-side script it does
require any web server’s help for its computation or calculation. So JavaScript is always faster
than any server-side script like ASP, PHP, etc.
⬆ Back to Top
You can apply checked property on selected checkbox in the DOM. If the value
is True means the checkbox is checked otherwise it is unchecked. For example, the below
HTML checkbox element can be access using javascript as below,
<input type="checkbox" name="checkboxname" value="Agree"> Agree the
conditions<br>
⬆ Back to Top
The double tilde operator(~~) is known as double NOT bitwise operator. This operator is
going to be a quicker substitute for Math.floor().
⬆ Back to Top
⬆ Back to Top
An ArrayBuffer object is used to represent a generic, fixed-length raw binary data buffer. You
can create it as below,
⬆ Back to Top
The output of the above expression is "W". Explanation: The bracket notation with specific
index on a string returns the character at a specific location. Hence, it returns character "W"
of the string. Since this is not supported in IE7 and below versions, you may need to use
.charAt() method to get the desired result.
⬆ Back to Top
The Error constructor creates an error object and the instances of error objects are thrown
when runtime errors occur. The Error object can also be used as a base object for user-
defined exceptions. The syntax of error object would be as below,
You can throw user defined exceptions or errors using Error object in try...catch block as
below,
try {
if(withdraw > balance)
throw new Error('Oops! You don't have enough balance');
} catch (e) {
console.log(e.name + ': ' + e.message);
}
⬆ Back to Top
The EvalError object indicates an error regarding the global eval() function. Even though
this exception is not thrown by JavaScript anymore, the EvalError object remains for
compatibility. The syntax of this expression would be as below,
new EvalError([message[, fileName[, lineNumber]]])
⬆ Back to Top
345. What are the list of cases error thrown from non-strict mode to
strict mode?
When you apply 'use strict'; syntax, some of the below cases will throw a SyntaxError before
executing the script
var n = 022;
Hence, the errors from above cases helpful to avoid errors in development/production
environments.
⬆ Back to Top
No. All objects have prototypes except for the base object which is created by the user, or an
object that is created using the new keyword.
⬆ Back to Top
Parameter is the variable name of a function definition whereas an argument represent the
value given to a function when it is invoked. Let's explain this with a simple function
⬆ Back to Top
The some() method is used to test whether at least one element in the array passes the test
implemented by the provided function. The method returns a boolean value. Let's take an
example to test for any odd elements,
⬆ Back to Top
The concat() method is used to join two or more arrays by returning a new array containing
all the elements. The syntax would be as below,
Let's take an example of array's concatenation with veggies and fruits arrays,
⬆ Back to Top
Shallow Copy
Shallow copy is a bit-wise copy of an object. A new object is created that has an exact copy
of the values in the original object. If any of the fields of the object are references to other
objects, just the reference addresses are copied i.e., only the memory address is copied.
Example
var empDetails = {
name: "John", age: 25, expertise: "Software Developer"
}
to create a duplicate
empDetailsShallowCopy.name = "Johnson"
The above statement will also change the name of empDetails, since we have a shallow
copy. That means we're loosing the original data as well.
Deep copy
A deep copy copies all fields, and makes copies of dynamically allocated memory pointed to
by the fields. A deep copy occurs when an object is copied along with the objects to which it
refers.
Example
var empDetails = {
name: "John", age: 25, expertise: "Software Developer"
}
Create a deep copy by using the properties from the original object into new variable
var empDetailsDeepCopy = {
name: empDetails.name,
age: empDetails.age,
expertise: empDetails.expertise
}
Now if you change empDetailsDeepCopy.name, it will only affect empDetailsDeepCopy &
not empDetails
⬆ Back to Top
The repeat() method is used to construct and returns a new string which contains the
specified number of copies of the string on which it was called, concatenated together.
Remember that this method has been added to the ECMAScript 2015 specification. Let's take
an example of Hello string to repeat it 4 times,
'Hello'.repeat(4); // 'HelloHelloHelloHello'
352. How do you return all matching strings against a regular
expression?
The matchAll() method can be used to return an iterator of all results matching a string
against a regular expression. For example, the below example returns an array of matching
string results against a regular expression,
let regexp = /Hello(\d?))/g;
let greeting = 'Hello1Hello2Hello3';
console.log(greetingList[0]); //Hello1
console.log(greetingList[1]); //Hello2
console.log(greetingList[2]); //Hello3
353. ?
354. ?
355. ?
356. ?