Dart Programming Language

  1. Dart Language Fundamentals
    1. Variables and Data Types
      1. Declaring Variables
        1. Using `var` for Type Inference
          1. Using `final` for Single-Assignment Variables
            1. Using `const` for Compile-Time Constants
              1. Explicit Type Declarations
              2. Built-in Data Types
                1. Numbers
                  1. `int`
                    1. `double`
                      1. `num`
                        1. Numeric Literals
                          1. Numeric Operations
                            1. Mathematical Functions
                            2. Strings
                              1. Single and Double Quotes
                                1. String Interpolation
                                  1. Multi-line Strings
                                    1. Raw Strings
                                      1. String Concatenation
                                        1. Common String Methods
                                          1. String Comparison
                                          2. Booleans
                                            1. The `bool` Type
                                              1. Boolean Literals
                                                1. Boolean Operations
                                                2. Records
                                                  1. Syntax and Structure
                                                    1. Named Fields
                                                      1. Positional Fields
                                                        1. Use Cases
                                                        2. Symbols
                                                          1. Purpose and Syntax
                                                            1. Use Cases
                                                          2. The `dynamic` Type
                                                            1. When to Use
                                                              1. Risks and Considerations
                                                                1. Type Checking at Runtime
                                                                2. Type Conversion
                                                                  1. Implicit Conversion
                                                                    1. Explicit Conversion
                                                                      1. Parsing Strings to Numbers
                                                                    2. Sound Null Safety
                                                                      1. Understanding Null in Dart
                                                                        1. Non-Nullable Types
                                                                          1. Default Behavior
                                                                            1. Compile-Time Guarantees
                                                                            2. Nullable Types
                                                                              1. Using the `?` Suffix
                                                                                1. Working with Nullable Variables
                                                                                2. The Null Assertion Operator (`!`)
                                                                                  1. When to Use
                                                                                    1. Runtime Risks
                                                                                    2. The `late` Keyword
                                                                                      1. Late Initialization
                                                                                        1. Use Cases
                                                                                          1. Pitfalls and Best Practices
                                                                                          2. Migration to Null Safety
                                                                                            1. Legacy Code Considerations
                                                                                          3. Operators
                                                                                            1. Arithmetic Operators
                                                                                              1. Addition (`+`)
                                                                                                1. Subtraction (`-`)
                                                                                                  1. Multiplication (`*`)
                                                                                                    1. Division (`/`)
                                                                                                      1. Integer Division (`~/`)
                                                                                                        1. Modulo (`%`)
                                                                                                          1. Unary Operators
                                                                                                          2. Equality and Relational Operators
                                                                                                            1. Equality (`==`)
                                                                                                              1. Inequality (`!=`)
                                                                                                                1. Greater Than (`>`)
                                                                                                                  1. Less Than (`<`)
                                                                                                                    1. Greater Than or Equal (`>=`)
                                                                                                                      1. Less Than or Equal (`<=`)
                                                                                                                      2. Type Test Operators
                                                                                                                        1. `is`
                                                                                                                          1. `is!`
                                                                                                                            1. Runtime Type Checking
                                                                                                                            2. Assignment Operators
                                                                                                                              1. Simple Assignment (`=`)
                                                                                                                                1. Compound Assignment
                                                                                                                                  1. `+=`
                                                                                                                                    1. `-=`
                                                                                                                                      1. `*=`
                                                                                                                                        1. `/=`
                                                                                                                                          1. `~/=`
                                                                                                                                            1. `%=`
                                                                                                                                          2. Logical Operators
                                                                                                                                            1. AND (`&&`)
                                                                                                                                              1. OR (`||`)
                                                                                                                                                1. NOT (`!`)
                                                                                                                                                  1. Short-Circuit Evaluation
                                                                                                                                                  2. Bitwise and Shift Operators
                                                                                                                                                    1. Bitwise AND (`&`)
                                                                                                                                                      1. Bitwise OR (`|`)
                                                                                                                                                        1. Bitwise XOR (`^`)
                                                                                                                                                          1. Bitwise NOT (`~`)
                                                                                                                                                            1. Left Shift (`<<`)
                                                                                                                                                              1. Right Shift (`>>`)
                                                                                                                                                              2. Conditional Expressions
                                                                                                                                                                1. Ternary Operator (`condition ? expr1 : expr2`)
                                                                                                                                                                2. Cascade Notation (`..`)
                                                                                                                                                                  1. Chaining Method Calls
                                                                                                                                                                    1. Null-Shorting Cascade (`?..`)
                                                                                                                                                                    2. Null-aware Operators
                                                                                                                                                                      1. Null-aware Access (`?.`)
                                                                                                                                                                        1. If-null Operator (`??`)
                                                                                                                                                                          1. Null-aware Assignment (`??=`)
                                                                                                                                                                          2. Operator Precedence
                                                                                                                                                                            1. Order of Operations
                                                                                                                                                                              1. Using Parentheses
                                                                                                                                                                            2. Control Flow Statements
                                                                                                                                                                              1. Conditional Statements
                                                                                                                                                                                1. `if` Statement
                                                                                                                                                                                  1. `else` Statement
                                                                                                                                                                                    1. `else if` Statement
                                                                                                                                                                                      1. Nested Conditionals
                                                                                                                                                                                      2. Looping Constructs
                                                                                                                                                                                        1. `for` Loop
                                                                                                                                                                                          1. Traditional For Loop
                                                                                                                                                                                            1. Loop Variables
                                                                                                                                                                                            2. `for-in` Loop
                                                                                                                                                                                              1. Iterating Over Collections
                                                                                                                                                                                              2. `while` Loop
                                                                                                                                                                                                1. `do-while` Loop
                                                                                                                                                                                                  1. Loop Control
                                                                                                                                                                                                    1. `break` Statement
                                                                                                                                                                                                      1. `continue` Statement
                                                                                                                                                                                                        1. Labeled Breaks and Continues
                                                                                                                                                                                                      2. Switch Statements
                                                                                                                                                                                                        1. Basic `switch` Syntax
                                                                                                                                                                                                          1. Using `case` Clauses
                                                                                                                                                                                                            1. Pattern Matching in `switch`
                                                                                                                                                                                                              1. Fall-through Behavior
                                                                                                                                                                                                                1. `default` Case
                                                                                                                                                                                                                  1. Switch Expressions
                                                                                                                                                                                                                2. Comments and Documentation
                                                                                                                                                                                                                  1. Single-line Comments (`//`)
                                                                                                                                                                                                                    1. Multi-line Comments (`/* */`)
                                                                                                                                                                                                                      1. Documentation Comments (`///`)
                                                                                                                                                                                                                        1. Doc Comment Conventions

                                                                                                                                                                                                                      Previous

                                                                                                                                                                                                                      1. Introduction to Dart

                                                                                                                                                                                                                      Go to top

                                                                                                                                                                                                                      Next

                                                                                                                                                                                                                      3. Functions