JavaScript Interview Cheat Sheet - Part 1

Array Operations

// Initialize
const arr = [];
const arr = new Array(size).fill(0);  // [0,0,0,0,0]
const arr = Array.from({length: n}, (_, i) => i);  // [0,1,2,...,n-1]

// Basic Operations
arr.push(element);     // Add to end
arr.pop();            // Remove from end
arr.unshift(element); // Add to start
arr.shift();          // Remove from start

// Slicing and Splicing
arr.slice(startIdx, endIdx);  // Returns new array, endIdx not included
arr.splice(startIdx, deleteCount, ...itemsToAdd);

// Common Methods
arr.map(x => x * 2);           // Returns new array
arr.filter(x => x > 0);        // Returns new array
arr.reduce((acc, curr) => acc + curr, initialValue);
arr.sort((a, b) => a - b);     // Ascending
arr.reverse();
arr.join('');                  // Convert to string
arr.includes(element);         // Check existence
arr.indexOf(element);          // First occurrence
arr.lastIndexOf(element);      // Last occurrence

String Operations

// Creation and Access
const str = "hello";
str.length;
str[0] or str.charAt(0);

// Common Methods
str.substring(startIdx, endIdx);   // endIdx not included
str.substr(startIdx, length);      // Deprecated but good to know
str.slice(startIdx, endIdx);       // Can use negative indices
str.split('');                     // Convert to array
str.toLowerCase();
str.toUpperCase();
str.trim();                        // Remove whitespace
str.replace(old, new);
str.replaceAll(old, new);
str.startsWith(prefix);
str.endsWith(suffix);
str.includes(substr);
str.repeat(count);

Map and Set

// Map
const map = new Map();
map.set(key, value);
map.get(key);
map.has(key);
map.delete(key);
map.clear();
map.size;

// Set
const set = new Set();
set.add(value);
set.has(value);
set.delete(value);
set.clear();
set.size;

// Object as HashMap
const obj = {};
obj[key] = value;
key in obj;                    // Check existence
delete obj[key];
Object.keys(obj);
Object.values(obj);
Object.entries(obj);

Class and Object

class Node {
    constructor(val) {
        this.val = val;
        this.next = null;
    }
}

// Quick object creation
const obj = { key1: value1, key2: value2 };

Common Data Structures

// Queue using Array
const queue = [];
queue.push(element);    // enqueue
queue.shift();         // dequeue

// Stack using Array
const stack = [];
stack.push(element);
stack.pop();

// LinkedList Node
class ListNode {
    constructor(val = 0, next = null) {
        this.val = val;
        this.next = next;
    }
}

// Binary Tree Node
class TreeNode {
    constructor(val = 0, left = null, right = null) {
        this.val = val;
        this.left = left;
        this.right = right;
    }
}

// Trie Node
class TrieNode {
    constructor() {
        this.children = new Map();
        this.isEndOfWord = false;
    }
}

Bit Manipulation

// Common Operations
n << 1;               // Multiply by 2
n >> 1;               // Divide by 2
n & 1;                // Check if odd
n & (n-1);            // Remove last set bit
n & -n;               // Get last set bit
n | (1 << pos);       // Set bit at position
n & ~(1 << pos);      // Clear bit at position
n ^ (1 << pos);       // Toggle bit at position

Common Patterns and Utilities

// Number Operations
Math.max(...arr);
Math.min(...arr);
Math.floor(n);
Math.ceil(n);
Math.abs(n);
Number.MAX_SAFE_INTEGER;
Number.MIN_SAFE_INTEGER;
Infinity;
-Infinity;

// Random Number
Math.random();                     // [0, 1)
Math.floor(Math.random() * n);     // [0, n-1]

// Character Code
'a'.charCodeAt(0);                 // 97
String.fromCharCode(97);           // 'a'

// Check Type
Number.isInteger(n);
Array.isArray(arr);
typeof variable;

// Parsing
parseInt(str);
parseFloat(str);

Common Interview Patterns

// Two Pointers
let left = 0, right = arr.length - 1;
while (left < right) {
    // process
    left++;
    right--;
}

// Sliding Window
let left = 0;
for (let right = 0; right < arr.length; right++) {
    // add arr[right] to window
    while (/* window condition */) {
        // remove arr[left] from window
        left++;
    }
}

// Binary Search
let left = 0, right = arr.length - 1;
while (left <= right) {
    const mid = Math.floor((left + right) / 2);
    if (arr[mid] === target) return mid;
    if (arr[mid] < target) left = mid + 1;
    else right = mid - 1;
}