📖 Guide

JavaScript — Complete Reference

Comprehensive JavaScript cheat sheet covering variables, types, operators, strings, arrays, objects, functions, async, DOM, ES6+, and more.

226 commands across 12 categories

Variables & TypesOperatorsStringsArraysObjectsFunctionsControl FlowPromises & AsyncDOMES6+ FeaturesError HandlingModules

Variables & Types

CommandDescription
let x = 10;
Declare a block-scoped variable
const PI = 3.14;
Declare a block-scoped constant
var name = "old";
Declare a function-scoped variable (legacy)
typeof x
e.g. typeof 42 // "number"
Returns the type of a value as a string
instanceof
e.g. [] instanceof Array // true
Check if object is instance of a class
undefined
Variable declared but not assigned a value
null
Intentional absence of any value
NaN
e.g. Number("abc") // NaN
Not a Number — result of invalid math
Number.isNaN(value)
e.g. Number.isNaN(NaN) // true
Check if value is NaN (safer than global isNaN)
Number.isFinite(value)
Check if value is a finite number
Number.isInteger(value)
e.g. Number.isInteger(4.0) // true
Check if value is an integer
Number.parseFloat("3.14")
Parse a string into a floating-point number
Number.parseInt("10", 10)
Parse a string into an integer with given radix
Boolean(value)
Convert to boolean — falsy: 0, '', null, undefined, NaN, false
BigInt(9007199254740991)
e.g. const big = 9007199254740991n;
Create a BigInt for arbitrarily large integers
Symbol("desc")
e.g. const id = Symbol("id");
Create a unique identifier

Operators

CommandDescription
===
e.g. 1 === "1" // false
Strict equality (no type coercion)
==
e.g. 1 == "1" // true
Loose equality (with type coercion)
!==
Strict inequality
? :
e.g. const r = age >= 18 ? "adult" : "minor";
Ternary operator
??
e.g. null ?? "default" // "default"
Nullish coalescing — returns right side if left is null/undefined
?.
e.g. user?.address?.city
Optional chaining — short-circuits if null/undefined
??=
e.g. x ??= 10; // assigns 10 only if x is null/undefined
Nullish coalescing assignment
||=
e.g. x ||= "fallback"; // assigns if x is falsy
Logical OR assignment
&&=
e.g. x &&= newValue; // assigns if x is truthy
Logical AND assignment
...
e.g. const arr2 = [...arr1, 4, 5];
Spread / rest operator
**
e.g. 2 ** 10 // 1024
Exponentiation operator
&, |, ^, ~, <<, >>
Bitwise operators: AND, OR, XOR, NOT, left/right shift
in
e.g. "name" in obj // true
Check if property exists in object
delete obj.prop
Delete a property from an object
void 0
Evaluates expression and returns undefined

Strings

CommandDescription
`template ${expr}`
Template literal with interpolation
str.length
Get the length of a string
str.includes("sub")
Check if string contains a substring
str.startsWith("he")
Check if string starts with a substring
str.endsWith("lo")
Check if string ends with a substring
str.indexOf("sub")
Find first index of substring (-1 if not found)
str.lastIndexOf("sub")
Find last index of substring
str.slice(start, end)
e.g. "hello".slice(1, 3) // "el"
Extract a portion of a string (supports negative indices)
str.substring(start, end)
Extract characters between two indices
str.toUpperCase()
Convert string to uppercase
str.toLowerCase()
Convert string to lowercase
str.trim()
Remove whitespace from both ends
str.trimStart()
Remove whitespace from the start
str.trimEnd()
Remove whitespace from the end
str.padStart(length, char)
e.g. "5".padStart(3, "0") // "005"
Pad from the start to a given length
str.padEnd(length, char)
Pad from the end to a given length
str.repeat(n)
e.g. "ha".repeat(3) // "hahaha"
Repeat the string n times
str.replace("old", "new")
Replace first occurrence
str.replaceAll("old", "new")
Replace all occurrences
str.split(separator)
e.g. "a,b,c".split(",") // ["a","b","c"]
Split string into an array
str.match(/regex/)
Match against a regular expression
str.matchAll(/regex/g)
Returns iterator of all regex matches
str.search(/regex/)
Search for regex and return index
str.at(index)
e.g. "hello".at(-1) // "o"
Get character at index (supports negative)
String.raw`\n`
e.g. String.raw`\n` // "\n"
Raw template string — no escape processing

Arrays

CommandDescription
Array.isArray(value)
Check if a value is an array
Array.from(iterable)
e.g. Array.from("abc") // ["a","b","c"]
Create array from iterable/array-like
Array.of(1, 2, 3)
Create array from arguments
arr.push(item)
Add element(s) to end, returns new length
arr.pop()
Remove and return last element
arr.unshift(item)
Add element(s) to beginning
arr.shift()
Remove and return first element
arr.splice(i, count, ...items)
e.g. arr.splice(1, 2, "a", "b")
Remove/insert elements at position
arr.slice(start, end)
Return shallow copy of a portion
arr.concat(arr2)
Merge arrays, returns new array
arr.flat(depth)
e.g. [1,[2,[3]]].flat(Infinity) // [1,2,3]
Flatten nested arrays
arr.flatMap(fn)
Map then flatten one level
arr.map(fn)
e.g. [1,2,3].map(x => x * 2)
Transform each element, returns new array
arr.filter(fn)
e.g. [1,2,3].filter(x => x > 1)
Keep elements that pass the test
arr.reduce(fn, init)
e.g. [1,2,3].reduce((sum, x) => sum + x, 0)
Reduce array to single value
arr.forEach(fn)
Execute a function for each element (no return)
arr.find(fn)
Return first element matching condition
arr.findIndex(fn)
Return index of first matching element
arr.findLast(fn)
Return last element matching condition
arr.findLastIndex(fn)
Return index of last matching element
arr.some(fn)
True if at least one element passes test
arr.every(fn)
True if all elements pass test
arr.includes(value)
Check if array contains a value
arr.indexOf(value)
Find index of value (-1 if not found)
arr.sort((a, b) => a - b)
Sort array in place (numeric ascending)
arr.reverse()
Reverse array in place
arr.toSorted(fn)
Return new sorted array (non-mutating, ES2023)
arr.toReversed()
Return new reversed array (non-mutating, ES2023)
arr.with(index, value)
e.g. [1,2,3].with(1, 20) // [1,20,3]
Return new array with element replaced (ES2023)
arr.at(index)
e.g. [1,2,3].at(-1) // 3
Get element at index (supports negative)
arr.join(separator)
e.g. [1,2,3].join("-") // "1-2-3"
Join all elements into a string
[...new Set(arr)]
Remove duplicates from array
structuredClone(arr)
Deep clone an array (or any object)

Objects

CommandDescription
{ key: value }
Object literal
{ [expr]: value }
e.g. const key = "name"; const obj = { [key]: "Dan" };
Computed property name
{ method() {} }
Shorthand method definition
{ key }
e.g. const name = "Dan"; const obj = { name };
Shorthand property (variable name = key)
Object.keys(obj)
Get array of own enumerable keys
Object.values(obj)
Get array of own enumerable values
Object.entries(obj)
Get array of [key, value] pairs
Object.fromEntries(entries)
e.g. Object.fromEntries([["a",1],["b",2]])
Create object from [key, value] pairs
Object.assign(target, ...sources)
Copy properties from sources to target (shallow)
{ ...obj }
Spread operator — shallow clone an object
structuredClone(obj)
Deep clone an object
Object.freeze(obj)
Make object immutable (shallow)
Object.isFrozen(obj)
Check if object is frozen
Object.seal(obj)
Prevent adding/removing properties (values still editable)
Object.hasOwn(obj, prop)
e.g. Object.hasOwn({a:1}, "a") // true
Check if object has own property (ES2022)
obj.hasOwnProperty("key")
Check if object has own property (legacy)
Object.getPrototypeOf(obj)
Get the prototype of an object
Object.create(proto)
Create object with specified prototype
Object.defineProperty(obj, prop, desc)
Define or modify a property with descriptor
const { a, b } = obj
Destructure properties from an object
const { a: x, b: y = 0 } = obj
Destructure with rename and default value
Object.getOwnPropertyNames(obj)
Get all own property names (including non-enumerable)

Functions

CommandDescription
function name(params) { }
Function declaration (hoisted)
const fn = function(params) { }
Function expression (not hoisted)
const fn = (params) => { }
Arrow function
const fn = (x) => x * 2
Arrow function with implicit return
function fn(a = 10) { }
Default parameter value
function fn(...args) { }
Rest parameters — collect remaining args into array
fn(...arr)
Spread arguments from array
function fn({ name, age }) { }
Destructured parameters
(function() { })()
IIFE — Immediately Invoked Function Expression
fn.call(thisArg, a, b)
Call function with specific this and arguments
fn.apply(thisArg, [a, b])
Call function with specific this and array of arguments
const bound = fn.bind(thisArg)
Create new function with bound this
function* gen() { yield 1; }
e.g. const g = gen(); g.next() // { value: 1, done: false }
Generator function
arguments
Array-like object of all arguments (not in arrow functions)
fn.name
Get the name of a function
fn.length
Get number of expected parameters

Control Flow

CommandDescription
if (cond) { } else if (cond) { } else { }
Conditional branching
switch (val) { case x: break; default: }
Switch statement
for (let i = 0; i < n; i++) { }
Classic for loop
for (const item of iterable) { }
For...of loop (arrays, strings, maps, sets)
for (const key in obj) { }
For...in loop (object keys, includes inherited)
while (cond) { }
While loop
do { } while (cond)
Do...while loop (runs at least once)
break
Exit current loop
continue
Skip to next iteration
label: for (...) { break label; }
Labeled statement — break/continue outer loops
for await (const x of asyncIterable) { }
Async iteration over async iterables

Promises & Async

CommandDescription
new Promise((resolve, reject) => { })
Create a new Promise
promise.then(onFulfilled, onRejected)
Handle promise resolution/rejection
promise.catch(onRejected)
Handle promise rejection
promise.finally(onFinally)
Run code after promise settles (fulfilled or rejected)
Promise.resolve(value)
Create a resolved promise
Promise.reject(reason)
Create a rejected promise
Promise.all(promises)
e.g. const [a, b] = await Promise.all([p1, p2])
Wait for all promises — rejects if any reject
Promise.allSettled(promises)
Wait for all to settle, returns status + value/reason
Promise.race(promises)
Resolve/reject with first settled promise
Promise.any(promises)
Resolve with first fulfilled — rejects only if all reject
async function fn() { }
Declare an async function (returns a Promise)
const result = await promise
Wait for a promise to resolve
await Promise.all([...])
Run promises concurrently and wait for all
setTimeout(fn, ms)
Run function after delay (returns timer ID)
setInterval(fn, ms)
Run function repeatedly at interval
clearTimeout(id)
Cancel a timeout
clearInterval(id)
Cancel an interval
queueMicrotask(fn)
Schedule a microtask (runs before next macrotask)

DOM

CommandDescription
document.getElementById("id")
Select element by ID
document.querySelector("css")
Select first matching element
document.querySelectorAll("css")
Select all matching elements (NodeList)
el.classList.add("cls")
Add a CSS class
el.classList.remove("cls")
Remove a CSS class
el.classList.toggle("cls")
Toggle a CSS class
el.classList.contains("cls")
Check if element has a class
el.setAttribute("attr", "val")
Set an attribute
el.getAttribute("attr")
Get an attribute value
el.removeAttribute("attr")
Remove an attribute
el.textContent = "text"
Set text content (no HTML parsing)
el.innerHTML = "<b>html</b>"
Set inner HTML (parses HTML)
el.style.color = "red"
Set inline style
el.addEventListener("click", fn)
Attach event listener
el.removeEventListener("click", fn)
Remove event listener
document.createElement("div")
Create a new element
parent.appendChild(child)
Append child to parent
parent.removeChild(child)
Remove child from parent
el.remove()
Remove element from the DOM
el.insertAdjacentHTML("beforeend", html)
Insert HTML at specified position
el.closest("selector")
Find closest ancestor matching selector
el.matches("selector")
Check if element matches CSS selector
el.getBoundingClientRect()
Get element position and dimensions
el.dataset.name
e.g. <div data-name="x"> → el.dataset.name // "x"
Access data-* attributes
el.cloneNode(true)
Clone element (true = deep clone with children)

ES6+ Features

CommandDescription
const [a, b, ...rest] = arr
Array destructuring with rest
const { a, b, ...rest } = obj
Object destructuring with rest
const [a = 1, b = 2] = arr
Destructuring with defaults
new Map()
e.g. const m = new Map(); m.set("k", "v"); m.get("k")
Create a Map (key-value, any key type)
new Set()
e.g. const s = new Set([1,2,2,3]); // Set {1,2,3}
Create a Set (unique values)
new WeakMap()
Map with weakly held object keys (GC-friendly)
new WeakSet()
Set with weakly held objects
for (const [k, v] of map) { }
Iterate over Map entries
class Foo { constructor() {} }
Class declaration
class Bar extends Foo { }
Class inheritance
static method() { }
Static method (called on class, not instance)
get prop() { } / set prop(v) { }
Getter and setter in class
#privateField
e.g. class Foo { #count = 0; }
Private class field (ES2022)
static #privateStatic
Private static field
globalThis
Universal global object (works in browser, Node, workers)
structuredClone(obj)
Deep clone any serializable value
Object.groupBy(arr, fn)
e.g. Object.groupBy([1,2,3], n => n > 1 ? "big" : "small")
Group array elements by key function (ES2024)
using resource = getResource()
Explicit resource management (ES2024 proposal)
arr.toSorted() / arr.toReversed()
Non-mutating sort/reverse (ES2023)
arr.toSpliced(i, n, ...items)
Non-mutating splice (ES2023)

Error Handling

CommandDescription
try { } catch (e) { } finally { }
Try-catch-finally block
throw new Error("message")
Throw an error
throw new TypeError("msg")
Throw a TypeError
throw new RangeError("msg")
Throw a RangeError
throw new ReferenceError("msg")
Throw a ReferenceError
throw new SyntaxError("msg")
Throw a SyntaxError
class MyError extends Error { }
Custom error class
error.message
Get the error message
error.name
Get the error type name
error.stack
Get the stack trace string
error.cause
e.g. throw new Error("fail", { cause: originalError })
Get the cause of the error (ES2022)
try { } catch { }
Optional catch binding (omit error param)

Modules

CommandDescription
export const x = 1;
Named export
export function fn() { }
Named function export
export default value
Default export
export { a, b }
Export multiple values
export { a as alias }
Export with alias
import { a, b } from "./mod"
Named import
import def from "./mod"
Default import
import * as mod from "./mod"
Namespace import
import { a as alias } from "./mod"
Import with alias
const mod = await import("./mod")
e.g. const { fn } = await import("./utils.js")
Dynamic import (code splitting)
export * from "./mod"
Re-export everything from another module
export { default } from "./mod"
Re-export default from another module
import.meta.url
URL of the current module

More Guides

🌿
Git Commands
Complete Git command reference cheat sheet — from basics to advanced workflows, including branching, stashing, rebasing, and tagging. Searchable, with examples.
📝
Vim Commands
Complete Vim/Vi command reference cheat sheet — modes, motions, editing, search and replace, macros, registers, marks, and window management.
🐳
Docker Commands
Complete Docker & Docker Compose command reference cheat sheet — containers, images, volumes, networks, registry auth, buildx multi-platform builds, & cleanup.
🔤
Regex Reference
Complete regular expression reference cheat sheet — character classes, anchors, quantifiers, groups, lookaheads, flags, and JavaScript string methods.
🐧
Linux Commands
Complete Linux/Bash command reference cheat sheet — file management, text processing, networking, system admin, and shell scripting.
☸️
Kubernetes Commands
Complete Kubernetes & kubectl command reference cheat sheet — pods, deployments, services, secrets, namespaces, scaling, RBAC, networking, and Helm charts.
🐍
Python Reference
Complete Python reference — syntax, data structures, string methods, control flow, classes, error handling, file I/O, comprehensions, and built-ins.
🗃️
SQL Reference
Complete SQL reference cheat sheet — queries, joins, aggregation, subqueries, indexes, window functions, string and date functions, and database management.
🌐
Nginx Reference
Complete Nginx configuration reference — server blocks, locations, proxying, SSL, load balancing, caching, security headers, and rate limiting.
🔐
SSH Commands
Complete SSH reference — connections, key management, tunneling, config, SCP/SFTP, agent forwarding, security hardening, and troubleshooting.
👷
Jenkins Reference
Complete Jenkins reference — pipeline syntax, Jenkinsfile, plugins, CLI, agents, shared libraries, credentials, and CI/CD patterns.
📨
HTTP Headers Reference
Complete HTTP headers reference — request headers, response headers, caching, security, CORS, and content negotiation. Searchable, with examples.
🐘
PostgreSQL Reference
Comprehensive PostgreSQL reference — from connection basics to advanced features like JSONB, full-text search, window functions, and performance tuning.
⚡
Async Patterns Reference
Multi-language async/concurrency patterns — JavaScript, Python, Go, Rust, Java, plus retry, rate limiting, and circuit breaker patterns.
📡
Protobuf & gRPC Reference
Comprehensive reference for Protocol Buffers (proto3) and gRPC — message definitions, services, streaming, and common patterns.
📚
JS Array Methods
Complete JavaScript Array methods reference — creating, searching, transforming, sorting, iterating, and common patterns. Searchable, with examples.
🌊
Tailwind CSS Reference
Complete Tailwind CSS reference — layout, spacing, typography, colors, responsive design, states, and common patterns. Searchable, with examples.
◈
GraphQL Reference
Complete GraphQL reference — schema definition, types, queries, mutations, directives, fragments, and common patterns. Searchable, with examples.
💻
VS Code Shortcuts
Complete VS Code keyboard shortcuts cheat sheet — editing, navigation, search, multi-cursor, terminal, debug, and more. Searchable, with Cmd/Ctrl notation.
🔲
CSS Grid Reference
Complete CSS Grid reference — container properties, item placement, grid functions, and common layout patterns. Searchable, with examples.
📦
CSS Flexbox Reference
Complete CSS Flexbox reference — container properties, item properties, and common layout patterns. Searchable, with examples.
⚛️
React Hooks Reference
Complete React Hooks reference — useState, useEffect, useContext, custom hooks, and common patterns. Searchable, with examples.
🔷
TypeScript Reference
Complete TypeScript reference — types, interfaces, generics, utility types, and advanced patterns. Searchable, with examples.
☁️
AWS CLI Reference
Complete AWS CLI reference — EC2, S3, IAM, Lambda, ECS, RDS, CloudFormation, CloudWatch, SQS/SNS, Route 53, and common operations.
🐹
Go Reference
Complete Go (Golang) reference — syntax, types, structs, interfaces, goroutines, channels, error handling, testing, and the standard library.
💠
PowerShell Reference
Complete PowerShell reference — cmdlets, pipelines, scripting, file operations, remote management, and Active Directory.
💾
Redis Commands
Complete Redis command reference — strings, hashes, lists, sets, sorted sets, pub/sub, transactions, and server management.
🏗️
Terraform Commands
Complete Terraform reference — init, plan, apply, state management, modules, workspaces, providers, backend configuration, and HCL syntax.
⚙️
Ansible Commands
Complete Ansible reference — playbooks, modules, inventory, roles, vault, Galaxy, handlers, conditionals, loops, and ad-hoc commands.
🪶
Apache
Complete Apache HTTP Server cheat sheet — virtual hosts, modules, rewrite rules, and SSL, plus access control, logging, and performance.
🔤
ASCII Table
Complete ASCII character reference with decimal, hexadecimal, and character values, plus control codes and common escape sequences.
🔧
Awk
Powerful text processing language for pattern scanning, data extraction, arrays, control flow, and report generation with built-in variables.
💻
Bash
Complete Bash reference cheat sheet — variables, strings, arrays, conditionals, loops, functions, file tests, I/O redirection, process management, and more.
⚙️
C
Complete C programming cheat sheet covering syntax, pointers, memory management, structs, file I/O, preprocessor, and standard library.
🔐
Chmod
Linux file permission commands and patterns for chmod, covering numeric and symbolic modes, recursive changes, and SUID/SGID/sticky bits.
🔧
Chrome DevTools
Essential Chrome DevTools shortcuts, commands, and workflows for web developers — covering Network, Performance, and Application panels.
🔷
C++
Complete C++ cheat sheet covering STL containers, OOP, templates, smart pointers, iterators, lambda expressions, and modern C++ features.
⏰
Cron
Cron scheduling reference covering syntax, special strings, field values, crontab management, environment variables, and logging.
🎨
CSS
Complete CSS reference cheat sheet — selectors, box model, positioning, typography, animations, media queries, custom properties, and more.
🌐
Curl
Curl command-line reference for HTTP requests, headers, authentication, cookies, proxies, file transfers, SSL/TLS, debugging, and API patterns.
🎯
Dart
Dart language cheat sheet covering syntax, types, OOP, null safety, and async patterns, plus collections, error handling, and classes.
🐳
Docker Compose
Docker Compose reference covering CLI commands, service configuration, networking, volumes, health checks, profiles, and build options.
💧
Drizzle ORM
Complete Drizzle ORM reference for schema definition, column types, queries, filters, joins, relations, migrations, indexes, and patterns.
⚡
Emmet
Quick reference for Emmet abbreviations for lightning-fast HTML and CSS coding, covering nesting, multiplication, numbering, and grouping.
🔍
Find
Search for files and directories in a directory hierarchy with powerful filtering by name, size, time, permissions, type, and actions.
🔥
Firebase
Firebase reference covering Authentication, Firestore, Realtime Database, Cloud Functions, Hosting, Storage, and security rules.
🤖
GitHub Actions
Complete GitHub Actions cheat sheet — workflows, triggers, jobs, and CI/CD patterns, plus matrix strategies, caching, and artifacts.
🔎
Grep
Search text using patterns. Filter lines from files, command output, or streams with regular expressions, context options, and file filtering.
📄
HTML
Complete HTML reference — document structure, text content, links, forms, tables, media, semantic elements, meta tags, attributes, and accessibility.
📡
HTTP Status Codes
Complete reference of all standard HTTP response status codes across 1xx-5xx classes, with descriptions, examples, and common usage patterns.
☕
Java
Complete Java reference — data types, strings, collections, OOP, interfaces, exceptions, file I/O, streams, lambdas, and more.
💲
jQuery
Quick reference for jQuery selectors, DOM manipulation, events, AJAX, and more, including animation effects, traversing, and plugins.
🔺
Laravel
Laravel PHP framework cheat sheet for routing, Eloquent, Blade, Artisan, and more, plus middleware, validation, and authentication.
📐
LaTeX
Quick reference for LaTeX document structure, math mode, formatting, and common packages, plus figures, tables, and citation styles.
📝
Markdown
Complete Markdown syntax reference for headings, formatting, links, tables, code blocks, task lists, footnotes, and extensions.
🍃
MongoDB
MongoDB reference covering CRUD operations, aggregation, indexes, and administration, plus replica sets, users, roles, and query operators.
🐬
MySQL
Complete MySQL cheat sheet covering queries, joins, indexes, transactions, data types, user permissions, and database administration.
▲
Next.js
Next.js App Router reference covering routing, data fetching, server components, API routes, middleware, and deployment configuration.
🟩
Node.js
Comprehensive Node.js runtime reference covering modules, file system, HTTP, streams, events, child processes, and npm scripts.
📦
npm
Complete npm cheat sheet — package management, scripts, publishing, and configuration, plus workspaces, security audits, and npx.
🔢
NumPy
Essential NumPy commands for array manipulation and numerical computing in Python, covering reshaping, broadcasting, and linear algebra.
🐼
Pandas
Pandas cheat sheet for data manipulation, analysis, and transformation in Python, covering DataFrames, grouping, merging, and date/time.
🐘
PHP
Complete PHP cheat sheet covering syntax, OOP, arrays, PDO, and modern PHP 8.x features, plus file I/O, superglobals, and error handling.
🔄
PM2
Production process manager for Node.js applications with cluster mode, monitoring, log management, startup scripts, and zero-downtime reloads.
💎
Prisma
Complete Prisma ORM cheat sheet — schema, queries, migrations, and CLI, plus relations, aggregations, filtering, and seeding patterns.
🦀
Rust
Comprehensive Rust language cheat sheet covering ownership, traits, pattern matching, structs, enums, error handling, closures, and concurrency.
💅
Sass
Complete Sass/SCSS cheat sheet covering variables, mixins, functions, nesting, extends, maps, and the modern module system.
📺
Screen
GNU Screen terminal multiplexer for persistent sessions, window and split-region management, key bindings, copy mode, and remote work.
✂️
Sed
Stream editor for filtering and transforming text, line by line — substitution, address ranges, hold space, branching, and flags.
⚡
Supabase
Complete Supabase cheat sheet — auth, database, realtime, storage, and edge functions, plus row level security and migrations.
🖥️
Tmux
Terminal multiplexer cheat sheet for managing multiple sessions, windows, and panes from a single terminal, with copy mode and status bar configuration.
📦
TOML
Quick reference for TOML configuration file syntax, types, tables, and common patterns, including arrays of tables and inline tables.
▲
Vercel CLI
Complete Vercel CLI reference for deployment, project management, domains, environment variables, secrets, logs, edge functions, and configuration.
⚡
Vite
Next-generation frontend build tool with instant HMR, native ES modules, plugins, environment variables, library mode, and Rollup-based builds.
📦
Webpack
Module bundler for JavaScript applications — entry/output config, loaders, plugins, code splitting, module resolution, and optimization.
🎯
XPath
Quick reference for XPath expressions, axes, predicates, string functions, node tests, and operators for XML/HTML querying.
📋
YAML
YAML syntax reference covering scalars, collections, anchors, aliases, multi-line strings, nested structures, and common patterns.

📖 Free, searchable command reference. Bookmark this page for quick access.