Swift Collection unterschätztCount-Nutzung

Question

Was ist ein Anwendungsfall für die Sammlung underestimateCount. Documentation sagt, dass es die gleiche Komplexität wie Standard Collection count hat.

Ich habe es Erklärung gesehen:

/// Returns a value less than or equal to the number of elements in 
/// `self`, *nondestructively*. 
/// 
/// - Complexity: O(N). 
public func underestimateCount() -> Int 

Aber es macht mir nichts gesagt, wann sollte ich es verwenden und aus welchem ​​Grund.

Answer 1

underestimateCount ist eigentlich eine Forderung des Sequence Protokoll und hat a default implementation, die gerade wieder 0:

public var underestimatedCount: Int { 
    return 0 
} 

für Sequenzen jedoch, die ihre eigene Implementierung von underestimatedCount liefern, kann dies für die Logik nützlich sein, die eine braucht Untergrenze, wie lange die Sequenz ist, ohne dass sie durchlaufen werden muss (bedenken Sie, dass Sequence keine Garantie für eine nicht-destruktive Iteration gibt).

Zum Beispiel kann die map(_:) Methode auf Sequence (see its implementation here) verwendet underestimateCount, um eine Anfangskapazität für die resultierende Anordnung zu reservieren:

public func map<T>(
    _ transform: (Iterator.Element) throws -> T 
) rethrows -> [T] { 

    let initialCapacity = underestimatedCount 
    var result = ContiguousArray<T>() 
    result.reserveCapacity(initialCapacity) 

    // ... 

Dies ermöglicht map(_:) die Kosten der wiederholt auf die result anhängt, zu minimieren, da ein erster Speicherblock (möglicherweise) bereits für ihn reserviert wurde (obwohl es auf jeden Fall erwähnenswert ist, dass ContiguousArray eine exponentielle Wachstumsstrategie hat, die die Kosten des Anhängens amortisiert).

jedoch im Falle eines Collection, the default implementation von underestimateCount tatsächlich gibt nur die Sammlung des count:

public var underestimatedCount: Int { 
    // TODO: swift-3-indexing-model - review the following 
    return numericCast(count) 
} 

die ein O (1) -Operation für Sammlungen werden, die RandomAccessCollection, O (n) entsprechen Andernfalls.

daher aufgrund dieser Standardimplementierung, ein Collection mit ‚s underestimatedCount direkt ist auf jeden Fall weniger verbreitet als ein Sequence mit‘ s, als Collection garantiert zerstörungs Iteration, und in den meisten Fällen underestimatedCount wird nur die count zurück.

Natürlich können benutzerdefinierte Sammlungstypen ihre eigene Implementierung von underestimatedCount - geben eine untere Grenze, wie viele Elemente sie enthalten, in einer möglicherweise effizienteren Weise als ihre Implementierung, die möglicherweise nützlich sein könnte.

Answer 2

(Da das doppelte Ziel, schlage ich vor habe, ist etwas veraltet)

In Swift 3, wobei das Verfahren underestimateCount()underestimatedCount durch die berechnete Eigenschaft ersetzt wurde. Wir können für die implementation of the latter for Collection auf den Quellcode haben einen Blick:

/// A value less than or equal to the number of elements in the collection. 
    /// 
    /// - Complexity: O(1) if the collection conforms to 
    /// `RandomAccessCollection`; otherwise, O(*n*), where *n* is the length 
    /// of the collection. 
    public var underestimatedCount: Int { 
    // TODO: swift-3-indexing-model - review the following 
    return numericCast(count) 
    } 

    /// The number of elements in the collection. 
    /// 
    /// - Complexity: O(1) if the collection conforms to 
    /// `RandomAccessCollection`; otherwise, O(*n*), where *n* is the length 
    /// of the collection. 
    public var count: IndexDistance { 
    return distance(from: startIndex, to: endIndex) 
    } 

Seine offensichtlich, dass underestimatedCount einfach nutzen count für Typen macht Collection konform (es sei denn, diese Typen implementiert ihre eigene Version von underestimatedCount).