> ## Documentation Index > Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt > Use this file to discover all available pages before exploring further. # Swift Array An `Array` in Swift is a generic, ordered, random-access collection that stores elements of a single, uniform type. Implemented as a value type (`struct`) in the Swift Standard Library, it utilizes a copy-on-write (CoW) mechanism to optimize performance during assignment and mutation. While an `Array` typically stores its elements in a contiguous memory block, it does not strictly guarantee contiguous storage if it is bridged to an Objective-C `NSArray`. ## Type Declaration and Syntax Swift provides both a formal generic syntax and a syntactic sugar shorthand for declaring arrays. The shorthand is the idiomatic standard. ```swift theme={"dark"} // Formal generic syntax var formalArray: Array // Shorthand syntax (preferred) var shorthandArray: [Int] ``` ## Initialization Arrays can be instantiated using empty initializers, array literals, or specialized initializers for pre-allocating repeated values. ```swift theme={"dark"} // Empty initialization let emptyArray: [String] = [] let anotherEmptyArray = [String]() // Array literal initialization (type inferred as [Int]) let literalArray = [1, 2, 3, 4, 5] // Repeating value initialization let repeatingArray = Array(repeating: 0.0, count: 5) // [0.0, 0.0, 0.0, 0.0, 0.0] ``` ## State Inspection and Iteration The `Array` type provides constant-time property access to check its current state and size, alongside standard sequence iteration. ```swift theme={"dark"} let numbers = [10, 20, 30] // State inspection let size = numbers.count // 3 let isArrayEmpty = numbers.isEmpty // false // Standard iteration for number in numbers { print(number) } // Iteration with index for (index, number) in numbers.enumerated() { print("Index: \(index), Value: \(number)") } ``` ## Memory and Performance Characteristics * **Value Semantics:** Because `Array` is a struct, assigning an array to a new variable or passing it to a function creates a logically distinct instance. * **Copy-on-Write (CoW):** To minimize memory overhead, Swift arrays share the same underlying memory buffer upon assignment. A physical copy of the buffer is only allocated in memory at the exact moment one of the references mutates the array. * **Capacity and Reallocation:** Arrays allocate a specific amount of memory to store elements. When an array exceeds its `capacity`, it allocates a larger memory buffer and copies the existing elements over. This reallocation strategy ensures that appending elements operates in amortized `O(1)` time. * **Bridging and Contiguity:** Swift `Array` bridges seamlessly to Foundation's `NSArray`. If the array contains class types or `@objc` protocols, it may be backed by an `NSArray` instance, which does not guarantee contiguous memory. For scenarios requiring strict contiguous memory allocation (such as interfacing with C APIs), Swift provides the `ContiguousArray` type. ## Slicing and Memory Management Extracting a subrange of an array returns an `ArraySlice` rather than a new `Array`. ```swift theme={"dark"} let originalArray = [10, 20, 30, 40, 50] let slice = originalArray[1...3] // Type is ArraySlice ``` An `ArraySlice` presents a view into the original array and shares its underlying memory buffer. This makes slicing an `O(1)` operation. However, because the slice holds a strong reference to the entire original buffer, keeping a long-lived reference to a small slice will prevent the original, potentially large array from being deallocated, resulting in prolonged memory retention (or memory bloat). This is not a memory leak, as the memory is safely tracked by Automatic Reference Counting (ARC) and will be properly deallocated once the slice goes out of scope. However, to allow the original buffer to be freed immediately when it is no longer needed, the slice must be explicitly converted into a new, independent array: ```swift theme={"dark"} // Allocates a new buffer and copies the elements, allowing originalArray to be deallocated let independentArray = Array(slice) ``` ## Protocol Conformance The behavior of `Array` is defined by its conformance to several key Swift protocols: * `RandomAccessCollection`: Guarantees `O(1)` time complexity for index-based element access and distance calculations. * `MutableCollection`: Permits in-place element mutation via subscripting. * `RangeReplaceableCollection`: Supports replacing arbitrary subranges of elements, appending, inserting, and removing. * `ExpressibleByArrayLiteral`: Enables instantiation using the `[value1, value2]` literal syntax. ## Structural Operations Array operations are strictly bound by index bounds checking. Accessing an index outside the range of `0.. Tired of Poor Swift Skills? Fix That With Deep Grasping! Learn More