JavaScript

Question 1

Explain prototypes in JavaScript.

Answer 1

When you call any property on any JavaScript object, the interpreter will first look for that property in the object itself. If it does not find it there, it will look in the object’s prototype (which is pointed to by the object’s internal __proto__ property).

If it does not find the property in the prototype, it will recursively look at the prototype’s __proto__ property to continue up the prototype chain. How does the chain stop? Object.prototype.__proto__ == *null, so eventually the chain ends.

Question 2

Explain closures

Answer 2

Closure allows a function to access variables from an enclosing scope — environment — even after it leaves the scope in which it was declared. Closures allow for factory functions.

function dwightJob(title) {
    return function(prefix) {
        return prefix + ' ' + title;
    };
}

var sales = dwightJob('Salesman');
var manager = dwightJob('Manager');

alert(sales(‘Top’)); // Top Salesman

Question 3

Explain Context

Answer 3

Refers to how a function is invoked, and refers to ‘this’.

Question 4

Explain scope

Answer 4

visibility of variables.

Question 5

Explain call, apply, bind

Answer 5

All 3 are used to attach ‘this’ into function

var say = function(greeting){
    alert(greeting + ', ' + this.name);
};
//person1 becomes 'this'
say.call(person1, 'Hello');

1) call is used list of argument
2) apply is for array of arguments
3) bind returns a new function, with a certain context and parameters. It is usually used when you want a function to be called later with a certain context.

const Snow = {surename: 'Snow'}
const char = {
  surename: 'Stark',
  knows: function(arg, name) {
    console.log(`You know ${arg}, ${name} ${this.surename}`);}
  }
const whoKnowsNothing = char.knows.bind(Snow, 'nothing');
whoKnowsNothing('Jon');  // You know nothing, Jon Snow

Question 6

Explain EventLoop

Answer 6

JavaScript is single-threaded. Functions are processed using a callstack. Async functions need to be processed a little bit differently. JavaScript moves Async functions to a task-queue and from there it sits until the entire callstack is empty. Then JS dequeues and processes the async functions.
Pros: Non-blocking. Browser doesn’t freeze while events are processing.

Question 7

Function Declaration vs Function Expression?

Answer 7

Function Expression:
var myFunction = function name {
statements
};

Function Declaration:
function sum (a,b){
 return  a + b;
}

Expression allows for annonymous functions to exist. Pros: Can be used as IIFE

Question 8

What is this in JS? What are some common pitfalls with this?

Answer 8

‘this’ refers to the current context. In the global scope, this refers to the window. ‘this’ can also reference the context inside a function or object.

Question 9

== vs. ===

Answer 9

== is equality with co-ersion. === checks for strict equality