Dart Programming Language

  1. Collections
    1. Lists
      1. List Characteristics
        1. Ordered Collections
          1. Index-Based Access
          2. List Types
            1. Fixed-Length Lists
              1. Growable Lists
              2. List Literals
                1. Empty Lists
                  1. Initialized Lists
                  2. Accessing Elements by Index
                    1. Common List Properties and Methods
                      1. `length`
                        1. `isEmpty`
                          1. `isNotEmpty`
                            1. `first`
                              1. `last`
                                1. `add`
                                  1. `addAll`
                                    1. `insert`
                                      1. `insertAll`
                                        1. `remove`
                                          1. `removeAt`
                                            1. `removeLast`
                                              1. `clear`
                                                1. `contains`
                                                  1. `indexOf`
                                                    1. `lastIndexOf`
                                                    2. Iterating Over Lists
                                                      1. For-in Loops
                                                        1. forEach Method
                                                          1. Iterator Pattern
                                                          2. List Manipulation
                                                            1. Sorting
                                                              1. Reversing
                                                                1. Shuffling
                                                                2. The Spread Operator (`...`)
                                                                  1. Null-aware Spread Operator (`...?`)
                                                                    1. Collection `if` and `for`
                                                                      1. Conditional Elements
                                                                        1. Generated Elements
                                                                      2. Sets
                                                                        1. Set Characteristics
                                                                          1. Unordered Collection
                                                                            1. Unique Elements
                                                                            2. Set Literals
                                                                              1. Common Set Operations
                                                                                1. `add`
                                                                                  1. `addAll`
                                                                                    1. `contains`
                                                                                      1. `remove`
                                                                                        1. `removeAll`
                                                                                          1. `clear`
                                                                                            1. `intersection`
                                                                                              1. `union`
                                                                                                1. `difference`
                                                                                                2. Iterating Over Sets
                                                                                                  1. Set Types
                                                                                                    1. HashSet
                                                                                                      1. LinkedHashSet
                                                                                                        1. SplayTreeSet
                                                                                                      2. Maps
                                                                                                        1. Map Characteristics
                                                                                                          1. Key-Value Pairs
                                                                                                            1. Unique Keys
                                                                                                            2. Map Literals
                                                                                                              1. Accessing Values by Key
                                                                                                                1. Common Map Properties and Methods
                                                                                                                  1. `keys`
                                                                                                                    1. `values`
                                                                                                                      1. `entries`
                                                                                                                        1. `length`
                                                                                                                          1. `isEmpty`
                                                                                                                            1. `isNotEmpty`
                                                                                                                              1. `containsKey`
                                                                                                                                1. `containsValue`
                                                                                                                                  1. `putIfAbsent`
                                                                                                                                    1. `remove`
                                                                                                                                      1. `clear`
                                                                                                                                        1. `update`
                                                                                                                                          1. `updateAll`
                                                                                                                                          2. Iterating Over Maps
                                                                                                                                            1. Iterating Keys
                                                                                                                                              1. Iterating Values
                                                                                                                                                1. Iterating Entries
                                                                                                                                                2. Map Types
                                                                                                                                                  1. HashMap
                                                                                                                                                    1. LinkedHashMap
                                                                                                                                                      1. SplayTreeMap
                                                                                                                                                    2. Iterables
                                                                                                                                                      1. Iterable Interface
                                                                                                                                                        1. Common Iterable Methods
                                                                                                                                                          1. `map`
                                                                                                                                                            1. `where`
                                                                                                                                                              1. `expand`
                                                                                                                                                                1. `fold`
                                                                                                                                                                  1. `reduce`
                                                                                                                                                                    1. `any`
                                                                                                                                                                      1. `every`
                                                                                                                                                                        1. `take`
                                                                                                                                                                          1. `skip`
                                                                                                                                                                            1. `toList`
                                                                                                                                                                              1. `toSet`
                                                                                                                                                                              2. Lazy Evaluation
                                                                                                                                                                                1. Method Chaining
                                                                                                                                                                                2. Generics
                                                                                                                                                                                  1. Purpose of Generics
                                                                                                                                                                                    1. Type-Safe Collections
                                                                                                                                                                                      1. Generic Lists (`List<T>`)
                                                                                                                                                                                        1. Generic Sets (`Set<T>`)
                                                                                                                                                                                          1. Generic Maps (`Map<K, V>`)
                                                                                                                                                                                          2. Using Generics with Classes
                                                                                                                                                                                            1. Generic Methods
                                                                                                                                                                                              1. Bounded Type Parameters (`<T extends SomeType>`)
                                                                                                                                                                                                1. Type Constraints
                                                                                                                                                                                                  1. Generic Type Inference

                                                                                                                                                                                                Previous

                                                                                                                                                                                                4. Object-Oriented Programming (OOP) in Dart

                                                                                                                                                                                                Go to top

                                                                                                                                                                                                Next

                                                                                                                                                                                                6. Asynchronous Programming