Cheat Sheet

Use this as a reference while working.

Table of Contents:

• Data Types and Variables

  • Data Types

  • Operators

  • Variables and Scope

• Functions

  • Defining Functions

  • Parameters, Arguments, and Return Values

• Strings

  • String Basics

  • String Methods

• Conditional Statements

• Node Modules and Testing

  • Modules

  • npm and package.json

  • Jest Testing

• Loops

• Arrays

  • Array Basics

  • Mutating Arrays

  • Reference Types and Pure Functions

  • Destructuring Arrays

• Objects

  • Object Basics

  • Modifying Objects

  • Iterating Over Objects

  • Destructuring Objects

• Error Handling

• Higher-Order Functions and Callbacks

• Array Higher-Order Methods

  • map, filter, find, findIndex

  • reduce

  • sort

  • Method Chaining

• Regular Expressions (Bonus)

Data Types and Variables

Data Types

Primitive Types (immutable, stored directly in memory):

Type	Example	Description
String	"hello", 'world'	Sequence of characters
Number	42, 10.5, -2	Numeric values
Boolean	true, false	Truth values
Undefined	undefined	Variable declared but not assigned
Null	null	Intentional absence of value

Reference Types (mutable, stored in heap memory):

Type	Example	Description
Object	{ name: "Alex", age: 25 }	Collection of key:value pairs
Array	["apple", "banana", "cherry"]	Ordered list of values
Function	(x) => x * 2	Reusable block of code

Type Coercion:

String(1)           // "1"
Number("hello")     // NaN
Boolean(0)          // false

// Falsy values: 0, '', null, undefined, NaN
// Everything else is truthy

Use typeof to check a value's type:

typeof "hello"    // "string"
typeof 42         // "number"
typeof true       // "boolean"
typeof undefined  // "undefined"
typeof null       // "object" (this is a known JS quirk)
typeof [1, 2]     // "object"

Operators

Category	Operators	Notes
Arithmetic	+, -, *, /, % (modulus), ** (exponent)
Comparison	>, <, >=, <=
Equality	=== (strict), !== (strict not equal)	Always use strict equality, never ==/!=
Logical	&& (AND), || (OR), ! (NOT)
Ternary	condition ? valueIfTrue : valueIfFalse	Shorthand for if/else

Variables and Scope

Three operations you can perform with variables:

1. Declare — create a new variable with let or const

2. Assign — give the variable a value (only with let)

3. Reference — use the variable to access its value

const preferred = 'use const';   // Cannot be reassigned (preferred)
let flexible = 'use let';        // Use when reassignment is needed
flexible = 'new value';          // OK

// DON'T use var or undeclared variables

Scope determines where a variable can be accessed:

• Block scope — inside {} of if/for/while blocks

• Function scope — inside a function

• Module scope — within a file

• Global scope — accessible everywhere (avoid!)

const a = 'module scope';

const myFunc = () => {
  const b = 'function scope';
  if (true) {
    const c = 'block scope';
    console.log(a, b, c); // all accessible
  }
  // c is NOT accessible here
};
// b is NOT accessible here

Functions

Defining Functions

Arrow functions are preferred:

// Arrow function (preferred)
const add = (x, y) => {
  return x + y;
};

// Implicit return (single expression, no curly braces)
const add = (x, y) => x + y;

Parameters, Arguments, and Return Values

• Parameters — placeholders in the function definition

• Arguments — actual values passed when calling the function

• Return values — the value sent back to the caller; terminates the function

const greet = (name) => {        // name is a parameter
  return `Hello, ${name}!`;
};
greet('Ada');                     // 'Ada' is an argument
// returns "Hello, Ada!"

// Functions without a return statement return undefined

Function calls resolve from the inside out:

add(add(1, 2), add(3, 4))
// add(3, 7)
// 10

Strings

String Basics

• Each character has an index starting at 0

• Strings are immutable — string methods return new strings

const message = 'Hello there!';
message[0]                    // 'H'
message[message.length - 1]   // '!'
message.length                // 12

Template Literals (string interpolation):

const name = 'Ada';
const greeting = `Hello, ${name}! 2 + 2 = ${2 + 2}`;
// "Hello, Ada! 2 + 2 = 4"

Escape Characters: \" (quote), \n (newline), \t (tab)

String Methods

Read-only methods (return booleans or numbers):

Method	Returns	Description
.includes(str)	boolean	Does the string contain str?
.startsWith(str)	boolean	Does the string start with str?
.endsWith(str)	boolean	Does the string end with str?
.indexOf(str)	number	Index of first match (-1 if not found)

Methods that return a modified copy:

Method	Description
.slice(start, end)	Extract a portion of the string
.toUpperCase()	Convert to uppercase
.toLowerCase()	Convert to lowercase
.repeat(n)	Repeat string n times
.replace(str, replacement)	Replace first occurrence
.replaceAll(str, replacement)	Replace all occurrences

const str = 'Hello World';
str.includes('World')         // true
str.slice(0, 5)               // 'Hello'
str.toLowerCase()             // 'hello world'
str.replace('World', 'Ada')   // 'Hello Ada'

Conditional Statements

// if / else if / else
if (condition1) {
  // runs if condition1 is true
} else if (condition2) {
  // runs if condition2 is true
} else {
  // runs if all conditions are false
}

Order matters! Only the first true condition executes.

Guard Clauses — return early to simplify logic:

const canVote = (age) => {
  if (age < 18) return false;
  return true;
};

Ternary Operator — shorthand for simple if/else:

const message = num % 2 === 0 ? 'even' : 'odd';

Node Modules and Testing

Modules

Modules let you split code across files and share functionality.

Exporting:

// Default export (single value)
module.exports = myFunction;

// Named exports (multiple values)
module.exports = { functionA, functionB, CONSTANT };

Importing:

// Import default export
const myFunction = require('./myFunction.js');

// Import named exports (with destructuring)
const { functionA, functionB } = require('./helpers.js');

// Import from node_modules
const prompt = require('prompt-sync');

npm and package.json

• npm i package-name — install a package

• npm i --save-dev jest — install as a dev dependency

• package.json — lists dependencies and scripts

• node_modules/ — contains downloaded packages (don't commit this!)

npm scripts in package.json:

"scripts": {
  "test": "jest",
  "test:w": "jest --watchAll",
  "dev": "nodemon index.js"
}

Run with: npm test, npm run test:w, npm run dev

Jest Testing

const sum = require('../src/sum');

test('adds two numbers', () => {
  expect(sum(1, 2)).toBe(3);        // strict equality (===)
});

test('returns an array', () => {
  expect(double([1, 2])).toEqual([2, 4]); // deep equality (objects/arrays)
});

test('negation', () => {
  expect(sum(1, 2)).not.toBe(4);    // .not negates any matcher
});

Loops

For Loop — use when you know how many iterations:

for (let i = 0; i < 10; i++) {
  console.log(i);
}
// Order: initialize → check condition → execute body → update → repeat

While Loop — use when the number of iterations is unknown:

while (true) {
  const input = prompt("Enter 'q' to quit: ");
  if (input === 'q') break;       // exit the loop
  if (isNaN(Number(input))) continue; // skip to next iteration
  console.log(`You entered: ${input}`);
}

break vs return:

• break — exits the current loop, continues after the loop

• return — exits the loop AND the current function

Nested Loops:

for (let i = 0; i < 3; i++) {
  for (let j = 0; j < 5; j++) {
    console.log(`${i} - ${j}`);
  }
}
// Outer runs 3 times × inner runs 5 times = 15 total iterations

Arrays

Array Basics

const fruits = ['apple', 'banana', 'cherry'];
fruits[0]           // 'apple'
fruits.length       // 3
fruits.includes('banana')  // true
fruits.indexOf('cherry')   // 2
fruits.slice(0, 2)         // ['apple', 'banana'] (non-mutating)

Mutating Arrays

Unlike strings, arrays are mutable:

const arr = ['a', 'b', 'c'];

arr[1] = 'B';              // change element at index
arr.push('d');              // add to end
arr.unshift('z');           // add to beginning
arr.pop();                  // remove from end
arr.shift();                // remove from beginning
arr.splice(1, 0, 'new');   // insert 'new' at index 1
arr.splice(1, 1, 'replaced'); // replace 1 element at index 1

Reference Types and Pure Functions

Reference type variables store a reference to data in memory, not the data itself:

const original = [1, 2, 3];
const copy = original;     // both point to the SAME array
copy.push(4);
console.log(original);     // [1, 2, 3, 4] — original is affected!

Pure functions avoid mutating input values. Use the spread operator to copy:

const extend = (arr, value) => {
  return [...arr, value];  // creates a new array
};

const nums = [1, 2, 3];
const result = extend(nums, 4); // [1, 2, 3, 4]
console.log(nums);               // [1, 2, 3] — unchanged

Destructuring Arrays

const [first, second, ...rest] = [1, 2, 3, 4, 5];
first   // 1
second  // 2
rest    // [3, 4, 5]

Objects

Object Basics

Objects store related data as key:value pairs (properties):

const user = {
  userId: 44292,
  username: 'c0d3rkid',
  friends: ['alice', 'bob'],
  favoriteMeal: {
    name: 'PB&J',
    ingredients: ['peanut butter', 'jelly', 'bread']
  }
};

Accessing properties:

// Dot notation (preferred)
user.username              // 'c0d3rkid'
user.favoriteMeal.name     // 'PB&J'

// Bracket notation (required when key is in a variable)
const key = 'username';
user[key]                  // 'c0d3rkid'

Modifying Objects

user.password = 'newpass';   // modify existing property
user.isAdmin = false;        // add new property
delete user.password;        // delete property

Objects are reference types — use spread to copy:

const copy = { ...original };  // shallow copy

Object shorthand — when key names match variable names:

const name = 'ben';
const age = 30;
const user = { name, age };  // { name: 'ben', age: 30 }

Iterating Over Objects

const scores = { math: 95, english: 88, science: 92 };

Object.keys(scores)     // ['math', 'english', 'science']
Object.values(scores)   // [95, 88, 92]
Object.entries(scores)  // [['math', 95], ['english', 88], ['science', 92]]

Object.entries(scores).forEach(([subject, score]) => {
  console.log(`${subject}: ${score}`);
});

Destructuring Objects

const { username, friends } = user;
console.log(username);  // 'c0d3rkid'

// In function parameters
const introduce = ({ name, age }) => {
  console.log(`${name} is ${age}`);
};

Error Handling

Common error types:

Error Type	Cause
SyntaxError	Invalid syntax (missing quotes, brackets)
ReferenceError	Variable not defined
TypeError	Wrong data type or method doesn't exist
RangeError	Value outside acceptable range

Reading an error message: look for the error type, the description, and the call stack (which shows the chain of function calls that led to the error).

Try/Catch — handle errors without crashing:

try {
  // code that might throw an error
  arr.push('value');
} catch (err) {
  console.log(`Oops! ${err.message}`);
}
// program continues running

Higher-Order Functions and Callbacks

• Higher-Order Function (HOF) — a function that accepts another function as an argument or returns a function

• Callback — a function passed as an argument to a HOF

Important: Pass the function reference, don't invoke it:

// Wrong — invokes immediately
setTimeout(printMessage(), 1000);

// Right — passes the function reference
setTimeout(printMessage, 1000);

// Inline callback
setTimeout(() => {
  console.log('1 second passed');
}, 1000);

Array.forEach — iterate and perform side effects:

const fruits = ['apples', 'bananas', 'cherries'];

fruits.forEach((value, index) => {
  console.log(`${index}: ${value}`);
});

Array Higher-Order Methods

Method	Callback Returns	Method Returns	Use Case
forEach(fn)	nothing	undefined	Perform side effects
map(fn)	transformed value	new array (same length)	Transform each element
filter(fn)	boolean	new array (subset)	Keep elements that pass
find(fn)	boolean	first matching element	Get first match
findIndex(fn)	boolean	index of first match	Get index of first match
reduce(fn, init)	accumulated value	single value	Combine into one value
sort(fn)	comparison number	sorted array (mutates!)	Sort elements

map, filter, find, findIndex

const nums = [1, 2, 3, 4, 5];

// map — transform each element
const doubled = nums.map((num) => num * 2);
// [2, 4, 6, 8, 10]

// filter — keep elements that pass a test
const evens = nums.filter((num) => num % 2 === 0);
// [2, 4]

// find — get the first element that passes
const firstEven = nums.find((num) => num % 2 === 0);
// 2

// findIndex — get the index of the first element that passes
const firstEvenIdx = nums.findIndex((num) => num % 2 === 0);
// 1

reduce

const nums = [1, 2, 3, 4, 5];

// Sum
const sum = nums.reduce((total, current) => {
  return total + current;
}, 0); // 15

// Frequency counter
const letters = ['a', 'b', 'a', 'c', 'b', 'a'];
const freqs = letters.reduce((acc, letter) => {
  acc[letter] = (acc[letter] || 0) + 1;
  return acc;
}, {});
// { a: 3, b: 2, c: 1 }

sort

const nums = [4, 2, 5, 1, 3];

// Ascending
nums.sort((a, b) => a - b);   // [1, 2, 3, 4, 5]

// Descending
nums.sort((a, b) => b - a);   // [5, 4, 3, 2, 1]

Warning: .sort() mutates the original array!

Method Chaining

const nums = [1, 2, 3, 4, 5];

const result = nums
  .map((num) => num * 3)       // [3, 6, 9, 12, 15]
  .filter((num) => num > 10);  // [12, 15]

Regular Expressions (Bonus)

Regular expressions are patterns for searching, matching, and manipulating text.

Common patterns:

Pattern	Meaning
^	Start of string
$	End of string
\w	Word character
\d	Digit (0-9)
\s	Whitespace
.	Any character
+	One or more
*	Zero or more
?	Zero or one
[abc]	Character class
[^abc]	Negated class
{n}	Exactly n times
{n,m}	Between n and m

Flags: i (case insensitive), g (global — find all matches)

Methods:

// test() — returns boolean
/cat/i.test('the Cat in the hat');    // true

// match() — returns array of matches
'My cat loves catnip'.match(/cat/g);  // ['cat', 'cat']

// replace() — replace matches
'hello world'.replace(/world/, 'JS'); // 'hello JS'