Question

在阅读Robert C. Martin的书“清洁代码”时，他说你应该总是试着保持1到2级的缩进。最多三个

假如我们有一个字典（myDict），它是[Int:[Int:[Int:String]]]（swift）的一种类型，我们想循环遍历所有值，我们会使用一段代码：

for (key1, value1) in myDict
{
    for (key2, value2) in value1
    {
         for (key3, value3) in value2
         {
              //Do stuff
         }
    }
}

正如你所看到的，'// Do stuff'部分是4次，而不是＆lt; = 3。

如何在保持最多3个缩进级别（最好是1或2）的情况下制作此代码？

这是否可行？我希望答案适用于所有语言，但是，如果它不是posivle，那么它可以用于Swift吗？

Answer 1

首先要意识到，如果所有数据都只在最深的字典中，嵌套字典没有平面字典的优势。因此，让我们将索引合并为一个对象：

struct MyIndex : Hashable {
    let indices: (Int, Int, Int)

    init(_ index1: Int, _ index2: Int, _ index3: Int) {
        self.indices = (index1, index2, index3)
    }

    var hashValue: Int {
        return indices.2 // this should ideally use all the 3 indices
    }

    public static func ==(lhs: MyIndex, rhs: MyIndex) -> Bool {
        return lhs.indices == rhs.indices
    }
}

（顺便说一句，这正是UIKit正在做的IndexPath）。

然后我们可以改用我们的索引：

var dictionary: [MyIndex: String] = [:]

dictionary[MyIndex(0, 0, 0)] = "test"
dictionary[MyIndex(0, 1, 2)] = "test2"

for (index, value) in dictionary {
    print(index.indices, value)
}

而不是3个嵌套的循环，我一次迭代值。

Answer 2

通用的点头不是很优雅的方式是创建函数......

func iterateFirstDict(dictionary: [Int: [Int: [Int: String]]]) {
    for (key, value) in dictionary {
        iterateSecondDictionary(value)
    }
}

func iterateSecondDictionary(dictionary: [Int: [Int: String]]) {
    for (key, value) in dictionary {
        iterateThirdDictionary(value)
    }
}

func iterateThirdDictionary(dictionary: [Int: String]) {
    for (key, value) in dictionary {
        // do stuff
    }
}

显然你会使用更具描述性的函数名，但因为我们无法看到你的数据是什么，所以我不可能在这里添加它们。

更好的方法是将数据对象和函数嵌入其中，以便为您完成工作。

如何保持1到2行缩进。

2 个答案: