Arrays Swift中多维数组的语法是什么？

共同粉丝：在你得出结论之前，它是一个复制品，有两种不同风格的数组，我想问的是不太流行的一种

---

到目前为止，我只看到了锯齿状数组的语法，如

[[Int]]

，但我找不到关于平面多维数组的任何信息。那么类型的语法是什么（比如

Ints

的2d数组）以及用数据初始化这样的数组的语法是什么？是否有任何

[2,3；；-1,0]

？

是的，没有内置的东西（据我所知）。您可以定义自定义类/结构（如中所示） 或者）使用下标运算符，以便

a[0,0]=1

工作

这里是这些解决方案的混合，但作为一个例子 通用

struct

而不是

class

。我还改变了会议的顺序 行和列参数，因为我发现更自然：

struct Array2D<T : IntegerLiteralConvertible > {
    let rows : Int
    let cols : Int
    var matrix: [T]

    init(rows : Int, cols : Int) {
        self.rows = rows
        self.cols = cols
        matrix = Array(count : rows * cols, repeatedValue : 0)
    }

    subscript(row : Int, col : Int) -> T {
        get { return matrix[cols * row + col] }
        set { matrix[cols*row+col] = newValue }
    }
}

例如：

let array = Array2D([[1, 2, 3], [4, 5, 6]])
println(array.rows)  // 2
println(array.cols)  // 3
println(array[1, 2]) // 6
println(array[1, 0]) // 4

let array : Array2D = [[1, 2, 3], [4, 5, 6]]

let squareArray = Array2D([2, 3, -1, 0])
println(squareArray.rows)  // 2
println(squareArray.cols)  // 3
println(squareArray[1, 0]) // -1

您还可以实现

ArrayTerralConvertible

协议，从嵌套数组文本初始化2d数组：

extension Array2D : ArrayLiteralConvertible {

    init(arrayLiteral elements: [T]...) {
        self.init(elements)
    }
}

例如：

let array = Array2D([[1, 2, 3], [4, 5, 6]])
println(array.rows)  // 2
println(array.cols)  // 3
println(array[1, 2]) // 6
println(array[1, 0]) // 4

let array : Array2D = [[1, 2, 3], [4, 5, 6]]

let squareArray = Array2D([2, 3, -1, 0])
println(squareArray.rows)  // 2
println(squareArray.cols)  // 3
println(squareArray[1, 0]) // -1

对于方形数组（

rows==columns

），您也可以从普通数组初始化它：

extension Array2D {

    init(_ elements: [T]) {
        let rows = Int(sqrt(Double(elements.count)))
        assert(rows * rows == elements.count, "Number of array elements must be a square")
        self.init(rows: rows, cols: rows)
        self.matrix = elements
    }
}

例如：

let array = Array2D([[1, 2, 3], [4, 5, 6]])
println(array.rows)  // 2
println(array.cols)  // 3
println(array[1, 2]) // 6
println(array[1, 0]) // 4

let array : Array2D = [[1, 2, 3], [4, 5, 6]]

let squareArray = Array2D([2, 3, -1, 0])
println(squareArray.rows)  // 2
println(squareArray.cols)  // 3
println(squareArray[1, 0]) // -1

---

是的，没有内置的（据我所知）。您可以定义自定义类/结构（如中所示） 或者）使用下标运算符，以便

a[0,0]=1

工作

这里是这些解决方案的混合，但作为一个例子 通用

struct

而不是

class

。我还改变了会议的顺序 行和列参数，因为我发现更自然：

struct Array2D<T : IntegerLiteralConvertible > {
    let rows : Int
    let cols : Int
    var matrix: [T]

    init(rows : Int, cols : Int) {
        self.rows = rows
        self.cols = cols
        matrix = Array(count : rows * cols, repeatedValue : 0)
    }

    subscript(row : Int, col : Int) -> T {
        get { return matrix[cols * row + col] }
        set { matrix[cols*row+col] = newValue }
    }
}

例如：

let array = Array2D([[1, 2, 3], [4, 5, 6]])
println(array.rows)  // 2
println(array.cols)  // 3
println(array[1, 2]) // 6
println(array[1, 0]) // 4

let array : Array2D = [[1, 2, 3], [4, 5, 6]]

let squareArray = Array2D([2, 3, -1, 0])
println(squareArray.rows)  // 2
println(squareArray.cols)  // 3
println(squareArray[1, 0]) // -1

您还可以实现

ArrayTerralConvertible

协议，从嵌套数组文本初始化2d数组：

extension Array2D : ArrayLiteralConvertible {

    init(arrayLiteral elements: [T]...) {
        self.init(elements)
    }
}

例如：

let array = Array2D([[1, 2, 3], [4, 5, 6]])
println(array.rows)  // 2
println(array.cols)  // 3
println(array[1, 2]) // 6
println(array[1, 0]) // 4

let array : Array2D = [[1, 2, 3], [4, 5, 6]]

let squareArray = Array2D([2, 3, -1, 0])
println(squareArray.rows)  // 2
println(squareArray.cols)  // 3
println(squareArray[1, 0]) // -1

对于方形数组（

rows==columns

），您也可以从普通数组初始化它：

extension Array2D {

    init(_ elements: [T]) {
        let rows = Int(sqrt(Double(elements.count)))
        assert(rows * rows == elements.count, "Number of array elements must be a square")
        self.init(rows: rows, cols: rows)
        self.matrix = elements
    }
}

例如：

let array = Array2D([[1, 2, 3], [4, 5, 6]])
println(array.rows)  // 2
println(array.cols)  // 3
println(array[1, 2]) // 6
println(array[1, 0]) // 4

let array : Array2D = [[1, 2, 3], [4, 5, 6]]

let squareArray = Array2D([2, 3, -1, 0])
println(squareArray.rows)  // 2
println(squareArray.cols)  // 3
println(squareArray[1, 0]) // -1

---

支持任意数量维度的示例实现：

struct ArrayMultiDimension<T> {
    private var _base:[T]
    let _dimensions: [Int]

    init(initialValue: T, dimensions:Int...) {
        _base = Array(count: reduce(dimensions, 1, *), repeatedValue: initialValue)
        _dimensions =  dimensions
    }
    private func _position2idx(position:[Int]) -> Int {
        assert(position.count == _dimensions.count)
        return reduce(Zip2(_dimensions, position), 0) {
            assert($1.0 > $1.1)
            return $0 * $1.0 + $1.1
        }
    }
    subscript(position:Int...) -> T {
        get { return _base[_position2idx(position)] }
        set { _base[_position2idx(position)] = newValue }
    }
}

// Usage:

var array3d = ArrayMultiDimension(initialValue: "", dimensions: 4,3,2)

for x in 0 ..< 4 {
    for y in 0 ..< 3 {
        for z in 0 ..< 2 {
            array3d[x,y,z] = "\(x)-\(y)-\(z)"
        }
    }
}

array3d[1,2,0] = "foo"

struct ArrayMultiDimension{
专用变量库：[T]
let_维度：[Int]
初始值（初始值：T，维度：Int…）{
_基=数组（计数：减少（维度，1，*），重复值：初始值）
_尺寸=尺寸
}
私有函数位置2idx（位置：[Int]）->Int{
断言（position.count==\u dimensions.count）
返回减少（Zip2（_尺寸，位置），0）{
断言（$1.0>$1.1）
返回$0*$1.0+1.1
}
}
下标（位置：Int…）->T{
获取{return _base[_position2idx（position）]}
设置{u base[_position2idx（position）]=newValue}
}
}
//用法：
var array3d=ArrayMultiDimension（初始值：“”，维度：4,3,2）
对于0中的x..<4{
对于0..<3中的y{
对于0中的z..<2{
array3d[x，y，z]=“\（x）-（y）-（z）”
}
}
}
array3d[1,2,0]=“foo”

---

但是，这可能非常慢…

一个支持任意数量维度的示例实现：

struct ArrayMultiDimension<T> {
    private var _base:[T]
    let _dimensions: [Int]

    init(initialValue: T, dimensions:Int...) {
        _base = Array(count: reduce(dimensions, 1, *), repeatedValue: initialValue)
        _dimensions =  dimensions
    }
    private func _position2idx(position:[Int]) -> Int {
        assert(position.count == _dimensions.count)
        return reduce(Zip2(_dimensions, position), 0) {
            assert($1.0 > $1.1)
            return $0 * $1.0 + $1.1
        }
    }
    subscript(position:Int...) -> T {
        get { return _base[_position2idx(position)] }
        set { _base[_position2idx(position)] = newValue }
    }
}

// Usage:

var array3d = ArrayMultiDimension(initialValue: "", dimensions: 4,3,2)

for x in 0 ..< 4 {
    for y in 0 ..< 3 {
        for z in 0 ..< 2 {
            array3d[x,y,z] = "\(x)-\(y)-\(z)"
        }
    }
}

array3d[1,2,0] = "foo"

struct ArrayMultiDimension{
专用变量库：[T]
let_维度：[Int]
初始值（初始值：T，维度：Int…）{
_基=数组（计数：减少（维度，1，*），重复值：初始值）
_尺寸=尺寸
}
私有函数位置2idx（位置：[Int]）->Int{
断言（position.count==\u dimensions.count）
返回减少（Zip2（_尺寸，位置），0）{
断言（$1.0>$1.1）
返回$0*$1.0+1.1
}
}
下标（位置：Int…）->T{
获取{return _base[_position2idx（position）]}
设置{u base[_position2idx（position）]=newValue}
}
}
//用法：
var array3d=ArrayMultiDimension（初始值：“”，维度：4,3,2）
对于0中的x..<4{
对于0..<3中的y{
对于0中的z..<2{
array3d[x，y，z]=“\（x）-（y）-（z）”
}
}
}
array3d[1,2,0]=“foo”

---

但是，这可能会非常缓慢……

我相信这一点已经在本文中得到了回答@PrashanthDs，没有。相关的问题是关于交错数组的。我不相信Swift现在支持真正的多维数组。这只是您希望采用的一种更简洁的语法，还是锯齿数组不适合您尝试使用的另一个原因？这可能会有所帮助：，。是的，没有内置的（据我所知）。您可以使用下标运算符定义自定义类/结构（如链接线程中），以便

a[0,0]=1

工作。但是我不知道如何用

[2,3；；-1,0]

这样的文字来创建这样的东西。对于方形数组（行==列），您可以实现ArrayTerralConvertible协议，然后从

[2,3，-1,0]

初始化它。我相信这个线程已经回答了这个问题@PrashanthDs，没有。相关的问题是关于交错数组的。我不相信Swift现在支持真正的多维数组。这只是您希望采用的一种更简洁的语法，还是锯齿数组不适合您尝试使用的另一个原因？这可能会有所帮助：，。是的，没有内置的（据我所知）。您可以使用下标运算符定义自定义类/结构（如链接线程中），以便

a[0,0]=1

工作。但是我不知道如何用

[2,3；；-1,0]

这样的文字来创建这样的东西。对于方形阵列（行=列），您可以实现ArrayTerralConvertible协议，然后从

[2,3，-1,0]

初始化它。