JavaScript Interview: What’s the difference between undefined and not defined in JavaScript

In JavaScript if you try to use a variable that doesn’t exist and has not been declared, then JavaScript will throw an error var name is not defined and the script will stop executing thereafter. But If you use typeof undeclared_variable then it will return undefined.

Before starting further discussion let’s understand the difference between declaration and definition.

var x is a declaration because we are not defining what value it holds yet, but we are declaring its existence and the need for memory allocation.

var x; // declaring x
console.log(x); // output: undefined

var x = 1 is both declaration and definition, here declaration and assignment of value happen inline for variable x—what we are doing is called “initialisation”. In JavaScript both variable declarations and function declarations go to the top of the scope in which they are declared, then assignment happens—this series of events is called “hoisting”.

A variable can be declared but not defined. When we try to access it, It will result undefined.

var x; // Declaration
typeof x === 'undefined'; // Will return true

A variable can be neither declared nor defined. When we try to reference such variable then the result will be not defined.

console.log(y); // Output: ReferenceError: y is not defined

For which value of x the results of the following statements are not the same?

if( x <= 100 ) {…} if( !(x > 100) ) {…}

NaN <= 100 is false and NaN > 100 is also false, so if the
value of x is NaN, the statements are not the same.

The same holds true for any value of x that being converted to type Number, returns NaN, e.g.: undefined, [1,2,5], {a:22} , etc.

This is why you need to pay attention when you deal with numeric variables. NaN can’t be equal, less than or more than any other numeric value, so the only reliable way to check if the value is NaN, is to use the isNaN() function.

JavaScript Interview: What is the drawback of declaring methods directly in JavaScript objects?

One of the drawbacks of declaring methods directly in JavaScript objects is that they are very memory inefficient. When you do that, a new copy of the method is created for each instance of an object. Here’s an example:

var Employee = function (name, company, salary) {
this.name = name || "";
this.company = company || "";
this.salary = salary || 5000;

// We can create a method like this:
this.formatSalary = function () {
return "$ " + this.salary;
};
};

// Alternatively we can add the method to Employee's prototype:
Employee.prototype.formatSalary2 = function() {
return "$ " + this.salary;
}

//creating objects
var emp1 = new Employee('john Doe', 'Company 1', 1000000);
var emp2 = new Employee('john Doe 2', 'Company 2', 1039999);
var emp3 = new Employee('john Doe 3', 'Company 3', 1299483);

In this case each instance variable emp1, emp2, emp3 has its own copy of theformatSalary method. However the formatSalary2 will only be added once to Employee.prototype.

JavaScript Interview: What is “closure” in javascript? Can you provide an example?

A closure is a function defined inside another function (called parent function) and as such it has access to the variables declared and defined within its parent function’s scope.

The closure has access to the variables in three scopes:

  • Variable declared in its own scope
  • Variable declared in its parent function’s scope
  • Variable declared in the global namespace

var globalVar = "abc"; //Global variable

// Parent self-invoking function
(function outerFunction (outerArg) { // start of outerFunction's scope

var outerFuncVar = 'x'; // Variable declared in outerFunction's function scope

// Closure self-invoking function
(function innerFunction (innerArg) { // start of innerFunction’s scope

var globalVar = "abc"; //Global variable

// Parent self-invoking function
(function outerFunction (outerArg) { // start of outerFunction's scope

  var outerFuncVar = 'x'; // Variable declared in outerFunction's function scope   
  
  // Closure self-invoking function
  (function innerFunction (innerArg) { // start of innerFunction's scope

    var innerFuncVar = "y"; // variable declared in innerFunction's function scope
    console.log(         
      "outerArg = " + outerArg + "\n" +
      "outerFuncVar = " + outerFuncVar + "\n" +
      "innerArg = " + innerArg + "\n" +
      "innerFuncVar = " + innerFuncVar + "\n" +
      "globalVar = " + globalVar);
  	
  // end of innerFunction's scope
  
  })(5); // Pass 5 as parameter to our Closure

// end of outerFunction's scope

})(7); // Pass 7 as parameter to the Parent function

innerFunction is a closure which is defined inside outerFunction and consequently has access to all the variables which have been declared and defined within outerFunction‘s scope as well as any variables residing in the program’s global scope.

The output of the code above would be:

outerArg = 7
outerFuncVar = x
innerArg = 5
innerFuncVar = y
globalVar = abc

JavaScript Interview: Write a mul function which will work properly when invoked with following syntax.


console.log(mul(2)(3)(4)); // output : 24
console.log(mul(4)(3)(4)); // output : 48

function mul (x) {
return function (y) { // anonymous function
return function (z) { // anonymous function
return x * y * z;
};
};
}

Here the mul function accepts the first argument and returns an anonymous function which then takes the second parameter and returns one last anonymous function which finally takes the third and final parameter; the last function then multiplies x, y and z, and returns the result of the operation.

In Javascript, a function defined inside another function has access to the outer function’s scope and can consequently return, interact with or pass on to other functions, the variables belonging to the scopes that incapsulate it.

  • A function is an instance of the Object type
  • A function can have properties and has a link to its constructor method
  • A function can be stored as a variable
  • A function can be passed as a parameter to another function
  • A function can be returned by another function

JavaScript Interview: How to empty an array in JavaScript?

For instance:

var arrayList = [‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’];

How can we empty the array above?
There are a couple of ways by which we can empty an array, So let’s discuss all the possible way by which we can empty an array.

Method 1

arrayList = []

The code above will set the variable arrayList to a new empty array. This is recommended if you don’t have references to the original array arrayList anywhere else because It will actually create a new empty array. You should be careful with this way of empty the array, because if you have referenced this array from another variable, then the original reference array will remain unchanged, Only use this way if you have only referenced the array by its original variable arrayList.

For instance:

var arrayList = ['a', 'b', 'c', 'd', 'e', 'f']; // Created array
var anotherArrayList = arrayList; // Referenced arrayList by another variable
arrayList = []; // Empty the array
console.log(anotherArrayList); // Output ['a', 'b', 'c', 'd', 'e', 'f']

Method 2

arrayList.length = 0;

The code above will clear the existing array by setting its length to 0. This way of emptying an array will also update all the reference variables that point to the original array.

For instance:

var arrayList = [‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’]; // Created array
var anotherArrayList = arrayList; // Referenced arrayList by another variable
arrayList.length = 0; // Empty the array by setting length to 0
console.log(anotherArrayList); // Output []

Method 3

arrayList.splice(0, arrayList.length);

Above implementation will also work perfectly. This way of empty the array will also update all the references of the original array.

var arrayList = ['a', 'b', 'c', 'd', 'e', 'f']; // Created array
var anotherArrayList = arrayList; // Referenced arrayList by another variable
arrayList.splice(0, arrayList.length); // Empty the array by setting length to 0
console.log(anotherArrayList); // Output []

Method 4

while(arrayList.length) {
arrayList.pop();
}

Above implementation can also empty the array. But not recommended to use often.

JavaScript Interview: How to check if an object is an array or not?

The best way to find whether an object is instance of a particular class or not using toString method from Object.prototype

var arrayList = [1 , 2, 3];

One of the best use cases of type checking of an object is when we do method overloading in JavaScript. To understand this, let’s say we have a method called greet which can take a single string and also a list of strings. To make our greet method workable in both situation we need to know what kind of parameter is being passed: is it single value or list of values?

function greet(param) {
if() {
// here have to check whether param is array or not
}
else {
}
}

However, in the above implementation it might not necessary to check the type of the array, we can check for single value string and put array logic code in else block, let see below code for the same.


function greet(param) {
if(typeof param === 'string') {
}
else {
// If param is of type array then this block of code would execute
}
}

Now it’s fine we can go with the previous two implementations, but when we have a situation like a parameter can be single value, array, and object type then we will be in trouble.

Coming back to checking the type of an object, As we mentioned that we can use Object.prototype.toString

if(Object.prototype.toString.call(arrayList) === '[object Array]') {
console.log('Array!');
}

If you are using jQuery then you can also used jQuery isArray method:

if($.isArray(arrayList)) {
console.log('Array');
} else {
console.log('Not an array');
}

FYI jQuery uses Object.prototype.toString.call internally to check whether an object is an array or not.

In modern browser, you can also use:

Array.isArray(arrayList);

Array.isArray is supported by Chrome 5, Firefox 4.0, IE 9, Opera 10.5 and Safari 5

What is undefined x 1 in JavaScript

var trees = [“redwood”, “bay”, “cedar”, “oak”, “maple”];
delete trees[3];

  • When you run the code above and do console.log(trees); in chrome developer console then you will get ["redwood", "bay", "cedar", undefined × 1, "maple"].
  • In the recent versions of Chrome you will see the word empty of undefined x 1.
  • When you run the same code in Firefox browser console then you will get ["redwood", "bay", "cedar", undefined, "maple"]

Clearly we can see that Chrome has its own way of displaying uninitialized index in arrays. However when you check trees[3] === undefined in any browser you will get similar output as true.

Note: Please remember that you need not check for the uninitialized index of the array in trees[3] === 'undefined × 1' it will give an error because 'undefined × 1' this is just way of displaying an uninitialized index of an array in chrome.

Some of reference:

Check our interview blog

Leave a Reply

Your email address will not be published. Required fields are marked *

five × four =

Web.com Site Builder Coral Draw - thewpstarter