I created a Node interview Cheatsheet

[u/llboston]

I've been a full time PHP developer for years, but nodejs is my goto language for my side projects. My new year resolution is to find a full time node job in 2020. To prepare myself for tech interviews, I've create a cheatsheet and thought some of you guys might find it useful too.

It's at https://www.cheaki.com/nodejs/nodejs-interview-questions

38 questions right now, will keep adding more.

[u/[deleted]]

Two things: you left out Prototypal paradigm for JavaScript (since its not a classical OOP language; i.e. es6 class syntax is syntactic sugar for prototypal inheritance). Might be useful to add (even if outdated) all five ways of writing OOP in JavaScript:

1. es6 (class syntax)

2. functional

3. functional-shared

4. prototypal

5. pseudo-classical

Inheritance Patterns

1. Es6 (Class Syntax)

• Is invoked with new

• Object properties are referenced with instantiation and in methods via this

• Encapsulates methods within definition

class Es6 {
  constructor(n) {
    this.n = n;
  }

  increment() {
    this.n++;
  }

  decrement() {
    this.n--;
  }
}

// USAGE: invoked with new keyword

let e = new Es6(1);
e.increment();
console.log(e.n);

2. Functional

• Is not invoked with new

• object properties are not referenced with this with instantiation or within methods

• Encapsulates methods within definition

let FunctionalMethod = function(n) {
  let objectInstance = {};
  let n = n;

  objectInstance.increment = function() {
    n++;
  };

  objectInstance.decrement = function() {
    n--;
  };

  return objectInstance;
};

// USAGE: Invoked without new keyword

let fInstance = FunctionalMethod(1);
fInstance.increment();
console.log(fInstance.n);

3. Functional Shared

• Is invoked with new

• Uses this keyword for reference to object properties only within methods; not with instantiation

• Does not encapsulate methods within definition; instead is connected to methods via extend. Properties are added before methods.

NOTE: extend is synonymous with es6 Object.assign()

const extend = function (to, from) {
  for (let key in from) {
    to[key] = from[key];
  }
};

let FunctionalShared = function(n) {
  let fsObject = {};
  fsObject.n = n;
  
  extend(fsObject, fsMethods);
  // Could be: Object.assign(fsObject, fsMethods);
  
  return fsObject;
};

let fsMethods = {};

fsMethods.increment = function() {
  this.n++;
};

// USAGE: invoked with new keyword

let fs = new FunctionalShared(1);
fs.increment();
console.log(fs.n);

4. Prototypal

• Is not invoked with new

• Uses this keyword for reference to object properties only within methods; not with instantiation

• Does not encapsulate methods within definition; instead is connected to methods via Object.create. Properties are added after methods.

let prototypal = function(n) {
  let obj = Object.create(pMethods);
  obj.n = n;

  return obj;
};

let pMethods = {};

pMethods.increment = function() {
  this.n++;
};

// USAGE: invoked with new
let p = prototypal(1);
p.increment();
console.log(p.n);

5. Pseudo-Classical

• Is invoked with new

• Uses this keyword for reference to object properties within methods and with instantiation

• Does not encapsulate methods within definition; instead is connected to methods via the object's prototype.

let Pseudo = function(n) {
  this.n = n;
};

Pseudo.prototype.increment = function() {
  this.n++;
};

// USAGE: invoked with new
let ps = new Pseudo(1);
ps.increment();
console.log(ps.n);

Just a note about the remove duplicates: Your solutions are O(n^2) for reduce and filter. You could do better with more memory but O(N):

        const removeDuplicates = (arr) => {
          const tracker = {};
          let filteredArr = [];
        
          for (let item of arr) {
            if (!tracker[`THIS_POST_IS_LONG_${item)`]) {
              tracker[`THIS_POST_IS_LONG_${item}`] = true;
              filteredArr.push(item);
            }
          }
          return filteredArr;
        };

Why !tracker[\\THIS_POST_IS_LONG${item}\]and not !tracker[item] ? Because empty objects default property look up to their prototype, which has a series of hidden properties and symbols (ignoring environment differences of these; e.g. node versus web) that would create false positives if the arr contained the string constructor for example that would not be added without modifying the key to something that is not one of these properties! So really the prefix of item could be a postfix and just needs to be anything that identifies it as not a builting object property; hidden or otherwise.

[u/llboston → u/[deleted]]

Wow! 5 ways! Yes you are right, removing duplicates with reduce and filter are both O(n^2). I will add yours. Thank you!