Каков самый короткий способ запуска такого же кода n раз в Swift?

Ответ 1

Придерживая цикл for, вы можете расширить Int, чтобы соответствовать SequenceType, чтобы иметь возможность писать:

for i in 5 { /* Repeated five times */ }

Чтобы сделать Int совместимым с SequenceType, вы можете сделать следующее:

extension Int : SequenceType {
    public func generate() -> RangeGenerator<Int> {
        return (0..<self).generate()
    }
}

Ответ 2

Говоря о синтаксисе, вы можете определить свой собственный самый короткий синтаксис:

extension Int {
    func times(_ f: () -> ()) {
        if self > 0 {
            for _ in 0..<self {
                f()
            }
        }
    }

    func times(@autoclosure f: () -> ()) {
        if self > 0 {
            for _ in 0..<self {
                f()
            }
        }
    }
}

var s = "a"
3.times {
    s.append(Character("b"))
}
s // "abbb"


var d = 3.0
5.times(d += 1.0)
d // 8.0

Ответ 3

У вас есть несколько способов сделать это:

Использование для циклов:

for i in 1...n { `/*code*/` }

for i = 0 ; i < n ; i++ { `/*code*/` }

for i in n { `/*code*/` }

используя циклы while:

var i = 0
while (i < n) {
    `/*code*/`
   ` i++`
}

var i = 0
repeat {
   ` /*code*/`
    `i++`
} while(i <= n)

Ответ 4

for _ in 1...5 {
  //action will be taken 5 times.
}

Ответ 5

Вы могли бы сделать что-то вроде этого:

10⨉{ print("loop") }

Используя пользовательский оператор и расширение для Int:

infix operator ⨉ // multiplication sign, not lowercase 'x'

extension Int {
    static func ⨉( count:Int, block: () ->Void  ) {
        (0..<count).forEach { _ in block() }
    }
}

Ответ 6

Вы можете использовать функциональное программирование в диапазоне вместо цикла, например, для более короткого и "более приятного" синтаксиса.

(0..<n).forEach{print("Index: \($0)")}

Ответ 7

Короче и (думаю) понятнее

for i in 1...n { } // note: this will fail if n < 1

или же

for i in n { }

Ответ 8

Ответ ABakerSmith обновлен для Swift 4:

extension Int: Sequence {
    public func makeIterator() -> CountableRange<Int>.Iterator {
        return (0..<self).makeIterator()
    }
}

Использование:

for i in 5 {
    //Performed 5 times
}

Ответ 9

Здесь есть много ответов, подчеркивающих, насколько креативным вы можете быть с Swift.

Мне нужен массив, поэтому я сделал это

extension Int {
    func of<T>(iteration: (Int) -> T) -> [T] {
        var collection = [T]()
        for i in 0..<self {
            collection.append(iteration(i))
        }
        return collection
    }
}

fun strings() -> [String] {
    return 4.of { "\($0) teletubby" }
}

Ответ 10

В Swift у вас есть кратчайший синтаксис для выполнения операции цикла.

Swift предоставляет два вида циклов, которые выполняют набор операторов a определенное количество раз:

Цикл for-in выполняет набор операторов для каждого элемента в последовательность.

Цикл для выполняет набор операторов, пока не будет определен условие выполнено.

Если вы хотите запустить его бесконечно, попробуйте использовать while.

Ответ 11

Единственный цикл короче, чем бесконечный цикл while:

while (true) {
}

Но вам все равно придется увеличивать счетчик и проверять его в цикле, чтобы разбить цикл, и, в конце концов, он не будет короче.

Ответ 12

for-loops - обычный способ повторить код. Вот пример использования цикла for-loop, чтобы скрыть шесть выходов, вместо того, чтобы писать один и тот же код для шести точек. Плюс, если вы делаете еще одну розетку, все, что вам нужно сделать, это добавить ее в массив.

let array = [outLet0, outlet1, outlet2, outLet3, outLet4, outLet5]

for outlet in array {
  outlet.hidden = true
}

В отличие от написания:

outlet0.hidden = true
outlet1.hidden = true
outlet2.hidden = true
outlet3.hidden = true
outlet4.hidden = true
outlet5.hidden = true

Ответ 13

Если вы просто тестируете вещи и вам нужна ДЕЙСТВИТЕЛЬНО короткая линия, попробуйте это. Акцент на использование этого для тестирования, а не в производстве, потому что никто не будет знать, что происходит без документации.

определить это где-то глобально

func r(_ n : UInt, _ c: @escaping () -> Void) { for _ in 0..<n { c() } }

звоните, когда хотите запустить

r(5) { /*code*/ }