Go Programming

  1. Composite Data Types
    1. Arrays
      1. Array Declaration
        1. Array Initialization
          1. Array Literals
            1. Array Length
              1. Accessing Array Elements
                1. Array Comparison
                  1. Multidimensional Arrays
                    1. Array Limitations
                    2. Slices
                      1. Slice Fundamentals
                        1. Slice vs Array
                          1. Slice Declaration
                            1. Slice Literals
                            2. Slice Operations
                              1. Length and Capacity
                                1. Slicing Operations
                                  1. Appending Elements
                                    1. Copying Slices
                                    2. Slice Internals
                                      1. Underlying Array
                                        1. Slice Header Structure
                                          1. Memory Management
                                          2. Advanced Slice Techniques
                                            1. Slice Tricks
                                              1. Performance Considerations
                                                1. Common Pitfalls
                                              2. Maps
                                                1. Map Fundamentals
                                                  1. Map Declaration
                                                    1. Map Initialization
                                                      1. Map Literals
                                                      2. Map Operations
                                                        1. Adding Elements
                                                          1. Accessing Elements
                                                            1. Deleting Elements
                                                              1. Key Existence Testing
                                                              2. Map Iteration
                                                                1. Range over Maps
                                                                  1. Key-Value Pairs
                                                                    1. Order Considerations
                                                                    2. Map Characteristics
                                                                      1. Reference Type Behavior
                                                                        1. Zero Value of Maps
                                                                          1. Map Comparison Limitations
                                                                        2. Pointers
                                                                          1. Pointer Basics
                                                                            1. Memory Addresses
                                                                              1. Pointer Declaration
                                                                                1. Address Operator
                                                                                  1. Dereference Operator
                                                                                  2. Pointer Usage
                                                                                    1. Pointers to Variables
                                                                                      1. Pointers to Structs
                                                                                        1. Pointer Arithmetic Limitations
                                                                                        2. Pointer Safety
                                                                                          1. Nil Pointers
                                                                                            1. Pointer Validation
                                                                                              1. Memory Safety
                                                                                            2. Structs
                                                                                              1. Struct Definition
                                                                                                1. Struct Declaration
                                                                                                  1. Field Types
                                                                                                    1. Field Names
                                                                                                    2. Struct Usage
                                                                                                      1. Struct Literals
                                                                                                        1. Field Access
                                                                                                          1. Struct Pointers
                                                                                                            1. Anonymous Fields
                                                                                                            2. Struct Composition
                                                                                                              1. Embedded Structs
                                                                                                                1. Method Promotion
                                                                                                                  1. Composition vs Inheritance
                                                                                                                  2. Struct Tags
                                                                                                                    1. Tag Syntax
                                                                                                                      1. Reflection and Tags
                                                                                                                        1. JSON Tags
                                                                                                                          1. Custom Tag Usage

                                                                                                                      Previous

                                                                                                                      3. Control Flow

                                                                                                                      Go to top

                                                                                                                      Next

                                                                                                                      5. Methods and Interfaces