My Wiki
String APIs
Initializing search
My Wiki
Home
Dart
Dart
Getting Started
Getting Started
What is Dart?
Installing Dart
Running Dart Programs
Project Structure
Language Tour
Fundamentals
Fundamentals
Variables
Null Safety
Type System
Type Inference
Operators
Control Flow
Functions
Collections
Records
Patterns
Pattern Matching
Destructuring
Enums
Extensions
Extension Types
Typedefs
Metadata (Annotations)
Comments & Documentation
Object-Oriented Programming
Object-Oriented Programming
Classes
Constructors
Fields
Methods
Getters & Setters
Inheritance
Mixins
Abstract Classes
Interfaces
Sealed Classes
Base Classes
Interface Classes
Final Classes
Factory Constructors
Callable Classes
Object Lifecycle
Generics
Generics
Generic Classes
Generic Functions
Type Bounds
Generic Methods
Covariance
Variance
Asynchronous Programming
Asynchronous Programming
Future
async & await
FutureOr
Streams
StreamController
async*
sync*
Isolates
Zones
Async Error Handling
Error Handling
Error Handling
Exceptions
try-catch
finally
throw
Custom Exceptions
Assertions
Libraries & Packages
Libraries & Packages
Libraries Overview
Imports
Exports
Parts
Deferred Loading
Packages
Core Libraries Deep Dive
Core Libraries Deep Dive
dart:core Object
dart:core String
dart:core Numbers
dart:core Boolean
dart:core Collections
dart:core Iterable & Iterator
dart:core DateTime & Duration
dart:core RegExp
dart:core Uri & Symbol
dart:async Overview
dart:convert
dart:io
dart:math
dart:collection
dart:isolate
dart:typed_data
dart:developer
Concurrency
Concurrency
Event Loop
Microtask Queue
Isolates Deep Dive
Message Passing
Scheduling
Testing & Benchmarking
Testing & Benchmarking
Unit Testing
Mocking
Test Matchers
Benchmarking
Performance Architecture
Performance Architecture
Memory Management
Garbage Collection
Const Optimizations
Lazy Initialization
Collections Performance
Compiler Optimizations
Best Practices
Best Practices
Effective Dart
Naming Conventions
API Design
Immutability
Error Handling Patterns
Project Structure
Common Pitfalls
Structural Comparisons
Structural Comparisons
Future vs Stream
List vs Set vs Map
Mixin vs Extension
Abstract Class vs Interface
Factory vs Generative Constructor
Record vs Class
Pattern vs Switch
Extension vs Extension Type
final vs const
Quick API Cheat Sheet
Quick API Cheat Sheet
Collections
Async APIs
String APIs
DateTime APIs
Iterable APIs
Language Keywords
Flutter
Flutter
Getting Started
Getting Started
What is Flutter?
Installation
Project Structure
Running Your First App
Hot Reload vs Hot Restart
Framework Architecture
Framework Architecture
Flutter Architecture
Widget Tree
Element Tree
Render Tree
Build Process
Rendering Pipeline
Frame Scheduling
Constraints
Layout Process
Widgets Underlying
Widgets Underlying
What is a Widget?
StatelessWidget
StatefulWidget
BuildContext
Keys
Widget Lifecycle
Widget Composition
Widget Catalog
Layout Engine
Layout Engine
Constraints Concept
Box Model
Flex Layout
Row
Column
Flex
Stack
Wrap
Flow
Align
Center
SizedBox
Expanded
Flexible
Spacer
AspectRatio
FractionallySizedBox
Intrinsic Widgets
Custom Layouts
Scrolling & Viewports
Scrolling & Viewports
ScrollView
ListView
GridView
CustomScrollView
Slivers
ScrollController
ScrollPhysics
Nested Scrolling
Infinite Scrolling
Navigation
Navigation
Navigator
Routes
Named Routes
Router API
Deep Linking
Route Guards
Navigation Patterns
State Management Base
State Management Base
Local State
InheritedWidget
InheritedModel
ValueNotifier
ChangeNotifier
Listenable
Restoration
State Management Overview
Forms & Input
Forms & Input
TextField
TextEditingController
Form
Form Validation
Focus
Keyboard Handling
Input Formatters
Animation
Animation
Implicit Animations
Explicit Animations
AnimationController
Tween
Curves
Hero
AnimatedBuilder
CustomPainter Animation
Physics Animations
Gestures
Gestures
GestureDetector
InkWell
Pointer Events
Drag & Drop
Hit Testing
Low-Level Rendering
Low-Level Rendering
CustomPaint
CustomPainter
Canvas
RenderObject
RenderBox
Layers
Compositing
Images & Assets
Images & Assets
Asset Management
Image Widget
Network Images
Caching
SVG
Asset Bundles
Theming
Theming
ThemeData
ColorScheme
Material 3
Typography
Dark Mode
Dynamic Color
Custom Themes
Platform Integration
Platform Integration
Platform Channels
MethodChannel
EventChannel
FFI
Plugins
Platform Views
Async UI
Async UI
FutureBuilder
StreamBuilder
ValueListenableBuilder
AnimatedBuilder
Async Patterns
Performance Optimization
Performance Optimization
Rebuild Optimization
const Widgets
Keys
Widget Splitting
RepaintBoundary
Image Optimization
DevTools
Profiling
Testing Suite
Testing Suite
Unit Tests
Widget Tests
Integration Tests
Golden Tests
Test Utilities
Accessibility
Accessibility
Semantics
Screen Readers
Keyboard Navigation
Accessibility Best Practices
Best Practices
Best Practices
Project Structure
Folder Organization
Separation of Concerns
Error Handling
Responsive Design
Adaptive Design
Architecture Patterns
Deep Comparisons
Deep Comparisons
StatelessWidget vs StatefulWidget
Row vs Column vs Flex
Expanded vs Flexible
ListView vs CustomScrollView
FutureBuilder vs StreamBuilder
GestureDetector vs InkWell
Navigator 1.0 vs Router API
Implicit vs Explicit Animation
State Management Approaches
Framework Cheat Sheet
Framework Cheat Sheet
Layout Widgets
Input Widgets
Scrolling Widgets
Animation Widgets
Builder Widgets
Common Patterns
Drift
Drift
Getting Started
Getting Started
What is Drift?
Installation
Setting Up a Database
Code Generation
Your First Query
Database Architecture
Database Architecture
GeneratedDatabase
Database Connection
Database Lifecycle
Opening the Database
Database Configuration
Multiple Databases
Schema Tables
Schema Tables
Defining Tables
Columns
Constraints
Primary Keys
Composite Keys
Foreign Keys
Default Values
Generated Columns
Custom Types
Table Inheritance
Data Classes & Mapping
Data Classes & Mapping
Generated Data Classes
Companions
Value Types
Insertable Interface
Custom Data Classes
CRUD Operations
CRUD Operations
Insert
Batch Insert
Update
Replace
Delete
Upsert
Returning Rows
Batch Operations
Query Builder Engine
Query Builder Engine
Select
Filtering
Ordering
Limiting
Distinct
Aliases
Expressions
Custom SQL Expressions
Dynamic Queries
SQL Joins & Relations
SQL Joins & Relations
Inner Join
Left Join
Cross Join
Self Join
Many-to-Many
One-to-Many
One-to-One
Mapping Joined Results
Reactive Streams
Reactive Streams
Watching Queries
Stream Updates
Reactive Queries
Watching Multiple Tables
Stream Performance
Transactions
Transactions
Transactions Overview
Nested Transactions
Batch vs Transaction
Rollback Behavior
Advanced SQL Features
Advanced SQL Features
Custom SQL
SQL Variables
Views
Indexes
Triggers
Common Table Expressions
Window Functions
SQLite Functions
Schema Migrations
Schema Migrations
Schema Versions
Migration Strategy
Migration Examples
Destructive Migrations
Testing Migrations
Best Practices
Type Converters
Type Converters
TypeConverter API
Enum Conversion
DateTime Conversion
JSON Conversion
Custom Objects
Reusable Converters
DAOs (Data Access Objects)
DAOs (Data Access Objects)
What is a DAO?
Defining DAOs
Organizing Queries
Injecting Dependencies
Best Practices
Performance Optimization
Performance Optimization
Indexing Strategy
Query Optimization
Batch Operations
Lazy Loading
Avoiding N+1 Queries
Stream Efficiency
Testing Suite
Testing Suite
In-Memory Database
Testing Queries
Testing DAOs
Mocking Dependencies
Migration Testing
Architectural Best Practices
Architectural Best Practices
Project Structure
Organizing Tables
Repository Pattern
Error Handling
Naming Conventions
Database Design Tips
Core Storage Comparisons
Core Storage Comparisons
Drift vs sqflite
Drift vs Isar
Drift vs Hive
DAO vs Repository
Watch vs Get
Batch vs Transaction
Database Cheat Sheet
Database Cheat Sheet
Query APIs
CRUD APIs
Stream APIs
Migration APIs
Common Patterns
Riverpod
Riverpod
Concept Map
Getting Started
Getting Started
What is Riverpod
Installation
Your First Provider
Consumer Widget
ProviderScope
Core Concepts
Core Concepts
ProviderContainer
ProviderScope In-Depth
Provider Lifecycle
Dependency Graph
State Invalidation
Caching
Auto Dispose
Code Generation
Provider Types
Provider Types
Provider
StateProvider
FutureProvider
StreamProvider
NotifierProvider
AsyncNotifierProvider
StreamNotifierProvider
ChangeNotifierProvider
StateNotifierProvider
Notifiers & Mutations
Notifiers & Mutations
Notifier
AsyncNotifier
StreamNotifier
The build() Method
The state Property
The ref Property
Provider Families
Ref
Ref
What is Ref
ref.watch()
ref.read()
ref.listen()
ref.listenManual()
ref.invalidate()
ref.invalidateSelf()
ref.refresh()
ref.keepAlive()
ref.onDispose()
ref.onCancel()
ref.onResume()
ref.exists()
Ref Lifecycle
AsyncValue
AsyncValue
What is AsyncValue?
Loading State
Data State
Error State
when()
maybeWhen()
map()
maybeMap()
guard()
Best Practices
Provider Modifiers
Provider Modifiers
.autoDispose
.family
.overrideWith
.overrideWithValue
.select
keepAlive
Consumers
Consumers
Consumer
ConsumerWidget
ConsumerStatefulWidget
WidgetRef
Provider Observers
Provider Observers
ProviderObserver
Logging
Debugging
Performance Monitoring
Testing
Testing
ProviderContainer
Overriding Providers
Testing Providers
Testing Notifiers
Mocking Dependencies
Integration Testing
Performance
Performance
Minimizing Rebuilds
Fine-grained select()
Splitting Providers
Auto Dispose Strategy
Caching Structures
Common Pitfalls
Best Practices
Best Practices
Project Structure
Naming Conventions
Provider Organization
Error Handling
State Management Patterns
Dependency Injection
Migrations
Migrations
Provider → Riverpod
StateNotifier → Notifier
FutureProvider → AsyncNotifier
StateProvider → Notifier
Riverpod 2 → Riverpod 3
Comparisons
Comparisons
Provider vs StateProvider
FutureProvider vs AsyncNotifier
StreamProvider vs StreamNotifier
Notifier vs AsyncNotifier
Notifier vs StateNotifier
Provider vs BLoC
Provider vs GetX
Choosing the Right Provider
API Cheat Sheet
API Cheat Sheet
Common APIs
Lifecycle APIs
Ref APIs
AsyncValue APIs
Provider Types Overview
String APIs
Back to top