Dart Programming Language

  1. Functions
    1. Defining Functions
      1. Function Syntax
        1. Return Types
          1. Explicit Return Types
            1. Inferred Return Types
              1. `void` Return Type
              2. The Arrow Syntax (`=>`) for Single-Expression Functions
              3. Function Parameters
                1. Required Positional Parameters
                  1. Optional Positional Parameters
                    1. Using Square Brackets (`[]`)
                      1. Default Values
                      2. Named Parameters
                        1. Using Curly Braces (`{}`)
                          1. Optional Named Parameters
                            1. Required Named Parameters (`required`)
                            2. Default Parameter Values
                              1. Compile-Time Constants
                                1. Expression Defaults
                                2. Parameter Validation
                                3. The `main()` Function Revisited
                                  1. Entry Point Behavior
                                    1. Accepting Command-Line Arguments (`List<String> args`)
                                      1. Accessing and Using Arguments
                                        1. Return Values from Main
                                        2. Anonymous Functions
                                          1. Syntax for Anonymous Functions
                                            1. Lambda Expressions
                                              1. Assigning Functions to Variables
                                                1. Passing Functions as Arguments
                                                2. Lexical Scope and Closures
                                                  1. Understanding Variable Scope
                                                    1. Global Scope
                                                      1. Function Scope
                                                        1. Block Scope
                                                        2. How Closures Capture Variables
                                                          1. Practical Uses of Closures
                                                            1. Memory Considerations
                                                            2. Higher-Order Functions
                                                              1. Functions as First-Class Objects
                                                                1. Functions that Accept Functions as Parameters
                                                                  1. Functions that Return Functions
                                                                    1. Common Higher-Order Function Patterns
                                                                    2. Recursive Functions
                                                                      1. Understanding Recursion
                                                                        1. Base Cases and Recursive Cases
                                                                          1. Tail Recursion
                                                                            1. Stack Overflow Considerations

                                                                          Previous

                                                                          2. Dart Language Fundamentals

                                                                          Go to top

                                                                          Next

                                                                          4. Object-Oriented Programming (OOP) in Dart