Dlaczego używać krotek, kiedy możemy użyć tablicy, aby zwrócić wiele wartości w szybkim tempie?

Question

Dzisiaj właśnie przechodziłem kilka podstawowych, szybkich koncepcji i pracowałem z kilkoma przykładami, aby zrozumieć te pojęcia. Właśnie ukończyłem studiowanie krotek.

Mam jedną wątpliwość, tj. Jaka jest potrzeba używania krotek? Zrobiłem kopanie na tym oto, co mam:

Możemy zwracać wiele wartości z funkcji. Ok, ale możemy to również zrobić, zwracając tablicę.

Tablica ok, ale możemy zwrócić wiele wartości różnych typów. Ok fajne, ale może to być również wykonane przez tablicę AnyObject tak:

func calculateStatistics (scores:[Int])->[AnyObject] 
{ 
    var min = scores[0] 
    var max = scores[0] 
    var sum = 0 

    for score in scores 
    { 
     if score > max{ 
      max = score 
     } 
     else if score < min{ 
      min = score 
     } 
     sum += score 
    } 
    return [min,max,"Hello"] 
} 

let statistics = calculateStatistics([25,39,78,66,74,80]) 

var min = statistics[0] 
var max = statistics[1] 
var msg = statistics[2] // Contains hello 

Możemy nazwać obiektów znajdujących się w krotek. Ok, ale mogę użyć słownika AnyObject.

Nie mówię o tym, dlaczego używać krotek, gdy mamy to. Ale powinno być coś, co może zrobić tylko krotka lub łatwa do zrobienia tylko z krotkami. Co więcej, ludzie, którzy stworzyli szybko, nie zaangażowaliby krotek szybko, gdyby nie było dobrego powodu. Więc powinniśmy mieć jakiś dobry powód, żeby je zaangażować.

Więc proszę daj mi znać, jeśli są jakieś szczególne przypadki, w których krotki są najlepszym wyborem.

Z góry dziękuję.

Answer 1

Krotki są anonimowymi strukturami, które można wykorzystać na wiele sposobów, a jednym z nich jest przywrócenie wielu wartości z funkcji znacznie łatwiejszej.

Zalety korzystania krotki zamiast tablicy to:

• wiele typów mogą być przechowywane w krotki, natomiast w tablicy jesteś ograniczony do tylko (o ile nie używasz [AnyObject])
jednego typu
• ustalona liczba wartości: nie można przekazać mniej lub więcej parametrów niż oczekiwano, podczas gdy w tablicy można podać dowolną liczbę argumentów:
• mocno wpisane: jeśli parametry różnych typów są przekazywane w niewłaściwych pozycjach, kompilator wykryje, że , używając tablicy, która się nie stanie
• refaktoryzacji: jeśli liczba parametrów lub ich rodzaj, zmiany, kompilator będzie produkować odpowiednią błąd kompilacji, natomiast z tablicami że przejdzie niezauważony
• nazwie: jest to możliwe, aby powiązać nazwę z każdego parametru

• przypisanie to łatwiejsze i bardziej elastyczny - na przykład wartość powrotna może być przypisany do krotki:

  let tuple = functionReturningTuple() 
  

  lub wszystkich parametrów mogą być automatycznie ekstrahowano i przypisany do zmiennych

  let (param1, param2, param3) = functionReturningTuple() 
  

  i jest możliwe, aby ignorować pewne wartości

  let (param1, _, _) = functionReturningTuple() 
  

• podobieństwo parametrów funkcji: gdy funkcja jest wywoływana, gdy parametry przekazane są rzeczywiście krotka. Przykład:

  // SWIFT 2 
  func doSomething(number: Int, text: String) { 
      println("\(number): \(text)") 
  } 
  
  doSomething(1, "one") 
  
  // SWIFT 3  
  func doSomething(number: Int, text: String) { 
      print("\(number): \(text)") 
  } 
  
  doSomething(number: 1, text: "one") 
  

  (Przestarzałe w Swift 2) Funkcja ta może być również wywołany jako:

  let params = (1, "one") 
  doSomething(params) 
  

Ta lista prawdopodobnie nie jest wyczerpująca, ale myślę, że to wystarczy, by faworyzować krotki do tablic zwracających wiele wartości

Answer 2

Korek jest strukturą, która jest lżejsza niż heterogeniczna macierz. Chociaż są bardzo podobne, w dostępie do elementów po indeksie, zaletą jest to, że krotki można bardzo łatwo skonstruować w Swift. Intencją wprowadzenia/interpolacji tej struktury danych (Tuple) jest wiele typów zwrotów. Zwracając wiele danych od "kanclerza" przy minimalnym wysiłku, to zaleta posiadania krotek. Mam nadzieję że to pomoże!

Answer 3

Na przykład, należy rozważyć ten prosty przykład:

enum MyType { 
    case A, B, C 
} 

func foo() -> (MyType, Int, String) { 
    // ... 
    return (.B, 42, "bar") 
} 

let (type, amount, desc) = foo() 

Korzystanie Array, aby uzyskać taki sam efekt, trzeba to zrobić:

func foo() -> [Any] { 
    // ... 
    return [MyType.B, 42, "bar"] 
} 

let result = foo() 
let type = result[0] as MyType, amount = result[1] as Int, desc = result[2] as String 

krotka jest znacznie prostszy i bezpieczniejszy, ISN” t to?