So erhalten Sie Ergebnisse von Struct in Array

Question

Ich habe eine Enum und Struct, die wie folgt aussieht.

enum Position: String { 
    case lw = "Left Wing" 
    case rw = "Right Wing" 
    case c = "Centre" 
    case d = "Defense" 
    case g = "Goalie" 
} 

struct PlayerInformation { 
    let firstName: String 
    let lastName: String 
    let position: Position 
    let number: Int 

} 

struct ShiftDetails { 
    let player: PlayerInformation 
    var timeOnIce: Int 
    var dateOnIce: Date 
} 

Ich baue die playerInformationArray mit dem folgenden:

var playerInformationArray = [PlayerInformation]() 

let sidneyCrosby  = PlayerInformation.init(firstName: "Sidney", lastName: "Crosby", position: Position.c, number: 87) 
let alexOvechkin  = PlayerInformation.init(firstName: "Alex", lastName: "Ovechkin", position: Position.lw, number: 8) 
let patrickKane  = PlayerInformation.init(firstName: "Patrick", lastName: "Kane", position: Position.rw, number: 88) 

playerInformationArray.append(sidneyCrosby) 
playerInformationArray.append(alexOvechkin) 
playerInformationArray.append(patrickKane) 

Ich speichere Informationen zu einem Spieler "shift" in der folgenden Anordnung:

var shiftDetails = [ShiftDetails]() 

ich die Informationen über die "abrufen "Player aus einer Sammlungsansicht mit den folgenden Optionen ausgewählt:

let selectedPlayer = playerInformationArray[indexPath.row] 

ich dann aktualisieren, um die shiftDetails Array mit den folgenden:

shiftDetails.append(ShiftDetails.init(player: selectedPlayer, timeOnIce: timerCounter, dateOnIce: Date())) 

Alles funktioniert wie ausgenommen, aber ich habe eine harte Zeit Verständnis haben, wie Daten aus den Arrays abzurufen. Zum Beispiel:

Wie würde ich die count von shiftDetails pro Spieler abrufen?

Wie würde ich die sum von timeOnIce pro Spieler abrufen?

Danke!

Answer 1

Dies ist möglicherweise nicht der sauberste Weg, dies zu tun, da alle Ihre ShiftDetails in einem einzigen, gemeinsamen Array gehalten werden, aber um dies mit Ihrer aktuellen Einrichtung zu erreichen, könnten Sie die eingebaute filter Funktion verwenden Informationen über einen bestimmten Spieler. Dies könnte etwa so aussehen:

let selectedPlayer = playerInformationArray[indexPath.row] 
let filteredDetails = shiftDetails.filter({ $0.player == selectedPlayer }) 
let shiftCount = filteredDetails.count 
let timeOnIce = filteredDetails.reduce(0, { $0 + $1.timeOnIce }) 

Eine weitere Möglichkeit, eine shiftDetails Array für jeden Spieler zu halten wäre, an welcher Stelle Sie brauchen keine Filterung zu tun. Oder eine andere Option wäre, die shiftDetails ein Wörterbuch zu sein, in dem der Schlüssel der Spieler ist und der Wert ein Array von shiftDetails ist.

Es ist auch erwähnenswert, dass mein Beispiel der filter-Funktion davon ausgeht, dass Ihre Player-Struktur dem Equatable-Protokoll entspricht - mit anderen Worten, dass Sie legal playerOne == playerTwo sagen können. Wenn Sie dies nicht tun, müssen Sie auf ein anderes eindeutiges Feld wie Name oder playerId oder etwas Ähnliches abgleichen.

Answer 2

Wenn Sie überprüfen müssen, ob ein bestimmter Player einem anderen Player entspricht, müssen Sie ihn dem Equatable-Protokoll anpassen, das den doppelten Operator == implementiert.Sie können auch Ihre Struktur zu `CustomStringConvertible machen entsprechen und eine eigene Beschreibung es bieten:

struct Player: Equatable, CustomStringConvertible { 
    let firstName: String 
    let lastName: String 
    let position: Position 
    let number: Int 
    static func ==(lhs: Player, rhs: Player) -> Bool { 
     return lhs.firstName == rhs.firstName && lhs.lastName == rhs.lastName 
    } 
    var description: String { 
     return "Player: " + firstName + " " + lastName 
    } 
} 

---

Auch in Swift sollten Sie immer bevorzugen lange Namen (Camelcase) für eine bessere Lesbarkeit und versuchen, redundante Informationen zu vermeiden, wenn Benennen Sie Ihre Eigenschaften und Sie sollten den Typ Ihre Objektnamen nicht hinzufügen:

enum Position: String { 
    case leftWing = "Left Wing" 
    case rightWing = "Right Wing" 
    case center = "Center" 
    case defense = "Defense" 
    case golie = "Goalie" 
} 

struct Shift { 
    let player: Player 
    var timeOnIce: Int 
    var dateOnIce: Date 
} 

---

var players: [Player] = [] 

let sidneyCrosby = Player(firstName: "Sidney", lastName: "Crosby", position: .center, number: 87) 
let alexOvechkin = Player(firstName: "Alex", lastName: "Ovechkin", position: .leftWing, number: 8) 
let patrickKane = Player(firstName: "Patrick", lastName: "Kane", position: .rightWing, number: 88) 

players += [sidneyCrosby, alexOvechkin, patrickKane] 

var shifts: [Shift] = [] 
var index = IndexPath(row: 0, section: 0) 
var selectedPlayer = players[index.row] 
let shift1 = Shift(player: selectedPlayer, timeOnIce: 3, dateOnIce: Date()) 
shifts.append(shift1) 
let shift2 = Shift(player: selectedPlayer, timeOnIce: 5, dateOnIce: Date()) 
shifts.append(shift2) 

---

Um timeOnIce Eigenschaft pro Spieler summieren und seine Zählung, könnten Sie Array beschränke die Elemente erweitern Typ Shift:

extension Array where Element == Shift { 
    func timeOnIceAndCount(for player: Player) -> (timeOnIce: Int, count: Int) { 
     return reduce((0,0)) { 
      $1.player == player ? ($0.0 + $1.timeOnIce, $0.1 + 1) : $0 
     } 
    } 
} 

---

let (timeOnIce, count) = shifts.timeOnIceAndCount(for: selectedPlayer) 
print(selectedPlayer) 
print("TimeOnIce:",timeOnIce) 
print("Count: ", count) 

Das für diese

Player: Sidney Crosby

TimeOnIce: 8

Count: 2