RealmCollection

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

Uma collection uniforme de Objects que pode ser recuperada, filtrada, classificada e operada.

Propriedades

  • O Realm que managed a collection ou nil para collection não managed.

    Declaração

    Swift

    var realm: Realm? { get }
  • Indica se a collection não pode mais ser acessada.

    A coleção não poderá mais ser acessada se invalidate() for chamado no Realm que gerencia a coleção.

    Declaração

    Swift

    var isInvalidated: Bool { get }
  • O número de objetos na collection.

    Declaração

    Swift

    var count: Int { get }
  • Uma descrição legível por humanos dos objetos contidos na collection.

    Declaração

    Swift

    var description: String { get }

Recuperação de objetos

  • Retorna o primeiro objeto na collection ou nil se a collection estiver vazia.

    Declaração

    Swift

    var first: Element? { get }
  • Retorna o último objeto da collection ou nil se a collection estiver vazia.

    Declaração

    Swift

    var last: Element? { get }

Recuperação de Índice

  • Retorna o índice de um objeto na collection ou nil se o objeto não estiver presente.

    Declaração

    Swift

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

    Parâmetros

    object

    Um objeto.

  • index(matching:) Implementação padrão

    Retorna o índice do primeiro objeto que corresponde ao predicado ou nil se nenhum objeto corresponder.

    Isso só é aplicável a collection ordenadas e será abortado se a collection não estiver ordenada.

    Implementação padrão

    Retorna o índice do primeiro objeto que corresponde à query ou nil se nenhum objeto corresponder.

    Isso só é aplicável a collection ordenadas e será abortado se a collection não estiver ordenada.

    Observação

    Isso só deve ser usado com classes usando a declaração de propriedade @Persistable .

    • Uso:

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

    Observação

    Consulte Query para obter mais informações sobre quais operações de query estão disponíveis.

    Declaração

    Swift

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

    Parâmetros

    predicate

    O predicado a ser usado para filtrar os objetos.

  • index(matching:_:) Implementação padrão

    Retorna o índice do primeiro objeto que corresponde ao predicado ou nil se nenhum objeto corresponder.

    Isso só é aplicável a collection ordenadas e será abortado se a collection não estiver ordenada.

    Implementação padrão

    Retorna o índice do primeiro objeto que corresponde ao predicado fornecido ou nil se nenhum objeto corresponder.

    Declaração

    Swift

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

    Parâmetros

    predicateFormat

    Uma string de formato de predicado, opcionalmente seguida por um número variável de argumentos.

Recuperação de objetos

  • Retorna uma array contendo os objetos na collection nos índices especificados por um determinado conjunto de índices.

    Aviso

    Lança se um índice fornecido no IndexSet estiver fora dos limites.

    Declaração

    Swift

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

    Parâmetros

    indexes

    Os índices na collection dos quais selecionar objetos.

Filtragem

  • filter(_:_:) Implementação padrão

    Retorna um Results contendo todos os objetos que correspondem ao predicado fornecido na coleção.

    Implementação padrão

    Retorna um Results contendo todos os objetos que correspondem ao predicado fornecido na coleção.

    Declaração

    Swift

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

    Parâmetros

    predicateFormat

    Uma string de formato de predicado, opcionalmente seguida por um número variável de argumentos.

  • Retorna um Results contendo todos os objetos que correspondem ao predicado fornecido na coleção.

    Declaração

    Swift

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

    Parâmetros

    predicate

    O predicado a ser usado para filtrar os objetos.

Classificação

  • Retorna um Results contendo os objetos na collection, mas ordenados.

    Aviso

    As collection só podem ser classificadas por propriedade dos tipos booleano, Date, NSDate, ponto flutuante de precisão única e dupla, inteiro e string.

    Declaração

    Swift

    func sorted<S>(by sortDescriptors: S) -> Results<Element> where S : Sequence, S.Element == SortDescriptor

    Parâmetros

    sortDescriptors

    Uma sequência de SortDescriptors para classificar.

  • Retorna um Results contendo objetos distintos com base nos caminhos de chave especificados.

    Declaração

    Swift

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

    Parâmetros

    keyPaths

    Os principais caminhos para distinguir.

Operações agregadas

  • Retorna o valor mínimo (mais baixo) da propriedade fornecida entre todos os objetos da collection ou nil se a collection estiver vazia.

    Aviso

    Somente uma propriedade cujo tipo esteja em conformidade com o protocolo MinMaxType pode ser especificada.

    Declaração

    Swift

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

    Parâmetros

    property

    O nome de uma propriedade cujo valor mínimo é desejado.

  • Retorna o valor máximo (mais alto) da propriedade fornecida entre todos os objetos na collection ou nil se a collection estiver vazia.

    Aviso

    Somente uma propriedade cujo tipo esteja em conformidade com o protocolo MinMaxType pode ser especificada.

    Declaração

    Swift

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

    Parâmetros

    property

    O nome de uma propriedade cujo valor mínimo é desejado.

  • Retorna a soma da propriedade fornecida para objetos na collection ou nil se a collection estiver vazia.

    Aviso

    Somente nomes de propriedades de um tipo em conformidade com o protocolo AddableType podem ser usados.

    Declaração

    Swift

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

    Parâmetros

    property

    O nome de uma propriedade em conformidade com AddableType para calcular a soma.

  • Retorna o valor médio de uma determinada propriedade sobre todos os objetos na collection ou nil se a collection estiver vazia.

    Aviso

    Somente uma propriedade cujo tipo esteja em conformidade com o protocolo AddableType pode ser especificada.

    Declaração

    Swift

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

    Parâmetros

    property

    O nome de uma propriedade cujos valores devem ser somados.

Codificação de valor-chave

  • Retorna um Array contendo os resultados da invocação de valueForKey(_:) com key em cada um dos objetos da collection.

    Declaração

    Swift

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

    Parâmetros

    key

    O nome da propriedade cujos valores são desejados.

  • Retorna um Array contendo os resultados da invocação de valueForKeyPath(_:) com keyPath em cada um dos objetos da collection.

    Declaração

    Swift

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

    Parâmetros

    keyPath

    O caminho da chave para a propriedade cujos valores são desejados.

  • Invoca setValue(_:forKey:) em cada um dos objetos da coleção utilizando o value e key especificados.

    Aviso

    Este método só pode ser chamado durante uma transação de escrita.

    Declaração

    Swift

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

    Parâmetros

    value

    O valor do objeto.

    key

    O nome da propriedade cujo valor deve ser definido em cada objeto.

Notificações

  • observe(keyPaths:on:_:) Implementação padrão

    Registra um bloco a ser chamado cada vez que a collection for alterada.

    O bloco será chamado de forma assíncrona com os resultados iniciais e, em seguida, chamado novamente após cada transação de gravação que altere qualquer um dos objetos da coleção ou quais objetos estão na coleção.

    O parâmetro change que é passado para o bloco reporta, na forma de índices dentro da collection, quais dos objetos foram adicionados, removidos ou modificados durante cada transação de escrita. Consulte a documentação do RealmCollectionChange para obter mais informações sobre as informações de alteração fornecidas e um exemplo de como usá-las para atualizar um UITableView .

    No momento em que o bloqueio for chamado, a coleção será totalmente avaliada e atualizada e, desde que você não execute uma transação de gravação na mesma thread ou chame explicitamente realm.refresh() , acessá-la nunca executará o bloqueio trabalho.

    Se nenhuma fila for fornecida, as notificações serão entregues por meio do loop de execução padrão e, portanto, não poderão ser entregues enquanto o loop de execução estiver bloqueado por outra atividade. Se uma fila for fornecida, as notificações serão entregues para essa fila. Quando as notificações não podem ser entregues instantaneamente, várias notificações podem ser agrupadas em uma única notificação. Isso pode incluir a notificação com a coleção inicial.

    Por exemplo, o código a seguir executa uma transação de escrita imediatamente após adicionar o bloqueio de notificação, para que não haja oportunidade para que a notificação inicial seja entregue primeiro. Como resultado, a notificação inicial refletirá o estado do Realm após a transação de escrita.

    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
    

    Se nenhum caminho-chave for fornecido, o bloqueio será executado em qualquer inserção, modificação ou exclusão para todas as propriedades do objeto e as propriedades de quaisquer objetos vinculados aninhados. Se um caminho de chave ou caminhos de chave forem fornecidos, o bloco será chamado para alterações que ocorrem apenas nos caminhos de chave fornecidos. Por exemplo, se:

    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
    
    • Se o caminho da chave observado fosse ["toys.brand"], qualquer inserção ou exclusão na lista toys em qualquer um dos elementos da collection trigger o bloqueio. Alterações no valor brand em qualquer Toy vinculado a um Dog nessa collection triggerão o bloqueio. Alterações em um valor diferente de brand em qualquer Toy vinculado a um Dog nessa collection não trigger o bloqueio. Qualquer inserção ou remoção na collection de tipos Dog que está sendo observada também trigger uma notificação.
    • Se o exemplo acima observasse o caminho da chave ["toys"], qualquer inserção, exclusão ou modificação na lista toys para qualquer elemento da collection trigger o bloqueio. Alterações em qualquer valor em qualquer Toy que esteja vinculado a um Dog nesta collection não trigger o bloqueio. Qualquer inserção ou remoção na collection de tipos Dog que está sendo observada ainda trigger uma notificação.

    Observação

    Vários tokens de notificação no mesmo objeto que filtram exclusivamente caminhos de chave separados não filtram. Se uma alteração de caminho-chavefor satisfeita para um token de notificação, todos os bloqueios de token de notificação para esse objeto serão executados.

    Você deve reter o token retornado pelo tempo que desejar que as atualizações sejam enviadas ao bloco. Para parar de receber atualizações, ligue para invalidate() no token.

    Aviso

    Este método não pode ser chamado durante uma transação de escrita, ou quando o Realm que o contém for somente leitura.

    Implementação padrão

    Registra um bloco a ser chamado cada vez que a collection for alterada.

    O bloco será chamado de forma assíncrona com os resultados iniciais e, em seguida, chamado novamente após cada transação de gravação que altere qualquer um dos objetos da coleção ou quais objetos estão na coleção.

    O parâmetro change que é passado para o bloco reporta, na forma de índices dentro da collection, quais dos objetos foram adicionados, removidos ou modificados durante cada transação de escrita. Consulte a documentação do RealmCollectionChange para obter mais informações sobre as informações de alteração fornecidas e um exemplo de como usá-las para atualizar um UITableView .

    No momento em que o bloqueio for chamado, a coleção será totalmente avaliada e atualizada e, desde que você não execute uma transação de gravação na mesma thread ou chame explicitamente realm.refresh() , acessá-la nunca executará o bloqueio trabalho.

    Se nenhuma fila for fornecida, as notificações serão entregues por meio do loop de execução padrão e, portanto, não poderão ser entregues enquanto o loop de execução estiver bloqueado por outra atividade. Se uma fila for fornecida, as notificações serão entregues para essa fila. Quando as notificações não podem ser entregues instantaneamente, várias notificações podem ser agrupadas em uma única notificação. Isso pode incluir a notificação com a coleção inicial.

    Por exemplo, o código a seguir executa uma transação de escrita imediatamente após adicionar o bloqueio de notificação, para que não haja oportunidade para que a notificação inicial seja entregue primeiro. Como resultado, a notificação inicial refletirá o estado do Realm após a transação de escrita.

    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
    

    Se nenhum caminho-chave for fornecido, o bloqueio será executado em qualquer inserção, modificação ou exclusão para todas as propriedades do objeto e as propriedades de quaisquer objetos vinculados aninhados. Se um caminho de chave ou caminhos de chave forem fornecidos, o bloco será chamado para alterações que ocorrem apenas nos caminhos de chave fornecidos. Por exemplo, se:

    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
    
    • Se o caminho da chave observado fosse [\Dog.toys.brand], qualquer inserção ou exclusão na lista toys em qualquer um dos elementos da collection trigger o bloqueio. Alterações no valor brand em qualquer Toy vinculado a um Dog nessa collection triggerão o bloqueio. Alterações em um valor diferente de brand em qualquer Toy vinculado a um Dog nessa collection não trigger o bloqueio. Qualquer inserção ou remoção na collection de tipos Dog que está sendo observada também trigger uma notificação.
    • Se o exemplo acima observasse o caminho da chave [\Dog.toys], qualquer inserção, exclusão ou modificação na lista toys para qualquer elemento da collection trigger o bloqueio. Alterações em qualquer valor em qualquer Toy que esteja vinculado a um Dog nesta collection não trigger o bloqueio. Qualquer inserção ou remoção na collection de tipos Dog que está sendo observada ainda trigger uma notificação.

    Observação

    Vários tokens de notificação no mesmo objeto que filtram exclusivamente caminhos de chave separados não filtram. Se uma alteração de caminho-chavefor satisfeita para um token de notificação, todos os bloqueios de token de notificação para esse objeto serão executados.

    Você deve reter o token retornado pelo tempo que desejar que as atualizações sejam enviadas ao bloco. Para parar de receber atualizações, ligue para invalidate() no token.

    Aviso

    Este método não pode ser chamado durante uma transação de escrita, ou quando o Realm que o contém for somente leitura.

    Declaração

    Swift

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

    Parâmetros

    keyPaths

    Somente a propriedade contida na array de caminhos principais vai trigger o bloqueio quando forem modificadas. Se nil, notificações serão entregues para qualquer alteração de propriedade no objeto. Os caminhos da chave de string que não correspondem a uma propriedade válida lançarão uma exceção. Consulte a descrição acima para obter mais detalhes sobre propriedades vinculadas.

    queue

    A fila de despacho em série para receber a notificação. Se nil, as notificações são entregues ao thread atual.

    block

    O bloco a ser chamado sempre que ocorre uma alteração.

    Valor de retorno

    Um token que deve ser mantido pelo tempo que você quiser que as atualizações sejam entregues.

  • observe(keyPaths:on:_isolation:_:) Implementação padrão, assíncrona

    Registra um bloco a ser chamado cada vez que a collection for alterada.

    O bloco será chamado de forma assíncrona com uma versão inicial da coleção e, em seguida, chamado novamente após cada transação de gravação que altere qualquer um dos objetos da coleção ou quais objetos estão na coleção.

    O parâmetro actor passado para o bloco é o ator que você passa para esta função. Este parâmetro é necessário para isolar a chamada de resposta para o ator.

    O parâmetro change que é passado para o bloco reporta, na forma de índices dentro da collection, quais dos objetos foram adicionados, removidos ou modificados após a notificação anterior. O campo collection na enumeração de alteração será isolado para o ator solicitado e é seguro para uso somente dentro desse ator. Consulte a documentação do RealmCollectionChange para obter mais informações sobre as informações de alteração fornecidas e um exemplo de como usá-las para atualizar um UITableView.

    Depois que a notificação inicial for entregue, a coleção será totalmente avaliada e atualizada, e acessá-la nunca realizará nenhum trabalho de bloqueio. Essa garantia é válida apenas enquanto você não realizar uma transação de escrita no mesmo ator para o qual as notificações estão sendo entregues. Se você fizer isso, para acessar a coleção antes da próxima notificação ser entregue, talvez seja necessário executar novamente a query.

    As notificações são entregues ao executor do ator em questão. Quando as notificações não podem ser entregues instantaneamente, várias notificações podem ser agrupadas em uma única notificação. Isso pode incluir a notificação com a collection inicial: quaisquer gravações que ocorram antes da entrega da notificação inicial podem não produzir notificações de alteração.

    Adicionar, remover ou atribuir objetos na coleção sempre produz uma notificação. Por padrão, modificar os objetos aos quais uma coleção está vinculada (e os objetos aos quais esses objetos se vinculam, se aplicável) também informará que esse índice na coleção está sendo modificado. Se uma array não vazia de keypaths for fornecida, somente as modificações nesses keypaths marcarão o objeto como modificado. Por exemplo:

    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
        }
    }
    
    • Se o caminho da chave observado fosse ["toys.brand"], qualquer inserção ou exclusão na lista toys em qualquer um dos elementos da collection trigger o bloqueio. Alterações no valor brand em qualquer Toy vinculado a um Dog nessa collection triggerão o bloqueio. Alterações em um valor diferente de brand em qualquer Toy vinculado a um Dog nessa collection não trigger o bloqueio. Qualquer inserção ou remoção na collection de tipos Dog que está sendo observada também trigger uma notificação.
    • Se o exemplo acima observasse o caminho da chave ["toys"], qualquer inserção, exclusão ou modificação na lista toys para qualquer elemento da collection trigger o bloqueio. Alterações em qualquer valor em qualquer Toy que esteja vinculado a um Dog nesta collection não trigger o bloqueio. Qualquer inserção ou remoção na collection de tipos Dog que está sendo observada ainda trigger uma notificação.

    Você deve reter o token retornado pelo tempo que desejar que as atualizações sejam enviadas ao bloco. Para parar de receber atualizações, ligue para invalidate() no token.

    Aviso

    Este método não pode ser chamado durante uma transação de escrita, ou quando o Realm que o contém for somente leitura.

    Implementação padrão

    Registra um bloco a ser chamado cada vez que a collection for alterada.

    O bloco será chamado de forma assíncrona com uma versão inicial da coleção e, em seguida, chamado novamente após cada transação de gravação que altere qualquer um dos objetos da coleção ou quais objetos estão na coleção.

    O parâmetro actor passado para o bloco é o ator que você passa para esta função. Este parâmetro é necessário para isolar a chamada de resposta para o ator.

    O parâmetro change que é passado para o bloco reporta, na forma de índices dentro da collection, quais dos objetos foram adicionados, removidos ou modificados após a notificação anterior. O campo collection na enumeração de alteração será isolado para o ator solicitado e é seguro para uso somente dentro desse ator. Consulte a documentação do RealmCollectionChange para obter mais informações sobre as informações de alteração fornecidas e um exemplo de como usá-las para atualizar um UITableView.

    Depois que a notificação inicial for entregue, a coleção será totalmente avaliada e atualizada, e acessá-la nunca realizará nenhum trabalho de bloqueio. Essa garantia é válida apenas enquanto você não realizar uma transação de escrita no mesmo ator para o qual as notificações estão sendo entregues. Se você fizer isso, para acessar a coleção antes da próxima notificação ser entregue, talvez seja necessário executar novamente a query.

    As notificações são entregues ao executor do ator em questão. Quando as notificações não podem ser entregues instantaneamente, várias notificações podem ser agrupadas em uma única notificação. Isso pode incluir a notificação com a collection inicial: quaisquer gravações que ocorram antes da entrega da notificação inicial podem não produzir notificações de alteração.

    Adicionar, remover ou atribuir objetos na coleção sempre produz uma notificação. Por padrão, modificar os objetos aos quais uma coleção está vinculada (e os objetos aos quais esses objetos se vinculam, se aplicável) também informará que esse índice na coleção está sendo modificado. Se uma array não vazia de keypaths for fornecida, somente as modificações nesses keypaths marcarão o objeto como modificado. Por exemplo:

    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
        }
    }
    
    • Se o caminho da chave observado fosse ["toys.brand"], qualquer inserção ou exclusão na lista toys em qualquer um dos elementos da collection trigger o bloqueio. Alterações no valor brand em qualquer Toy vinculado a um Dog nessa collection triggerão o bloqueio. Alterações em um valor diferente de brand em qualquer Toy vinculado a um Dog nessa collection não trigger o bloqueio. Qualquer inserção ou remoção na collection de tipos Dog que está sendo observada também trigger uma notificação.
    • Se o exemplo acima observasse o caminho da chave ["toys"], qualquer inserção, exclusão ou modificação na lista toys para qualquer elemento da collection trigger o bloqueio. Alterações em qualquer valor em qualquer Toy que esteja vinculado a um Dog nesta collection não trigger o bloqueio. Qualquer inserção ou remoção na collection de tipos Dog que está sendo observada ainda trigger uma notificação.

    Você deve reter o token retornado pelo tempo que desejar que as atualizações sejam enviadas ao bloco. Para parar de receber atualizações, ligue para invalidate() no token.

    Aviso

    Este método não pode ser chamado durante uma transação de escrita, ou quando o Realm que o contém for somente leitura.

    Declaração

    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

    Parâmetros

    keyPaths

    Somente as propriedades contidas na array de caminhos principais acionarão o bloqueio quando forem modificadas. Se nil ou vazio, as notificações serão entregues para qualquer alteração de propriedade no objeto. Os caminhos da chave de string que não correspondem a uma propriedade válida lançarão uma exceção. Consulte a descrição acima para obter mais detalhes sobre propriedades vinculadas.

    actor

    O ator para o qual isolar as notificações.

    block

    O bloco a ser chamado sempre que ocorre uma alteração.

    Valor de retorno

    Um token que deve ser mantido pelo tempo que você quiser que as atualizações sejam entregues.

Objetos congelados

  • Retorna verdadeiro se esta collection estiver congelada

    Declaração

    Swift

    var isFrozen: Bool { get }
  • Retorna um snapshot congelado (imutável) desta collection.

    A cópia congelada é uma coleção imutável que contém os mesmos dados que esta coleção contém atualmente, mas não será atualizada quando forem feitas gravações no Realm que a contém. Ao contrário das collections ativas, as collections congeladas podem ser acessadas de qualquer thread.

    Aviso

    Este método não pode ser chamado durante uma transação de escrita, ou quando o Realm que o contém for somente leitura.

    Aviso

    Manter uma collection congelada por um longo período enquanto executa transação de escrita no Realm pode fazer com que o Arquivo de Realm cresça para tamanhos grandes. Consulte Realm.Configuration.maximumNumberOfActiveVersions para obter mais informações.

    Declaração

    Swift

    func freeze() -> Self
  • Retorna uma versão ativa (mutável) dessa collection congelada.

    Esse método resolve uma referência a uma cópia ativa da mesma collection congelada. Se for chamado em uma coleção ativa, retornará a si mesmo.

    Declaração

    Swift

    func thaw() -> Self?
  • Classifica esta collection a partir de uma determinada array de descritores de classificação e executa o seccionamento por meio de uma chamada de resposta definido pelo usuário, retornando o resultado como uma instância de SectionedResults.

    Observação

    O descritor de classificação primária deve ser responsável por determinar a chave de seção.

    Declaração

    Swift

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

    Parâmetros

    sortDescriptors

    Uma array de SortDescriptors para classificar.

    keyBlock

    Uma chamada de resposta invocada em cada elemento na collection Results. Esta chamada de resposta é para retornar a chave de seção para o elemento na collection.

    Valor de retorno

    Uma instância de SectionedResults.

Query seguras por tipo

  • where(_:) Método de extensão

    Retorna um Results contendo todos os objetos que correspondem à query fornecida na collection.

    Observação

    Isso só deve ser usado com classes usando a declaração de propriedade @Persistable .

    • Uso:

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

    Observação

    Consulte Query para obter mais informações sobre quais operações de query estão disponíveis.

    Declaração

    Swift

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

    Parâmetros

    isIncluded

    O fechamento da query a ser usado para filtrar os objetos.

Protocolo de collection

  • startIndex Método de extensão

    A posição do primeiro elemento em uma coleção não vazia. Idêntico ao endIndex em uma coleta vazia.

    Declaração

    Swift

    var startIndex: Int { get }
  • endIndex Método de extensão

    A posição "além do final" da collection. endIndex não é um argumento válido para subscrito e está sempre acessível a partir de startIndex por zero ou mais aplicações de sucessor ().

    Declaração

    Swift

    var endIndex: Int { get }
  • index(after:) Método de extensão

    Retorna a posição imediatamente após o índice fornecido.

    Declaração

    Swift

    func index(after i: Int) -> Int

    Parâmetros

    i

    Um índice válido da coleção. i deve ser menor que endIndex .

  • index(before:) Método de extensão

    Retorna a posição imediatamente antes do índice fornecido.

    Declaração

    Swift

    func index(before i: Int) -> Int

    Parâmetros

    i

    Um índice válido da collection. i deve ser maior que startIndex.

Resultados seccionados em primitivos

  • sectioned(by:ascending:) Método de extensão

    Classifica esta coleção em ordem crescente ou decrescente e executa o seccionamento por meio de uma função de retorno de chamada definida pelo usuário.

    Declaração

    Swift

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

    Parâmetros

    block

    Uma chamada de resposta invocada em cada elemento da collection. Esta chamada de resposta é para retornar a chave de seção para o elemento na collection.

    ascending

    A direção para classificar.

    Valor de retorno

    Uma instância de SectionedResults.

Observação

  • sectioned(by:ascending:) Método de extensão

    Classifica e seciona esta collection a partir de um determinado caminho de chave de propriedade, retornando o resultado como uma instância de SectionedResults. Para cada valor único recuperado do keyPath, uma chave de seção será gerada.

    Declaração

    Swift

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

    Parâmetros

    keyPath

    O caminho da chave de propriedade para classificar.

    ascending

    A direção para classificar.

    Valor de retorno

    Uma instância de SectionedResults.

  • sectioned(by:sortDescriptors:) Método de extensão

    Classifica e seciona esta collection a partir de um determinado caminho de chave de propriedade, retornando o resultado como uma instância de SectionedResults. Para cada valor único recuperado do keyPath, uma chave de seção será gerada.

    Observação

    O descritor de classificação primária deve ser responsável por determinar a chave de seção.

    Declaração

    Swift

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

    Parâmetros

    keyPath

    O caminho da chave de propriedade para classificar.

    sortDescriptors

    Uma array de SortDescriptors para classificar.

    Valor de retorno

    Uma instância de SectionedResults.

  • sectioned(by:sortDescriptors:) Método de extensão

    Classifica esta collection a partir de uma determinada array de descritores de classificação e executa o seccionamento a partir de uma chamada de resposta definido pelo usuário, retornando o resultado como uma instância de SectionedResults.

    Observação

    O descritor de classificação primária deve ser responsável por determinar a chave de seção.

    Declaração

    Swift

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

    Parâmetros

    block

    Uma chamada de resposta invocada em cada elemento na collection Results. Esta chamada de resposta é para retornar a chave de seção para o elemento na collection.

    sortDescriptors

    Uma array de SortDescriptors para classificar.

    Valor de retorno

    Uma instância de SectionedResults.

Disponível onde Self: RealmSubscribable

  • objectWillChange Método de extensão

    Uma editora que emite um vazio toda vez que a collection muda.

    Apesar do nome, isso na verdade é emitido após a mudança da collection.

    Declaração

    Swift

    public var objectWillChange: RealmPublishers.WillChange<Self> { get }
  • collectionPublisher Método de extensão

    Um editor que emite a collection toda vez que a collection é alterada.

    Declaração

    Swift

    public var collectionPublisher: RealmPublishers.Value<Self> { get }
  • collectionPublisher(keyPaths:) Método de extensão

    Um editor que emite a collection toda vez que a collection muda nos keyPaths de propriedade fornecidos.

    Declaração

    Swift

    public func collectionPublisher(keyPaths: [String]?) -> RealmPublishers.Value<Self>
  • changesetPublisher Método de extensão

    Um editor que emite um conjunto de alterações de collection toda vez que a collection é alterada.

    Declaração

    Swift

    public var changesetPublisher: RealmPublishers.CollectionChangeset<Self> { get }
  • changesetPublisher(keyPaths:) Método de extensão

    Um editor que emite um conjunto de alterações de collection cada vez que a collection é alterada nos keyPaths de propriedade fornecidos.

    Declaração

    Swift

    public func changesetPublisher(keyPaths: [String]?) -> RealmPublishers.CollectionChangeset<Self>

Disponível onde Element: Encodable

  • encode(to:) Método de extensão

    Codifica o conteúdo desta coleção no codificador fornecido.

    Declaração

    Swift

    public func encode(to encoder: Encoder) throws

Disponível onde Element: ObjectBase

  • min(of:) Método de extensão

    Retorna o valor mínimo (mais baixo) da propriedade fornecida entre todos os objetos da collection ou nil se a collection estiver vazia.

    Aviso

    Somente uma propriedade cujo tipo esteja em conformidade com o protocolo MinMaxType pode ser especificada.

    Declaração

    Swift

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

    Parâmetros

    keyPath

    O keyPath de uma propriedade cujo valor mínimo é desejado.

  • max(of:) Método de extensão

    Retorna o valor máximo (mais alto) da propriedade fornecida entre todos os objetos na collection ou nil se a collection estiver vazia.

    Aviso

    Somente uma propriedade cujo tipo esteja em conformidade com o protocolo MinMaxType pode ser especificada.

    Declaração

    Swift

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

    Parâmetros

    keyPath

    O keyPath de uma propriedade cujo valor mínimo é desejado.

  • sum(of:) Método de extensão

    Retorna a soma da propriedade fornecida para objetos na collection ou nil se a collection estiver vazia.

    Aviso

    Somente nomes de propriedades de um tipo em conformidade com o protocolo AddableType podem ser usados.

    Declaração

    Swift

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

    Parâmetros

    keyPath

    O keyPath de uma propriedade em conformidade com AddableType para calcular a soma.

  • average(of:) Método de extensão

    Retorna o valor médio de uma determinada propriedade sobre todos os objetos na collection ou nil se a collection estiver vazia.

    Aviso

    Somente uma propriedade cujo tipo esteja em conformidade com o protocolo AddableType pode ser especificada.

    Declaração

    Swift

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

    Parâmetros

    keyPath

    O keyPath de uma propriedade cujos valores devem ser somados.

  • sectioned(by:ascending:) Método de extensão

    Classifica e seciona esta collection a partir de um determinado caminho de chave de propriedade, retornando o resultado como uma instância de SectionedResults. Para cada valor único recuperado do keyPath, uma chave de seção será gerada.

    Declaração

    Swift

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

    Parâmetros

    keyPath

    O caminho da chave da propriedade para classificar e seccionar.

    ascending

    A direção para classificar.

    Valor de retorno

    Uma instância de SectionedResults.

  • sectioned(by:sortDescriptors:) Método de extensão

    Classifica e seciona esta collection a partir de um determinado caminho de chave de propriedade, retornando o resultado como uma instância de SectionedResults. Para cada valor único recuperado do keyPath, uma chave de seção será gerada.

    Observação

    O descritor de classificação primária deve ser responsável por determinar a chave de seção.

    Declaração

    Swift

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

    Parâmetros

    keyPath

    O caminho da chave da propriedade para classificar e seccionar.

    sortDescriptors

    Uma array de SortDescriptors para classificar.

    Valor de retorno

    Uma instância de SectionedResults.

  • sectioned(by:sortDescriptors:) Método de extensão

    Classifica esta collection a partir de uma determinada array de SortDescriptore executa o seccionamento por meio de uma função de chamada de resposta definida pelo usuário.

    Observação

    O descritor de classificação primária deve ser responsável por determinar a chave de seção.

    Declaração

    Swift

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

    Parâmetros

    block

    Uma chamada de resposta invocada em cada elemento da collection. Esta chamada de resposta é para retornar a chave de seção para o elemento na collection.

    sortDescriptors

    Uma array de SortDescriptors para classificar.

    Valor de retorno

    Uma instância de SectionedResults.

Disponível onde Element.PersistedType: MinMaxType

  • min() Método de extensão

    Retorna o valor mínimo (mais baixo) da coleção ou nil se a coleção estiver vazia.

    Declaração

    Swift

    func min() -> Element?
  • max() Método de extensão

    Retorna o valor máximo (mais alto) da collection ou nil se a collection estiver vazia.

    Declaração

    Swift

    func max() -> Element?

Disponível onde Element.PersistedType: AddableType

  • sum() Método de extensão

    Retorna a soma dos valores na collection ou nil se a collection estiver vazia.

    Declaração

    Swift

    func sum() -> Element
  • average() Método de extensão

    Retorna a média de todos os valores na collection.

    Declaração

    Swift

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

Disponível onde Element: KeypathSortable

  • sorted(byKeyPath:ascending:) Método de extensão

    Retorna um Results contendo os objetos na collection, mas ordenados.

    Os objetos são classificados com base nos valores do caminho de chave fornecido. Por exemplo, para classificar uma coleção de Student s do mais novo para o mais antigo com base em sua propriedade age , você pode chamar students.sorted(byKeyPath: "age", ascending: true) .

    Aviso

    As collection só podem ser classificadas por propriedade dos tipos booleano, Date, NSDate, ponto flutuante de precisão única e dupla, inteiro e string.

    Declaração

    Swift

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

    Parâmetros

    keyPath

    O caminho da chave para classificar por.

    ascending

    A direção para classificar.

  • sorted(by:ascending:) Método de extensão

    Retorna um Results contendo os objetos na collection, mas ordenados.

    Os objetos são classificados com base nos valores do caminho de chave fornecido. Por exemplo, para classificar uma coleção de Student s do mais novo para o mais antigo com base em sua propriedade age , você pode chamar students.sorted(byKeyPath: "age", ascending: true) .

    Aviso

    As collection só podem ser classificadas por propriedade dos tipos booleano, Date, NSDate, ponto flutuante de precisão única e dupla, inteiro e string.

    Declaração

    Swift

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

    Parâmetros

    keyPath

    O caminho da chave para classificar por.

    ascending

    A direção para classificar.

  • distinct(by:) Implementação padrão

    Implementação padrão

    Retorna um Results contendo objetos distintos com base nos caminhos de chave especificados

    Declaração

    Swift

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

    Parâmetros

    keyPaths

    Os principais caminhos utilizados produzem resultados distintos

Disponível onde Element.PersistedType: SortableType

  • sorted(ascending:) Método de extensão

    Retorna um Results contendo os objetos na collection, mas ordenados.

    objeto são classificados com base em seus valores. Por exemplo, para classificar uma coleção de Date s do mais recente para o mais antigo, você pode chamar dates.sorted(ascending: true) .

    Declaração

    Swift

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

    Parâmetros

    ascending

    A direção para classificar.

  • distinct() Método de extensão

    Retorna um Results contendo os valores distintos na collection.

    Declaração

    Swift

    func distinct() -> Results<Element>

Disponível onde Element: ObjectBase

  • observe(keyPaths:on:_:) Implementação padrão

    Implementação padrão

    Registra um bloco a ser chamado cada vez que a collection for alterada.

    O bloco será chamado de forma assíncrona com os resultados iniciais e, em seguida, chamado novamente após cada transação de gravação que altere qualquer um dos objetos da coleção ou quais objetos estão na coleção.

    O parâmetro change que é passado para o bloco reporta, na forma de índices dentro da collection, quais dos objetos foram adicionados, removidos ou modificados durante cada transação de escrita. Consulte a documentação do RealmCollectionChange para obter mais informações sobre as informações de alteração fornecidas e um exemplo de como usá-las para atualizar um UITableView .

    No momento em que o bloqueio for chamado, a coleção será totalmente avaliada e atualizada e, desde que você não execute uma transação de gravação na mesma thread ou chame explicitamente realm.refresh() , acessá-la nunca executará o bloqueio trabalho.

    Se nenhuma fila for fornecida, as notificações serão entregues por meio do loop de execução padrão e, portanto, não poderão ser entregues enquanto o loop de execução estiver bloqueado por outra atividade. Se uma fila for fornecida, as notificações serão entregues para essa fila. Quando as notificações não podem ser entregues instantaneamente, várias notificações podem ser agrupadas em uma única notificação. Isso pode incluir a notificação com a coleção inicial.

    Por exemplo, o código a seguir executa uma transação de escrita imediatamente após adicionar o bloqueio de notificação, para que não haja oportunidade para que a notificação inicial seja entregue primeiro. Como resultado, a notificação inicial refletirá o estado do Realm após a transação de escrita.

    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
    

    Se nenhum caminho-chave for fornecido, o bloqueio será executado em qualquer inserção, modificação ou exclusão para todas as propriedades do objeto e as propriedades de quaisquer objetos vinculados aninhados. Se um caminho de chave ou caminhos de chave forem fornecidos, o bloco será chamado para alterações que ocorrem apenas nos caminhos de chave fornecidos. Por exemplo, se:

    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
    
    • Se o caminho da chave observado fosse [\Dog.toys.brand], qualquer inserção ou exclusão na lista toys em qualquer um dos elementos da collection trigger o bloqueio. Alterações no valor brand em qualquer Toy vinculado a um Dog nessa collection triggerão o bloqueio. Alterações em um valor diferente de brand em qualquer Toy vinculado a um Dog nessa collection não trigger o bloqueio. Qualquer inserção ou remoção na collection de tipos Dog que está sendo observada também trigger uma notificação.
    • Se o exemplo acima observasse o caminho da chave [\Dog.toys], qualquer inserção, exclusão ou modificação na lista toys para qualquer elemento da collection trigger o bloqueio. Alterações em qualquer valor em qualquer Toy que esteja vinculado a um Dog nesta collection não trigger o bloqueio. Qualquer inserção ou remoção na collection de tipos Dog que está sendo observada ainda trigger uma notificação.

    Observação

    Vários tokens de notificação no mesmo objeto que filtram exclusivamente caminhos de chave separados não filtram. Se uma alteração de caminho-chavefor satisfeita para um token de notificação, todos os bloqueios de token de notificação para esse objeto serão executados.

    Você deve reter o token retornado pelo tempo que desejar que as atualizações sejam enviadas ao bloco. Para parar de receber atualizações, ligue para invalidate() no token.

    Aviso

    Este método não pode ser chamado durante uma transação de escrita, ou quando o Realm que o contém for somente leitura.

    Declaração

    Swift

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

    Parâmetros

    keyPaths

    Somente a propriedade contida na array de caminhos principais irá trigger o bloqueio quando for modificada. Consulte a descrição acima para obter mais detalhes sobre propriedades vinculadas.

    queue

    A fila de despacho em série para receber a notificação. Se nil, as notificações são entregues ao thread atual.

    block

    O bloco a ser chamado sempre que ocorre uma alteração.

    Valor de retorno

    Um token que deve ser mantido pelo tempo que você quiser que as atualizações sejam entregues.

  • observe(keyPaths:on:_isolation:_:) Implementação padrão, assíncrona

    Implementação padrão

    Registra um bloco a ser chamado cada vez que a collection for alterada.

    O bloco será chamado de forma assíncrona com uma versão inicial da coleção e, em seguida, chamado novamente após cada transação de gravação que altere qualquer um dos objetos da coleção ou quais objetos estão na coleção.

    O parâmetro actor passado para o bloco é o ator que você passa para esta função. Este parâmetro é necessário para isolar a chamada de resposta para o ator.

    O parâmetro change que é passado para o bloco reporta, na forma de índices dentro da collection, quais dos objetos foram adicionados, removidos ou modificados após a notificação anterior. O campo collection na enumeração de alteração será isolado para o ator solicitado e é seguro para uso somente dentro desse ator. Consulte a documentação do RealmCollectionChange para obter mais informações sobre as informações de alteração fornecidas e um exemplo de como usá-las para atualizar um UITableView.

    Depois que a notificação inicial for entregue, a coleção será totalmente avaliada e atualizada, e acessá-la nunca realizará nenhum trabalho de bloqueio. Essa garantia é válida apenas enquanto você não realizar uma transação de escrita no mesmo ator para o qual as notificações estão sendo entregues. Se você fizer isso, para acessar a coleção antes da próxima notificação ser entregue, talvez seja necessário executar novamente a query.

    As notificações são entregues ao executor do ator em questão. Quando as notificações não podem ser entregues instantaneamente, várias notificações podem ser agrupadas em uma única notificação. Isso pode incluir a notificação com a collection inicial: quaisquer gravações que ocorram antes da entrega da notificação inicial podem não produzir notificações de alteração.

    Adicionar, remover ou atribuir objetos na coleção sempre produz uma notificação. Por padrão, modificar os objetos aos quais uma coleção está vinculada (e os objetos aos quais esses objetos se vinculam, se aplicável) também informará que esse índice na coleção está sendo modificado. Se uma array não vazia de keypaths for fornecida, somente as modificações nesses keypaths marcarão o objeto como modificado. Por exemplo:

    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
        }
    }
    
    • Se o caminho da chave observado fosse [\.toys.brand], qualquer inserção ou exclusão na lista toys em qualquer um dos elementos da collection trigger o bloqueio. Alterações no valor brand em qualquer Toy vinculado a um Dog nessa collection triggerão o bloqueio. Alterações em um valor diferente de brand em qualquer Toy vinculado a um Dog nessa collection não trigger o bloqueio. Qualquer inserção ou remoção na collection de tipos Dog que está sendo observada também trigger uma notificação.
    • Se o exemplo acima observasse o caminho da chave [\.toys], qualquer inserção, exclusão ou modificação na lista toys para qualquer elemento da collection trigger o bloqueio. Alterações em qualquer valor em qualquer Toy que esteja vinculado a um Dog nesta collection não trigger o bloqueio. Qualquer inserção ou remoção na collection de tipos Dog que está sendo observada ainda trigger uma notificação.

    Você deve reter o token retornado pelo tempo que desejar que as atualizações sejam enviadas ao bloco. Para parar de receber atualizações, ligue para invalidate() no token.

    Aviso

    Este método não pode ser chamado durante uma transação de escrita, ou quando o Realm que o contém for somente leitura.

    Declaração

    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

    Parâmetros

    keyPaths

    Somente a propriedade contida na array de caminhos principais vai trigger o bloqueio quando forem modificadas. Se estiver vazio, as notificações serão entregues para qualquer alteração de propriedade no objeto. Os caminhos da chave de string que não correspondem a uma propriedade válida lançarão uma exceção. Consulte a descrição acima para obter mais detalhes sobre propriedades vinculadas.

    actor

    O ator para o qual isolar as notificações.

    block

    O bloco a ser chamado sempre que ocorre uma alteração.

    Valor de retorno

    Um token que deve ser mantido pelo tempo que você quiser que as atualizações sejam entregues.