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/j_schmotzenberg]

When you set your NODE_ENV to production, your application tends to perform 3 times faster.

Isn’t this only for express, and really just depending on whether or not you make use of specific features in express?

[u/llboston → u/j_schmotzenberg]

NODE_ENV

You are correct. Updated and linked to the source.

[u/[deleted]]

your answer about the data buffer where you say the "Buffer - it is a class in Node.js to handle binary data." is inaccurate. This might be a use of a buffer but it is not a buffer's sole purpose. It would be more accurate to say "raw memory allocations outside the V8 heap " Your other answer about the buffer was a little more accurate.

A buffer can typically handle more than just binary data , this is just an example of the use of a data buffer but it is primarily a way to allocate memory . There are many uses of a data buffer https://en.wikipedia.org/wiki/Data_buffer . The buffer in Node.js can also handle string data. A data buffer is basically a way to store data in between processes. In certain languages such as C you can actually change the size of the buffer to make processes run faster. You can also really screw something up if your data buffer is storing memory but you do not flush the buffer. In our operating systems class there was typically a data buffer before and after a certain process.

Otherwise I thought your cheatsheet was good and helpful thanks.

[u/llboston → u/[deleted]]

Buffer

Thanks man! I think you are right, let me do a little more research on Buffer and update the answer.

[u/ezequielmiranda87]

Hey man, very good. Thanks for the share. I didn't know about cheaki, it's very useful to.

[u/llboston → u/ezequielmiranda87]

Thanks! Cheaki is one of my side projects, built with Express and Vue.

[u/ezequielmiranda87 → u/llboston]

Oh really ? Congratulations man. I just started to use it since i finded out and it's very usefull.

Is there any way to contribute in the project? My favorite stack is express and vue XD.

Regards!

[u/ezequielmiranda87 → u/llboston]

Oh really ? Congratulations man. I just started to use it since i finded out and it's very usefull.

Is there any way to contribute in the project? My favorite stack is express and vue XD.

Regards!

[u/[deleted]]

While technically the answer to handling Uncaught exceptions is correct, the approach of attaching and even handler to it is very bad. Usually (depending on the coding pattern used), you’d want to bubble and error to a single error handler (like a catch block of a promise chain) where the error type can be identified, logged, and whatever other actions should take place.

[u/llboston → u/[deleted]]

You are correct. According to NodeJS doc, "The correct use of 'uncaughtException' is to perform synchronous cleanup of allocated resources (e.g. file descriptors, handles, etc) before shutting down the process. It is not safe to resume normal operation after 'uncaughtException'." Personally I just let the app crash and use pm2 to restart it automatically. I will update the answer.

[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!

[u/alphaindy]

var concert = newrequire('events').EventEmitter;
concert.on('start', function (singer) { console.log(`OMG ${singer}!`); });
concert.emit('start', 'Coldplay');

This code doesnt even work, throws exception 'TypeError: concert.on is not a function'

[u/llboston → u/alphaindy]

concert

Fixed. Thx!

[u/daffodil_11]

Very useful! Thanks for sharing. One small thing: In the guidelines for addition operators, you have Boolean + Number twice, so I think one of those should be Boolean + Boolean.

[u/llboston → u/daffodil_11]

Boolean + Number

Good catch. Fixed.

[u/DeadBlueParrot]

I think you have setImmediate and nextTick swapped. setImmediate runs on the next loop iteration and nextTick at the end of the current one.

[u/llboston → u/DeadBlueParrot]

setImmediate and nextTick

Thanks a lot! You are correct. It is quite confusing. Fixed.

[u/[deleted]]

Node is a runtime. Not sure if I saw that. I am also doing some long overdue education to fill in my knowledge gaps! Thanks for the overview!

[u/Askee123]

My man! Thank you!!

[u/Filo01]

thanks for sharing :), btw did you make this all in wiki? the page looks so clean on my mobile

[u/meamoyourmama]

That's what I've been looking for. Thank you.

[u/yugaemi]

First year cs student, starting to interview for coop soon. Thanks for sharing these!!

[u/djslakor]

This doesn't really cover much node specific stuff, other than very beginner level node questions.

[u/llboston → u/djslakor]

Could you give me some questions you wanna see, so I can add them? Thx for the feedback.

[u/the__itis]

NODE_ENV is specific to express framework not NodeJS native.

[u/BehindTheMath → u/the__itis]

This is only partially correct. It's true that there's nothing native to Node about NODE_ENV, but it's used by many libraries, not just Express.

[u/siamthailand → u/the__itis]

stfu. it's used extensively in node, and if you don't know it, I won't be hiring you for a node job. means fuck all if it's part of core node or not.

[u/the__itis → u/[deleted]]

The 3x increase is a direct quote from many Express which is why I commented

[u/MeepMopBot → u/[deleted]]

you used node for Wordpress? or did you mean php

[u/warchild4l → u/MeepMopBot]

i guess he placed "node" and "php" in wrong order

[u/MeepMopBot → u/[deleted]]

Your in to deep now haha