RealmCollection

public protocol RealmCollection : RealmCollectionBase, Equatable where Self.Iterator == RLMIterator<Self.Element>

可以检索、筛选、排序和操作的Object的同质collection。

属性

对象检索

  • 返回集合中的第一个对象,如果集合为空,则返回nil

    声明

    Swift

    var first: Element? { get }
  • 返回集合中的最后一个对象,如果集合为空,则返回nil

    声明

    Swift

    var last: Element? { get }

索引检索

  • 返回对象在collection中的索引,如果该对象不存在,则返回nil

    声明

    Swift

    func index(of object: Element) -> Int?

    参数

    object

    一个对象。

  • index(matching:) 默认实现

    返回与谓词匹配的第一个对象的索引,如果没有对象匹配,则返回nil

    这仅适用于有序collection,如果collection无序,则会中止。

    默认实现

    返回与查询匹配的第一个对象的索引,如果没有对象匹配,则返回nil

    这仅适用于有序collection,如果collection无序,则会中止。

    注意

    这只应与使用@Persistable属性声明的类一起使用。

    • 用法:

      obj.index(matching: { $0.fooCol < 456 })
      

    注意

    有关可用查询操作的更多信息,请参阅Query

    声明

    Swift

    func index(matching predicate: NSPredicate) -> Int?

    参数

    predicate

    用于筛选对象的谓词。

  • index(matching:_:) 默认实现

    返回与谓词匹配的第一个对象的索引,如果没有对象匹配,则返回nil

    这仅适用于有序collection,如果collection无序,则会中止。

    默认实现

    返回与给定谓词匹配的第一个对象的索引,如果没有对象匹配,则返回nil

    声明

    Swift

    func index(matching predicateFormat: String, _ args: Any...) -> Int?

    参数

    predicateFormat

    谓词格式字符串,可以选择后跟可变数量的参数。

对象检索

  • 返回一个数组,其中包含collection中位于给定索引集指定索引处的对象。

    警告

    如果 IndexSet 中提供的索引越界,则抛出此异常。

    声明

    Swift

    func objects(at indexes: IndexSet) -> [Element]

    参数

    indexes

    在collection中的索引,用于从中选择对象。

过滤

  • filter(_:_:) 默认实现

    返回一个Results ,其中包含collection中与给定谓词匹配的所有对象。

    默认实现

    返回一个Results ,其中包含collection中与给定谓词匹配的所有对象。

    声明

    Swift

    func filter(_ predicateFormat: String, _ args: Any...) -> Results<Element>

    参数

    predicateFormat

    谓词格式字符串,可以选择后跟可变数量的参数。

  • 返回一个Results ,其中包含collection中与给定谓词匹配的所有对象。

    声明

    Swift

    func filter(_ predicate: NSPredicate) -> Results<Element>

    参数

    predicate

    用于筛选对象的谓词。

排序

聚合操作

  • 返回集合中所有对象中给定属性的最小值,如果集合为空,则返回nil

    警告

    只能指定类型符合MinMaxType协议的属性。

    声明

    Swift

    func min<T>(ofProperty property: String) -> T? where T : _HasPersistedType, T.PersistedType : MinMaxType

    参数

    property

    所需最小值的属性名称。

  • 返回集合中所有对象中给定属性的最大值,如果集合为空,则返回nil

    警告

    只能指定类型符合MinMaxType协议的属性。

    声明

    Swift

    func max<T>(ofProperty property: String) -> T? where T : _HasPersistedType, T.PersistedType : MinMaxType

    参数

    property

    所需最小值的属性名称。

  • 返回集合中对象的给定属性的总和,如果集合为空,则返回nil

    警告

    只能使用符合AddableType协议的类型的属性名称。

    声明

    Swift

    func sum<T>(ofProperty property: String) -> T where T : _HasPersistedType, T.PersistedType : AddableType

    参数

    property

    符合AddableType的属性名称,用于计算总和。

  • 返回集合中所有对象的给定属性的平均值,如果集合为空,则返回nil

    警告

    只能指定类型符合AddableType协议的属性。

    声明

    Swift

    func average<T>(ofProperty property: String) -> T? where T : _HasPersistedType, T.PersistedType : AddableType

    参数

    property

    应对其值求和的属性的名称。

键值编码

  • 返回一个Array ,其中包含对集合的每个对象调用valueForKey(_:)key的结果。

    声明

    Swift

    func value(forKey key: String) -> Any?

    参数

    key

    所需值的属性的名称。

  • 返回一个Array ,其中包含对集合的每个对象调用valueForKeyPath(_:)keyPath的结果。

    声明

    Swift

    func value(forKeyPath keyPath: String) -> Any?

    参数

    keyPath

    所需值属性的键路径。

  • setValue(_:forKey:)使用指定的value 和 在集合的每个对象上调用key

    警告

    此方法只能在写事务(write transaction)期间调用。

    声明

    Swift

    func setValue(_ value: Any?, forKey key: String)

    参数

    value

    对象值。

    key

    应在每个对象上设置其值的属性的名称。

通知

  • 注册一个区块,以便在每次collection更改时调用。

    该区块将与初始结果一起异步调用,然后在每次写事务(write transaction)后再次调用,这会更改collection中的任何对象或collection中的哪些对象。

    传递给区块的change参数以collection内索引的形式报告在每个写事务(write transaction)期间添加、删除或修改了哪些对象。有关所提供变更信息的更多信息,以及如何使用这些信息来更新UITableView的示例,请参阅RealmCollectionChange文档。

    调用区块时,collection将进行全面求值且是最新的,只要不在同一线程上执行写事务(write transaction)或显式调用realm.refresh() ,访问该collection就永远不会执行阻塞工作。

    如果未指定队列,则将通过标准事件循环传递通知,因此当事件循环被其他活动阻塞时无法传递通知。如果给出了队列,则将通知传递到该队列。 当无法立即传递通知时,可以将多个通知合并为一个通知。 这可以包括初始collection的通知。

    例如,以下代码在添加通知块后立即执行写事务(write transaction),因此没有机会首先传递初始通知。因此,初始通知将反映写事务后 Realm 的状态。

    let dogs = realm.objects(Dog.self)
    print("dogs.count: \(dogs?.count)") // => 0
    let token = dogs.observe { changes in
        switch changes {
        case .initial(let dogs):
            // Will print "dogs.count: 1"
            print("dogs.count: \(dogs.count)")
            break
        case .update:
            // Will not be hit in this example
            break
        case .error:
            break
        }
    }
    try! realm.write {
        let dog = Dog()
        dog.name = "Rex"
        person.dogs.append(dog)
    }
    // end of run loop execution context
    

    如果未给出键路径,则在所有对象属性以及任何嵌套、链接对象的属性的任何插入、修改或删除操作时都会执行该区块。 如果提供了一个或多个关键路径,则将调用该区块以进行仅在所提供的关键路径上发生的更改。 例如,如果:

    class Dog: Object {
        @Persisted var name: String
        @Persisted var age: Int
        @Persisted var toys: List<Toy>
    }
    // ...
    let dogs = realm.objects(Dog.self)
    
    let token = dogs.observe(keyPaths: ["name"]) { changes in
        switch changes {
        case .initial(let dogs):
           // ...
        case .update:
           // This case is hit:
           // - after the token is initialized
           // - when the name property of an object in the
           // collection is modified
           // - when an element is inserted or removed
           //   from the collection.
           // This block is not triggered:
           // - when a value other than name is modified on
           //   one of the elements.
        case .error:
            // ...
        }
    }
    // end of run loop execution context
    
    • 如果观察到的键路径为["toys.brand"] ,则对collection任何元素上的toys列表进行的任何插入或删除操作都会trigger该区块。 对链接到此collection中的Dog的任何Toybrand值进行更改都会trigger该区块。在链接到此collection中的Dog的任何Toy上,对brand以外的值进行更改都不会trigger该区块。对所观察到的Dog类型collection的任何插入或删除也会trigger通知。
    • 如果在上面的示例中观察到了["toys"]键路径,那么针对集合中的任何元素对toys列表进行的任何插入、删除或修改都会触发区块。 对链接到此collection中的Dog的任何Toy的任何值进行更改都不会trigger该区块。对正在观察的Dog类型集合的任何插入或删除仍会触发通知。

    注意

    同一对象上的多个通知令牌(针对单独的键路径进行过滤)不会进行排他性过滤。如果一项键路径变更符合一个通知令牌的条件,则该对象的所有通知令牌块都将执行。

    只要您希望将更新发送到区块,就必须保留返回的令牌。 要停止接收更新,请对令牌调用invalidate()

    警告

    在写事务(write transaction)期间或当包含的 Realm 为只读时,无法调用此方法。

    默认实现

    注册一个区块,以便在每次collection更改时调用。

    该区块将与初始结果一起异步调用,然后在每次写事务(write transaction)后再次调用,这会更改collection中的任何对象或collection中的哪些对象。

    传递给区块的change参数以collection内索引的形式报告在每个写事务(write transaction)期间添加、删除或修改了哪些对象。有关所提供变更信息的更多信息,以及如何使用这些信息来更新UITableView的示例,请参阅RealmCollectionChange文档。

    调用区块时,collection将进行全面求值且是最新的,只要不在同一线程上执行写事务(write transaction)或显式调用realm.refresh() ,访问该collection就永远不会执行阻塞工作。

    如果未指定队列,则将通过标准事件循环传递通知,因此当事件循环被其他活动阻塞时无法传递通知。如果给出了队列,则将通知传递到该队列。 当无法立即传递通知时,可以将多个通知合并为一个通知。 这可以包括初始collection的通知。

    例如,以下代码在添加通知块后立即执行写事务(write transaction),因此没有机会首先传递初始通知。因此,初始通知将反映写事务后 Realm 的状态。

    let dogs = realm.objects(Dog.self)
    print("dogs.count: \(dogs?.count)") // => 0
    let token = dogs.observe { changes in
        switch changes {
        case .initial(let dogs):
            // Will print "dogs.count: 1"
            print("dogs.count: \(dogs.count)")
            break
        case .update:
            // Will not be hit in this example
            break
        case .error:
            break
        }
    }
    try! realm.write {
        let dog = Dog()
        dog.name = "Rex"
        person.dogs.append(dog)
    }
    // end of run loop execution context
    

    如果未给出键路径,则在所有对象属性以及任何嵌套、链接对象的属性的任何插入、修改或删除操作时都会执行该区块。 如果提供了一个或多个关键路径,则将调用该区块以进行仅在所提供的关键路径上发生的更改。 例如,如果:

    class Dog: Object {
        @Persisted var name: String
        @Persisted var age: Int
        @Persisted var toys: List<Toy>
    }
    // ...
    let dogs = realm.objects(Dog.self)
    
    let token = dogs.observe(keyPaths: [\Dog.name]) { changes in
        switch changes {
        case .initial(let dogs):
           // ...
        case .update:
           // This case is hit:
           // - after the token is initialized
           // - when the name property of an object in the
           // collection is modified
           // - when an element is inserted or removed
           //   from the collection.
           // This block is not triggered:
           // - when a value other than name is modified on
           //   one of the elements.
        case .error:
            // ...
        }
    }
    // end of run loop execution context
    
    • 如果观察到的键路径为[\Dog.toys.brand] ,则对collection任何元素上的toys列表进行的任何插入或删除操作都会trigger该区块。 对链接到此collection中的Dog的任何Toybrand值进行更改都会trigger该区块。在链接到此collection中的Dog的任何Toy上,对brand以外的值进行更改都不会trigger该区块。对所观察到的Dog类型collection的任何插入或删除也会trigger通知。
    • 如果在上面的示例中观察到了[\Dog.toys]键路径,那么针对集合中的任何元素对toys列表进行的任何插入、删除或修改都会触发区块。 对链接到此collection中的Dog的任何Toy的任何值进行更改都不会trigger该区块。对正在观察的Dog类型集合的任何插入或删除仍会触发通知。

    注意

    同一对象上的多个通知令牌(针对单独的键路径进行过滤)不会进行排他性过滤。如果一项键路径变更符合一个通知令牌的条件,则该对象的所有通知令牌块都将执行。

    只要您希望将更新发送到区块,就必须保留返回的令牌。 要停止接收更新,请对令牌调用invalidate()

    警告

    在写事务(write transaction)期间或当包含的 Realm 为只读时,无法调用此方法。

    声明

    Swift

    func observe(keyPaths: [String]?,
                 on queue: DispatchQueue?,
                 _ block: @escaping (RealmCollectionChange<Self>) -> Void) -> NotificationToken

    参数

    keyPaths

    只有键路径数组中包含的属性在修改时才会触发区块。 如果为nil ,则对象上的任何属性更改都会发送通知。 与有效属性不对应的字符串键路径将引发异常。 有关关联属性的更多详细信息,请参阅上述描述。

    queue

    用于接收通知的串行调度队列。 如果为nil ,则通知将传递到当前线程。

    block

    发生更改时要调用的区块。

    返回值

    只要您希望传递更新,就必须持有的令牌。

  • observe(keyPaths:on:_isolation:_:) 默认实现,异步

    注册一个区块,以便在每次collection更改时调用。

    该区块将与collection的初始版本一起异步调用,然后在每次写事务(write transaction)后再次调用,这会更改collection中的任何对象或collection中的哪些对象。

    传递给该区块的actor参数是传递给该函数的 actor。 需要此参数来隔离对 actor 的回调。

    传递给区块的change参数以collection内索引的形式报告在上次通知后添加、删除或修改了哪些对象。变更枚举中的collection字段将与请求的 actor 隔离,并且只能在该 actor 中安全使用。 有关所提供变更信息的更多信息以及如何使用这些信息来更新UITableView的示例,请参阅RealmCollectionChange文档。

    发出初始通知后,该collection将进行全面评估并保持最新状态,访问该collection永远不会执行任何阻塞工作。仅当您不在通知发送到的同一 actor 上执行写事务(write transaction)时,此保证才有效。如果这样做,在传递下一个通知之前访问该collection可能需要重新运行查询。

    通知将传递给给定 actor 的执行程序。 当无法立即传递通知时,可以将多个通知合并为一个通知。 这可以包括带有初始collection的通知:在传递初始通知之前发生的任何写入都可能不会生成变更通知。

    在collection中添加、删除或分配对象始终会生成通知。默认情况下,修改collection链接到的对象(以及这些对象链接到的对象,如果适用)也会将collection中的索引报告为正在修改。如果提供了非空的键路径数组,则只有对这些键路径的修改才会将对象标记为已修改。 例如:

    class Dog: Object {
        @Persisted var name: String
        @Persisted var age: Int
        @Persisted var toys: List<Toy>
    }
    
    let dogs = realm.objects(Dog.self)
    let token = await dogs.observe(keyPaths: ["name"], on: myActor) { actor, changes in
        switch changes {
        case .initial(let dogs):
            // Query has finished running and dogs can not be used without blocking
        case .update:
            // This case is hit:
            // - after the token is initialized
            // - when the name property of an object in the collection is modified
            // - when an element is inserted or removed from the collection.
            // This block is not triggered:
            // - when a value other than name is modified on one of the elements.
        case .error:
            // Can no longer happen but is left for backwards compatiblity
        }
    }
    
    • 如果观察到的键路径为["toys.brand"] ,则对collection任何元素上的toys列表进行的任何插入或删除操作都会trigger该区块。 对链接到此collection中的Dog的任何Toybrand值进行更改都会trigger该区块。在链接到此collection中的Dog的任何Toy上,对brand以外的值进行更改都不会trigger该区块。对所观察到的Dog类型collection的任何插入或删除也会trigger通知。
    • 如果在上面的示例中观察到了["toys"]键路径,那么针对集合中的任何元素对toys列表进行的任何插入、删除或修改都会触发区块。 对链接到此collection中的Dog的任何Toy的任何值进行更改都不会trigger该区块。对正在观察的Dog类型集合的任何插入或删除仍会触发通知。

    只要您希望将更新发送到区块,就必须保留返回的令牌。 要停止接收更新,请对令牌调用invalidate()

    警告

    在写事务(write transaction)期间或当包含的 Realm 为只读时,无法调用此方法。

    默认实现

    注册一个区块,以便在每次collection更改时调用。

    该区块将与collection的初始版本一起异步调用,然后在每次写事务(write transaction)后再次调用,这会更改collection中的任何对象或collection中的哪些对象。

    传递给该区块的actor参数是传递给该函数的 actor。 需要此参数来隔离对 actor 的回调。

    传递给区块的change参数以collection内索引的形式报告在上次通知后添加、删除或修改了哪些对象。变更枚举中的collection字段将与请求的 actor 隔离,并且只能在该 actor 中安全使用。 有关所提供变更信息的更多信息以及如何使用这些信息来更新UITableView的示例,请参阅RealmCollectionChange文档。

    发出初始通知后,该collection将进行全面评估并保持最新状态,访问该collection永远不会执行任何阻塞工作。仅当您不在通知发送到的同一 actor 上执行写事务(write transaction)时,此保证才有效。如果这样做,在传递下一个通知之前访问该collection可能需要重新运行查询。

    通知将传递给给定 actor 的执行程序。 当无法立即传递通知时,可以将多个通知合并为一个通知。 这可以包括带有初始collection的通知:在传递初始通知之前发生的任何写入都可能不会生成变更通知。

    在collection中添加、删除或分配对象始终会生成通知。默认情况下,修改collection链接到的对象(以及这些对象链接到的对象,如果适用)也会将collection中的索引报告为正在修改。如果提供了非空的键路径数组,则只有对这些键路径的修改才会将对象标记为已修改。 例如:

    class Dog: Object {
        @Persisted var name: String
        @Persisted var age: Int
        @Persisted var toys: List<Toy>
    }
    
    let dogs = realm.objects(Dog.self)
    let token = await dogs.observe(keyPaths: ["name"], on: myActor) { actor, changes in
        switch changes {
        case .initial(let dogs):
            // Query has finished running and dogs can not be used without blocking
        case .update:
            // This case is hit:
            // - after the token is initialized
            // - when the name property of an object in the collection is modified
            // - when an element is inserted or removed from the collection.
            // This block is not triggered:
            // - when a value other than name is modified on one of the elements.
        case .error:
            // Can no longer happen but is left for backwards compatiblity
        }
    }
    
    • 如果观察到的键路径为["toys.brand"] ,则对collection任何元素上的toys列表进行的任何插入或删除操作都会trigger该区块。 对链接到此collection中的Dog的任何Toybrand值进行更改都会trigger该区块。在链接到此collection中的Dog的任何Toy上,对brand以外的值进行更改都不会trigger该区块。对所观察到的Dog类型collection的任何插入或删除也会trigger通知。
    • 如果在上面的示例中观察到了["toys"]键路径,那么针对集合中的任何元素对toys列表进行的任何插入、删除或修改都会触发区块。 对链接到此collection中的Dog的任何Toy的任何值进行更改都不会trigger该区块。对正在观察的Dog类型集合的任何插入或删除仍会触发通知。

    只要您希望将更新发送到区块,就必须保留返回的令牌。 要停止接收更新,请对令牌调用invalidate()

    警告

    在写事务(write transaction)期间或当包含的 Realm 为只读时,无法调用此方法。

    声明

    Swift

    @available(macOS 10.15, tvOS 13.0, iOS 13.0, watchOS 6.0, *)
    func observe<A: Actor>(keyPaths: [String]?,
                           on actor: A,
                           _isolation: isolated (any Actor)?,
                           _ block: @Sendable @escaping (isolated A, RealmCollectionChange<Self>) -> Void) async -> NotificationToken

    参数

    keyPaths

    只有键路径数组中包含的属性在修改时才会触发区块。 如果nil或为空,则对象上的任何属性更改都会发送通知。 与有效属性不对应的字符串键路径将引发异常。 有关关联属性的更多详细信息,请参阅上述描述。

    actor

    要隔离通知的 actor。

    block

    发生更改时要调用的区块。

    返回值

    只要您希望传递更新,就必须持有的令牌。

冻结对象

  • 如果此collection已冻结,则返回 true

    声明

    Swift

    var isFrozen: Bool { get }
  • 返回此collection的冻结(不可变)快照。

    冻结副本是一个不可变的collection,其中包含与该collection当前包含的数据相同的数据,但在写入包含的 Realm 时不会更新。与实时集合不同,冻结集合可以从任何线程访问。

    警告

    在写事务(write transaction)期间或当包含的 Realm 为只读时,无法调用此方法。

    警告

    在 Realm 上执行写事务(write transaction)时长时间持有冻结的 collection 可能会导致 Realm 文件过大。有关更多信息,请参阅Realm.Configuration.maximumNumberOfActiveVersions

    声明

    Swift

    func freeze() -> Self
  • 返回此冻结collection的活动(可变)版本。

    此方法解析对同一冻结collection的实时副本的引用。如果在实时collection上调用,则返回自身。

    声明

    Swift

    func thaw() -> Self?
  • 根据给定的排序描述符数组对此collection进行排序,并通过用户定义的回调执行分段,将结果作为实例的SectionedResults返回。

    注意

    主排序描述符必须负责确定节键。

    声明

    Swift

    func sectioned<Key: _Persistable>(sortDescriptors: [SortDescriptor],
                                      _ keyBlock: @escaping ((Element) -> Key)) -> SectionedResults<Key, Element>

    参数

    sortDescriptors

    要排序的SortDescriptor数组。

    keyBlock

    对 Results collection中的每个元素调用的回调。此回调将返回集合中元素的部分键。

    返回值

    SectionedResults的实例。

类型安全查询

  • where(_:) 扩展方法

    返回一个Results,其中包含collection中与给定查询匹配的所有对象。

    注意

    这只应与使用@Persistable属性声明的类一起使用。

    • 用法:

      myCol.where {
      ($0.fooCol > 5) && ($0.barCol == "foobar")
      }
      

    注意

    有关可用查询操作的更多信息,请参阅Query

    声明

    Swift

    func `where`(_ isIncluded: ((Query<Element>) -> Query<Bool>)) -> Results<Element>

    参数

    isIncluded

    用于筛选对象的查询闭包。

collection协议

  • startIndex 扩展方法

    非空collection中第一个元素的位置。与空collection中的 endIndex 相同。

    声明

    Swift

    var startIndex: Int { get }
  • endIndex 扩展方法

    集合的“超过末尾”位置。 endIndex 不是下标的有效参数,但始终可以通过零次或多次应用程序 successor() 从 startIndex 访问 endIndex。

    声明

    Swift

    var endIndex: Int { get }
  • index(after:) 扩展方法

    返回紧随给定索引之后的位置。

    声明

    Swift

    func index(after i: Int) -> Int

    参数

    i

    collection的有效索引。i必须小于endIndex

  • index(before:) 扩展方法

    返回给定索引之前的位置。

    声明

    Swift

    func index(before i: Int) -> Int

    参数

    i

    collection的有效索引。i必须大于startIndex

关于基元的分段结果

  • 按升序或降序对此collection进行排序,并通过用户定义的回调执行分段。

    声明

    Swift

    func sectioned<Key: _Persistable>(by block: @escaping ((Element) -> Key),
                                      ascending: Bool = true) -> SectionedResults<Key, Element>

    参数

    block

    对集合中的每个元素调用的回调。 此回调将返回集合中元素的部分键。

    ascending

    排序的方向。

    返回值

    SectionedResults的实例。

观察

  • 从给定属性键路径对此集合进行排序和分段,并以SectionedResults的实例形式返回结果。 对于从 keyPath 检索到的每个唯一值,都会生成一个部分键。

    声明

    Swift

    public func sectioned<Key: _Persistable, O: ObjectBase>(by keyPath: KeyPath<Element, Key>,
                                                            ascending: Bool = true) -> SectionedResults<Key, Element> where Element: Projection<O>

    参数

    keyPath

    排序所依据的属性键路径。

    ascending

    排序的方向。

    返回值

    SectionedResults的实例。

  • 从给定属性键路径对此集合进行排序和分段,并以SectionedResults的实例形式返回结果。 对于从 keyPath 检索到的每个唯一值,都会生成一个部分键。

    注意

    主排序描述符必须负责确定节键。

    声明

    Swift

    public func sectioned<Key: _Persistable, O: ObjectBase>(by keyPath: KeyPath<Element, Key>,
                                                            sortDescriptors: [SortDescriptor]) -> SectionedResults<Key, Element> where Element: Projection<O>

    参数

    keyPath

    排序所依据的属性键路径。

    sortDescriptors

    要排序的SortDescriptor数组。

    返回值

    SectionedResults的实例。

  • 根据给定的排序描述符数组对此collection进行排序,并通过用户定义的回调执行分段,将结果作为实例的SectionedResults返回。

    注意

    主排序描述符必须负责确定节键。

    声明

    Swift

    public func sectioned<Key: _Persistable, O: ObjectBase>(by block: @escaping ((Element) -> Key),
                                                            sortDescriptors: [SortDescriptor]) -> SectionedResults<Key, Element> where Element: Projection<O>

    参数

    block

    对 Results collection中的每个元素调用的回调。此回调将返回集合中元素的部分键。

    sortDescriptors

    要排序的SortDescriptor数组。

    返回值

    SectionedResults的实例。

适用于以下位置: SelfRealmSubscribable

适用于以下位置: ElementEncodable

  • encode(to:) 扩展方法

    将此collection的内容编码到给定的编码器中。

    声明

    Swift

    public func encode(to encoder: Encoder) throws

适用于以下位置: ElementObjectBase

  • min(of:) 扩展方法

    返回集合中所有对象中给定属性的最小值,如果集合为空,则返回nil

    警告

    只能指定类型符合MinMaxType协议的属性。

    声明

    Swift

    func min<T>(of keyPath: KeyPath<Element, T>) -> T? where T : _HasPersistedType, T.PersistedType : MinMaxType

    参数

    keyPath

    所需属性的 keyPath。

  • max(of:) 扩展方法

    返回集合中所有对象中给定属性的最大值,如果集合为空,则返回nil

    警告

    只能指定类型符合MinMaxType协议的属性。

    声明

    Swift

    func max<T>(of keyPath: KeyPath<Element, T>) -> T? where T : _HasPersistedType, T.PersistedType : MinMaxType

    参数

    keyPath

    所需属性的 keyPath。

  • sum(of:) 扩展方法

    返回集合中对象的给定属性的总和,如果集合为空,则返回nil

    警告

    只能使用符合AddableType协议的类型的属性名称。

    声明

    Swift

    func sum<T>(of keyPath: KeyPath<Element, T>) -> T where T : _HasPersistedType, T.PersistedType : AddableType

    参数

    keyPath

    符合AddableType的属性的 keyPath 来计算总和。

  • average(of:) 扩展方法

    返回集合中所有对象的给定属性的平均值,如果集合为空,则返回nil

    警告

    只能指定类型符合AddableType协议的属性。

    声明

    Swift

    func average<T>(of keyPath: KeyPath<Element, T>) -> T? where T : _HasPersistedType, T.PersistedType : AddableType

    参数

    keyPath

    应对其值求和的属性的 keyPath。

  • 从给定属性键路径对此集合进行排序和分段,并以SectionedResults的实例形式返回结果。 对于从 keyPath 检索到的每个唯一值,都会生成一个部分键。

    声明

    Swift

    func sectioned<Key: _Persistable>(by keyPath: KeyPath<Element, Key>,
                                      ascending: Bool = true) -> SectionedResults<Key, Element> where Element: ObjectBase

    参数

    keyPath

    排序和分段所依据的属性键路径。

    ascending

    排序的方向。

    返回值

    SectionedResults的实例。

  • 从给定属性键路径对此集合进行排序和分段,并以SectionedResults的实例形式返回结果。 对于从 keyPath 检索到的每个唯一值,都会生成一个部分键。

    注意

    主排序描述符必须负责确定节键。

    声明

    Swift

    func sectioned<Key: _Persistable>(by keyPath: KeyPath<Element, Key>,
                                      sortDescriptors: [SortDescriptor]) -> SectionedResults<Key, Element> where Element: ObjectBase

    参数

    keyPath

    排序和分段所依据的属性键路径。

    sortDescriptors

    要排序的SortDescriptor数组。

    返回值

    SectionedResults的实例。

  • 将此collection从给定的SortDescriptor数组中排序,并通过用户定义的回调执行分段。

    注意

    主排序描述符必须负责确定节键。

    声明

    Swift

    func sectioned<Key: _Persistable>(by block: @escaping ((Element) -> Key),
                                      sortDescriptors: [SortDescriptor]) -> SectionedResults<Key, Element> where Element: ObjectBase

    参数

    block

    对集合中的每个元素调用的回调。 此回调将返回集合中元素的部分键。

    sortDescriptors

    要排序的SortDescriptor数组。

    返回值

    SectionedResults的实例。

适用于以下位置: Element.PersistedTypeMinMaxType

  • min() 扩展方法

    返回集合的最小值;如果集合为空,则返回nil

    声明

    Swift

    func min() -> Element?
  • max() 扩展方法

    返回集合的最大值,如果集合为空,则返回nil

    声明

    Swift

    func max() -> Element?

适用于以下位置: Element.PersistedTypeAddableType

适用于以下位置: ElementKeypathSortable

  • 返回包含collection中的对象的Results ,但已排序。

    对象根据给定键路径的值进行排序。 例如,要根据Student age属性对collection从新到旧进行排序,您可以调用students.sorted(byKeyPath: "age", ascending: true)

    警告

    collection只能按boolean、 DateNSDate 、单精度和双精度浮点、整数和字符串类型的属性进行排序。

    声明

    Swift

    func sorted(byKeyPath keyPath: String, ascending: Bool = true) -> Results<Element>

    参数

    keyPath

    排序依据的键路径。

    ascending

    排序的方向。

  • sorted(by:ascending:) 扩展方法

    返回包含collection中的对象的Results ,但已排序。

    对象根据给定键路径的值进行排序。 例如,要根据Student age属性对collection从新到旧进行排序,您可以调用students.sorted(byKeyPath: "age", ascending: true)

    警告

    collection只能按boolean、 DateNSDate 、单精度和双精度浮点、整数和字符串类型的属性进行排序。

    声明

    Swift

    func sorted<T>(by keyPath: KeyPath<Element, T>, ascending: Bool = true) -> Results<Element> where T : _HasPersistedType, Self.Element : RLMObjectBase, T.PersistedType : SortableType

    参数

    keyPath

    排序依据的键路径。

    ascending

    排序的方向。

  • distinct(by:) 默认实现

    默认实现

    根据指定的键路径返回包含不同对象的Results

    声明

    Swift

    func distinct<S: Sequence>(by keyPaths: S) -> Results<Element>
        where S.Iterator.Element == PartialKeyPath<Element>, Element: ObjectBase

    参数

    keyPaths

    使用的键路径会产生不同的结果

适用于以下位置: Element.PersistedTypeSortableType

  • sorted(ascending:) 扩展方法

    返回包含collection中的对象的Results ,但已排序。

    对象根据其值进行排序。 例如,要对collection的Date进行从新到旧的排序,您可以调用dates.sorted(ascending: true)

    声明

    Swift

    func sorted(ascending: Bool = true) -> Results<Element>

    参数

    ascending

    排序的方向。

  • distinct() 扩展方法

    返回包含collection中非重复值的Results

    声明

    Swift

    func distinct() -> Results<Element>

适用于以下位置: ElementObjectBase

  • 默认实现

    注册一个区块,以便在每次collection更改时调用。

    该区块将与初始结果一起异步调用,然后在每次写事务(write transaction)后再次调用,这会更改collection中的任何对象或collection中的哪些对象。

    传递给区块的change参数以collection内索引的形式报告在每个写事务(write transaction)期间添加、删除或修改了哪些对象。有关所提供变更信息的更多信息,以及如何使用这些信息来更新UITableView的示例,请参阅RealmCollectionChange文档。

    调用区块时,collection将进行全面求值且是最新的,只要不在同一线程上执行写事务(write transaction)或显式调用realm.refresh() ,访问该collection就永远不会执行阻塞工作。

    如果未指定队列,则将通过标准事件循环传递通知,因此当事件循环被其他活动阻塞时无法传递通知。如果给出了队列,则将通知传递到该队列。 当无法立即传递通知时,可以将多个通知合并为一个通知。 这可以包括初始collection的通知。

    例如,以下代码在添加通知块后立即执行写事务(write transaction),因此没有机会首先传递初始通知。因此,初始通知将反映写事务后 Realm 的状态。

    let dogs = realm.objects(Dog.self)
    print("dogs.count: \(dogs?.count)") // => 0
    let token = dogs.observe { changes in
        switch changes {
        case .initial(let dogs):
            // Will print "dogs.count: 1"
            print("dogs.count: \(dogs.count)")
            break
        case .update:
            // Will not be hit in this example
            break
        case .error:
            break
        }
    }
    try! realm.write {
        let dog = Dog()
        dog.name = "Rex"
        person.dogs.append(dog)
    }
    // end of run loop execution context
    

    如果未给出键路径,则在所有对象属性以及任何嵌套、链接对象的属性的任何插入、修改或删除操作时都会执行该区块。 如果提供了一个或多个关键路径,则将调用该区块以进行仅在所提供的关键路径上发生的更改。 例如,如果:

    class Dog: Object {
        @Persisted var name: String
        @Persisted var age: Int
        @Persisted var toys: List<Toy>
    }
    // ...
    let dogs = realm.objects(Dog.self)
    
    let token = dogs.observe(keyPaths: [\Dog.name]) { changes in
        switch changes {
        case .initial(let dogs):
           // ...
        case .update:
           // This case is hit:
           // - after the token is initialized
           // - when the name property of an object in the
           // collection is modified
           // - when an element is inserted or removed
           //   from the collection.
           // This block is not triggered:
           // - when a value other than name is modified on
           //   one of the elements.
        case .error:
            // ...
        }
    }
    // end of run loop execution context
    
    • 如果观察到的键路径为[\Dog.toys.brand] ,则对collection任何元素上的toys列表进行的任何插入或删除操作都会trigger该区块。 对链接到此collection中的Dog的任何Toybrand值进行更改都会trigger该区块。在链接到此collection中的Dog的任何Toy上,对brand以外的值进行更改都不会trigger该区块。对所观察到的Dog类型collection的任何插入或删除也会trigger通知。
    • 如果在上面的示例中观察到了[\Dog.toys]键路径,那么针对集合中的任何元素对toys列表进行的任何插入、删除或修改都会触发区块。 对链接到此collection中的Dog的任何Toy的任何值进行更改都不会trigger该区块。对正在观察的Dog类型集合的任何插入或删除仍会触发通知。

    注意

    同一对象上的多个通知令牌(针对单独的键路径进行过滤)不会进行排他性过滤。如果一项键路径变更符合一个通知令牌的条件,则该对象的所有通知令牌块都将执行。

    只要您希望将更新发送到区块,就必须保留返回的令牌。 要停止接收更新,请对令牌调用invalidate()

    警告

    在写事务(write transaction)期间或当包含的 Realm 为只读时,无法调用此方法。

    声明

    Swift

    func observe(keyPaths: [PartialKeyPath<Element>],
                 on queue: DispatchQueue? = nil,
                 _ block: @escaping (RealmCollectionChange<Self>) -> Void) -> NotificationToken

    参数

    keyPaths

    只有键路径数组中包含的属性在修改时才会触发区块。 有关关联属性的更多详细信息,请参阅上述描述。

    queue

    用于接收通知的串行调度队列。 如果为nil ,则通知将传递到当前线程。

    block

    发生更改时要调用的区块。

    返回值

    只要您希望传递更新,就必须持有的令牌。

  • observe(keyPaths:on:_isolation:_:) 默认实现,异步

    默认实现

    注册一个区块,以便在每次collection更改时调用。

    该区块将与collection的初始版本一起异步调用,然后在每次写事务(write transaction)后再次调用,这会更改collection中的任何对象或collection中的哪些对象。

    传递给该区块的actor参数是传递给该函数的 actor。 需要此参数来隔离对 actor 的回调。

    传递给区块的change参数以collection内索引的形式报告在上次通知后添加、删除或修改了哪些对象。变更枚举中的collection字段将与请求的 actor 隔离,并且只能在该 actor 中安全使用。 有关所提供变更信息的更多信息以及如何使用这些信息来更新UITableView的示例,请参阅RealmCollectionChange文档。

    发出初始通知后,该collection将进行全面评估并保持最新状态,访问该collection永远不会执行任何阻塞工作。仅当您不在通知发送到的同一 actor 上执行写事务(write transaction)时,此保证才有效。如果这样做,在传递下一个通知之前访问该collection可能需要重新运行查询。

    通知将传递给给定 actor 的执行程序。 当无法立即传递通知时,可以将多个通知合并为一个通知。 这可以包括带有初始collection的通知:在传递初始通知之前发生的任何写入都可能不会生成变更通知。

    在collection中添加、删除或分配对象始终会生成通知。默认情况下,修改collection链接到的对象(以及这些对象链接到的对象,如果适用)也会将collection中的索引报告为正在修改。如果提供了非空的键路径数组,则只有对这些键路径的修改才会将对象标记为已修改。 例如:

    class Dog: Object {
        @Persisted var name: String
        @Persisted var age: Int
        @Persisted var toys: List<Toy>
    }
    
    let dogs = realm.objects(Dog.self)
    let token = await dogs.observe(keyPaths: [\.name], on: myActor) { actor, changes in
        switch changes {
        case .initial(let dogs):
            // Query has finished running and dogs can not be used without blocking
        case .update:
            // This case is hit:
            // - after the token is initialized
            // - when the name property of an object in the collection is modified
            // - when an element is inserted or removed from the collection.
            // This block is not triggered:
            // - when a value other than name is modified on one of the elements.
        case .error:
            // Can no longer happen but is left for backwards compatiblity
        }
    }
    
    • 如果观察到的键路径为[\.toys.brand] ,则对collection任何元素上的toys列表进行的任何插入或删除操作都会trigger该区块。 对链接到此collection中的Dog的任何Toybrand值进行更改都会trigger该区块。在链接到此collection中的Dog的任何Toy上,对brand以外的值进行更改都不会trigger该区块。对所观察到的Dog类型collection的任何插入或删除也会trigger通知。
    • 如果在上面的示例中观察到了[\.toys]键路径,那么针对集合中的任何元素对toys列表进行的任何插入、删除或修改都会触发区块。 对链接到此collection中的Dog的任何Toy的任何值进行更改都不会trigger该区块。对正在观察的Dog类型集合的任何插入或删除仍会触发通知。

    只要您希望将更新发送到区块,就必须保留返回的令牌。 要停止接收更新,请对令牌调用invalidate()

    警告

    在写事务(write transaction)期间或当包含的 Realm 为只读时,无法调用此方法。

    声明

    Swift

    @available(macOS 10.15, tvOS 13.0, iOS 13.0, watchOS 6.0, *)
    func observe<A: Actor>(keyPaths: [PartialKeyPath<Element>], on actor: A,
                           _isolation: isolated (any Actor)? = #isolation,
                           _ block: @Sendable @escaping (isolated A, RealmCollectionChange<Self>) -> Void) async -> NotificationToken

    参数

    keyPaths

    只有键路径数组中包含的属性在修改时才会触发区块。 如果为空,则对象上的任何属性更改都会发送通知。 与有效属性不对应的字符串键路径将引发异常。 有关关联属性的更多详细信息,请参阅上述描述。

    actor

    要隔离通知的 actor。

    block

    发生更改时要调用的区块。

    返回值

    只要您希望传递更新,就必须持有的令牌。