Utilizza gli elenchi di dati sulle piattaforme Apple

Ottieni un FIRDatabaseReference

Per leggere o scrivere dati dal database, devi avere un'istanza di FIRDatabaseReference:

var ref: DatabaseReference!

ref = Database.database().reference()

@property (strong, nonatomic) FIRDatabaseReference *ref;

self.ref = [[FIRDatabase database] reference];

Lettura e scrittura di elenchi

Aggiungi a un elenco di dati

Utilizza il metodo childByAutoId per aggiungere dati a un elenco nelle applicazioni multiutente. Il metodo childByAutoId genera una chiave univoca ogni volta che viene aggiunto un nuovo elemento secondario al riferimento Firebase specificato. Utilizzando queste chiavi generate automaticamente per ogni nuovo elemento dell'elenco, più client possono aggiungere elementi secondari alla stessa posizione contemporaneamente senza conflitti di scrittura. La chiave univoca generata da childByAutoId si basa su un timestamp, quindi gli elementi dell'elenco vengono ordinati automaticamente in ordine cronologico.

Puoi utilizzare il riferimento ai nuovi dati restituiti dal metodo childByAutoId per ottenere il valore della chiave generata automaticamente dell'elemento secondario o impostare i dati per l'elemento secondario. La chiamata di getKey su un riferimento childByAutoId restituisce la chiave generata automaticamente.

Puoi utilizzare queste chiavi generate automaticamente per semplificare l'appiattimento della struttura dei dati. Per saperne di più, consulta l'esempio di fan-out dei dati.

Ascolta gli eventi figlio

Gli eventi figlio vengono attivati in risposta a operazioni specifiche che si verificano sugli elementi figlio di un nodo da un'operazione, ad esempio l'aggiunta di un nuovo elemento figlio tramite il metodo childByAutoId o l'aggiornamento di un elemento figlio tramite il metodo updateChildValues.

Ognuno di questi elementi può essere utile per ascoltare le modifiche a un nodo specifico di un database. Ad esempio, un'app di social blogging potrebbe utilizzare questi metodi insieme per monitorare l'attività nei commenti di un post, come mostrato di seguito:

// Listen for new comments in the Firebase database
commentsRef.observe(.childAdded, with: { (snapshot) -> Void in
  self.comments.append(snapshot)
  self.tableView.insertRows(
    at: [IndexPath(row: self.comments.count - 1, section: self.kSectionComments)],
    with: UITableView.RowAnimation.automatic
  )
})
// Listen for deleted comments in the Firebase database
commentsRef.observe(.childRemoved, with: { (snapshot) -> Void in
  let index = self.indexOfMessage(snapshot)
  self.comments.remove(at: index)
  self.tableView.deleteRows(
    at: [IndexPath(row: index, section: self.kSectionComments)],
    with: UITableView.RowAnimation.automatic
  )
})

// Listen for new comments in the Firebase database
[_commentsRef
              observeEventType:FIRDataEventTypeChildAdded
              withBlock:^(FIRDataSnapshot *snapshot) {
                [self.comments addObject:snapshot];
                [self.tableView insertRowsAtIndexPaths:@[
                  [NSIndexPath indexPathForRow:self.comments.count - 1 inSection:kSectionComments]
                ]
                                      withRowAnimation:UITableViewRowAnimationAutomatic];
              }];
// Listen for deleted comments in the Firebase database
[_commentsRef
 observeEventType:FIRDataEventTypeChildRemoved
 withBlock:^(FIRDataSnapshot *snapshot) {
   int index = [self indexOfMessage:snapshot];
   [self.comments removeObjectAtIndex:index];
   [self.tableView deleteRowsAtIndexPaths:@[[NSIndexPath indexPathForRow:index inSection:kSectionComments]]
                         withRowAnimation:UITableViewRowAnimationAutomatic];
 }];

Ascolta gli eventi di valore

Sebbene l'ascolto degli eventi figlio sia il modo consigliato per leggere gli elenchi di dati, in alcune situazioni è utile l'ascolto degli eventi di valore su un riferimento di elenco.

Se colleghi un osservatore FIRDataEventTypeValue a un elenco di dati, verrà restituito l'intero elenco di dati come un singolo DataSnapshot, su cui puoi eseguire un ciclo per accedere ai singoli elementi secondari.

Anche se esiste una sola corrispondenza per la query, lo snapshot è comunque un elenco, ma contiene un solo elemento. Per accedere all'elemento, devi eseguire un loop sul risultato:

_commentsRef.observe(.value) { snapshot in
  for child in snapshot.children {
    ...
  }
}

[_commentsRef
              observeEventType:FIRDataEventTypeValue
              withBlock:^(FIRDataSnapshot *snapshot) {
                // Loop over children
                NSEnumerator *children = [snapshot children];
                FIRDataSnapshot *child;
                while (child = [children nextObject]) {
                  // ...
                }
              }];

Questo pattern può essere utile quando vuoi recuperare tutti gli elementi secondari di un elenco in un'unica operazione, anziché rimanere in ascolto di ulteriori eventi di aggiunta di elementi secondari.

Ordinamento e filtro dei dati

Puoi utilizzare la classe Realtime Database FIRDatabaseQuery per recuperare i dati ordinati per chiave, per valore o per valore di un elemento secondario. Puoi anche filtrare il risultato ordinato in base a un numero specifico di risultati o a un intervallo di chiavi o valori.

Ordina i dati

Per recuperare i dati ordinati, inizia specificando uno dei metodi di ordinamento per determinare l'ordine dei risultati:

Puoi utilizzare un solo metodo di ordinamento alla volta. La chiamata di un metodo di ordinamento più volte nella stessa query genera un errore.

L'esempio seguente mostra come recuperare un elenco dei post principali di un utente ordinati in base al numero di stelle:

// My top posts by number of stars
let myTopPostsQuery = ref.child("user-posts").child(getUid()).queryOrdered(byChild: "starCount")

// My top posts by number of stars
FIRDatabaseQuery *myTopPostsQuery = [[[self.ref child:@"user-posts"]
                                      child:[super getUid]]
                                     queryOrderedByChild:@"starCount"];

Questa query recupera i post dell'utente dal percorso nel database in base al suo ID utente, ordinati in base al numero di stelle ricevute da ogni post. Questa tecnica di utilizzo degli ID come chiavi di indice è chiamata fan-out dei dati. Per saperne di più, consulta Struttura il tuo database.

La chiamata al metodo queryOrderedByChild specifica la chiave secondaria in base alla quale ordinare i risultati. In questo esempio, i post vengono ordinati in base al valore dell'elemento secondario "starCount" in ogni post. Le query possono anche essere ordinate in base ai nodi secondari nidificati, nel caso in cui i dati siano simili ai seguenti:

"posts": {
  "ts-functions": {
    "metrics": {
      "views" : 1200000,
      "likes" : 251000,
      "shares": 1200,
    },
    "title" : "Why you should use TypeScript for writing Cloud Functions",
    "author": "Doug",
  },
  "android-arch-3": {
    "metrics": {
      "views" : 900000,
      "likes" : 117000,
      "shares": 144,
    },
    "title" : "Using Android Architecture Components with Firebase Realtime Database (Part 3)",
    "author": "Doug",
  }
},

In questo caso, possiamo ordinare gli elementi dell'elenco in base ai valori nidificati sotto la chiave metrics specificando il percorso relativo dell'elemento secondario nidificato nella nostra chiamata queryOrderedByChild.

 
let postsByMostPopular = ref.child("posts").queryOrdered(byChild: "metrics/views")

 
FIRDatabaseQuery *postsByMostPopular = [[ref child:@"posts"] queryOrderedByChild:@"metrics/views"];

Per saperne di più su come vengono ordinati gli altri tipi di dati, consulta Come vengono ordinati i dati delle query.

Filtrare i dati

Per filtrare i dati, puoi combinare uno qualsiasi dei metodi di limite o intervallo con un metodo di ordinamento durante la creazione di una query.

A differenza dei metodi di ordinamento, puoi combinare più funzioni di limite o intervallo. Ad esempio, puoi combinare i metodi queryStartingAtValue e queryEndingAtValue per limitare i risultati a un intervallo di valori specificato.

Limita il numero di risultati

Puoi utilizzare i metodi queryLimitedToFirst e queryLimitedToLast per impostare un numero massimo di elementi secondari da sincronizzare per un determinato callback. Ad esempio, se utilizzi queryLimitedToFirst per impostare un limite di 100, inizialmente riceverai solo fino a 100 callback FIRDataEventTypeChildAdded. Se nel tuo database Firebase sono archiviati meno di 100 elementi, viene attivato un callback FIRDataEventTypeChildAdded per ogni elemento.

Man mano che gli elementi cambiano, ricevi callback FIRDataEventTypeChildAdded per gli elementi che entrano nella query e callback FIRDataEventTypeChildRemoved per gli elementi che ne escono, in modo che il numero totale rimanga pari a 100.

L'esempio seguente mostra come un'app di blogging di esempio potrebbe recuperare un elenco dei 100 post più recenti di tutti gli utenti:

// Last 100 posts, these are automatically the 100 most recent
// due to sorting by push() keys
let recentPostsQuery = (ref?.child("posts").queryLimited(toFirst: 100))!

// Last 100 posts, these are automatically the 100 most recent
// due to sorting by push() keys
FIRDatabaseQuery *recentPostsQuery = [[self.ref child:@"posts"] queryLimitedToFirst:100];

Filtra per chiave o valore

Puoi utilizzare queryStartingAtValue, queryStartingAfterValue, queryEndingAtValue, queryEndingBeforeValue e queryEqualToValue per scegliere punti di inizio, fine ed equivalenza arbitrari per le query. Questa opzione può essere utile per impaginare i dati o trovare elementi con elementi secondari che hanno un valore specifico.

Come vengono ordinati i dati delle query

Questa sezione spiega come i dati vengono ordinati in base a ciascuno dei metodi di ordinamento nella classe FIRDatabaseQuery.

queryOrderedByKey

Quando utilizzi queryOrderedByKey per ordinare i dati, questi vengono restituiti in ordine crescente per chiave.

1. I nodi secondari con una chiave che può essere analizzata come un numero intero a 32 bit vengono visualizzati per primi, ordinati in ordine crescente.
2. Seguono gli elementi secondari con un valore di stringa come chiave, ordinati lessicograficamente in ordine crescente.

queryOrderedByValue

Quando utilizzi queryOrderedByValue, gli elementi secondari vengono ordinati in base al loro valore. I criteri di ordinamento sono gli stessi di queryOrderedByChild, ad eccezione del fatto che viene utilizzato il valore del nodo anziché il valore di una chiave secondaria specificata.

queryOrderedByChild

Quando utilizzi queryOrderedByChild, i dati che contengono la chiave secondaria specificata vengono ordinati come segue:

1. I nodi secondari con un valore nil per la chiave secondaria specificata vengono visualizzati per primi.
2. Seguono i nodi secondari con un valore di false per la chiave secondaria specificata. Se più elementi secondari hanno un valore false, vengono ordinati lessicograficamente in base alla chiave.
3. Seguono i nodi secondari con un valore true per la chiave secondaria specificata. Se più elementi secondari hanno un valore true, vengono ordinati in ordine lessicografico per chiave.
4. Seguono gli elementi secondari con un valore numerico, ordinati in ordine crescente. Se più elementi secondari hanno lo stesso valore numerico per il nodo secondario specificato, vengono ordinati per chiave.
5. Le stringhe vengono dopo i numeri e sono ordinate lessicograficamente in ordine crescente. Se più elementi secondari hanno lo stesso valore per il nodo secondario specificato, vengono ordinati in ordine lessicografico per chiave.
6. Gli oggetti vengono visualizzati per ultimi e sono ordinati lessicograficamente per chiave in ordine crescente.

Scollega i listener

Gli osservatori non interrompono automaticamente la sincronizzazione dei dati quando esci da un ViewController. Se un osservatore non viene rimosso correttamente, continua a sincronizzare i dati con la memoria locale e conserva tutti gli oggetti acquisiti nella chiusura del gestore di eventi, il che può causare perdite di memoria. Quando un osservatore non è più necessario, rimuovilo passando l'oggetto FIRDatabaseHandle associato al metodo removeObserverWithHandle.

Quando aggiungi un blocco di callback a un riferimento, viene restituito un FIRDatabaseHandle. Questi handle possono essere utilizzati per rimuovere il blocco di callback.

Se a un riferimento al database sono stati aggiunti più listener, ogni listener viene chiamato quando viene generato un evento. Per interrompere la sincronizzazione dei dati in quella posizione, devi rimuovere tutti gli osservatori in una posizione chiamando il metodo removeAllObservers.

La chiamata di removeObserverWithHandle o removeAllObservers su un listener non rimuove automaticamente i listener registrati sui relativi nodi secondari; devi anche tenere traccia di questi riferimenti o handle per rimuoverli.

Passaggi successivi

• Scopri come strutturare i dati
• Archivia i dati offline