Tuple vs Swift in Yapısı

Question

Swift'in tuples'inin, bir fonksiyonun birden fazla değer döndürmesi için basit bir yol olarak hizmet ettiğini anlıyorum. Ancak, bu "basitlik yönünün" ötesinde, yapı yerine tuplelerin kullanılmasının gerekliliğini çok iyi göremiyorum.

Bu nedenle, benim sorum: tasarım açısından, tupllerin yapılardan açıkça daha iyi bir seçim olduğu bir senaryo var mı?

Answer 1

biraz "tartışması" Doğanın bu soru ama:

var myJavaVar = JavaUtilLinkedHashMap() 
var headerArray : [(varName : String, param : Int, varId : jlong)] = [] 


myJavaVar = myStaticMethodToGetMyVar 

    // get var array 
    let keySetJava = myJavaVar.keySet().toArray() 
    for jCounter in 0..<Int(myJavaVar.size()){ 
     // id for index 
     let key : Int = keySetJava.objectAtIndex(UInt(jCounter)) as! Int 
     let varId = jlong.init(key) 
     let varName = myMethodToGetName(varId) 
     let myParam : Int = myJavaVar.getWithId(keySetJava.objectAtIndex(UInt(jCounter))) as! Int 
     // append data to the array 
     headerArray.append((varName: categoryName, param : myParam,duration: duration, varId: varId)) 
    } 

Ardından (sizin CollectionView yönteminde) verilerinizi şöyle alabilirsiniz: kod zaman bir numune bu göstermek için Bazen yapılar üzerinde tuplleri tercih etmekten yana iki nokta ekleyeceğim. Sınırlı büyüklükteki küpe Swift 2.2 olarak

için

---

Yerli Equatable uygunluk ait küpe büyüklüğü 6'ya kadar o üyeler equatable olan var olduğu göz önüne alındığında, doğal equatable olacak

• Proposal SE-0015: Tuple comparison operators

Bu, tuplelerin bazen doğal seçim olacağı anlamına gelir. Sınırlı bir kapsamda küçük yapılar kullanarak.

E.g. (1) kullanılarak aşağıdaki durumu ele alalım: bir yapı

struct Foo { 
    var a : Int = 1 
    var b : Double = 2.0 
    var c : String = "3" 
} 

var a = Foo() 
var b = Foo() 

// a == b // error, Foo not Equatable 

/* we can naturally fix this by conforming Foo to Equatable, 
    but this needs a custom fix and is not as versatile as just 
    using a tuple instead. For some situations, the latter will 
    suffice, and is to prefer.         */ 
func == (lhs: Foo, rhs: Foo) -> Bool { 
    return lhs.a == rhs.a && lhs.b == rhs.b && lhs.c == rhs.c 
} 

ve (2): tuple farklı türde dizilerini için

/* This will be native in Swift 2.2 */ 
@warn_unused_result 
public func == <A: Equatable, B: Equatable, C: Equatable>(lhs: (A,B,C), rhs: (A,B,C)) -> Bool { 
    return lhs.0 == rhs.0 && lhs.1 == rhs.1 && lhs.2 == rhs.2 
} 
/* end of native part ...   */ 

var aa = (1, 2.0, "3") 
var bb = (1, 2.0, "3") 

aa == bb // true 
aa.0 = 2 
aa == bb // false 

---

Genel erişim: Farklı yapılara ait daha çok yönlü

Yukarıdakilerden (== işlevlerini karşılaştırın) aynı zamanda appare .0, .1 ... soneklerini kullanarak anonim üye özelliklerine erişebildiğimiz için, tupllerin jenerikler bağlamında kolayca çalışabilmeleri; Bir yapı için, bu davranışı taklit etmenin en kolay yolu, çalışma zamanı içgözlemesi ve benzeri işlemler gibi oldukça karmaşık ve ihtiyaç duyulan araçlar haline gelir, bkz. e.g. this.

Answer 2

Bunu düşünün, java objektif-C. Kendinizi projenizdeki bu tür veri kaynağına takmanız gerektiğinde (android için büyük bir temel kodunuz olduğundan ve her şeyi sıfırdan istemediğiniz veya yapamayacağınız için), kendinizi java türleri veri kaynağıyla bulabilirsiniz (örneğin, hashmap gibi) Bunlar temel olarak objektif-c tiplerinden yazılmıştır. Bu, toplandığınız şeye bağlı olarak hızlıca takılabilir değildir, eğer koleksiyonunuz için güzel bir diziye sahip olmak istiyorsanız, java veri kaynağı tarafından doldurulan bir dizi tuple güzel olabilir.

let time = headerArray[indexPath.section].param