斯威夫特有片面的进步吗？

Question

我想做这样的事情：

let sequence1 = stride(from: Int32(2), by: 2)
for (i, address) in zip(sequence1, addresses) {
  sqlite3_bind_int64(stmt, i, address.userID)
  sqlite3_bind_int(stmt, i+1, address.deviceID)
}

但是stride(from:by:) 不存在。

我知道我可以将第一行改为：

let sequence1 = stride(from: Int32(2), through: Int32.max, by: 2)

或到：

let sequence1 = sequence(first: Int32(2), next: { $0 + 2 })

而且我知道 Swift 的范围是单向的，例如 PartialRangeFrom，但是 Swift 有单向的跨步吗？

相关：

• Iterate over collection two at a time in Swift
• Swift: What's the best way to pair up elements of an Array

Answer 1

不，在 Swift 中没有片面的进步。

对于一个一般的（惰性求值的）序列，每隔一个整数就迭代一次

let sequence1 = sequence(first: Int32(2), next: { $0 + 2 })

是一个简单、清晰、灵活的解决方案。另一种选择是

let sequence1 = (Int32(1)...).lazy.map { $0 * 2 }

在您的特定情况下，我会简单地使用单边范围：

for (i, address) in zip(Int32(1)..., addresses) {
    sqlite3_bind_int64(stmt, 2 * i, address.userID)
    sqlite3_bind_int(stmt, 2 * i + 1, address.deviceID)
}

Answer 2

就像他们说的，不。但无论如何你都不想要那样。加分太多了。打破你的部分范围！ ⚒️

public extension Sequence {
  /// Splits a `Sequence` into equal "chunks".
  /// - Parameter maxArrayCount: The maximum number of elements in a chunk.
  /// - Returns: `Array`s with `maxArrayCount` `counts`,
  ///   until the last chunk, which may be smaller.
  subscript(maxArrayCount maxCount: Int) -> AnySequence<[Element]> {
    .init(
      sequence( state: makeIterator() ) { iterator in
        Optional(
          (0..<maxCount).compactMap { _ in iterator.next() },
          nilWhen: \.isEmpty
        )
      }
    )
  }
}

public extension Optional {
  /// Wraps a value in an optional, based on a condition.
  /// - Parameters:
  ///   - wrapped: A non-optional value.
  ///   - getIsNil: The condition that will result in `nil`.
  init(
    _ wrapped: Wrapped,
    nilWhen getIsNil: (Wrapped) throws -> Bool
  ) rethrows {
    self = try getIsNil(wrapped) ? nil : wrapped
  }
}

zip( (2...)[maxArrayCount: 2], addresses ).forEach {
  sqlite3_bind_int64(stmt, $0[0], $1.userID)
  sqlite3_bind_int(stmt, $0[1], $1.deviceID)
}