Obtener datos con Cloud Firestore

Hay tres formas de recuperar datos almacenados en Cloud Firestore. Cualquiera de estos métodos se puede utilizar con documentos, colecciones de documentos o resultados de consultas:

  • Llame a un método para obtener los datos una vez.
  • Configure un oyente para recibir eventos de cambio de datos.
  • Carga masiva de datos de instantáneas de Firestore desde una fuente externa a través de paquetes de datos . Consulte el documento de paquetes para obtener más detalles.

Cuando configura un oyente, Cloud Firestore le envía una instantánea inicial de los datos y luego otra instantánea cada vez que cambia el documento.

Antes de que empieces

Consulta Comenzar con Cloud Firestore para crear una base de datos de Cloud Firestore.

Inicializar Cloud Firestore

Inicialice una instancia de Cloud Firestore:

import { initializeApp } from "firebase/app";
import { getFirestore } from "firebase/firestore";

// TODO: Replace the following with your app's Firebase project configuration
// See: https://support.google.com/firebase/answer/7015592
const firebaseConfig = {
   
FIREBASE_CONFIGURATION
};

// Initialize Firebase
const app = initializeApp(firebaseConfig);


// Initialize Cloud Firestore and get a reference to the service
const db = getFirestore(app);

Reemplace FIREBASE_CONFIGURATION con firebaseConfig de su aplicación web.

Para conservar los datos cuando el dispositivo pierde la conexión, consulte la documentación Habilitar datos sin conexión .

import firebase from "firebase/app";
import "firebase/firestore";

// TODO: Replace the following with your app's Firebase project configuration
// See: https://support.google.com/firebase/answer/7015592
const firebaseConfig = {
   
FIREBASE_CONFIGURATION
};

// Initialize Firebase
firebase
.initializeApp(firebaseConfig);


// Initialize Cloud Firestore and get a reference to the service
const db = firebase.firestore();

Reemplace FIREBASE_CONFIGURATION con firebaseConfig de su aplicación web.

Para conservar los datos cuando el dispositivo pierde la conexión, consulte la documentación Habilitar datos sin conexión .

Nota: Este producto no está disponible en destinos watchOS y App Clip.
import FirebaseCore
import FirebaseFirestore
FirebaseApp.configure()

let db = Firestore.firestore()
Nota: Este producto no está disponible en destinos watchOS y App Clip.
@import FirebaseCore;
@import FirebaseFirestore;

// Use Firebase library to configure APIs
[FIRApp configure];
 
FIRFirestore *defaultFirestore = [FIRFirestore firestore];
// Access a Cloud Firestore instance from your Activity
val db = Firebase.firestore
// Access a Cloud Firestore instance from your Activity
FirebaseFirestore db = FirebaseFirestore.getInstance();
db = FirebaseFirestore.instance;
El SDK de Cloud Firestore se inicializa de diferentes maneras según su entorno. A continuación se muestran los métodos más comunes. Para obtener una referencia completa, consulte Inicializar el SDK de administrador .
  • Inicializar en Google Cloud
    import com.google.auth.oauth2.GoogleCredentials;
    import com.google.cloud.firestore.Firestore;

    import com.google.firebase.FirebaseApp;
    import com.google.firebase.FirebaseOptions;

    // Use the application default credentials
    GoogleCredentials credentials = GoogleCredentials.getApplicationDefault();
    FirebaseOptions options = new FirebaseOptions.Builder()
       
    .setCredentials(credentials)
       
    .setProjectId(projectId)
       
    .build();
    FirebaseApp.initializeApp(options);

    Firestore db = FirestoreClient.getFirestore();
  • Inicializar en su propio servidor

    Para usar el SDK de Firebase Admin en su propio servidor, use una cuenta de servicio .

    Vaya a IAM y administración > Cuentas de servicio en la consola de Google Cloud. Genere una nueva clave privada y guarde el archivo JSON. Luego use el archivo para inicializar el SDK:

    import com.google.auth.oauth2.GoogleCredentials;
    import com.google.cloud.firestore.Firestore;

    import com.google.firebase.FirebaseApp;
    import com.google.firebase.FirebaseOptions;

    // Use a service account
    InputStream serviceAccount = new FileInputStream("path/to/serviceAccount.json");
    GoogleCredentials credentials = GoogleCredentials.fromStream(serviceAccount);
    FirebaseOptions options = new FirebaseOptions.Builder()
       
    .setCredentials(credentials)
       
    .build();
    FirebaseApp.initializeApp(options);

    Firestore db = FirestoreClient.getFirestore();
  • El SDK de Cloud Firestore se inicializa de diferentes maneras según su entorno. A continuación se muestran los métodos más comunes. Para obtener una referencia completa, consulte Inicializar el SDK de administrador .
  • Inicializar en Google Cloud
    import firebase_admin
    from firebase_admin import firestore

    # Application Default credentials are automatically created.
    app
    = firebase_admin.initialize_app()
    db
    = firestore.client()

    También se puede utilizar una credencial predeterminada de la aplicación existente para inicializar el SDK.

    import firebase_admin
    from firebase_admin import credentials
    from firebase_admin import firestore

    # Use the application default credentials.
    cred
    = credentials.ApplicationDefault()

    firebase_admin
    .initialize_app(cred)
    db
    = firestore.client()
  • Inicializar en su propio servidor

    Para usar el SDK de Firebase Admin en su propio servidor, use una cuenta de servicio .

    Vaya a IAM y administración > Cuentas de servicio en la consola de Google Cloud. Genere una nueva clave privada y guarde el archivo JSON. Luego use el archivo para inicializar el SDK:

    import firebase_admin
    from firebase_admin import credentials
    from firebase_admin import firestore

    # Use a service account.
    cred
    = credentials.Certificate('path/to/serviceAccount.json')

    app
    = firebase_admin.initialize_app(cred)

    db
    = firestore.client()
  • El SDK de Cloud Firestore se inicializa de diferentes maneras según su entorno. A continuación se muestran los métodos más comunes. Para obtener una referencia completa, consulte Inicializar el SDK de administrador .
  • Inicializar en Google Cloud
    import firebase_admin
    from firebase_admin import firestore_async

    # Application Default credentials are automatically created.
    app
    = firebase_admin.initialize_app()
    db
    = firestore_async.client()

    También se puede utilizar una credencial predeterminada de la aplicación existente para inicializar el SDK.

    import firebase_admin
    from firebase_admin import credentials
    from firebase_admin import firestore_async

    # Use the application default credentials.
    cred
    = credentials.ApplicationDefault()

    firebase_admin
    .initialize_app(cred)
    db
    = firestore_async.client()
  • Inicializar en su propio servidor

    Para usar el SDK de Firebase Admin en su propio servidor, use una cuenta de servicio .

    Vaya a IAM y administrador > Cuentas de servicio en la consola de Google Cloud. Genere una nueva clave privada y guarde el archivo JSON. Luego use el archivo para inicializar el SDK:

    import firebase_admin
    from firebase_admin import credentials
    from firebase_admin import firestore_async

    # Use a service account.
    cred
    = credentials.Certificate('path/to/serviceAccount.json')

    app
    = firebase_admin.initialize_app(cred)

    db
    = firestore_async.client()
  • // Make sure the call to `Create()` happens some time before you call Firestore::GetInstance().
    App::Create();
    Firestore* db = Firestore::GetInstance();
    El SDK de Cloud Firestore se inicializa de diferentes maneras según su entorno. A continuación se muestran los métodos más comunes. Para obtener una referencia completa, consulte Inicializar el SDK de administrador .
    • Inicializar en Cloud Functions
      const { initializeApp, applicationDefault, cert } = require('firebase-admin/app');
      const { getFirestore, Timestamp, FieldValue, Filter } = require('firebase-admin/firestore');
      initializeApp();

      const db = getFirestore();
    • Inicializar en Google Cloud
      const { initializeApp, applicationDefault, cert } = require('firebase-admin/app');
      const { getFirestore, Timestamp, FieldValue, Filter } = require('firebase-admin/firestore');
      initializeApp({
        credential
      : applicationDefault()
      });

      const db = getFirestore();
    • Inicializar en su propio servidor

      Para usar el SDK de Firebase Admin en su propio servidor (o cualquier otro entorno de Node.js), use una cuenta de servicio . Vaya a IAM y administrador > Cuentas de servicio en la consola de Google Cloud. Genere una nueva clave privada y guarde el archivo JSON. Luego use el archivo para inicializar el SDK:

      const { initializeApp, applicationDefault, cert } = require('firebase-admin/app');
      const { getFirestore, Timestamp, FieldValue, Filter } = require('firebase-admin/firestore');
      const serviceAccount = require('./path/to/serviceAccountKey.json');

      initializeApp
      ({
        credential
      : cert(serviceAccount)
      });

      const db = getFirestore();
    El SDK de Cloud Firestore se inicializa de diferentes maneras según su entorno. A continuación se muestran los métodos más comunes. Para obtener una referencia completa, consulte Inicializar el SDK de administrador .
  • Inicializar en Google Cloud
    import (
     
    "log"

      firebase
    "firebase.google.com/go"
     
    "google.golang.org/api/option"
    )

    // Use the application default credentials
    ctx
    := context.Background()
    conf
    := &firebase.Config{ProjectID: projectID}
    app
    , err := firebase.NewApp(ctx, conf)
    if err != nil {
      log
    .Fatalln(err)
    }

    client
    , err := app.Firestore(ctx)
    if err != nil {
      log
    .Fatalln(err)
    }
    defer client
    .Close()
  • Inicializar en su propio servidor

    Para usar el SDK de Firebase Admin en su propio servidor, use una cuenta de servicio .

    Vaya a IAM y administrador > Cuentas de servicio en la consola de Google Cloud. Genere una nueva clave privada y guarde el archivo JSON. Luego use el archivo para inicializar el SDK:

    import (
     
    "log"

      firebase
    "firebase.google.com/go"
     
    "google.golang.org/api/option"
    )

    // Use a service account
    ctx
    := context.Background()
    sa
    := option.WithCredentialsFile("path/to/serviceAccount.json")
    app
    , err := firebase.NewApp(ctx, nil, sa)
    if err != nil {
      log
    .Fatalln(err)
    }

    client
    , err := app.Firestore(ctx)
    if err != nil {
      log
    .Fatalln(err)
    }
    defer client
    .Close()
  • PHP

    Para obtener más información sobre cómo instalar y crear un cliente de Cloud Firestore, consulte Bibliotecas de clientes de Cloud Firestore .

    use Google\Cloud\Firestore\FirestoreClient;

    /**
     * Initialize Cloud Firestore with default project ID.
     */

    function setup_client_create(string $projectId = null)
    {
       
    // Create the Cloud Firestore client
       
    if (empty($projectId)) {
           
    // The `projectId` parameter is optional and represents which project the
           
    // client will act on behalf of. If not supplied, the client falls back to
           
    // the default project inferred from the environment.
            $db
    = new FirestoreClient();
            printf
    ('Created Cloud Firestore client with default project ID.' . PHP_EOL);
       
    } else {
            $db
    = new FirestoreClient([
               
    'projectId' => $projectId,
           
    ]);
            printf
    ('Created Cloud Firestore client with project ID: %s' . PHP_EOL, $projectId);
       
    }
    }
    using Firebase.Firestore;
    using Firebase.Extensions;
    FirebaseFirestore db = FirebaseFirestore.DefaultInstance;

    C#

    Para obtener más información sobre cómo instalar y crear un cliente de Cloud Firestore, consulte Bibliotecas de clientes de Cloud Firestore .

    FirestoreDb db = FirestoreDb.Create(project);
    Console.WriteLine("Created Cloud Firestore client with project ID: {0}", project);
    require "google/cloud/firestore"

    # The `project_id` parameter is optional and represents which project the
    # client will act on behalf of. If not supplied, the client falls back to the
    # default project inferred from the environment.
    firestore
    = Google::Cloud::Firestore.new project_id: project_id

    puts
    "Created Cloud Firestore client with given project ID."

    Datos de ejemplo

    Para comenzar, escriba algunos datos sobre las ciudades para que podamos ver diferentes formas de leerlos:

    import { collection, doc, setDoc } from "firebase/firestore"; 

    const citiesRef = collection(db, "cities");

    await setDoc
    (doc(citiesRef, "SF"), {
        name
    : "San Francisco", state: "CA", country: "USA",
        capital
    : false, population: 860000,
        regions
    : ["west_coast", "norcal"] });
    await setDoc
    (doc(citiesRef, "LA"), {
        name
    : "Los Angeles", state: "CA", country: "USA",
        capital
    : false, population: 3900000,
        regions
    : ["west_coast", "socal"] });
    await setDoc
    (doc(citiesRef, "DC"), {
        name
    : "Washington, D.C.", state: null, country: "USA",
        capital
    : true, population: 680000,
        regions
    : ["east_coast"] });
    await setDoc
    (doc(citiesRef, "TOK"), {
        name
    : "Tokyo", state: null, country: "Japan",
        capital
    : true, population: 9000000,
        regions
    : ["kanto", "honshu"] });
    await setDoc
    (doc(citiesRef, "BJ"), {
        name
    : "Beijing", state: null, country: "China",
        capital
    : true, population: 21500000,
        regions
    : ["jingjinji", "hebei"] });
    var citiesRef = db.collection("cities");

    citiesRef
    .doc("SF").set({
        name
    : "San Francisco", state: "CA", country: "USA",
        capital
    : false, population: 860000,
        regions
    : ["west_coast", "norcal"] });
    citiesRef
    .doc("LA").set({
        name
    : "Los Angeles", state: "CA", country: "USA",
        capital
    : false, population: 3900000,
        regions
    : ["west_coast", "socal"] });
    citiesRef
    .doc("DC").set({
        name
    : "Washington, D.C.", state: null, country: "USA",
        capital
    : true, population: 680000,
        regions
    : ["east_coast"] });
    citiesRef
    .doc("TOK").set({
        name
    : "Tokyo", state: null, country: "Japan",
        capital
    : true, population: 9000000,
        regions
    : ["kanto", "honshu"] });
    citiesRef
    .doc("BJ").set({
        name
    : "Beijing", state: null, country: "China",
        capital
    : true, population: 21500000,
        regions
    : ["jingjinji", "hebei"] });
    Nota: Este producto no está disponible en destinos watchOS y App Clip.
    let citiesRef = db.collection("cities")

    citiesRef
    .document("SF").setData([
     
    "name": "San Francisco",
     
    "state": "CA",
     
    "country": "USA",
     
    "capital": false,
     
    "population": 860000,
     
    "regions": ["west_coast", "norcal"]
    ])
    citiesRef
    .document("LA").setData([
     
    "name": "Los Angeles",
     
    "state": "CA",
     
    "country": "USA",
     
    "capital": false,
     
    "population": 3900000,
     
    "regions": ["west_coast", "socal"]
    ])
    citiesRef
    .document("DC").setData([
     
    "name": "Washington D.C.",
     
    "country": "USA",
     
    "capital": true,
     
    "population": 680000,
     
    "regions": ["east_coast"]
    ])
    citiesRef
    .document("TOK").setData([
     
    "name": "Tokyo",
     
    "country": "Japan",
     
    "capital": true,
     
    "population": 9000000,
     
    "regions": ["kanto", "honshu"]
    ])
    citiesRef
    .document("BJ").setData([
     
    "name": "Beijing",
     
    "country": "China",
     
    "capital": true,
     
    "population": 21500000,
     
    "regions": ["jingjinji", "hebei"]
    ])
    Nota: Este producto no está disponible en destinos watchOS y App Clip.
    FIRCollectionReference *citiesRef = [self.db collectionWithPath:@"cities"];
    [[citiesRef documentWithPath:@"SF"] setData:@{
     
    @"name": @"San Francisco",
     
    @"state": @"CA",
     
    @"country": @"USA",
     
    @"capital": @(NO),
     
    @"population": @860000,
     
    @"regions": @[@"west_coast", @"norcal"]
    }];
    [[citiesRef documentWithPath:@"LA"] setData:@{
     
    @"name": @"Los Angeles",
     
    @"state": @"CA",
     
    @"country": @"USA",
     
    @"capital": @(NO),
     
    @"population": @3900000,
     
    @"regions": @[@"west_coast", @"socal"]
    }];
    [[citiesRef documentWithPath:@"DC"] setData:@{
     
    @"name": @"Washington D.C.",
     
    @"country": @"USA",
     
    @"capital": @(YES),
     
    @"population": @680000,
     
    @"regions": @[@"east_coast"]
    }];
    [[citiesRef documentWithPath:@"TOK"] setData:@{
     
    @"name": @"Tokyo",
     
    @"country": @"Japan",
     
    @"capital": @(YES),
     
    @"population": @9000000,
     
    @"regions": @[@"kanto", @"honshu"]
    }];
    [[citiesRef documentWithPath:@"BJ"] setData:@{
     
    @"name": @"Beijing",
     
    @"country": @"China",
     
    @"capital": @(YES),
     
    @"population": @21500000,
     
    @"regions": @[@"jingjinji", @"hebei"]
    }];
    val cities = db.collection("cities")

    val data1 = hashMapOf(
       
    "name" to "San Francisco",
       
    "state" to "CA",
       
    "country" to "USA",
       
    "capital" to false,
       
    "population" to 860000,
       
    "regions" to listOf("west_coast", "norcal"),
    )
    cities
    .document("SF").set(data1)

    val data2 = hashMapOf(
       
    "name" to "Los Angeles",
       
    "state" to "CA",
       
    "country" to "USA",
       
    "capital" to false,
       
    "population" to 3900000,
       
    "regions" to listOf("west_coast", "socal"),
    )
    cities
    .document("LA").set(data2)

    val data3 = hashMapOf(
       
    "name" to "Washington D.C.",
       
    "state" to null,
       
    "country" to "USA",
       
    "capital" to true,
       
    "population" to 680000,
       
    "regions" to listOf("east_coast"),
    )
    cities
    .document("DC").set(data3)

    val data4 = hashMapOf(
       
    "name" to "Tokyo",
       
    "state" to null,
       
    "country" to "Japan",
       
    "capital" to true,
       
    "population" to 9000000,
       
    "regions" to listOf("kanto", "honshu"),
    )
    cities
    .document("TOK").set(data4)

    val data5 = hashMapOf(
       
    "name" to "Beijing",
       
    "state" to null,
       
    "country" to "China",
       
    "capital" to true,
       
    "population" to 21500000,
       
    "regions" to listOf("jingjinji", "hebei"),
    )
    cities
    .document("BJ").set(data5)
    CollectionReference cities = db.collection("cities");

    Map<String, Object> data1 = new HashMap<>();
    data1
    .put("name", "San Francisco");
    data1
    .put("state", "CA");
    data1
    .put("country", "USA");
    data1
    .put("capital", false);
    data1
    .put("population", 860000);
    data1
    .put("regions", Arrays.asList("west_coast", "norcal"));
    cities
    .document("SF").set(data1);

    Map<String, Object> data2 = new HashMap<>();
    data2
    .put("name", "Los Angeles");
    data2
    .put("state", "CA");
    data2
    .put("country", "USA");
    data2
    .put("capital", false);
    data2
    .put("population", 3900000);
    data2
    .put("regions", Arrays.asList("west_coast", "socal"));
    cities
    .document("LA").set(data2);

    Map<String, Object> data3 = new HashMap<>();
    data3
    .put("name", "Washington D.C.");
    data3
    .put("state", null);
    data3
    .put("country", "USA");
    data3
    .put("capital", true);
    data3
    .put("population", 680000);
    data3
    .put("regions", Arrays.asList("east_coast"));
    cities
    .document("DC").set(data3);

    Map<String, Object> data4 = new HashMap<>();
    data4
    .put("name", "Tokyo");
    data4
    .put("state", null);
    data4
    .put("country", "Japan");
    data4
    .put("capital", true);
    data4
    .put("population", 9000000);
    data4
    .put("regions", Arrays.asList("kanto", "honshu"));
    cities
    .document("TOK").set(data4);

    Map<String, Object> data5 = new HashMap<>();
    data5
    .put("name", "Beijing");
    data5
    .put("state", null);
    data5
    .put("country", "China");
    data5
    .put("capital", true);
    data5
    .put("population", 21500000);
    data5
    .put("regions", Arrays.asList("jingjinji", "hebei"));
    cities
    .document("BJ").set(data5);
    final cities = db.collection("cities");
    final data1 = <String, dynamic>{
     
    "name": "San Francisco",
     
    "state": "CA",
     
    "country": "USA",
     
    "capital": false,
     
    "population": 860000,
     
    "regions": ["west_coast", "norcal"]
    };
    cities
    .doc("SF").set(data1);

    final data2 = <String, dynamic>{
     
    "name": "Los Angeles",
     
    "state": "CA",
     
    "country": "USA",
     
    "capital": false,
     
    "population": 3900000,
     
    "regions": ["west_coast", "socal"],
    };
    cities
    .doc("LA").set(data2);

    final data3 = <String, dynamic>{
     
    "name": "Washington D.C.",
     
    "state": null,
     
    "country": "USA",
     
    "capital": true,
     
    "population": 680000,
     
    "regions": ["east_coast"]
    };
    cities
    .doc("DC").set(data3);

    final data4 = <String, dynamic>{
     
    "name": "Tokyo",
     
    "state": null,
     
    "country": "Japan",
     
    "capital": true,
     
    "population": 9000000,
     
    "regions": ["kanto", "honshu"]
    };
    cities
    .doc("TOK").set(data4);

    final data5 = <String, dynamic>{
     
    "name": "Beijing",
     
    "state": null,
     
    "country": "China",
     
    "capital": true,
     
    "population": 21500000,
     
    "regions": ["jingjinji", "hebei"],
    };
    cities
    .doc("BJ").set(data5);
    CollectionReference cities = db.collection("cities");
    List<ApiFuture<WriteResult>> futures = new ArrayList<>();
    futures
    .add(
        cities
           
    .document("SF")
           
    .set(
               
    new City(
                   
    "San Francisco",
                   
    "CA",
                   
    "USA",
                   
    false,
                   
    860000L,
                   
    Arrays.asList("west_coast", "norcal"))));
    futures
    .add(
        cities
           
    .document("LA")
           
    .set(
               
    new City(
                   
    "Los Angeles",
                   
    "CA",
                   
    "USA",
                   
    false,
                   
    3900000L,
                   
    Arrays.asList("west_coast", "socal"))));
    futures
    .add(
        cities
           
    .document("DC")
           
    .set(
               
    new City(
                   
    "Washington D.C.", null, "USA", true, 680000L, Arrays.asList("east_coast"))));
    futures
    .add(
        cities
           
    .document("TOK")
           
    .set(
               
    new City(
                   
    "Tokyo", null, "Japan", true, 9000000L, Arrays.asList("kanto", "honshu"))));
    futures
    .add(
        cities
           
    .document("BJ")
           
    .set(
               
    new City(
                   
    "Beijing",
                   
    null,
                   
    "China",
                   
    true,
                   
    21500000L,
                   
    Arrays.asList("jingjinji", "hebei"))));
    // (optional) block on operation
    ApiFutures.allAsList(futures).get();
    class City:
       
    def __init__(self, name, state, country, capital=False, population=0, regions=[]):
           
    self.name = name
           
    self.state = state
           
    self.country = country
           
    self.capital = capital
           
    self.population = population
           
    self.regions = regions

       
    @staticmethod
       
    def from_dict(source):
           
    # ...

       
    def to_dict(self):
           
    # ...

       
    def __repr__(self):
           
    return f"City(\
                    name={self.name}, \
                    country={self.country}, \
                    population={self.population}, \
                    capital={self.capital}, \
                    regions={self.regions}\
                )"


    cities_ref = db.collection("cities")
    cities_ref
    .document("BJ").set(
       
    City("Beijing", None, "China", True, 21500000, ["hebei"]).to_dict()
    )
    cities_ref
    .document("SF").set(
       
    City(
           
    "San Francisco", "CA", "USA", False, 860000, ["west_coast", "norcal"]
       
    ).to_dict()
    )
    cities_ref
    .document("LA").set(
       
    City(
           
    "Los Angeles", "CA", "USA", False, 3900000, ["west_coast", "socal"]
       
    ).to_dict()
    )
    cities_ref
    .document("DC").set(
       
    City("Washington D.C.", None, "USA", True, 680000, ["east_coast"]).to_dict()
    )
    cities_ref
    .document("TOK").set(
       
    City("Tokyo", None, "Japan", True, 9000000, ["kanto", "honshu"]).to_dict()
    )
    cities_ref = db.collection("cities")
    await cities_ref
    .document("BJ").set(
       
    City("Beijing", None, "China", True, 21500000, ["hebei"]).to_dict()
    )
    await cities_ref
    .document("SF").set(
       
    City(
           
    "San Francisco", "CA", "USA", False, 860000, ["west_coast", "norcal"]
       
    ).to_dict()
    )
    await cities_ref
    .document("LA").set(
       
    City(
           
    "Los Angeles", "CA", "USA", False, 3900000, ["west_coast", "socal"]
       
    ).to_dict()
    )
    await cities_ref
    .document("DC").set(
       
    City("Washington D.C.", None, "USA", True, 680000, ["east_coast"]).to_dict()
    )
    await cities_ref
    .document("TOK").set(
       
    City("Tokyo", None, "Japan", True, 9000000, ["kanto", "honshu"]).to_dict()
    )
    CollectionReference cities = db->Collection("cities");

    cities
    .Document("SF").Set({
       
    {"name", FieldValue::String("San Francisco")},
       
    {"state", FieldValue::String("CA")},
       
    {"country", FieldValue::String("USA")},
       
    {"capital", FieldValue::Boolean(false)},
       
    {"population", FieldValue::Integer(860000)},
       
    {"regions", FieldValue::Array({FieldValue::String("west_coast"),
                                       
    FieldValue::String("norcal")})},
    });

    cities
    .Document("LA").Set({
       
    {"name", FieldValue::String("Los Angeles")},
       
    {"state", FieldValue::String("CA")},
       
    {"country", FieldValue::String("USA")},
       
    {"capital", FieldValue::Boolean(false)},
       
    {"population", FieldValue::Integer(3900000)},
       
    {"regions", FieldValue::Array({FieldValue::String("west_coast"),
                                       
    FieldValue::String("socal")})},
    });

    cities
    .Document("DC").Set({
       
    {"name", FieldValue::String("Washington D.C.")},
       
    {"state", FieldValue::Null()},
       
    {"country", FieldValue::String("USA")},
       
    {"capital", FieldValue::Boolean(true)},
       
    {"population", FieldValue::Integer(680000)},
       
    {"regions",
         
    FieldValue::Array({FieldValue::String("east_coast")})},
    });

    cities
    .Document("TOK").Set({
       
    {"name", FieldValue::String("Tokyo")},
       
    {"state", FieldValue::Null()},
       
    {"country", FieldValue::String("Japan")},
       
    {"capital", FieldValue::Boolean(true)},
       
    {"population", FieldValue::Integer(9000000)},
       
    {"regions", FieldValue::Array({FieldValue::String("kanto"),
                                       
    FieldValue::String("honshu")})},
    });

    cities
    .Document("BJ").Set({
       
    {"name", FieldValue::String("Beijing")},
       
    {"state", FieldValue::Null()},
       
    {"country", FieldValue::String("China")},
       
    {"capital", FieldValue::Boolean(true)},
       
    {"population", FieldValue::Integer(21500000)},
       
    {"regions", FieldValue::Array({FieldValue::String("jingjinji"),
                                       
    FieldValue::String("hebei")})},
    });
    const citiesRef = db.collection('cities');

    await citiesRef
    .doc('SF').set({
      name
    : 'San Francisco', state: 'CA', country: 'USA',
      capital
    : false, population: 860000
    });
    await citiesRef
    .doc('LA').set({
      name
    : 'Los Angeles', state: 'CA', country: 'USA',
      capital
    : false, population: 3900000
    });
    await citiesRef
    .doc('DC').set({
      name
    : 'Washington, D.C.', state: null, country: 'USA',
      capital
    : true, population: 680000
    });
    await citiesRef
    .doc('TOK').set({
      name
    : 'Tokyo', state: null, country: 'Japan',
      capital
    : true, population: 9000000
    });
    await citiesRef
    .doc('BJ').set({
      name
    : 'Beijing', state: null, country: 'China',
      capital
    : true, population: 21500000
    });

    import (
           
    "context"

           
    "cloud.google.com/go/firestore"
    )

    func prepareRetrieve
    (ctx context.Context, client *firestore.Client) error {
            cities
    := []struct {
                    id
    string
                    c  
    City
           
    }{
                   
    {id: "SF", c: City{Name: "San Francisco", State: "CA", Country: "USA", Capital: false, Population: 860000}},
                   
    {id: "LA", c: City{Name: "Los Angeles", State: "CA", Country: "USA", Capital: false, Population: 3900000}},
                   
    {id: "DC", c: City{Name: "Washington D.C.", Country: "USA", Capital: true, Population: 680000}},
                   
    {id: "TOK", c: City{Name: "Tokyo", Country: "Japan", Capital: true, Population: 9000000}},
                   
    {id: "BJ", c: City{Name: "Beijing", Country: "China", Capital: true, Population: 21500000}},
           
    }
           
    for _, c := range cities {
                    _
    , err := client.Collection("cities").Doc(c.id).Set(ctx, c.c)
                   
    if err != nil {
                           
    return err
                   
    }
           
    }
           
    return nil
    }

    PHP

    Para obtener más información sobre cómo instalar y crear un cliente de Cloud Firestore, consulte Bibliotecas de clientes de Cloud Firestore .

    $citiesRef = $db->collection('samples/php/cities');
    $citiesRef
    ->document('SF')->set([
       
    'name' => 'San Francisco',
       
    'state' => 'CA',
       
    'country' => 'USA',
       
    'capital' => false,
       
    'population' => 860000
    ]);
    $citiesRef
    ->document('LA')->set([
       
    'name' => 'Los Angeles',
       
    'state' => 'CA',
       
    'country' => 'USA',
       
    'capital' => false,
       
    'population' => 3900000
    ]);
    $citiesRef
    ->document('DC')->set([
       
    'name' => 'Washington D.C.',
       
    'state' => null,
       
    'country' => 'USA',
       
    'capital' => true,
       
    'population' => 680000
    ]);
    $citiesRef
    ->document('TOK')->set([
       
    'name' => 'Tokyo',
       
    'state' => null,
       
    'country' => 'Japan',
       
    'capital' => true,
       
    'population' => 9000000
    ]);
    $citiesRef
    ->document('BJ')->set([
       
    'name' => 'Beijing',
       
    'state' => null,
       
    'country' => 'China',
       
    'capital' => true,
       
    'population' => 21500000
    ]);
    printf
    ('Added example cities data to the cities collection.' . PHP_EOL);
    CollectionReference citiesRef = db.Collection("cities");
    citiesRef
    .Document("SF").SetAsync(new Dictionary<string, object>(){
           
    { "Name", "San Francisco" },
           
    { "State", "CA" },
           
    { "Country", "USA" },
           
    { "Capital", false },
           
    { "Population", 860000 }
       
    }).ContinueWithOnMainThread(task =>
            citiesRef
    .Document("LA").SetAsync(new Dictionary<string, object>(){
               
    { "Name", "Los Angeles" },
               
    { "State", "CA" },
               
    { "Country", "USA" },
               
    { "Capital", false },
               
    { "Population", 3900000 }
           
    })
    ).ContinueWithOnMainThread(task =>
        citiesRef
    .Document("DC").SetAsync(new Dictionary<string, object>(){
               
    { "Name", "Washington D.C." },
               
    { "State", null },
               
    { "Country", "USA" },
               
    { "Capital", true },
               
    { "Population", 680000 }
       
    })
    ).ContinueWithOnMainThread(task =>
        citiesRef
    .Document("TOK").SetAsync(new Dictionary<string, object>(){
               
    { "Name", "Tokyo" },
               
    { "State", null },
               
    { "Country", "Japan" },
               
    { "Capital", true },
               
    { "Population", 9000000 }
       
    })
    ).ContinueWithOnMainThread(task =>
        citiesRef
    .Document("BJ").SetAsync(new Dictionary<string, object>(){
               
    { "Name", "Beijing" },
               
    { "State", null },
               
    { "Country", "China" },
               
    { "Capital", true },
               
    { "Population", 21500000 }
       
    })
    );
    CollectionReference citiesRef = db.Collection("cities");
    await citiesRef
    .Document("SF").SetAsync(new Dictionary<string, object>(){
       
    { "Name", "San Francisco" },
       
    { "State", "CA" },
       
    { "Country", "USA" },
       
    { "Capital", false },
       
    { "Population", 860000 }
    });
    await citiesRef
    .Document("LA").SetAsync(new Dictionary<string, object>(){
       
    { "Name", "Los Angeles" },
       
    { "State", "CA" },
       
    { "Country", "USA" },
       
    { "Capital", false },
       
    { "Population", 3900000 }
    });
    await citiesRef
    .Document("DC").SetAsync(new Dictionary<string, object>(){
       
    { "Name", "Washington D.C." },
       
    { "State", null },
       
    { "Country", "USA" },
       
    { "Capital", true },
       
    { "Population", 680000 }
    });
    await citiesRef
    .Document("TOK").SetAsync(new Dictionary<string, object>(){
       
    { "Name", "Tokyo" },
       
    { "State", null },
       
    { "Country", "Japan" },
       
    { "Capital", true },
       
    { "Population", 9000000 }
    });
    await citiesRef
    .Document("BJ").SetAsync(new Dictionary<string, object>(){
       
    { "Name", "Beijing" },
       
    { "State", null },
       
    { "Country", "China" },
       
    { "Capital", true },
       
    { "Population", 21500000 }
    });
    Console.WriteLine("Added example cities data to the cities collection.");
    cities_ref = firestore.col collection_path
    cities_ref
    .doc("SF").set(
     
    {
        name
    :       "San Francisco",
        state
    :      "CA",
        country
    :    "USA",
        capital
    :    false,
        population
    : 860_000
     
    }
    )
    cities_ref
    .doc("LA").set(
     
    {
        name
    :       "Los Angeles",
        state
    :      "CA",
        country
    :    "USA",
        capital
    :    false,
        population
    : 3_900_000
     
    }
    )
    cities_ref
    .doc("DC").set(
     
    {
        name
    :       "Washington D.C.",
        state
    :      nil,
        country
    :    "USA",
        capital
    :    true,
        population
    : 680_000
     
    }
    )
    cities_ref
    .doc("TOK").set(
     
    {
        name
    :       "Tokyo",
        state
    :      nil,
        country
    :    "Japan",
        capital
    :    true,
        population
    : 9_000_000
     
    }
    )
    cities_ref
    .doc("BJ").set(
     
    {
        name
    :       "Beijing",
        state
    :      nil,
        country
    :    "China",
        capital
    :    true,
        population
    : 21_500_000
     
    }
    )

    obtener un documento

    El siguiente ejemplo muestra cómo recuperar el contenido de un solo documento usando get() :

    import { doc, getDoc } from "firebase/firestore";

    const docRef = doc(db, "cities", "SF");
    const docSnap = await getDoc(docRef);

    if (docSnap.exists()) {
      console
    .log("Document data:", docSnap.data());
    } else {
     
    // docSnap.data() will be undefined in this case
      console
    .log("No such document!");
    }
    var docRef = db.collection("cities").doc("SF");

    docRef
    .get().then((doc) => {
       
    if (doc.exists) {
            console
    .log("Document data:", doc.data());
       
    } else {
           
    // doc.data() will be undefined in this case
            console
    .log("No such document!");
       
    }
    }).catch((error) => {
        console
    .log("Error getting document:", error);
    });
    Nota: Este producto no está disponible en destinos watchOS y App Clip.
    let docRef = db.collection("cities").document("SF")

    do {
     
    let document = try await docRef.getDocument()
     
    if document.exists {
       
    let dataDescription = document.data().map(String.init(describing:)) ?? "nil"
        print
    ("Document data: \(dataDescription)")
     
    } else {
        print
    ("Document does not exist")
     
    }
    } catch {
      print
    ("Error getting document: \(error)")
    }
    Nota: Este producto no está disponible en destinos watchOS y App Clip.
    FIRDocumentReference *docRef =
       
    [[self.db collectionWithPath:@"cities"] documentWithPath:@"SF"];
    [docRef getDocumentWithCompletion:^(FIRDocumentSnapshot *snapshot, NSError *error) {
     
    if (snapshot.exists) {
       
    // Document data may be nil if the document exists but has no keys or values.
       
    NSLog(@"Document data: %@", snapshot.data);
     
    } else {
       
    NSLog(@"Document does not exist");
     
    }
    }];
    val docRef = db.collection("cities").document("SF")
    docRef
    .get()
       
    .addOnSuccessListener { document ->
           
    if (document != null) {
               
    Log.d(TAG, "DocumentSnapshot data: ${document.data}")
           
    } else {
               
    Log.d(TAG, "No such document")
           
    }
       
    }
       
    .addOnFailureListener { exception ->
           
    Log.d(TAG, "get failed with ", exception)
       
    }
    DocumentReference docRef = db.collection("cities").document("SF");
    docRef
    .get().addOnCompleteListener(new OnCompleteListener<DocumentSnapshot>() {
       
    @Override
       
    public void onComplete(@NonNull Task<DocumentSnapshot> task) {
           
    if (task.isSuccessful()) {
               
    DocumentSnapshot document = task.getResult();
               
    if (document.exists()) {
                   
    Log.d(TAG, "DocumentSnapshot data: " + document.getData());
               
    } else {
                   
    Log.d(TAG, "No such document");
               
    }
           
    } else {
               
    Log.d(TAG, "get failed with ", task.getException());
           
    }
       
    }
    });
    final docRef = db.collection("cities").doc("SF");
    docRef
    .get().then(
     
    (DocumentSnapshot doc) {
       
    final data = doc.data() as Map<String, dynamic>;
       
    // ...
     
    },
      onError
    : (e) => print("Error getting document: $e"),
    );
    DocumentReference docRef = db.collection("cities").document("SF");
    // asynchronously retrieve the document
    ApiFuture<DocumentSnapshot> future = docRef.get();
    // ...
    // future.get() blocks on response
    DocumentSnapshot document = future.get();
    if (document.exists()) {
     
    System.out.println("Document data: " + document.getData());
    } else {
     
    System.out.println("No such document!");
    }
    doc_ref = db.collection("cities").document("SF")

    doc
    = doc_ref.get()
    if doc.exists:
       
    print(f"Document data: {doc.to_dict()}")
    else:
       
    print("No such document!")
    doc_ref = db.collection("cities").document("SF")

    doc
    = await doc_ref.get()
    if doc.exists:
       
    print(f"Document data: {doc.to_dict()}")
    else:
       
    print("No such document!")
    DocumentReference doc_ref = db->Collection("cities").Document("SF");
    doc_ref
    .Get().OnCompletion([](const Future<DocumentSnapshot>& future) {
     
    if (future.error() == Error::kErrorOk) {
       
    const DocumentSnapshot& document = *future.result();
       
    if (document.exists()) {
          std
    ::cout << "DocumentSnapshot id: " << document.id() << std::endl;
       
    } else {
          std
    ::cout << "no such document" << std::endl;
       
    }
     
    } else {
        std
    ::cout << "Get failed with: " << future.error_message() << std::endl;
     
    }
    });
    const cityRef = db.collection('cities').doc('SF');
    const doc = await cityRef.get();
    if (!doc.exists) {
      console
    .log('No such document!');
    } else {
      console
    .log('Document data:', doc.data());
    }

    import (
           
    "context"
           
    "fmt"

           
    "cloud.google.com/go/firestore"
    )

    func docAsMap
    (ctx context.Context, client *firestore.Client) (map[string]interface{}, error) {
            dsnap
    , err := client.Collection("cities").Doc("SF").Get(ctx)
           
    if err != nil {
                   
    return nil, err
           
    }
            m
    := dsnap.Data()
            fmt
    .Printf("Document data: %#v\n", m)
           
    return m, nil
    }

    PHP

    Para obtener más información sobre cómo instalar y crear un cliente de Cloud Firestore, consulte Bibliotecas de clientes de Cloud Firestore .

    $docRef = $db->collection('samples/php/cities')->document('SF');
    $snapshot
    = $docRef->snapshot();

    if ($snapshot->exists()) {
        printf
    ('Document data:' . PHP_EOL);
        print_r
    ($snapshot->data());
    } else {
        printf
    ('Document %s does not exist!' . PHP_EOL, $snapshot->id());
    }
    DocumentReference docRef = db.Collection("cities").Document("SF");
    docRef
    .GetSnapshotAsync().ContinueWithOnMainThread(task =>
    {
     
    DocumentSnapshot snapshot = task.Result;
     
    if (snapshot.Exists) {
       
    Debug.Log(String.Format("Document data for {0} document:", snapshot.Id));
       
    Dictionary<string, object> city = snapshot.ToDictionary();
       
    foreach (KeyValuePair<string, object> pair in city) {
         
    Debug.Log(String.Format("{0}: {1}", pair.Key, pair.Value));
       
    }
     
    } else {
       
    Debug.Log(String.Format("Document {0} does not exist!", snapshot.Id));
     
    }
    });
    DocumentReference docRef = db.Collection("cities").Document("SF");
    DocumentSnapshot snapshot = await docRef.GetSnapshotAsync();
    if (snapshot.Exists)
    {
       
    Console.WriteLine("Document data for {0} document:", snapshot.Id);
       
    Dictionary<string, object> city = snapshot.ToDictionary();
       
    foreach (KeyValuePair<string, object> pair in city)
       
    {
           
    Console.WriteLine("{0}: {1}", pair.Key, pair.Value);
       
    }
    }
    else
    {
       
    Console.WriteLine("Document {0} does not exist!", snapshot.Id);
    }
    doc_ref  = firestore.doc "#{collection_path}/SF"
    snapshot
    = doc_ref.get
    if snapshot.exists?
      puts
    "#{snapshot.document_id} data: #{snapshot.data}."
    else
      puts
    "Document #{snapshot.document_id} does not exist!"
    end

    Opciones de fuente

    Para plataformas con soporte sin conexión, puede configurar la opción source para controlar cómo una get utiliza el caché sin conexión.

    De forma predeterminada, una llamada get intentará recuperar la última instantánea del documento de su base de datos. En plataformas con soporte sin conexión, la biblioteca cliente utilizará el caché sin conexión si la red no está disponible o si la solicitud se agota.

    Puede especificar la opción source en una llamada get() para cambiar el comportamiento predeterminado. Puede buscar solo desde la base de datos e ignorar el caché sin conexión, o puede buscar solo desde el caché sin conexión. Por ejemplo:

    import { doc, getDocFromCache } from "firebase/firestore";

    const docRef = doc(db, "cities", "SF");

    // Get a document, forcing the SDK to fetch from the offline cache.
    try {
     
    const doc = await getDocFromCache(docRef);

     
    // Document was found in the cache. If no cached document exists,
     
    // an error will be returned to the 'catch' block below.
      console
    .log("Cached document data:", doc.data());
    } catch (e) {
      console
    .log("Error getting cached document:", e);
    }
    var docRef = db.collection("cities").doc("SF");

    // Valid options for source are 'server', 'cache', or
    // 'default'. See https://firebase.google.com/docs/reference/js/v8/firebase.firestore.GetOptions
    // for more information.
    var getOptions = {
        source
    : 'cache'
    };

    // Get a document, forcing the SDK to fetch from the offline cache.
    docRef
    .get(getOptions).then((doc) => {
       
    // Document was found in the cache. If no cached document exists,
       
    // an error will be returned to the 'catch' block below.
        console
    .log("Cached document data:", doc.data());
    }).catch((error) => {
        console
    .log("Error getting cached document:", error);
    });
    Nota: Este producto no está disponible en destinos watchOS y App Clip.
    let docRef = db.collection("cities").document("SF")

    do {
     
    // Force the SDK to fetch the document from the cache. Could also specify
      // FirestoreSource.server or FirestoreSource.default.
      let document = try await docRef.getDocument(source: .cache)
     
    if document.exists {
       
    let dataDescription = document.data().map(String.init(describing:)) ?? "nil"
        print
    ("Cached document data: \(dataDescription)")
     
    } else {
        print
    ("Document does not exist in cache")
     
    }
    } catch {
      print
    ("Error getting document: \(error)")
    }
    Nota: Este producto no está disponible en destinos watchOS y App Clip.
    FIRDocumentReference *docRef =
    [[self.db collectionWithPath:@"cities"] documentWithPath:@"SF"];

    // Force the SDK to fetch the document from the cache. Could also specify
    // FIRFirestoreSourceServer or FIRFirestoreSourceDefault.
    [docRef getDocumentWithSource:FIRFirestoreSourceCache
                       completion
    :^(FIRDocumentSnapshot *snapshot, NSError *error) {
     
    if (snapshot != NULL) {
       
    // The document data was found in the cache.
       
    NSLog(@"Cached document data: %@", snapshot.data);
     
    } else {
       
    // The document data was not found in the cache.
       
    NSLog(@"Document does not exist in cache: %@", error);
     
    }
    }];
    val docRef = db.collection("cities").document("SF")

    // Source can be CACHE, SERVER, or DEFAULT.
    val source = Source.CACHE

    // Get the document, forcing the SDK to use the offline cache
    docRef
    .get(source).addOnCompleteListener { task ->
       
    if (task.isSuccessful) {
           
    // Document found in the offline cache
           
    val document = task.result
           
    Log.d(TAG, "Cached document data: ${document?.data}")
       
    } else {
           
    Log.d(TAG, "Cached get failed: ", task.exception)
       
    }
    }
    DocumentReference docRef = db.collection("cities").document("SF");

    // Source can be CACHE, SERVER, or DEFAULT.
    Source source = Source.CACHE;

    // Get the document, forcing the SDK to use the offline cache
    docRef
    .get(source).addOnCompleteListener(new OnCompleteListener<DocumentSnapshot>() {
       
    @Override
       
    public void onComplete(@NonNull Task<DocumentSnapshot> task) {
           
    if (task.isSuccessful()) {
               
    // Document found in the offline cache
               
    DocumentSnapshot document = task.getResult();
               
    Log.d(TAG, "Cached document data: " + document.getData());
           
    } else {
               
    Log.d(TAG, "Cached get failed: ", task.getException());
           
    }
       
    }
    });
    final docRef = db.collection("cities").doc("SF");

    // Source can be CACHE, SERVER, or DEFAULT.
    const source = Source.cache;

    docRef
    .get(const GetOptions(source: source)).then(
         
    (res) => print("Successfully completed"),
          onError
    : (e) => print("Error completing: $e"),
       
    );

    No es compatible con el SDK de Java.

    No es compatible con el SDK de Python.

    DocumentReference doc_ref = db->Collection("cities").Document("SF");
    Source source = Source::kCache;
    doc_ref
    .Get(source).OnCompletion([](const Future<DocumentSnapshot>& future) {
     
    if (future.error() == Error::kErrorOk) {
       
    const DocumentSnapshot& document = *future.result();
       
    if (document.exists()) {
          std
    ::cout << "Cached document id: " << document.id() << std::endl;
       
    } else {
       
    }
     
    } else {
        std
    ::cout << "Cached get failed: " << future.error_message() << std::endl;
     
    }
    });

    No es compatible con el SDK de Node.js.

    No es compatible con Go SDK.

    No es compatible con el SDK de PHP.

    No es compatible con el SDK de Unity.

    No es compatible con el SDK de C#.

    No es compatible con el SDK de Ruby.

    Objetos personalizados

    El ejemplo anterior recuperó el contenido del documento como un mapa, pero en algunos idiomas suele ser más conveniente utilizar un tipo de objeto personalizado. En Agregar datos , definiste una clase City que usaste para definir cada ciudad. Puedes convertir tu documento nuevamente en un objeto City :

    Para usar objetos personalizados, debe definir una función FirestoreDataConverter para su clase. Por ejemplo:

    class City {
        constructor
    (name, state, country ) {
           
    this.name = name;
           
    this.state = state;
           
    this.country = country;
       
    }
        toString
    () {
           
    return this.name + ', ' + this.state + ', ' + this.country;
       
    }
    }

    // Firestore data converter
    const cityConverter = {
        toFirestore
    : (city) => {
           
    return {
                name
    : city.name,
                state
    : city.state,
                country
    : city.country
               
    };
       
    },
        fromFirestore
    : (snapshot, options) => {
           
    const data = snapshot.data(options);
           
    return new City(data.name, data.state, data.country);
       
    }
    };

    Para usar objetos personalizados, debe definir una función FirestoreDataConverter para su clase. Por ejemplo:

    class City {
        constructor
    (name, state, country ) {
           
    this.name = name;
           
    this.state = state;
           
    this.country = country;
       
    }
        toString
    () {
           
    return this.name + ', ' + this.state + ', ' + this.country;
       
    }
    }

    // Firestore data converter
    var cityConverter = {
        toFirestore
    : function(city) {
           
    return {
                name
    : city.name,
                state
    : city.state,
                country
    : city.country
               
    };
       
    },
        fromFirestore
    : function(snapshot, options){
           
    const data = snapshot.data(options);
           
    return new City(data.name, data.state, data.country);
       
    }
    };

    Llame a su convertidor de datos con sus operaciones de lectura. Después de la conversión, puede acceder a métodos de objetos personalizados:

    import { doc, getDoc} from "firebase/firestore"; 

    const ref = doc(db, "cities", "LA").withConverter(cityConverter);
    const docSnap = await getDoc(ref);
    if (docSnap.exists()) {
     
    // Convert to City object
     
    const city = docSnap.data();
     
    // Use a City instance method
      console
    .log(city.toString());
    } else {
      console
    .log("No such document!");
    }

    Llame a su convertidor de datos con sus operaciones de lectura. Después de la conversión, puede acceder a métodos de objetos personalizados:

    db.collection("cities").doc("LA")
     
    .withConverter(cityConverter)
     
    .get().then((doc) => {
       
    if (doc.exists){
         
    // Convert to City object
         
    var city = doc.data();
         
    // Use a City instance method
          console
    .log(city.toString());
       
    } else {
          console
    .log("No such document!");
       
    }}).catch((error) => {
          console
    .log("Error getting document:", error);
       
    });
    Nota: Este producto no está disponible en destinos watchOS y App Clip.

    Para admitir la serialización automática de tipos en Swift, su tipo debe ajustarse al protocolo Codable .

    let docRef = db.collection("cities").document("BJ")

    do {
     
    let city = try await docRef.getDocument(as: City.self)
      print
    ("City: \(city)")
    } catch {
      print
    ("Error decoding city: \(error)")
    }
    Nota: Este producto no está disponible en destinos watchOS y App Clip.

    En Objective-C debes hacer esto manualmente.

    FIRDocumentReference *docRef =
    [[self.db collectionWithPath:@"cities"] documentWithPath:@"BJ"];
    [docRef getDocumentWithCompletion:^(FIRDocumentSnapshot *snapshot, NSError *error) {
     
    FSTCity *city = [[FSTCity alloc] initWithDictionary:snapshot.data];
     
    if (city != nil) {
       
    NSLog(@"City: %@", city);
     
    } else {
       
    NSLog(@"Document does not exist");
     
    }
    }];
    val docRef = db.collection("cities").document("BJ")
    docRef
    .get().addOnSuccessListener { documentSnapshot ->
       
    val city = documentSnapshot.toObject<City>()
    }

    Importante: cada clase personalizada debe tener un constructor público que no acepte argumentos. Además, la clase debe incluir un captador público para cada propiedad.

    DocumentReference docRef = db.collection("cities").document("BJ");
    docRef
    .get().addOnSuccessListener(new OnSuccessListener<DocumentSnapshot>() {
       
    @Override
       
    public void onSuccess(DocumentSnapshot documentSnapshot) {
           
    City city = documentSnapshot.toObject(City.class);
       
    }
    });

    Para usar objetos personalizados, debes definir funciones de conversión de datos de Firestore para tu clase. Por ejemplo:

    class City {
     
    final String? name;
     
    final String? state;
     
    final String? country;
     
    final bool? capital;
     
    final int? population;
     
    final List<String>? regions;

     
    City({
       
    this.name,
       
    this.state,
       
    this.country,
       
    this.capital,
       
    this.population,
       
    this.regions,
     
    });

      factory
    City.fromFirestore(
       
    DocumentSnapshot<Map<String, dynamic>> snapshot,
       
    SnapshotOptions? options,
     
    ) {
       
    final data = snapshot.data();
       
    return City(
          name
    : data?['name'],
          state
    : data?['state'],
          country
    : data?['country'],
          capital
    : data?['capital'],
          population
    : data?['population'],
          regions
    :
              data
    ?['regions'] is Iterable ? List.from(data?['regions']) : null,
       
    );
     
    }

     
    Map<String, dynamic> toFirestore() {
       
    return {
         
    if (name != null) "name": name,
         
    if (state != null) "state": state,
         
    if (country != null) "country": country,
         
    if (capital != null) "capital": capital,
         
    if (population != null) "population": population,
         
    if (regions != null) "regions": regions,
       
    };
     
    }
    }

    Luego, cree una referencia de documento con sus funciones de conversión de datos. Cualquier operación de lectura que realice utilizando esta referencia devolverá instancias de su clase personalizada:

    final ref = db.collection("cities").doc("LA").withConverter(
          fromFirestore
    : City.fromFirestore,
          toFirestore
    : (City city, _) => city.toFirestore(),
       
    );
    final docSnap = await ref.get();
    final city = docSnap.data(); // Convert to City object
    if (city != null) {
     
    print(city);
    } else {
     
    print("No such document.");
    }

    Cada clase personalizada debe tener un constructor público que no acepte argumentos. Además, la clase debe incluir un captador público para cada propiedad.

    DocumentReference docRef = db.collection("cities").document("BJ");
    // asynchronously retrieve the document
    ApiFuture<DocumentSnapshot> future = docRef.get();
    // block on response
    DocumentSnapshot document = future.get();
    City city = null;
    if (document.exists()) {
     
    // convert document to POJO
      city
    = document.toObject(City.class);
     
    System.out.println(city);
    } else {
     
    System.out.println("No such document!");
    }
    doc_ref = db.collection("cities").document("BJ")

    doc
    = doc_ref.get()
    city
    = City.from_dict(doc.to_dict())
    print(city)
    doc_ref = db.collection("cities").document("BJ")

    doc
    = await doc_ref.get()
    city
    = City.from_dict(doc.to_dict())
    print(city)
    // This is not yet supported.

    Node.js utiliza objetos JavaScript.


    import (
           
    "context"
           
    "fmt"

           
    "cloud.google.com/go/firestore"
    )

    func docAsEntity
    (ctx context.Context, client *firestore.Client) (*City, error) {
            dsnap
    , err := client.Collection("cities").Doc("BJ").Get(ctx)
           
    if err != nil {
                   
    return nil, err
           
    }
           
    var c City
            dsnap
    .DataTo(&c)
            fmt
    .Printf("Document data: %#v\n", c)
           
    return &c, nil
    }

    PHP

    Para obtener más información sobre cómo instalar y crear un cliente de Cloud Firestore, consulte Bibliotecas de clientes de Cloud Firestore .

    $docRef = $db->collection('samples/php/cities')->document('SF');
    $snapshot
    = $docRef->snapshot();
    $city
    = City::fromArray($snapshot->data());

    if ($snapshot->exists()) {
        printf
    ('Document data:' . PHP_EOL);
       
    print((string) $city);
    } else {
        printf
    ('Document %s does not exist!' . PHP_EOL, $snapshot->id());
    }
    DocumentReference docRef = db.Collection("cities").Document("BJ");

    docRef
    .GetSnapshotAsync().ContinueWith((task) =>
    {
     
    var snapshot = task.Result;
     
    if (snapshot.Exists)
     
    {
       
    Debug.Log(String.Format("Document data for {0} document:", snapshot.Id));
       
    City city = snapshot.ConvertTo<City>();
       
    Debug.Log(String.Format("Name: {0}", city.Name));
       
    Debug.Log(String.Format("State: {0}", city.State));
       
    Debug.Log(String.Format("Country: {0}", city.Country));
       
    Debug.Log(String.Format("Capital: {0}", city.Capital));
       
    Debug.Log(String.Format("Population: {0}", city.Population));
     
    }
     
    else
     
    {
       
    Debug.Log(String.Format("Document {0} does not exist!", snapshot.Id));
     
    }
    });
    DocumentReference docRef = db.Collection("cities").Document("BJ");
    DocumentSnapshot snapshot = await docRef.GetSnapshotAsync();
    if (snapshot.Exists)
    {
       
    Console.WriteLine("Document data for {0} document:", snapshot.Id);
       
    City city = snapshot.ConvertTo<City>();
       
    Console.WriteLine("Name: {0}", city.Name);
       
    Console.WriteLine("State: {0}", city.State);
       
    Console.WriteLine("Country: {0}", city.Country);
       
    Console.WriteLine("Capital: {0}", city.Capital);
       
    Console.WriteLine("Population: {0}", city.Population);
    }
    else
    {
       
    Console.WriteLine("Document {0} does not exist!", snapshot.Id);
    }

    No aplicable para Rubí.

    Obtenga varios documentos de una colección

    También puede recuperar varios documentos con una sola solicitud consultando documentos en una colección. Por ejemplo, puedes usar where() para consultar todos los documentos que cumplen una determinada condición y luego usar get() para recuperar los resultados:

    import { collection, query, where, getDocs } from "firebase/firestore";

    const q = query(collection(db, "cities"), where("capital", "==", true));

    const querySnapshot = await getDocs(q);
    querySnapshot
    .forEach((doc) => {
     
    // doc.data() is never undefined for query doc snapshots
      console
    .log(doc.id, " => ", doc.data());
    });
    db.collection("cities").where("capital", "==", true)
       
    .get()
       
    .then((querySnapshot) => {
            querySnapshot
    .forEach((doc) => {
               
    // doc.data() is never undefined for query doc snapshots
                console
    .log(doc.id, " => ", doc.data());
           
    });
       
    })
       
    .catch((error) => {
            console
    .log("Error getting documents: ", error);
       
    });
    Nota: Este producto no está disponible en destinos watchOS y App Clip.
    do {
     
    let querySnapshot = try await db.collection("cities").whereField("capital", isEqualTo: true)
       
    .getDocuments()
     
    for document in querySnapshot.documents {
        print
    ("\(document.documentID) => \(document.data())")
     
    }
    } catch {
      print
    ("Error getting documents: \(error)")
    }
    Nota: Este producto no está disponible en destinos watchOS y App Clip.
    [[[self.db collectionWithPath:@"cities"] queryWhereField:@"capital" isEqualTo:@(YES)]
        getDocumentsWithCompletion
    :^(FIRQuerySnapshot *snapshot, NSError *error) {
         
    if (error != nil) {
           
    NSLog(@"Error getting documents: %@", error);
         
    } else {
           
    for (FIRDocumentSnapshot *document in snapshot.documents) {
             
    NSLog(@"%@ => %@", document.documentID, document.data);
           
    }
         
    }
       
    }];
    db.collection("cities")
       
    .whereEqualTo("capital", true)
       
    .get()
       
    .addOnSuccessListener { documents ->
           
    for (document in documents) {
               
    Log.d(TAG, "${document.id} => ${document.data}")
           
    }
       
    }
       
    .addOnFailureListener { exception ->
           
    Log.w(TAG, "Error getting documents: ", exception)
       
    }
    db.collection("cities")
           
    .whereEqualTo("capital", true)
           
    .get()
           
    .addOnCompleteListener(new OnCompleteListener<QuerySnapshot>() {
               
    @Override
               
    public void onComplete(@NonNull Task<QuerySnapshot> task) {
                   
    if (task.isSuccessful()) {
                       
    for (QueryDocumentSnapshot document : task.getResult()) {
                           
    Log.d(TAG, document.getId() + " => " + document.getData());
                       
    }
                   
    } else {
                       
    Log.d(TAG, "Error getting documents: ", task.getException());
                   
    }
               
    }
           
    });
    db.collection("cities").where("capital", isEqualTo: true).get().then(
     
    (querySnapshot) {
       
    print("Successfully completed");
       
    for (var docSnapshot in querySnapshot.docs) {
         
    print('${docSnapshot.id} => ${docSnapshot.data()}');
       
    }
     
    },
      onError
    : (e) => print("Error completing: $e"),
    );
    // asynchronously retrieve multiple documents
    ApiFuture<QuerySnapshot> future = db.collection("cities").whereEqualTo("capital", true).get();
    // future.get() blocks on response
    List<QueryDocumentSnapshot> documents = future.get().getDocuments();
    for (DocumentSnapshot document : documents) {
     
    System.out.println(document.getId() + " => " + document.toObject(City.class));
    }
    # Note: Use of CollectionRef stream() is prefered to get()
    docs
    = (
        db
    .collection("cities")
       
    .where(filter=FieldFilter("capital", "==", True))
       
    .stream()
    )

    for doc in docs:
       
    print(f"{doc.id} => {doc.to_dict()}")
    # Note: Use of CollectionRef stream() is prefered to get()
    docs
    = (
        db
    .collection("cities")
       
    .where(filter=FieldFilter("capital", "==", True))
       
    .stream()
    )

    async
    for doc in docs:
       
    print(f"{doc.id} => {doc.to_dict()}")
    db->Collection("cities")
       
    .WhereEqualTo("capital", FieldValue::Boolean(true))
       
    .Get()
       
    .OnCompletion([](const Future<QuerySnapshot>& future) {
         
    if (future.error() == Error::kErrorOk) {
           
    for (const DocumentSnapshot& document :
                 future
    .result()->documents()) {
              std
    ::cout << document << std::endl;
           
    }
         
    } else {
            std
    ::cout << "Error getting documents: " << future.error_message()
                     
    << std::endl;
         
    }
       
    });
    const citiesRef = db.collection('cities');
    const snapshot = await citiesRef.where('capital', '==', true).get();
    if (snapshot.empty) {
      console
    .log('No matching documents.');
     
    return;
    }  

    snapshot
    .forEach(doc => {
      console
    .log(doc.id, '=>', doc.data());
    });

    import (
           
    "context"
           
    "fmt"

           
    "cloud.google.com/go/firestore"
           
    "google.golang.org/api/iterator"
    )

    func multipleDocs
    (ctx context.Context, client *firestore.Client) error {
            fmt
    .Println("All capital cities:")
            iter
    := client.Collection("cities").Where("capital", "==", true).Documents(ctx)
           
    for {
                    doc
    , err := iter.Next()
                   
    if err == iterator.Done {
                           
    break
                   
    }
                   
    if err != nil {
                           
    return err
                   
    }
                    fmt
    .Println(doc.Data())
           
    }
           
    return nil
    }

    PHP

    Para obtener más información sobre cómo instalar y crear un cliente de Cloud Firestore, consulte Bibliotecas de clientes de Cloud Firestore .

    $citiesRef = $db->collection('samples/php/cities');
    $query
    = $citiesRef->where('capital', '=', true);
    $documents
    = $query->documents();
    foreach ($documents as $document) {
       
    if ($document->exists()) {
            printf
    ('Document data for document %s:' . PHP_EOL, $document->id());
            print_r
    ($document->data());
            printf
    (PHP_EOL);
       
    } else {
            printf
    ('Document %s does not exist!' . PHP_EOL, $document->id());
       
    }
    }
    Query capitalQuery = db.Collection("cities").WhereEqualTo("Capital", true);
    capitalQuery
    .GetSnapshotAsync().ContinueWithOnMainThread(task => {
     
    QuerySnapshot capitalQuerySnapshot = task.Result;
     
    foreach (DocumentSnapshot documentSnapshot in capitalQuerySnapshot.Documents) {
       
    Debug.Log(String.Format("Document data for {0} document:", documentSnapshot.Id));
       
    Dictionary<string, object> city = documentSnapshot.ToDictionary();
       
    foreach (KeyValuePair<string, object> pair in city) {
         
    Debug.Log(String.Format("{0}: {1}", pair.Key, pair.Value));
       
    }

       
    // Newline to separate entries
       
    Debug.Log("");
     
    };
    });
    Query capitalQuery = db.Collection("cities").WhereEqualTo("Capital", true);
    QuerySnapshot capitalQuerySnapshot = await capitalQuery.GetSnapshotAsync();
    foreach (DocumentSnapshot documentSnapshot in capitalQuerySnapshot.Documents)
    {
       
    Console.WriteLine("Document data for {0} document:", documentSnapshot.Id);
       
    Dictionary<string, object> city = documentSnapshot.ToDictionary();
       
    foreach (KeyValuePair<string, object> pair in city)
       
    {
           
    Console.WriteLine("{0}: {1}", pair.Key, pair.Value);
       
    }
       
    Console.WriteLine("");
    }
    cities_ref = firestore.col collection_path

    query
    = cities_ref.where "capital", "=", true

    query
    .get do |city|
      puts
    "#{city.document_id} data: #{city.data}."
    end

    De forma predeterminada, Cloud Firestore recupera todos los documentos que satisfacen la consulta en orden ascendente por ID de documento, pero puedes ordenar y limitar los datos devueltos .

    Obtener todos los documentos de una colección

    Además, puedes recuperar todos los documentos de una colección omitiendo por completo el filtro where() :

    import { collection, getDocs } from "firebase/firestore";

    const querySnapshot = await getDocs(collection(db, "cities"));
    querySnapshot
    .forEach((doc) => {
     
    // doc.data() is never undefined for query doc snapshots
      console
    .log(doc.id, " => ", doc.data());
    });
    db.collection("cities").get().then((querySnapshot) => {
        querySnapshot
    .forEach((doc) => {
           
    // doc.data() is never undefined for query doc snapshots
            console
    .log(doc.id, " => ", doc.data());
       
    });
    });
    Nota: Este producto no está disponible en destinos watchOS y App Clip.
    do {
     
    let querySnapshot = try await db.collection("cities").getDocuments()
     
    for document in querySnapshot.documents {
        print
    ("\(document.documentID) => \(document.data())")
     
    }
    } catch {
      print
    ("Error getting documents: \(error)")
    }
    Nota: Este producto no está disponible en destinos watchOS y App Clip.
    [[self.db collectionWithPath:@"cities"]
        getDocumentsWithCompletion
    :^(FIRQuerySnapshot *snapshot, NSError *error) {
         
    if (error != nil) {
           
    NSLog(@"Error getting documents: %@", error);
         
    } else {
           
    for (FIRDocumentSnapshot *document in snapshot.documents) {
             
    NSLog(@"%@ => %@", document.documentID, document.data);
           
    }
         
    }
       
    }];
    db.collection("cities")
       
    .get()
       
    .addOnSuccessListener { result ->
           
    for (document in result) {
               
    Log.d(TAG, "${document.id} => ${document.data}")
           
    }
       
    }
       
    .addOnFailureListener { exception ->
           
    Log.d(TAG, "Error getting documents: ", exception)
       
    }
    db.collection("cities")
           
    .get()
           
    .addOnCompleteListener(new OnCompleteListener<QuerySnapshot>() {
               
    @Override
               
    public void onComplete(@NonNull Task<QuerySnapshot> task) {
                   
    if (task.isSuccessful()) {
                       
    for (QueryDocumentSnapshot document : task.getResult()) {
                           
    Log.d(TAG, document.getId() + " => " + document.getData());
                       
    }
                   
    } else {
                       
    Log.d(TAG, "Error getting documents: ", task.getException());
                   
    }
               
    }
           
    });
    db.collection("cities").get().then(
     
    (querySnapshot) {
       
    print("Successfully completed");
       
    for (var docSnapshot in querySnapshot.docs) {
         
    print('${docSnapshot.id} => ${docSnapshot.data()}');
       
    }
     
    },
      onError
    : (e) => print("Error completing: $e"),
    );
    // asynchronously retrieve all documents
    ApiFuture<QuerySnapshot> future = db.collection("cities").get();
    // future.get() blocks on response
    List<QueryDocumentSnapshot> documents = future.get().getDocuments();
    for (QueryDocumentSnapshot document : documents) {
     
    System.out.println(document.getId() + " => " + document.toObject(City.class));
    }
    docs = db.collection("cities").stream()

    for doc in docs:
       
    print(f"{doc.id} => {doc.to_dict()}")
    docs = db.collection("cities").stream()

    async
    for doc in docs:
       
    print(f"{doc.id} => {doc.to_dict()}")
    db->Collection("cities").Get().OnCompletion(
       
    [](const Future<QuerySnapshot>& future) {
         
    if (future.error() == Error::kErrorOk) {
           
    for (const DocumentSnapshot& document :
                 future
    .result()->documents()) {
              std
    ::cout << document << std::endl;
           
    }
         
    } else {
            std
    ::cout << "Error getting documents: " << future.error_message()
                     
    << std::endl;
         
    }
       
    });
    const citiesRef = db.collection('cities');
    const snapshot = await citiesRef.get();
    snapshot
    .forEach(doc => {
      console
    .log(doc.id, '=>', doc.data());
    });

    import (
           
    "context"
           
    "fmt"

           
    "cloud.google.com/go/firestore"
           
    "google.golang.org/api/iterator"
    )

    func allDocs
    (ctx context.Context, client *firestore.Client) error {
            fmt
    .Println("All cities:")
            iter
    := client.Collection("cities").Documents(ctx)
           
    for {
                    doc
    , err := iter.Next()
                   
    if err == iterator.Done {
                           
    break
                   
    }
                   
    if err != nil {
                           
    return err
                   
    }
                    fmt
    .Println(doc.Data())
           
    }
           
    return nil
    }

    PHP

    Para obtener más información sobre cómo instalar y crear un cliente de Cloud Firestore, consulte Bibliotecas de clientes de Cloud Firestore .

    $citiesRef = $db->collection('samples/php/cities');
    $documents
    = $citiesRef->documents();
    foreach ($documents as $document) {
       
    if ($document->exists()) {
            printf
    ('Document data for document %s:' . PHP_EOL, $document->id());
            print_r
    ($document->data());
            printf
    (PHP_EOL);
       
    } else {
            printf
    ('Document %s does not exist!' . PHP_EOL, $document->id());
       
    }
    }
    Query allCitiesQuery = db.Collection("cities");
    allCitiesQuery
    .GetSnapshotAsync().ContinueWithOnMainThread(task =>
    {
     
    QuerySnapshot allCitiesQuerySnapshot = task.Result;
     
    foreach (DocumentSnapshot documentSnapshot in allCitiesQuerySnapshot.Documents)
     
    {
       
    Debug.Log(String.Format("Document data for {0} document:", documentSnapshot.Id));
       
    Dictionary<string, object> city = documentSnapshot.ToDictionary();
       
    foreach (KeyValuePair<string, object> pair in city)
       
    {
         
    Debug.Log(String.Format("{0}: {1}", pair.Key, pair.Value));
       
    }

       
    // Newline to separate entries
       
    Debug.Log("");
     
    }
    });
    Query allCitiesQuery = db.Collection("cities");
    QuerySnapshot allCitiesQuerySnapshot = await allCitiesQuery.GetSnapshotAsync();
    foreach (DocumentSnapshot documentSnapshot in allCitiesQuerySnapshot.Documents)
    {
       
    Console.WriteLine("Document data for {0} document:", documentSnapshot.Id);
       
    Dictionary<string, object> city = documentSnapshot.ToDictionary();
       
    foreach (KeyValuePair<string, object> pair in city)
       
    {
           
    Console.WriteLine("{0}: {1}", pair.Key, pair.Value);
       
    }
       
    Console.WriteLine("");
    }
    cities_ref = firestore.col collection_path
    cities_ref
    .get do |city|
      puts
    "#{city.document_id} data: #{city.data}."
    end

    Obtener todos los documentos en una subcolección

    Para recuperar todos los documentos de una subcolección, cree una referencia con la ruta completa a esa subcolección:

    const { collection, getDocs } = require("firebase/firestore");
    // Query a reference to a subcollection
    const querySnapshot = await getDocs(collection(db, "cities", "SF", "landmarks"));
    querySnapshot
    .forEach((doc) => {
     
    // doc.data() is never undefined for query doc snapshots
      console
    .log(doc.id, " => ", doc.data());
    });
    // Snippet not available
    do {
     
    let querySnapshot = try await db.collection("cities/SF/landmarks").getDocuments()
     
    for document in querySnapshot.documents {
        print
    ("\(document.documentID) => \(document.data())")
     
    }
    } catch {
      print
    ("Error getting documents: \(error)")
    }
    [[self.db collectionWithPath:@"cities/SF/landmarks"]
        getDocumentsWithCompletion
    :^(FIRQuerySnapshot *snapshot, NSError *error) {
         
    if (error != nil) {
           
    NSLog(@"Error getting documents: %@", error);
         
    } else {
           
    for (FIRDocumentSnapshot *document in snapshot.documents) {
             
    NSLog(@"%@ => %@", document.documentID, document.data);
           
    }
         
    }
       
    }];
    db.collection("cities")
       
    .document("SF")
       
    .collection("landmarks")
       
    .get()
       
    .addOnSuccessListener { result ->
           
    for (document in result) {
               
    Log.d(TAG, "${document.id} => ${document.data}")
           
    }
       
    }
       
    .addOnFailureListener { exception ->
           
    Log.d(TAG, "Error getting documents: ", exception)
       
    }
    db.collection("cities")
           
    .document("SF")
           
    .collection("landmarks")
           
    .get()
           
    .addOnCompleteListener(new OnCompleteListener<QuerySnapshot>() {
               
    @Override
               
    public void onComplete(@NonNull Task<QuerySnapshot> task) {
                   
    if (task.isSuccessful()) {
                       
    for (QueryDocumentSnapshot document : task.getResult()) {
                           
    Log.d(TAG, document.getId() + " => " + document.getData());
                       
    }
                   
    } else {
                       
    Log.d(TAG, "Error getting documents: ", task.getException());
                   
    }
               
    }
           
    });
    db.collection("cities").doc("SF").collection("landmarks").get().then(
     
    (querySnapshot) {
        print
    ("Successfully completed");
       
    for (var docSnapshot in querySnapshot.docs) {
          print
    ('${docSnapshot.id} => ${docSnapshot.data()}');
       
    }
     
    },
      onError
    : (e) => print("Error completing: $e"),
    );
    // Snippet not available
    // Snippet not available
    // Snippet not available
    // Snippet not available
    // Snippet not available
    // Snippet not available
    // Snippet not available
    // Snippet not available
    // Snippet not available
    // Snippet not available

    Obtener varios documentos de un grupo de colección

    Un grupo de colecciones consta de todas las colecciones con el mismo ID. Por ejemplo, si cada documento de su colección cities tiene una subcolección llamada landmarks , todas las subcolecciones landmarks pertenecen al mismo grupo de colección. De forma predeterminada, las consultas recuperan resultados de una única colección en su base de datos. Utilice una consulta de grupo de colecciones para recuperar resultados de un grupo de colecciones en lugar de de una sola colección.

    Listar subcolecciones de un documento.

    El método listCollections() de las bibliotecas cliente del servidor Cloud Firestore enumera todas las subcolecciones de una referencia de documento.

    No es posible recuperar una lista de colecciones con las bibliotecas del cliente web/móvil. Sólo debe buscar nombres de colecciones como parte de tareas administrativas en entornos de servidores confiables. Si descubre que necesita esta capacidad en las bibliotecas de clientes web/móviles, considere reestructurar sus datos para que los nombres de las subcolecciones sean predecibles.

    No disponible en la biblioteca del cliente web.

    No disponible en la biblioteca del cliente Swift.

    No disponible en la biblioteca cliente de Objective-C.

    No disponible en la biblioteca del cliente de Android.

    No disponible en la biblioteca del cliente de Android.

    No disponible en la biblioteca cliente de Flutter.

    Iterable<CollectionReference> collections =
        db
    .collection("cities").document("SF").listCollections();

    for (CollectionReference collRef : collections) {
     
    System.out.println("Found subcollection with id: " + collRef.getId());
    }
    collections = db.collection("cities").document("SF").collections()
    for collection in collections:
       
    for doc in collection.stream():
           
    print(f"{doc.id} => {doc.to_dict()}")
    collections = db.collection("cities").document("SF").collections()
    async
    for collection in collections:
        async
    for doc in collection.stream():
           
    print(f"{doc.id} => {doc.to_dict()}")

    No disponible en la biblioteca cliente de C++.

    const sfRef = db.collection('cities').doc('SF');
    const collections = await sfRef.listCollections();
    collections
    .forEach(collection => {
      console
    .log('Found subcollection with id:', collection.id);
    });

    import (
           
    "context"
           
    "fmt"

           
    "cloud.google.com/go/firestore"
           
    "google.golang.org/api/iterator"
    )

    func getCollections
    (ctx context.Context, client *firestore.Client) error {
            iter
    := client.Collection("cities").Doc("SF").Collections(ctx)
           
    for {
                    collRef
    , err := iter.Next()
                   
    if err == iterator.Done {
                           
    break
                   
    }
                   
    if err != nil {
                           
    return err
                   
    }
                    fmt
    .Printf("Found collection with id: %s\n", collRef.ID)
           
    }
           
    return nil
    }

    PHP

    Para obtener más información sobre cómo instalar y crear un cliente de Cloud Firestore, consulte Bibliotecas de clientes de Cloud Firestore .

    $cityRef = $db->collection('samples/php/cities')->document('SF');
    $collections
    = $cityRef->collections();
    foreach ($collections as $collection) {
        printf
    ('Found subcollection with id: %s' . PHP_EOL, $collection->id());
    }
    // This is not yet supported in the Unity SDK.
    DocumentReference cityRef = db.Collection("cities").Document("SF");
    IAsyncEnumerable<CollectionReference> subcollections = cityRef.ListCollectionsAsync();
    IAsyncEnumerator<CollectionReference> subcollectionsEnumerator = subcollections.GetAsyncEnumerator(default);
    while (await subcollectionsEnumerator.MoveNextAsync())
    {
       
    CollectionReference subcollectionRef = subcollectionsEnumerator.Current;
       
    Console.WriteLine("Found subcollection with ID: {0}", subcollectionRef.Id);
    }
    city_ref = firestore.doc "#{collection_path}/SF"
    city_ref
    .cols do |col|
      puts col
    .collection_id
    end

    Obtenga más información sobre los diferentes tipos de consultas .

    Para obtener más información sobre códigos de error y cómo resolver problemas de latencia al obtener datos, consulte la página de solución de problemas .