Защо и кога да използваме lazy с Array в Swift?

lazy променя начина, по който се обработва масивът. Когато lazy не се използва, filter обработва целия масив и съхранява резултатите в нов масив. Когато се използва lazy, стойностите в последователността или колекцията се произвеждат при поискване от функциите надолу по веригата. Стойностите не се съхраняват в масив; те просто се произвеждат, когато е необходимо.

Помислете за този модифициран пример, в който използвах reduce вместо count, за да можем да отпечатаме какво се случва:

Не използвам lazy:

В този случай всички елементи първо ще бъдат филтрирани, преди да се преброи нещо.

[1, 2, 3, -1, -2].filter({ print("filtered one"); return $0 > 0 })
    .reduce(0) { (total, elem) -> Int in print("counted one"); return total + 1 }

filtered one
filtered one
filtered one
filtered one
filtered one
counted one
counted one
counted one

Използване на lazy:

В този случай reduce иска елемент за преброяване и filter ще работи, докато намери такъв, след това reduce ще поиска друг и filter ще работи, докато намери друг.

[1, 2, 3, -1, -2].lazy.filter({ print("filtered one"); return $0 > 0 })
    .reduce(0) { (total, elem) -> Int in print("counted one"); return total + 1 }

filtered one
counted one
filtered one
counted one
filtered one
counted one
filtered one
filtered one

Кога да използвате lazy:

опция-щракването върху lazy дава това обяснение:

От Дискусията за lazy:

Използвайте мързеливото свойство при верижни операции:

1. за предотвратяване на междинните операции от разпределяне на хранилище

   or

2. когато имате нужда само от част от крайната колекция, за да избегнете ненужни изчисления

   Бих добавил и трети:

3. когато искате процесите надолу по веригата да започнат по-рано и да не се налага да чакате процесите нагоре по веригата да свършат цялата си работа първи

Така например бихте искали да използвате lazy преди filter, ако търсите първия положителен Int, защото търсенето ще спре веднага щом намерите такъв и това ще спести filter от необходимостта да филтрира целия масив и ще спестете необходимостта да отделяте място за филтрирания масив.

За 3-та точка си представете, че имате програма, която показва прости числа в диапазона 1...10_000_000, използвайки filter в този диапазон. Бихте предпочели да покажете простите числа, както сте ги намерили, отколкото да чакате да ги изчислите всички, преди да покажете нещо.

Не бях виждал това преди, затова потърсих малко и го намерих.

Синтаксисът, който публикувате, създава мързелива колекция. Мързеливото събиране избягва създаването на цяла поредица от междинни масиви за всяка стъпка от вашия код. Не е толкова уместно, когато имате само оператор за филтър, ще има много по-голям ефект, ако направите нещо като filter.map.map.filter.map, тъй като без мързеливата колекция се създава нов масив на всяка стъпка.

Вижте тази статия за повече информация:

https://medium.com/developermind/lightning-read-1-lazy-collections-in-swift-fa997564c1a3

РЕДАКТИРАНЕ:

Направих някои сравнителни анализи и серия от функции от по-висок порядък като карти и филтри всъщност е малко по-бавна при мързелива колекция, отколкото при обикновена колекция.

Изглежда, че мързеливите колекции ви дават по-малък отпечатък от паметта на цената на малко по-бавна производителност.

Редактиране #2:

@discardableResult func timeTest() -> Double {
    let start = Date()
    let array = 1...1000000
    let random = array
        .map { (value) -> UInt32 in
            let random = arc4random_uniform(100)
            //print("Mapping", value, "to random val \(random)")
            return random
    }
    let result = random.lazy  //Remove the .lazy here to compare
        .filter {
            let result = $0 % 100 == 0
            //print("  Testing \($0) < 50", result)
            return result
        }
        .map { (val: UInt32) -> NSNumber in
            //print("    Mapping", val, "to NSNumber")
            return NSNumber(value: val)
        }
        .compactMap { (number) -> String? in
            //print("      Mapping", number, "to String")
            return formatter.string(from: number)
        }
        .sorted { (lhv, rhv) -> Bool in
            //print("        Sorting strings")
            return (lhv.compare(rhv, options: .numeric) == .orderedAscending)
    }
    
    let elapsed = Date().timeIntervalSince(start)
    
    print("Completed in", String(format: "%0.3f", elapsed), "seconds. count = \(result.count)")
    return elapsed
}

В кода по-горе, ако промените реда

let result = random.lazy  //Remove the .lazy here to compare

to

let result = random  //Removes the .lazy here

След това работи по-бързо. С lazy, моят бенчмарк показва, че отнема около 1,5 пъти повече време с .lazy колекцията в сравнение с прав масив.