Skip to content
Interview Prep
Buddy
Docs
Visualizers
Algorithm Visualizers
Visualizers Hub
Two Pointers Visualizer
Sliding Window Visualizer
Backtracking Visualizer
Sorting Visualizer
Searching Visualizer
Arrays Visualizer
Linked List Visualizer
Stack & Queue
Hash Tables
Trees Visualizer
Trie (Prefix Tree)
Graphs Visualizer
Heaps Visualizer
Dynamic Programming
DSA Playground
Labs
Practice Labs
HTML Labs
CSS Labs
JS Interview Lab
React Practice Lab
DSA Problem Lab
DSA Patterns Guide
SQL Query Lab
Python Labs
MongoDB Lab
Git & GitHub Labs
Tailwind CSS Playground
System Design
System Architecture
System Design Hub (HLD)
Low-Level Design Hub (LLD)
Object-Oriented Design (OOD)
Design URL Shortener (TinyURL)
Design Ride-Sharing (Uber)
Design Chat App (WhatsApp)
Interview Questions
Interview Preparation
3,100+ Tech Interview Questions
AI, LLM & RAG Interview Prep
Tricky JavaScript Outputs
Behavioural Questions
MCQ Hub
Roadmaps
Study & Prep Roadmaps
Roadmaps Overview
Blind 75 Guided Plan
30-Day DSA Bootcamp
Frontend Interview (21 Days)
Striver's Blind 75
JavaScript Mastery Plan
SQL in 7 Days
Last-Minute Revision
Amazon Interview Plan
Google Interview Plan
Companies
Company Interview Prep
Companies Overview
Google
Amazon
Meta
Microsoft
Apple
Netflix
Uber
Flipkart
Swiggy
Contact
Search...
⌘K
Sign In
Share Feedback
Help us improve this platform
✕
🐛
Bug
💡
Idea
⭐
Praise
💬
Other
Your Message *
How's your experience?
⭐
⭐
⭐
⭐
⭐
Email
(optional — for reply)
Send Feedback
✕
hide
Share Feedback
Interview Prep Buddy
1,400+ interview questions & docs
All Topics
All Topics
Home
Overview
Playground
JS Interview Lab
MCQ Hub
MCQ Dashboard
Interview Questions
AI Engineering
Object-Oriented Programming (OOP)
Computer Networks
Git & GitHub
HTML & CSS
Tailwind CSS
Namaste JavaScript
JavaScript
React Academy
Next.js
Angular
SQL / MySQL
MongoDB
Redis
Data Structures
Striver Blind 75 Solutions
Node.js
GraphQL
Python
TypeScript
Cloud & AWS
Docker
Design Patterns & SOLID
System Design
High-Level Design (HLD)
Low-Level Design (LLD)
Interview Prep
Behavioral Interview Prep
Home
Overview
Playground
JS Interview Lab
MCQ Hub
MCQ Dashboard
Interview Questions
AI Engineering
AI Engineering Overview
Phase 1: AI Fundamentals
01. Introduction to AI
02. History of AI
03. Why AI?
04. Types of AI
05. AI vs ML vs DL
06. How AI Works
07. AI Lifecycle
08. AI Terminology
09. Real World AI
10. AI Applications
11. AI Limitations
12. AI Myths
13. AI Ethics
14. Future of AI
15. AI Cheat Sheet
Phase 2: Machine Learning
01. What is ML?
02. Why ML?
03. ML Workflow
04. Data & Datasets
05. Features & Labels
06. Supervised Learning
07. Unsupervised Learning
08. Reinforcement Learning
09. Training vs Inference
10. Models
11. Loss Functions
12. Overfitting & Underfitting
13. Bias vs Variance
14. Train / Test / Validation
15. Model Evaluation
16. Feature Engineering
17. Data Preprocessing
18. Common ML Algorithms
19. Production ML
20. ML Cheat Sheet
Phase 3: Deep Learning
01. What is Deep Learning?
02. ML vs Deep Learning
03. Neural Networks
04. Biological vs Artificial Neuron
05. Perceptron
06. Layers in Neural Networks
07. Forward Propagation
08. Activation Functions
09. Loss Functions
10. Backpropagation
11. Gradient Descent
12. Optimizers
13. Convolutional Neural Networks
14. Recurrent Neural Networks
15. LSTM
16. GRU
17. Attention Mechanism
18. Introduction to Transformers
19. Deep Learning Pipeline
20. Deep Learning Cheat Sheet
Phase 4: Large Language Models
Module 1: LLM Foundations
📖 Module Overview
01. What is an LLM?
02. How Language Models Work
03. Tokenization
04. Context Window
📝 Module Summary
Module 2: Transformer Architecture
📖 Module Overview
05. Transformer Overview
06. Self-Attention
07. Query, Key, Value
08. Multi-Head Attention
09. Positional Encoding
10. Feed-Forward Network
11. Decoder-Only Transformers
12. GPT Architecture
📝 Module Summary
Module 3: Training
📖 Module Overview
13. Pretraining
14. Next Token Prediction
15. Supervised Fine-Tuning
16. RLHF
17. DPO
📝 Module Summary
Module 4: Inference
📖 Module Overview
18. Inference
19. Decoding Strategies
20. Temperature, Top-K & Top-P
21. Streaming
22. Function Calling
23. Structured Output
24. Hallucinations
📝 Module Summary
Module 5: Revision & Project
📖 Module Overview
📋 Phase Summary
📄 Cheat Sheet
✏️ Practice Questions
✅ MCQs
🎯 Interview Questions
🛠️ Mini Project
Phase 5: Prompt Engineering
01. What is Prompt Engineering?
02. How LLMs Understand Prompts
03. Prompt Anatomy
04. System, User & Assistant Prompts
05. Zero-Shot, One-Shot & Few-Shot
06. Role & Persona Prompting
07. Context Engineering
08. Output Formatting
09. JSON & Structured Output
10. Prompt Templates
11. Prompt Chaining
12. Chain of Thought
13. Tree of Thought
14. ReAct Prompting
15. Self-Consistency
16. Step-Back Prompting
17. Meta Prompting
18. Prompt Optimization
19. Prompt Testing
20. Prompt Versioning
21. Prompt Evaluation
22. Prompt Security
23. Prompt Injection
24. Production Prompt Engineering
25. Phase Summary
Phase 6: AI Agents
01. What is an AI Agent?
02. Agent vs LLM
03. Agent Lifecycle
04. Planning & Reasoning
05. Memory in AI Agents
06. Tool Usage
07. Agent Loop
08. Single vs Multi-Agent
09. Agent Design Patterns
10. Agent Architectures
11. LangGraph
12. CrewAI
13. AutoGen & OpenAI SDK
14. Production Architecture
15. Projects & Roadmap
Phase 7: Model Context Protocol (MCP)
01. What is MCP?
02. Why MCP?
03. MCP Architecture
04. MCP Client
05. MCP Server
06. Tools
07. Resources
08. Prompts
09. Communication
10. Transports
11. Build Your First MCP Server
12. Build Your First MCP Client
13. MCP with AI Agents
14. Production MCP
15. Phase Summary
Phase 8: Retrieval Systems & RAG
01. Why Retrieval Systems
02. Embeddings Deep Dive
03. Vector Space
04. Similarity Search
05. Vector Databases Introduction
06. What is RAG?
07. Document Chunking
08. Document Ingestion Pipeline
09. Retrievers
10. Building a Complete RAG Pipeline
11. Hybrid Search
12. Re-ranking
13. Context Compression
14. Parent-Child Retrieval
15. Multi-Query Retrieval
16. Production RAG Architecture
17. Metadata Filtering & Security
18. RAG Evaluation & Observability
19. Performance & Scaling
20. Production Best Practices
21. Chat with PDF
22. Company Knowledge Assistant
23. Documentation Chatbot
24. GitHub Code Assistant
25. Phase Summary & Roadmap
Phase 9: Production AI Engineering
01. Introduction to LLMOps
02. Production AI Architecture
03. Prompt Management
04. Observability & Tracing
05. AI Evaluation
06. Guardrails & Safety
07. Security & Compliance
08. Performance & Cost Optimization
09. Deployment & Scaling
10. Monitoring, Logging & Alerting
11. CI/CD for AI
12. Production Case Studies
13. Phase Summary
Phase 10: Real-World AI Projects
01. ChatGPT Clone
02. Perplexity Clone
03. NotebookLM Clone
04. Cursor Clone
05. GitHub Copilot Clone
06. AI Code Reviewer
07. AI Document Assistant
08. AI Meeting Assistant
09. AI Email Assistant
10. AI Research Agent
11. AI Resume & Interview
12. AI CRM Assistant
13. AI System Design
14. Capstone Project
15. Phase Summary
Object-Oriented Programming (OOP)
Overview
01. Introduction
What is OOP?
Procedural vs OOP
02. Classes & Objects
Class
Object
Constructor
this Keyword
03. Four Pillars
Overview
Encapsulation
Abstraction
Inheritance
Overview
Types
Single
Multilevel
Hierarchical
Multiple
Hybrid
super Keyword
Method Overriding
Polymorphism
Overview
Method Overloading
04. Object Relationships
Association
Aggregation
Composition
Dependency
Coupling vs Cohesion
05. Advanced Concepts
Access Modifiers
Static Members
Interfaces
Abstract Classes
Object Lifecycle
Memory Management
06. Design Principles
SOLID Principles
DRY, KISS, YAGNI
07. Practice
Real-World Examples
Machine Coding
Interview Questions
Cheat Sheet
Computer Networks
Overview
01. Fundamentals
What is a Network?
OSI & TCP/IP Models
IP Addresses & Ports
DNS (Domain Name System)
Network Topologies & Devices
02. Transport
TCP vs UDP
TCP Handshake & Connection
TCP Flow Control & Congestion
03. Web Protocols
HTTP & HTTPS
HTTP Versions
HTTP Status Codes
REST vs WebSocket
Cookies, Sessions & CORS
HTTP Caching
04. Infrastructure
Load Balancers & Proxies
CDN & Caching
Network Security Basics
API Gateways & WAF
05. Interview
Network Interview Questions
Git & GitHub
Overview
01. Basics
What is Git?
Installing & Configuring Git
The Three Areas of Git
Core Git Commands
02. Branching
Branches
Merging
Merge vs Rebase
Resolving Conflicts
03. Remote & GitHub
Remotes
Pull Requests
Collaboration Workflow
04. Advanced
Undoing Changes
Stash, Tags & Cherry-pick
History & Blame
.gitignore & Best Practices
05. Interview
Git Interview Questions
HTML & CSS
Overview
01. HTML Basics
What is HTML?
Semantic HTML
Text & Links
Forms & Inputs
Tables & Media
02. CSS Basics
CSS Syntax & Selectors
Colors, Units & Typography
The Box Model
Display & Positioning
03. Layout
Flexbox
CSS Grid
Responsive Design
04. Advanced
Transitions & Animations
Variables & Modern CSS
Accessibility (a11y)
Best Practices
05. Interview
HTML & CSS Interview Questions
Tailwind CSS
Tailwind Overview
01. Basics
What is Tailwind CSS?
Setup & Configuration
Utility-First Workflow
02. Core Utilities
Spacing & Sizing
Colors & Typography
Backgrounds, Borders & Effects
03. Layout
Flexbox
Grid
Responsive Design
States & Variants
04. Advanced
Customizing the Theme
Reusing Styles
Plugins & Best Practices
05. Interview
Interview Questions
Namaste JavaScript
Overview
Season 1 — Foundations
1. Execution Context
2. How JS is Executed & Call Stack
3. Hoisting
4. Functions & Variable Environments
5. Shortest JS Program, window & this
6. undefined vs not defined
7. Scope Chain & Lexical Environment
8. let & const, Temporal Dead Zone
9. Block Scope & Shadowing
10. Closures
11. setTimeout + Closures
12. Famous Interview Questions ft. Closures
13. First Class Functions
14. Callback Functions
15. Event Loop
16. V8 Architecture
17. Trust issues with setTimeout
18. Higher-Order Functions
19. map, filter & reduce
Season 2 — Promises & Async
20. Callback Hell & Inversion of Control
21. Promises
22. Creating a Promise, Chaining & Error Handling
23. Promise APIs (all, allSettled, race, any)
24. async / await
25. this keyword in JavaScript
JavaScript
Phase 1 — Fundamentals
01. Introduction
Introduction to JavaScript
What is JavaScript?
The History of JavaScript
JavaScript vs ECMAScript
JavaScript Engines
Compilation vs Interpretation
JavaScript Runtime
02. Environment
Browser Environment
JavaScript Environment
Node.js Environment
JavaScript Console
Developer Tools
03. Variables
var
let
Variables
const
Temporal Dead Zone (TDZ)
Variable Hoisting
04. Data Types
Primitive Types
Reference Types
Type Conversion
Data Types
Type Coercion
Truthy & Falsy Values
typeof Operator
NaN — Not a Number
05. Operators
Arithmetic Operators
Comparison Operators
Logical Operators
Assignment Operators
Operators
Ternary Operator
Nullish Coalescing Operator
Optional Chaining
06. Control Flow
if-else
switch
Loops
break and continue
Guard Clauses
Control Flow
07. Functions
Function Declaration
Function Expression
Arrow Functions
Anonymous Functions
Named Functions
Callback Functions
Functions
Higher-Order Functions
Pure Functions
Recursion
IIFE
Default Parameters
Rest Parameters
arguments Object
Function Hoisting
08. Scope
Lexical Scope
Block Scope
Global Scope
Scope Chain
Closures
Scope
09. Arrays
Creating Arrays
Array Methods
map()
filter()
reduce()
forEach()
find() and findIndex()
some() and every()
Arrays
every()
flat() and flatMap()
sort()
Array Performance
10. Objects
Object Literals
Properties
Methods
Object Destructuring
Spread Operator
Object.freeze()
Object.seal()
Property Descriptors
Object.defineProperty()
Objects
Phase 2 — Core Concepts
Execution Context
Execution Context
Types of Execution Context
Creation Phase
Execution Phase
Lexical Environment
Call Stack
Stack Frames
Call Stack
Stack Overflow
Async Stack
Hoisting
Function Hoisting
var Hoisting
Hoisting
let/const Hoisting
Temporal Dead Zone
this Keyword
Default Binding
Implicit Binding
Explicit Binding
The this Keyword
new Binding
Arrow Functions and this
Common Pitfalls with this
Prototypes
The Prototype Chain
Setting Prototypes
Built-in Prototypes
Prototype vs Instance
Prototypes
Inheritance
Prototypal Inheritance
Class Inheritance
Composition vs Inheritance
Inheritance
Classes
Class Declaration
Constructor
extends & super
Getters & Setters
Static Members
Private Fields
Classes
Modules
Named Exports
Default Exports
Dynamic Import
ESM vs CommonJS
Modules
Iterators
Iteration Protocol
Custom Iterables
Iterators
Generators
Generator Functions
yield
Async Generators
Generators
Symbols
Creating Symbols
Well-Known Symbols
Symbols
Map
Map Methods
Map vs Object
Map Iteration
WeakMap
Map
Set
Set Methods
Set Operations
WeakSet
Set
WeakMap/WeakSet
WeakMap
WeakSet
WeakMap & WeakSet
Memory Management
Stack vs Heap
Memory Lifecycle
Memory Leaks
Memory Management
Garbage Collection
Mark-and-Sweep
Generational GC
Common Memory Leaks
Garbage Collection
Phase 3 — Async JS
Sync vs Async
Callbacks & Callback Hell
Promises
Promise Chaining
Promise APIs
Async/Await
Event Loop
Microtask & Macrotask
Fetch API
AbortController
Web Workers
requestAnimationFrame
Debounce & Throttle
Phase 4 — Browser APIs
DOM Overview
DOM Selectors
DOM Traversal
DOM Manipulation
Events
Bubbling & Capturing
Event Delegation
Forms
Web Storage
Cookies
IndexedDB
Clipboard API
History API
Location API
Navigator API
Geolocation
Intersection Observer
Mutation Observer
Resize Observer
Phase 5 — Modern JS
ES6+ Overview
Template Literals
Destructuring
Dynamic Import
Functional Programming
Currying
Composition
BigInt
Phase 6 — Performance
Rendering, Repaint & Reflow
Performance API
Memory Optimization
Lazy Loading
Tree Shaking & Code Splitting
Phase 7 — Design Patterns
Module Pattern
Singleton
Factory
Observer
Strategy
Command
Decorator
Proxy
Pub-Sub
Phase 8 — Internals
Parser
Compiler & Interpreter
V8 Architecture
Hidden Classes & IC
Event Loop Internals
Memory Layout
Phase 9 — Enterprise JS
Architecture
Folder Structure
Logging
Error Handling
Testing
Security
Clean Code
Best Practices
🎯 Interview Questions (150+)
Interview Questions
Overview
Fundamentals
Objects, Prototypes & Classes
Arrays & Collections
ES6+ & Modern JS
Async JavaScript
DOM & Browser APIs
Advanced & System Design
Trick Questions — Code Output
React Academy
Phase 1: React Fundamentals
Overview
1. Introduction to React & SPAs
2. Development Setup & Config
3. Virtual DOM & Reconciliation
4. JSX & Elements Under the Hood
Phase 2: Components & JSX
Overview
1. Component Fundamentals
2. Props & Data Flow
3. Advanced Component Patterns
Phase 3: State Management
Overview
1. Local State Basics & Queueing
2. Advanced Local State & Reducers
3. The Context API & Global State
Phase 4: React Hooks
Overview
1. Hook Fundamentals
2. useEffect & Lifecycles
3. Optimization Hooks
4. Creating Custom Hooks
5. Advanced & Edge Hooks
Phase 5: Routing & Data Fetching
Overview
1. Client-Side Routing
2. Data Fetching Basics
3. TanStack Query & Data Caching
Phase 6: Performance Optimization
Overview
1. Component Rendering Optimization
2. Code Splitting & Lazy Loading
3. State & List Optimization
Phase 7: Advanced React
Overview
1. Reconciliation & Diffing Deep Dive
2. Error Boundaries & Crash Recovery
3. Portals & Overlay Elements
4. Suspense & Dynamic Loading
5. Refs & forwardRef DOM Forwarding
6. Fiber Architecture & Concurrent Rendering
7. Hydration & SSR Architecture
Phase 8: Modern React
Overview
1. React Server Components (RSC)
2. Suspense-Driven Data Fetching
3. Server Actions & Mutations
4. The React Compiler
Phase 9: Architecture & Enterprise
Overview
1. Folder Structures & Modularity
2. State Management Architectures
3. Design Systems & Components
4. Feature-Based Architecture
5. Atomic Design in React
Phase 10: Production React & Testing
Overview
1. Testing Principles & Vitest
2. Deployment Strategies & CDNs
3. CI/CD Pipelines & Automation
React Interview Questions
Overview
Easy Questions
Medium Questions
Hard Questions
Quick Cheatsheet
Next.js
Next.js Overview
Fundamentals
Introduction to Next.js
Installing Next.js
Folder Structure
Routing
Special Files
Dynamic Routes
Layouts and Templates
Review & Practice
Core Concepts
Components
Server & Client Components
Styling
Data Fetching
Rendering Methods
Streaming & Suspense
Caching & Revalidation
Route Handlers
API Routes and Backend
Review & Practice
Data, State & Forms
Database Integration
State Management
Server Actions
Forms and Validation
Review & Practice
Authentication & Authorization
Overview
What is Authentication?
Auth vs Authorization
Session vs JWT
Cookies
Authentication Flow
Auth.js Introduction
Auth.js Installation
Auth.js Providers
Auth.js Session Management
Auth.js Basic Example
Middleware
Protected Pages
Protected API Routes
Role-Based Access
Google Login
GitHub Login
Custom Provider
Review & Practice
Performance & SEO
Overview
Why Performance Matters
Image Optimization
Font Optimization
Script Optimization
Lazy Loading
Bundle Optimization
Performance Best Practices
SEO Introduction
Metadata API
Open Graph
Robots.txt
Sitemap
Canonical URLs
SEO Best Practices
Caching Introduction
Cache Overview
Revalidation
Cache Control
Caching Examples
Review & Practice
Production & Deployment
Overview
Deployment Introduction
Vercel Deployment
Self-Hosting
Environment Variables
Deployment Checklist
Production Build
Build Analysis
Static Assets
Production Best Practices
Logging
Error Monitoring
Analytics
Performance Monitoring
Testing Introduction
Unit Testing
Integration Testing
E2E Testing
Testing Best Practices
Updating Dependencies
Upgrading Next.js
Security Updates
Maintenance Checklist
Review & Practice
Enterprise Architecture
Overview
Folder Structure
Feature-Based Architecture
Shared Components
Reusable Hooks
Naming Conventions
Separating Concerns
Reusable Utilities
Constants & Config
API Layer
Environment Management
Project Scaling
Module Organization
Code Splitting
Lazy Loading
Scalability Best Practices
Protecting Env Variables
API Security
Auth Best Practices
Authorization Best Practices
Common Security Mistakes
Clean Code
Documentation
Code Review
Refactoring
Project Checklist
Review & Practice
Real-World Projects
Overview
Portfolio — Overview
Portfolio — Project Overview
Portfolio — Folder Structure
Portfolio — Building Pages
Portfolio — Deployment
Portfolio — Improvements
Blog — Overview
Blog — Project Overview
Blog — Markdown Blog
Blog — Dynamic Routing
Blog — SEO
Blog — Deployment
Dashboard — Overview
Dashboard — Project Overview
Dashboard — Authentication
Dashboard — Layout
Dashboard — Charts
Dashboard — Deployment
E-Commerce — Overview
E-Commerce — Project Overview
E-Commerce — Product Listing
E-Commerce — Shopping Cart
E-Commerce — Checkout
E-Commerce — Deployment
AI App — Overview
AI App — Project Overview
AI App — AI Integration
AI App — Chat Interface
AI App — Streaming Response
AI App — Deployment
Review & Practice
Advanced
Security Best Practices
Parallel & Intercepting Routes
Edge & Node.js Runtimes
Partial Prerendering (PPR)
Advanced Concepts
Review & Practice
Legacy — Middleware & Auth
Middleware
Authentication
Review & Practice
Legacy — Performance & SEO
Performance Optimization
Image, Font & Script Optimization
Metadata & SEO
SEO in Next.js
Review & Practice
Legacy — Production
Error Handling
Deployment
Testing
Review & Practice
Angular
Overview
Phase 1: Fundamentals
01-angular-fundamentals
Angular Fundamentals Overview
1. Introduction to Angular
2. Development Environment Setup
Angular Architecture
4. Angular Core Concepts
Angular CLI
Angular Workspace
TypeScript Configuration (tsconfig.json)
Angular JSON Configuration
02-typescript
TypeScript Fundamentals
3. TypeScript Fundamentals for Angular
Interfaces in TypeScript
Access Modifiers in TypeScript
Generics in TypeScript
Decorators in TypeScript
Enums in TypeScript
03-components
Creating Components
Component Lifecycle
Components
Component Communication
Standalone Components
Component Best Practices
04-data-binding
Interpolation
Property Binding
Event Binding
Data Binding
Two-Way Binding
05-directives
Structural Directives
Attribute Directives
Custom Directives
Directives
06-pipes
Built-in Pipes
Custom Pipes
Pipes
07-services
Creating Services
Dependency Injection Introduction
Services & Dependency Injection
Phase 2: Components, Routing & Forms
01-routing
Routing
Router Setup & Basics
Child Routes
Lazy Loading
Route Guards
Resolvers
Route Data
02-forms
Introduction to Forms
Angular Forms
Template-Driven Forms
Reactive Forms
FormGroup
FormControl
FormArray
Built-in Validators
Custom Validators
Async Validators
Dynamic Forms
Nested Forms
Reusable Form Components
Forms Best Practices
03-dependency-injection
Injectors
Providers
Dependency Injection
inject() Function
Hierarchical DI
Phase 3: Advanced
01-rxjs
RxJS
Observables
RxJS Subjects
RxJS Operators
switchMap
mergeMap
concatMap
exhaustMap
combineLatest
forkJoin
takeUntil
Error Handling
02-state-management
Component State
State Management
Service-based State
Signals for State
NgRx
ComponentStore
03-performance
OnPush Change Detection
trackBy
Performance Optimization
Lazy Loading & Preloading
Preloading Strategies
Change Detection Deep Dive
Memoization
Phase 4: Enterprise
01-architecture
Angular Architecture
Smart vs Dumb Components
Feature Modules
Folder Structure
Scalable Architecture
Clean Architecture
Micro-Frontends
02-authentication
Authentication
Authentication & Authorization
Authorization
JWT Tokens
Token Refresh
Auth Route Guards
03-http
HttpClient
HTTP Interceptors
HTTP Client
Retry Strategies
HTTP Caching
File Upload
File Download
04-testing
Unit Testing
Integration Testing
Mocking
Testing
Jasmine
Karma
Cypress
Phase 5: Modern Angular
01-signals
Angular Signals
Writable Signals
Computed Signals
Effects
Signal Inputs & Model
Migration from RxJS/Observables to Signals
resource() & rxResource()
linkedSignal()
02-control-flow
@if
New Control Flow
@switch
@for
@defer
@let Syntax
03-standalone
Standalone Components
Standalone Routing
Standalone Components
Standalone Services
04-ssr
Server-Side Rendering
Hydration
Pre-rendering
SSR & Hydration
SEO with Angular SSR
05-zoneless
Zoneless Change Detection
Zoneless Mode
🎯 Interview Questions (100+)
SQL / MySQL
SQL / MySQL Overview
Database Basics
Database & RDBMS Basics
MySQL Architecture
Data Types
Keys & Constraints
Normalization
Querying Data
CRUD Operations
Aggregations & Functions
Subqueries & CTEs
Views
Window Functions
Set Operations
CASE & Conditional Logic
Query Execution Order
NULL Handling
Joins
Joins Overview
INNER JOIN
LEFT JOIN
RIGHT JOIN
FULL OUTER JOIN
CROSS JOIN
SELF JOIN
Exclusion Joins
JOIN Conditions & Pitfalls
Choosing the Right Join
Performance & Transactions
Indexing
EXPLAIN & Query Optimization
Performance Optimization
Transactions & ACID
Isolation Levels & Deadlocks
Locks
Programmability
Stored Procedures & Functions
Triggers
Administration & Scaling
Users & Privileges
Backup & Restore
Replication
Partitioning & Sharding
JSON & Full-Text Search
Interview & Revision
🎯 Interview Questions (150+)
MySQL Interview Prep
Common Interview Questions
Quick Revision Cheat Sheet
Quick Reference Summary
MongoDB
MongoDB Overview
Getting Started
What is MongoDB?
Installation & Tools
Documents & Collections
Core MongoDB
Fundamentals & CRUD
Query & Filtering
Data Modeling
Indexing
Aggregation Framework
Aggregation Overview
Pipeline Basics & Stages
$match, $project, $sort
$group & Accumulators
$lookup & $unwind
Expressions & Computed Fields
Real-World Examples
Aggregation Optimization
Operations
Replication & Replica Sets
Sharding
Transactions
Read & Write Concern
Change Streams
Performance & explain()
Security
Authentication & Authorization
Schema Validation
Security Best Practices
Integration
Mongoose — Node.js
Interview & Revision
🎯 Interview Questions (150+)
Top 100 Interview Questions
Quick Reference Cheat Sheet
Advanced Topics Hub
Redis
Redis Overview
Core Concepts
Introduction to Redis
In-Memory Database
Redis Architecture
Installing Redis
Data Types Overview
Data Types
Strings
Lists
Sets
Sorted Sets
Hashes
Streams
Features & Patterns
Key Expiration & TTL
Persistence
Pub/Sub
Transactions
Caching Patterns
Eviction Policies
Distributed Locks
Scaling & High Availability
Replication
Sentinel
Cluster
Integration & Commands
Redis with Node.js
Redis with Docker
Commands Cheat Sheet
Security
Practice & Interview
🎯 Interview Questions (150+)
Common Beginner Mistakes
Best Practices
Interview Questions
Learning Roadmap
Data Structures
Home
Fundamentals
Algorithm Basics
Time Complexity
Big-O Notation
O(1) Constant Time
O(log n) Logarithmic
O(n) Linear
O(n²) Quadratic
How to Find Time Complexity (Step-by-Step)
Quick Pattern Recognition
Worked Examples
Space Complexity
Complexity Summary
Data Structures & Algorithms Handbook
Table of Contents (Index)
Arrays
Arrays Overview
Two Sum Problem
Array Problems
Array Methods
Transformation Methods
Extract / Copy Methods
Modify (Mutating) Methods
Search / Check Methods
Utility Methods
JavaScript Array Methods (Interview Ready)
Strings
Strings
String Basics
Two-Pointer String Problems
Pattern Matching
String Problems
Matrix
Matrix Traversals
Matrix Problems
Hashing
Hash, HashMap, and Set in JavaScript
What is a Hash?
HashMap in JavaScript
When to Use Map vs Object
Set in JavaScript
Map vs Set Quick Difference
Most Important Set Pattern (Interview Favorite)
Stacks & Queues
Stack (LIFO)
Queue (FIFO)
Stack Implementation
Queue Implementation
Deque (Double-Ended Queue)
Priority Queue & Heap
Monotonic Stack
Stack & Queue Problems
Heap & Priority Queue
Priority Queue & Heap
Heap Operations
Heap Sort
Top K Elements (Heap Pattern)
Linked List
Linked List
What is a Linked List?
Types of Linked Lists
Time & Space Complexity
Core Operations
Important Patterns
Key Algorithms
Problem-Solving Approach
Interview Questions
Tips & Common Mistakes
Trees
Trees
Introduction to Trees
Types of Trees
Special Trees
Tree Representation
Time & Space Complexity
Tree Traversals
Important Tree Patterns
BST Operations
Heap Operations
Problem-Solving Approach
Code Examples
Interview Questions
Tips & Common Mistakes
Real-World Applications
Trie (Prefix Tree)
AVL Tree (Self-Balancing BST)
Red-Black Tree (Concept)
Segment Tree
Fenwick Tree (Binary Indexed Tree)
Graphs
Graphs
Introduction to Graphs
Graph Representations
Time & Space Complexity
Graph Traversals — BFS & DFS
Important Graph Patterns
Key Graph Algorithms
Problem-Solving Approach
Code Examples
Interview Questions
Tips & Common Mistakes
Real-World Applications
Dijkstra's Algorithm
Bellman-Ford Algorithm
Floyd-Warshall Algorithm
Topological Sort
Union-Find (Disjoint Set Union)
Minimum Spanning Tree: Kruskal & Prim
Cycle Detection in Graphs
Sorting
Sorting Algorithms
Sorting Algorithms — Introduction
Bubble Sort
Selection Sort
Insertion Sort
Merge Sort
Quick Sort
Heap Sort
Sorting Algorithms — Complexity Comparison
Sorting Algorithms — Interview Questions
Counting Sort
Radix Sort
Bucket Sort
Stability & When to Use Each Sort
Binary Search
Binary Search
Binary Search — Introduction
02-patterns
Pattern 1 — Classic Binary Search
Binary Search Patterns
Pattern 2 — First / Last Occurrence
Pattern 3 — Binary Search on Answer Space
Pattern 4 — Rotated Sorted Array
Pattern 5 — Binary Search on Monotonic Function
03-problems
Problem 1 — Search in Rotated Sorted Array
Problem 2 — Find Minimum in Rotated Array
Binary Search Problems
Problem 3 — Search a 2D Matrix
Problem 4 — Find Peak Element
Problem 5 — Koko Eating Bananas
Problem 6 — Capacity to Ship Packages
Problem 7 — Split Array Largest Sum
Problem 8 — Find Sqrt(x)
Problem 9 — First Bad Version
Problem 10 — Time-Based Key-Value Store
04-advanced
Floating-Point Binary Search
Find Median of Two Sorted Arrays
Exponential & Interpolation Search
Advanced Binary Search Applications
Real-World Binary Search Problems
05-interview-questions
Theory & Fundamentals
Pattern Recognition
Tricky Variations
Binary Search Interview Questions
5 Core Patterns
Pattern 1 — Classic Binary Search
Binary Search Patterns
Pattern 2 — First / Last Occurrence
Pattern 3 — Binary Search on Answer Space
Pattern 4 — Rotated Sorted Array
Pattern 5 — Binary Search on Monotonic Function
10 Classic Problems
Problem 1 — Search in Rotated Sorted Array
Problem 2 — Find Minimum in Rotated Array
Binary Search Problems
Problem 3 — Search a 2D Matrix
Problem 4 — Find Peak Element
Problem 5 — Koko Eating Bananas
Problem 6 — Capacity to Ship Packages
Problem 7 — Split Array Largest Sum
Problem 8 — Find Sqrt(x)
Problem 9 — First Bad Version
Problem 10 — Time-Based Key-Value Store
Advanced Topics
Floating-Point Binary Search
Find Median of Two Sorted Arrays
Exponential & Interpolation Search
Advanced Binary Search Applications
Real-World Binary Search Problems
Interview Questions
Theory & Fundamentals
Pattern Recognition
Tricky Variations
Binary Search Interview Questions
Recursion & Backtracking
Recursion & Backtracking
Introduction to Recursion
Understanding the Call Stack
Types of Recursion
Basic Recursion Problems
Recursion Patterns
Introduction to Backtracking
Backtracking Patterns
Advanced Backtracking
Problem-Solving Approach
Time & Space Complexity
Code Examples
Interview Questions
Common Mistakes & Tips
Real-World Applications
Dynamic Programming
Dynamic Programming
04-1d-dp
1D DP Problems
Climbing Stairs
House Robber
Coin Change
Kadane's Algorithm
05-2d-dp
2D DP Problems
Unique Paths
0/1 Knapsack
Longest Common Subsequence (LCS)
Edit Distance (Levenshtein Distance)
06-string-dp
String DP Problems
Longest Palindromic Substring
Longest Palindromic Subsequence (LPS)
Word Break
Interleaving String
Dynamic Programming — Introduction
Memoization (Top-Down DP)
Tabulation (Bottom-Up DP)
DP Patterns Guide
DP — Complexity Analysis
Dynamic Programming — Interview Questions
1D DP Problems
1D DP Problems
Climbing Stairs
House Robber
Coin Change
Kadane's Algorithm
2D DP Problems
2D DP Problems
Unique Paths
0/1 Knapsack
Longest Common Subsequence (LCS)
Edit Distance (Levenshtein Distance)
String DP Problems
String DP Problems
Longest Palindromic Substring
Longest Palindromic Subsequence (LPS)
Word Break
Interleaving String
Greedy
Greedy Algorithms
Greedy Algorithms — Introduction
Classic Greedy Problems
Huffman Coding
Bit Manipulation
Bit Manipulation
Bit Manipulation — Introduction
Bit Manipulation Tricks
Bit Manipulation Problems
Math
Math & Number Theory
GCD, LCM & Euclid's Algorithm
Primes & Sieve of Eratosthenes
Modular Arithmetic & Fast Power
Math Problems
Interview Prep
Interview Prep
JavaScript Array Methods
Map & Set Patterns
Two Pointer Technique
Sliding Window
Frequency Counter
Recursion & Backtracking for Interviews
Coding Problems
Pro Interview Tips
Study Plan & Cheat Sheet
Prefix Sum Pattern
Fast & Slow Pointers Pattern
Merge Intervals Pattern
Top K Elements (Heap Pattern)
Monotonic Stack Pattern
Greedy Patterns
Striver Blind 75 Solutions
All 75 Problems Overview
01. Arrays
Best Time to Buy and Sell Stock
Container With Most Water
Contains Duplicate
Find Minimum in Rotated Sorted Array
Maximum Product Subarray
Maximum Subarray
Product of Array Except Self
Search in Rotated Sorted Array
3Sum
Two Sum
02. Bit Manipulation
Missing Number
Counting Bits
Number of 1 Bits
Reverse Bits
Sum of Two Integers
03. Dynamic Programming
Climbing Stairs
Coin Change
Combination Sum
Decode Ways
House Robber
House Robber II
Jump Game
Longest Common Subsequence
Longest Increasing Subsequence
Unique Paths
Word Break
04. Graphs
Alien Dictionary
Clone Graph
Course Schedule
Graph Valid Tree
Longest Consecutive Sequence
Number of Connected Components in an Undirected Graph
Number of Islands
Pacific Atlantic Water Flow
05. Intervals
Insert Interval
Meeting Rooms
Meeting Rooms II
Merge Intervals
Non-overlapping Intervals
06. Linked List
Linked List Cycle
Merge k Sorted Lists
Merge Two Sorted Lists
Remove Nth Node From End of List
Reorder List
Reverse Linked List
07. Matrix
Rotate Image
Set Matrix Zeroes
Spiral Matrix
Word Search
08. Strings
Encode and Decode Strings
Group Anagrams
Longest Palindromic Substring
Longest Repeating Character Replacement
Longest Substring Without Repeating Characters
Minimum Window Substring
Palindromic Substrings
Valid Anagram
Valid Palindrome
Valid Parentheses
09. Trees & BST
Binary Tree Level Order Traversal
Binary Tree Maximum Path Sum
Construct Binary Tree from Preorder and Inorder Traversal
Invert Binary Tree
Kth Smallest Element in a BST
Lowest Common Ancestor of a Binary Search Tree
Maximum Depth of Binary Tree
Same Tree
Serialize and Deserialize Binary Tree
Subtree of Another Tree
Validate Binary Search Tree
10. Tries & Heaps
Design Add and Search Words Data Structure
Find Median from Data Stream
Implement Trie (Prefix Tree)
Top K Frequent Elements
Word Search II
Node.js
Node.js Overview
1. Fundamentals
1️⃣ Node.js Fundamentals
Introduction to Node.js
Node.js Architecture & Event Loop
npm & package.json
Modules: CommonJS vs ESM
Core Built-in Modules
Installation & Setup
Debugging Node.js Applications
Node.js with TypeScript
2. Core Concepts
Async Programming in Node.js
2️⃣ Core Concepts
Event Emitter
Streams & Buffers
Error Handling
3. Web Development
Building REST APIs
Express.js Framework
3️⃣ Web Development
Input Validation
File Uploads
Authentication & Security
WebSockets & Real-Time
GraphQL
4. Data Layer
Working with Databases
Caching
Message Queues
4️⃣ Data Layer
5. Production
Configuration & Environment
Logging & Monitoring
Testing
Deployment & CI/CD
5️⃣ Production
Performance Optimization
Clustering & Worker Threads
Design Patterns in Node.js
Production Architecture & Security Hardening
Real-World Project Architecture
6. Advanced Topics
Native Addons
Building CLI Tools
Event Sourcing
Monorepos & Workspaces
WebAssembly with Node.js
6️⃣ Advanced Topics
7. System Design
URL Shortener Design
Chat System Design
Distributed Rate Limiter
Task Management System
E-Commerce Backend Design
7️⃣ System Design
🎯 Interview Questions (150+)
GraphQL
GraphQL Overview
01. Basics
What is GraphQL?
GraphQL vs REST
Schema & Types
02. Operations
Queries
Mutations
Subscriptions
03. Server
Resolvers
Building a GraphQL Server
Connecting Data
04. Client & Practice
Client Usage
Errors & Validation
Best Practices
05. Interview
Interview Questions
Python
Python Overview
Introduction
What is Python?
History of Python
Features of Python
How Python Works Internally
Python Use Cases
Setup & Environment
Installing Python
Python REPL
Python IDEs and Tools
Virtual Environments
pip and Packages
Python Basics
First Python Program
Variables and Data Types
Operators in Python
Type Casting and Conversion
User Input and Output
Pythonic Style & PEP 8
Strings
String Basics
String Formatting
Unicode and String Performance
Numbers & Math
Numbers in Python
Math Module
Collections
Lists in Python
Tuples in Python
Sets in Python
Dictionaries in Python
Comprehensions in Python
Control Flow
Conditionals (if/elif/else)
Loops (for and while)
Pattern Matching (match/case)
Functions
Functions in Python
Function Parameters and Arguments
Lambda Functions
Scope and Namespace
Recursion in Python
Exception Handling
Exception Handling (try/except)
Custom Exceptions
Object-Oriented Programming
Classes and Objects
Encapsulation and Properties
Inheritance in Python
Polymorphism and Abstract Classes
Advanced OOP Topics
Modules & Packages
Modules and Packages
Packages in Python
Import System
File Handling
Reading and Writing Files
CSV, JSON, and Binary Files
Context Managers (with Statement)
Regular Expressions
Regular Expression Syntax
The re Module
Iterators, Generators & Decorators
Iterators in Python
Generators in Python
Decorators in Python
Advanced Concepts
Functional Programming
Memory Management and Garbage Collection
Type Hints & the typing Module
Dataclasses & Enums
*args, **kwargs & Unpacking
Descriptors & Metaclasses
Standard Library
collections Module
itertools & functools
datetime Module
os, sys & pathlib
logging Module
Concurrency
Threading in Python
Multiprocessing in Python
Async/Await (asyncio)
The Global Interpreter Lock (GIL)
Database Programming
SQL in Python (sqlite3)
ORMs in Python
NoSQL with Python
Testing
unittest Framework
pytest Framework
🎯 Interview Questions (150+)
Interview Preparation
Python Interview Questions
TypeScript
Introduction
Setup
Basic Types
Overview
Primitive Types
Special Types
Arrays & Tuples
Type Inference
Type System
Union Types
Intersection Types
Literal Types
Enums
Tuples
Functions
Functions Overview
Function Annotations
Function Overloads
Async Functions
Objects & Interfaces
Objects
Interfaces
Type Aliases
Index Signatures
Nested Objects
Property Modifiers
Excess Property Checks
Extending Interfaces
Declaration Merging
Interface vs Type
Generics
Generics Overview
Generic Constraints
Generic Patterns
Advanced Generics
Utility Types
Advanced Types
Mapped Types
Conditional Types
Indexed Access Types
Type Guards
Type Branding
Satisfies Operator
Assertion Functions
Template Literal Types
Async/Await Deep Dive
Error Handling Patterns
Architecture
Decorators
Namespaces
Modules
Declaration Files
tsconfig
React + TypeScript
React TypeScript Overview
Props Types
Hooks Types
Event Types
Context Types
Custom Hooks
State Management
Angular + TypeScript
Angular TypeScript Overview
Service Types
Form Types
RxJS Types
DI Types
Node.js + TypeScript
Node TypeScript Overview
Express Types
DTO Patterns
Middleware Types
Error Handling
Database Types
Interview Questions
Cheatsheet
Roadmap
Cloud & AWS
Cloud & AWS Overview
01. Fundamentals
What is Cloud Computing?
What is AWS?
IAM Basics
Cloud Deployment Models & Shared Responsibility
02. Compute
EC2 — Virtual Servers
Lambda — Serverless Functions
Elastic Beanstalk & Containers
Messaging, APIs & Workflows
03. Storage & Database
S3 — Object Storage
EBS vs S3 vs EFS
Databases on AWS
04. Networking & Delivery
VPC Basics
Route53 & CloudFront
Load Balancing & Auto Scaling
05. Deployment
Deploying a Web App
CI/CD on AWS
Monitoring & Billing
Infrastructure as Code
06. Interview
Interview Questions
AWS CLI Cheat Sheet
🎯 Interview Questions (150+)
Docker
Docker Overview
Fundamentals
Docker Fundamentals
Introduction to Docker
What are Containers
Docker Architecture
How Containers Work (Internals)
Installing Docker
Docker Images
Image Layers & Build Caching
Docker Containers
Docker CLI Deep Dive
Port Mapping
Docker Volumes
Docker Networks
Environment Variables
Resource Limits
Healthchecks
Docker Logs and Monitoring
Docker Exec
Docker Hub
Real Project Examples
Common Docker Commands Cheat Sheet
Common Mistakes Beginners Make
Best Practices
Interview Questions
Summary
Advanced Docker
Advanced Docker
Deep Dive into Dockerfile
Dockerfile Optimization
Multi-Stage Builds
BuildKit & Buildx
Docker Compose
Real Multi-Container Projects
Docker Networking Advanced
Docker Volumes Advanced
Docker Security
Docker in Production
Docker Registry
Docker CI/CD Integration
Monitoring Containers
Docker Backup and Recovery
Docker Best Practices
Docker Troubleshooting
Docker vs Kubernetes
Docker Interview Questions
Final Learning Roadmap
Practice Exercises
Orchestration
Docker Orchestration
Why Orchestration?
Docker Swarm
Intro to Kubernetes
🎯 Interview Questions (150+)
Design Patterns & SOLID
Overview
01. Fundamentals
What Are Design Patterns?
OOP Refresher
02. SOLID Principles
S — Single Responsibility
O — Open/Closed
L — Liskov Substitution
I — Interface Segregation
D — Dependency Inversion
03. Creational
Singleton
Factory Method
Abstract Factory
Builder
Prototype
04. Structural
Adapter
Decorator
Facade
Proxy
Composite
Bridge
Flyweight
05. Behavioral
Observer
Strategy
Command
Iterator
State
Template Method
Chain of Responsibility
Mediator
Memento
Visitor
06. Practical Guide
Choosing a Pattern
Anti-Patterns
Patterns in Real Frameworks
07. Interview
Interview Questions
System Design
Overview
Fundamentals
What is System Design?
How to Approach a System Design Problem
Functional vs Non-Functional Requirements
Back-of-the-Envelope Estimation
Building Blocks
Client-Server Model
Vertical vs Horizontal Scaling
Load Balancing
DNS & CDN
Proxies & API Gateway
Databases
SQL vs NoSQL
Database Types
Database Replication
Sharding & Partitioning
Indexing Basics (System Design)
ACID vs BASE
CAP Theorem & PACELC
Caching
Caching Basics
Cache Strategies
Eviction & Invalidation
Communication
Synchronous vs Asynchronous Communication
REST vs gRPC vs GraphQL
WebSockets & Real-Time Communication
Message Queues & Streaming
Event-Driven Architecture
Architecture Patterns
Monolith vs Microservices
Serverless Architecture
CQRS & Event Sourcing
Saga & Distributed Transactions
Layered & Hexagonal Architecture
Distributed Systems
Consistency Models
Consensus & Leader Election
Idempotency & Retries
Clocks & Ordering
Fault Tolerance & Redundancy
Reliability & Scale
Availability & SLAs
Rate Limiting & Throttling
Backpressure & Circuit Breakers
Observability
Security
Authentication & Authorization
Encryption & TLS
Common Attacks & Defenses
Interview Guide
The System Design Interview Framework
Common System Design Mistakes
Trade-Off Cheat Sheet
Case Studies
Design a URL Shortener
Design a Rate Limiter
Design a News Feed (Twitter/Instagram)
Design a Chat System (WhatsApp/Messenger)
Design Video Streaming (YouTube/Netflix)
Design a Ride-Sharing System (Uber)
Design a Notification System
Design a Web Crawler
Design Search Autocomplete
Design a Distributed Cache
Design File Storage (Dropbox/Google Drive)
Design a Payment System
Design a Ticket Booking System (BookMyShow/Ticketmaster)
Design an E-commerce Order System (Amazon)
Design a Distributed Key-Value Store (DynamoDB/Cassandra)
Design a Proximity Service (Yelp/Nearby Places)
Design a Collaborative Editor (Google Docs)
Design a Distributed Job Scheduler
Design an Ad Click Aggregation System
Design a Distributed Lock Service
Design Twitter/X — Timeline, Retweets & Trending Topics
Design Instagram — Image Pipeline, Stories & Discovery
Design a Distributed Search Engine (Elasticsearch-style)
Design an API Gateway
Design UPI (Unified Payments Interface)
Design a Short-Video Platform (TikTok/Reels)
Design Real-Time Chat & Voice (Discord/Slack)
Design Property & Hotel Booking (Airbnb)
Design a Metrics & Monitoring System (Prometheus)
Design a Distributed Message Queue (Kafka)
High-Level Design (HLD)
HLD Overview
Fundamentals
01. Introduction to HLD
02. Requirements
03. Capacity Estimation
04. Monolith vs Microservices
Architecture Components
05. Load Balancers
06. API Gateway
07. Caching Strategies
08. Database Selection
09. Message Queues
10. Event-Driven Architecture
11. CDN Design
12. Auth Architecture
13. File Storage
Advanced Topics
14. Monitoring & Observability
15. High Availability
16. Disaster Recovery
17. Cloud Architecture
18. Multi-Tenant Systems
19. Real-Time Systems
20. System Design Interviews
Case Studies
1. URL Shortener
2. Chat System (WhatsApp)
3. Video Streaming (YouTube)
4. Ride Sharing (Uber)
5. News Feed
6. Cloud Storage (Google Drive)
7. Notification System
8. Payment System
9. Proximity Service (Yelp)
10. Search Autocomplete
Low-Level Design (LLD)
LLD Overview
01. OOP & Design Principles
01. OOP Fundamentals
02. SOLID Principles
03. UML Basics
04. Class Diagrams
05. Object Relationships
02. Code & Architecture
06. Design Principles
07. Dependency Injection
08. Design Pattern Selection
09. Machine Coding Approach
10. Code Organization
LLD Projects
1. Parking Lot
2. ATM
3. BookMyShow
4. Library Management
5. Hotel Management
6. Elevator System
7. Vending Machine
8. Splitwise
9. Chess Game
10. Snake & Ladder
11. Tic Tac Toe
12. Logging Framework
13. Notification Service
14. Rate Limiter
15. Cache System
Interview Prep
Fullstack Interview Questions
Interview Prep
📁 Interview Preparation Content Structure Overview
Behavioral Interview Prep
Question Bank & Story Builder ↗
Guides
The STAR Method
Amazon Leadership Principles
Company Interview Styles
What Changes By Seniority
Behavioral Interview Prep
GitHub
Select theme
Dark
Light
Auto
O(n) Linear
O(n) Linear
Section titled “O(n) Linear”
for
(
let
item
of
array
) {
console
.
log
(
item
);
}