Swift 3: Wie für Schleife verwenden für Arrays

Question

Szenario Looping

Sagen wir, ich habe eine array = ["a", "b", "c", "d"]

Ich habe eine Funktion, die button mich Druckdaten in diesem Array ermöglicht. Ich habe eine for-Schleife verwendet, um das Array zu durchlaufen.

Aber nach dem letzten Array-Element (die index[3] ist) auf dem vierten Klick gedruckt wird, möchte ich es von Anfang an Druck auf dem fünften Klick (die index[0] ist).

Jede Hilfe wird sehr geschätzt!

Danke

Answer 1

Dazu müssen Sie einfach den Index des aktuellen Elements für Array-Objekt pflegen.

var currentIndex = 0 

@IBAction func buttonClick(_ sender: UIButton) { 
    print(array[currentIndex]) 
    currentIndex += 1 
    if currentIndex == array.count { 
     currentIndex = 0 
    } 
} 

Answer 2

einen Klick Zahl var halten (initialisieren mit 0) und die folgenden Befehle verwenden, wenn die Taste abgegriffen wird:

let valToPrint = yourArray[clickCount % yourArray.count] 
clickCount += 1 

print("Current value = \(valToPrint)") 

Die% (modulos) werden von einem Operator Zyklus clickCount durch den erforderlichen Bereich .

Answer 3

Schreib Code unten auf die Schaltfläche klicken

@IBAction func myButton(_ sender: UIButton) { 

    if sender.tag > array.count{ 
     sender.tag = 0 
    } 

    print("array[\(sender.tag)] = \(array[sender.tag])") 
    sender.tag += 1 

} 

Answer 4

Sie schreiben

let letters = ["a", "b", "c", "d"] 
var index = 0 

func printNext() { 
    print(letters[index]) 
    index = (index + 1) % letters.count 
} 

Answer 5

Für die technische Freude daran: eine andere Alternative wäre, um eine Sequenz zu definieren welches zyklisch über die Elemente des Arrays läuft.

eine unveränderliche Array Gegeben:

class Foo { 
    private let array: [String] 

    private lazy var cyclingSequenceOverArray: 
     UnfoldSequence<String, Int> = sequence(state: -1) { 
     (state: inout Int) -> String? in 
     guard !self.array.isEmpty else { return nil } 
     return self.array[(state = (state + 1) % self.array.count, state).1] 
    } 

    init(_ array: [String]) { 
     self.array = array 
    } 

    func printNext() { 
     if let next = cyclingSequenceOverArray.next() { 
      print(next) 
     } 
    } 
} 

let foo = Foo(["a", "b", "c", "d"]) 

foo.printNext() // a 
foo.printNext() // b 
foo.printNext() // c 
foo.printNext() // d 
foo.printNext() // a 
foo.printNext() // b 

---

In dem Fall, dass Sie das Array wandelbar sein lassen (var), und es wird immer leer: ein Aufruf an die next() Methode (wie oben ausgeführt) von Die Sequenz beendet die Sequenz. D. h., Selbst wenn das Array erneut gefüllt würde, würden nachfolgende Aufrufe an next() immer noch nil ergeben. In diesem Fall könnten Sie die Sequenz lassen unendlich sein (nie abbreche), einfach einen Standardwert bei der Rückkehr des Array nil:

class Foo { 
    var array: [String] 

    private lazy var cyclingSequenceOverArray: 
     UnfoldSequence<String, Int> = sequence(state: -1) { 
     (state: inout Int) -> String in 
     guard !self.array.isEmpty else { return (state = -1, "Empty!").1 } 
     return self.array[(state = (state + 1) % self.array.count, state).1] 
    } 

    init(_ array: [String]) { 
     self.array = array 
    } 

    func printNext() { 
     if let next = cyclingSequenceOverArray.next() { 
      print(next) 
     } 
    } 
} 

Beispiel Nutzung:

let foo = Foo(["a", "b", "c", "d"]) 

foo.printNext() // a 
foo.printNext() // b 
foo.printNext() // c 

foo.array = [] 

foo.printNext() // Empty! 
foo.printNext() // Empty! 

foo.array = ["a", "b", "c", "d"] 

foo.printNext() // a 
foo.printNext() // b 
foo.array[2] = "C" 
foo.printNext() // C 

foo.array = ["1", "2", "3"] 

foo.printNext() // 1