Hay varias formas de escribir datos en Cloud Firestore:
- Configurar los datos de un documento dentro de una colección y especificar explícitamente un identificador de documento.
- Agregar un documento nuevo a una colección. En este caso, Cloud Firestore genera automáticamente el identificador de documento.
- Crear un documento vacío con un identificador generado automáticamente y asignarle datos después.
En esta guía, se explica cómo usar los métodos para configurar, agregar o actualizar documentos individuales en Cloud Firestore. Si quieres escribir datos de manera masiva, consulta Transacciones y escrituras en lotes.
Antes de comenzar
Consulta Primeros pasos con Cloud Firestore para crear una base de datos de Cloud Firestore.Inicializa Cloud Firestore
Inicializa una instancia de Cloud Firestore:
API modular web
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);
Reemplaza FIREBASE_CONFIGURATION por el firebaseConfig
de tu aplicación web.
Para conservar datos cuando el dispositivo pierda su conexión, consulta la documentación sobre Habilitar los datos sin conexión.
API con espacio de nombres web
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();
Reemplaza FIREBASE_CONFIGURATION por el firebaseConfig
de tu aplicación web.
Para conservar datos cuando el dispositivo pierda su conexión, consulta la documentación sobre Habilitar los datos sin conexión.
Swift
import FirebaseCore import FirebaseFirestore
FirebaseApp.configure() let db = Firestore.firestore()
Objective‑C
@import FirebaseCore; @import FirebaseFirestore; // Use Firebase library to configure APIs [FIRApp configure];
FIRFirestore *defaultFirestore = [FIRFirestore firestore];
Kotlin KTX
// Access a Cloud Firestore instance from your Activity
val db = Firebase.firestore
Java
// Access a Cloud Firestore instance from your Activity
FirebaseFirestore db = FirebaseFirestore.getInstance();
Dart
db = FirebaseFirestore.instance;
Java
El SDK de Cloud Firestore se inicializa de maneras diferentes, según tu entorno. A continuación, se muestran los métodos más comunes. Para ver una referencia completa, consulta Inicializa el SDK de Admin.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();
Para usar el SDK de Firebase Admin en tu propio servidor, usa una cuenta de servicio.
En la consola de Google Cloud, ve a IAM y administración > Cuentas de servicio. Genera una clave privada nueva y guarda el archivo JSON. Luego, usa 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();
Python
El SDK de Cloud Firestore se inicializa de maneras diferentes, según tu entorno. A continuación, se muestran los métodos más comunes. Para ver una referencia completa, consulta Inicializa el SDK de Admin.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 usar 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()
Para usar el SDK de Firebase Admin en tu propio servidor, usa una cuenta de servicio.
En la consola de Google Cloud, ve a IAM y administración > Cuentas de servicio. Genera una clave privada nueva y guarda el archivo JSON. Luego, usa 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()
Python
El SDK de Cloud Firestore se inicializa de maneras diferentes, según tu entorno. A continuación, se muestran los métodos más comunes. Para ver una referencia completa, consulta Inicializa el SDK de Admin.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 usar 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()
Para usar el SDK de Firebase Admin en tu propio servidor, usa una cuenta de servicio.
En la consola de Google Cloud, ve a IAM y administración > Cuentas de servicio. Genera una clave privada nueva y guarda el archivo JSON. Luego, usa 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()
C
// Make sure the call to `Create()` happens some time before you call Firestore::GetInstance(). App::Create(); Firestore* db = Firestore::GetInstance();
Node.js
El SDK de Cloud Firestore se inicializa de maneras diferentes, según tu entorno. A continuación, se muestran los métodos más comunes. Para ver una referencia completa, consulta Inicializa el SDK de Admin.-
Inicializa en Cloud Functions
const { initializeApp, applicationDefault, cert } = require('firebase-admin/app'); const { getFirestore, Timestamp, FieldValue, Filter } = require('firebase-admin/firestore');
initializeApp(); const db = getFirestore();
- Inicializa 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();
-
Inicializa en tu propio servidor
Para usar el SDK de Firebase Admin en tu propio servidor (o cualquier otro entorno de Node.js), usa una cuenta de servicio. En la consola de Google Cloud, ve a IAM y administración > Cuentas de servicio. Genera una clave privada nueva y guarda el archivo JSON. Luego, usa 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();
Go
El SDK de Cloud Firestore se inicializa de maneras diferentes, según tu entorno. A continuación, se muestran los métodos más comunes. Para ver una referencia completa, consulta Inicializa el SDK de Admin.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()
Para usar el SDK de Firebase Admin en tu propio servidor, usa una cuenta de servicio.
En la consola de Google Cloud, ve a IAM y administración > Cuentas de servicio. Genera una clave privada nueva y guarda el archivo JSON. Luego, usa 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
PHP
Para obtener más información sobre la instalación y creación de un cliente de Cloud Firestore, consulta las bibliotecas cliente de Cloud Firestore.
Unity
using Firebase.Firestore; using Firebase.Extensions;
FirebaseFirestore db = FirebaseFirestore.DefaultInstance;
C#
C#
Para obtener más información sobre la instalación y creación de un cliente de Cloud Firestore, consulta las bibliotecas cliente de Cloud Firestore.
Ruby
Configura un documento
Para crear o reemplazar un solo documento, usa los métodos set()
específicos para cada lenguaje:
API modular web
Usa el método setDoc()
:
import { doc, setDoc } from "firebase/firestore"; // Add a new document in collection "cities" await setDoc(doc(db, "cities", "LA"), { name: "Los Angeles", state: "CA", country: "USA" });
API con espacio de nombres web
Usa el método set()
:
// Add a new document in collection "cities" db.collection("cities").doc("LA").set({ name: "Los Angeles", state: "CA", country: "USA" }) .then(() => { console.log("Document successfully written!"); }) .catch((error) => { console.error("Error writing document: ", error); });
Swift
Usa el método setData()
:
// Add a new document in collection "cities" do { try await db.collection("cities").document("LA").setData([ "name": "Los Angeles", "state": "CA", "country": "USA" ]) print("Document successfully written!") } catch { print("Error writing document: \(error)") }
Objective‑C
Usa el método setData:
:
// Add a new document in collection "cities" [[[self.db collectionWithPath:@"cities"] documentWithPath:@"LA"] setData:@{ @"name": @"Los Angeles", @"state": @"CA", @"country": @"USA" } completion:^(NSError * _Nullable error) { if (error != nil) { NSLog(@"Error writing document: %@", error); } else { NSLog(@"Document successfully written!"); } }];
Kotlin KTX
Usa el método set()
:
val city = hashMapOf( "name" to "Los Angeles", "state" to "CA", "country" to "USA", ) db.collection("cities").document("LA") .set(city) .addOnSuccessListener { Log.d(TAG, "DocumentSnapshot successfully written!") } .addOnFailureListener { e -> Log.w(TAG, "Error writing document", e) }
Java
Usa el método set()
:
Map<String, Object> city = new HashMap<>(); city.put("name", "Los Angeles"); city.put("state", "CA"); city.put("country", "USA"); db.collection("cities").document("LA") .set(city) .addOnSuccessListener(new OnSuccessListener<Void>() { @Override public void onSuccess(Void aVoid) { Log.d(TAG, "DocumentSnapshot successfully written!"); } }) .addOnFailureListener(new OnFailureListener() { @Override public void onFailure(@NonNull Exception e) { Log.w(TAG, "Error writing document", e); } });
Dart
Usa el método set()
:
final city = <String, String>{ "name": "Los Angeles", "state": "CA", "country": "USA" }; db .collection("cities") .doc("LA") .set(city) .onError((e, _) => print("Error writing document: $e"));
Java
Usa el método set()
:
Python
Usa el método set()
:
Python
Usa el método set()
:
C
Usa el método Set()
:
// Add a new document in collection 'cities' db->Collection("cities") .Document("LA") .Set({{"name", FieldValue::String("Los Angeles")}, {"state", FieldValue::String("CA")}, {"country", FieldValue::String("USA")}}) .OnCompletion([](const Future<void>& future) { if (future.error() == Error::kErrorOk) { std::cout << "DocumentSnapshot successfully written!" << std::endl; } else { std::cout << "Error writing document: " << future.error_message() << std::endl; } });
Node.js
Usa el método set()
:
Go
Usa el método Set()
:
PHP
Usa el método set()
:
PHP
Para obtener más información sobre la instalación y creación de un cliente de Cloud Firestore, consulta las bibliotecas cliente de Cloud Firestore.
Unity
Usa el método SetAsync()
:
DocumentReference docRef = db.Collection("cities").Document("LA"); Dictionary<string, object> city = new Dictionary<string, object> { { "Name", "Los Angeles" }, { "State", "CA" }, { "Country", "USA" } }; docRef.SetAsync(city).ContinueWithOnMainThread(task => { Debug.Log("Added data to the LA document in the cities collection."); });
C#
Usa el método SetAsync()
:
Ruby
Usa el método set()
:
Si el documento no existe, se creará. Si el documento existe, su contenido se reemplazará por los datos proporcionados, a menos que especifiques que los datos se deberían combinar en el documento existente, de la siguiente manera:
API modular web
import { doc, setDoc } from "firebase/firestore"; const cityRef = doc(db, 'cities', 'BJ'); setDoc(cityRef, { capital: true }, { merge: true });
API con espacio de nombres web
var cityRef = db.collection('cities').doc('BJ'); var setWithMerge = cityRef.set({ capital: true }, { merge: true });
Swift
// Update one field, creating the document if it does not exist. db.collection("cities").document("BJ").setData([ "capital": true ], merge: true)
Objective‑C
// Write to the document reference, merging data with existing // if the document already exists [[[self.db collectionWithPath:@"cities"] documentWithPath:@"BJ"] setData:@{ @"capital": @YES } merge:YES completion:^(NSError * _Nullable error) { // ... }];
Kotlin KTX
// Update one field, creating the document if it does not already exist. val data = hashMapOf("capital" to true) db.collection("cities").document("BJ") .set(data, SetOptions.merge())
Java
// Update one field, creating the document if it does not already exist. Map<String, Object> data = new HashMap<>(); data.put("capital", true); db.collection("cities").document("BJ") .set(data, SetOptions.merge());
Dart
// Update one field, creating the document if it does not already exist. final data = {"capital": true}; db.collection("cities").doc("BJ").set(data, SetOptions(merge: true));
Java
Python
Python
C
db->Collection("cities").Document("BJ").Set( {{"capital", FieldValue::Boolean(true)}}, SetOptions::Merge());
Node.js
Go
PHP
PHP
Para obtener más información sobre la instalación y creación de un cliente de Cloud Firestore, consulta las bibliotecas cliente de Cloud Firestore.
Unity
DocumentReference docRef = db.Collection("cities").Document("LA"); Dictionary<string, object> update = new Dictionary<string, object> { { "capital", false } }; docRef.SetAsync(update, SetOptions.MergeAll);
C#
Ruby
Si no sabes si el documento existe, no utilices la opción de combinar los datos nuevos con cualquier documento existente, para así evitar reemplazar documentos completos. En el caso de los documentos que contienen mapas, ten en cuenta que, si especificas un conjunto con un campo que contenga un mapa vacío, se reemplazará el campo del mapa del documento de destino.
Tipos de datos
Cloud Firestore te permite escribir una variedad de tipos de datos dentro de un documento, incluidos objetos y arrays anidados, cadenas, booleanos, números, fechas y nulos. Cloud Firestore siempre almacena los números en formato de punto flotante de doble precisión, independientemente del tipo de número que uses en tu código.
API modular web
import { doc, setDoc, Timestamp } from "firebase/firestore"; const docData = { stringExample: "Hello world!", booleanExample: true, numberExample: 3.14159265, dateExample: Timestamp.fromDate(new Date("December 10, 1815")), arrayExample: [5, true, "hello"], nullExample: null, objectExample: { a: 5, b: { nested: "foo" } } }; await setDoc(doc(db, "data", "one"), docData);
API con espacio de nombres web
var docData = { stringExample: "Hello world!", booleanExample: true, numberExample: 3.14159265, dateExample: firebase.firestore.Timestamp.fromDate(new Date("December 10, 1815")), arrayExample: [5, true, "hello"], nullExample: null, objectExample: { a: 5, b: { nested: "foo" } } }; db.collection("data").doc("one").set(docData).then(() => { console.log("Document successfully written!"); });
Swift
let docData: [String: Any] = [ "stringExample": "Hello world!", "booleanExample": true, "numberExample": 3.14159265, "dateExample": Timestamp(date: Date()), "arrayExample": [5, true, "hello"], "nullExample": NSNull(), "objectExample": [ "a": 5, "b": [ "nested": "foo" ] ] ] do { try await db.collection("data").document("one").setData(docData) print("Document successfully written!") } catch { print("Error writing document: \(error)") }
Objective‑C
NSDictionary *docData = @{ @"stringExample": @"Hello world!", @"booleanExample": @YES, @"numberExample": @3.14, @"dateExample": [FIRTimestamp timestampWithDate:[NSDate date]], @"arrayExample": @[@5, @YES, @"hello"], @"nullExample": [NSNull null], @"objectExample": @{ @"a": @5, @"b": @{ @"nested": @"foo" } } }; [[[self.db collectionWithPath:@"data"] documentWithPath:@"one"] setData:docData completion:^(NSError * _Nullable error) { if (error != nil) { NSLog(@"Error writing document: %@", error); } else { NSLog(@"Document successfully written!"); } }];
Kotlin KTX
val docData = hashMapOf( "stringExample" to "Hello world!", "booleanExample" to true, "numberExample" to 3.14159265, "dateExample" to Timestamp(Date()), "listExample" to arrayListOf(1, 2, 3), "nullExample" to null, ) val nestedData = hashMapOf( "a" to 5, "b" to true, ) docData["objectExample"] = nestedData db.collection("data").document("one") .set(docData) .addOnSuccessListener { Log.d(TAG, "DocumentSnapshot successfully written!") } .addOnFailureListener { e -> Log.w(TAG, "Error writing document", e) }
Java
Map<String, Object> docData = new HashMap<>(); docData.put("stringExample", "Hello world!"); docData.put("booleanExample", true); docData.put("numberExample", 3.14159265); docData.put("dateExample", new Timestamp(new Date())); docData.put("listExample", Arrays.asList(1, 2, 3)); docData.put("nullExample", null); Map<String, Object> nestedData = new HashMap<>(); nestedData.put("a", 5); nestedData.put("b", true); docData.put("objectExample", nestedData); db.collection("data").document("one") .set(docData) .addOnSuccessListener(new OnSuccessListener<Void>() { @Override public void onSuccess(Void aVoid) { Log.d(TAG, "DocumentSnapshot successfully written!"); } }) .addOnFailureListener(new OnFailureListener() { @Override public void onFailure(@NonNull Exception e) { Log.w(TAG, "Error writing document", e); } });
Dart
final docData = { "stringExample": "Hello world!", "booleanExample": true, "numberExample": 3.14159265, "dateExample": Timestamp.now(), "listExample": [1, 2, 3], "nullExample": null }; final nestedData = { "a": 5, "b": true, }; docData["objectExample"] = nestedData; db .collection("data") .doc("one") .set(docData) .onError((e, _) => print("Error writing document: $e"));
Java
Python
Python
C
MapFieldValue doc_data{ {"stringExample", FieldValue::String("Hello world!")}, {"booleanExample", FieldValue::Boolean(true)}, {"numberExample", FieldValue::Double(3.14159265)}, {"dateExample", FieldValue::Timestamp(Timestamp::Now())}, {"arrayExample", FieldValue::Array({FieldValue::Integer(1), FieldValue::Integer(2), FieldValue::Integer(3)})}, {"nullExample", FieldValue::Null()}, {"objectExample", FieldValue::Map( {{"a", FieldValue::Integer(5)}, {"b", FieldValue::Map( {{"nested", FieldValue::String("foo")}})}})}, }; db->Collection("data").Document("one").Set(doc_data).OnCompletion( [](const Future<void>& future) { if (future.error() == Error::kErrorOk) { std::cout << "DocumentSnapshot successfully written!" << std::endl; } else { std::cout << "Error writing document: " << future.error_message() << std::endl; } });
Node.js
Go
PHP
PHP
Para obtener más información sobre la instalación y creación de un cliente de Cloud Firestore, consulta las bibliotecas cliente de Cloud Firestore.
Unity
DocumentReference docRef = db.Collection("data").Document("one"); Dictionary<string, object> docData = new Dictionary<string, object> { { "stringExample", "Hello World" }, { "booleanExample", false }, { "numberExample", 3.14159265 }, { "nullExample", null }, { "arrayExample", new List<object>() { 5, true, "Hello" } }, { "objectExample", new Dictionary<string, object> { { "a", 5 }, { "b", true }, } }, }; docRef.SetAsync(docData);
C#
Ruby
Objetos personalizados
Usar objetos Map
o Dictionary
para representar tus documentos suele ser poco práctico, por lo que Cloud Firestore admite la escritura de documentos con clases personalizadas. Cloud Firestore convierte los objetos en tipos de datos compatibles.
Con las clases personalizadas, podrías reescribir el ejemplo inicial de la siguiente manera:
API modular web
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); } };
API con espacio de nombres web
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); } };
Swift
public struct City: Codable { let name: String let state: String? let country: String? let isCapital: Bool? let population: Int64? enum CodingKeys: String, CodingKey { case name case state case country case isCapital = "capital" case population } }
Objective‑C
// This isn't supported in Objective-C.
Kotlin KTX
data class City( val name: String? = null, val state: String? = null, val country: String? = null, @field:JvmField // use this annotation if your Boolean field is prefixed with 'is' val isCapital: Boolean? = null, val population: Long? = null, val regions: List<String>? = null, )
Java
Cada clase personalizada debe tener un constructor público que no acepte argumentos. Además, la clase debe incluir un método get público para cada propiedad.
public class City { private String name; private String state; private String country; private boolean capital; private long population; private List<String> regions; public City() {} public City(String name, String state, String country, boolean capital, long population, List<String> regions) { // ... } public String getName() { return name; } public String getState() { return state; } public String getCountry() { return country; } public boolean isCapital() { return capital; } public long getPopulation() { return population; } public List<String> getRegions() { return regions; } }
Dart
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, }; } }
Java
Python
Python
C
// This is not yet supported.
Node.js
// Node.js uses JavaScript objects
Go
PHP
PHP
Para obtener más información sobre la instalación y creación de un cliente de Cloud Firestore, consulta las bibliotecas cliente de Cloud Firestore.
Unity
[FirestoreData] public class City { [FirestoreProperty] public string Name { get; set; } [FirestoreProperty] public string State { get; set; } [FirestoreProperty] public string Country { get; set; } [FirestoreProperty] public bool Capital { get; set; } [FirestoreProperty] public long Population { get; set; } }
C#
Ruby
// This isn't supported in Ruby
API modular web
import { doc, setDoc } from "firebase/firestore"; // Set with cityConverter const ref = doc(db, "cities", "LA").withConverter(cityConverter); await setDoc(ref, new City("Los Angeles", "CA", "USA"));
API con espacio de nombres web
// Set with cityConverter db.collection("cities").doc("LA") .withConverter(cityConverter) .set(new City("Los Angeles", "CA", "USA"));
Swift
let city = City(name: "Los Angeles", state: "CA", country: "USA", isCapital: false, population: 5000000) do { try db.collection("cities").document("LA").setData(from: city) } catch let error { print("Error writing city to Firestore: \(error)") }
Objective‑C
// This isn't supported in Objective-C.
Kotlin KTX
val city = City( "Los Angeles", "CA", "USA", false, 5000000L, listOf("west_coast", "socal"), ) db.collection("cities").document("LA").set(city)
Java
City city = new City("Los Angeles", "CA", "USA", false, 5000000L, Arrays.asList("west_coast", "sorcal")); db.collection("cities").document("LA").set(city);
Dart
final city = City( name: "Los Angeles", state: "CA", country: "USA", capital: false, population: 5000000, regions: ["west_coast", "socal"], ); final docRef = db .collection("cities") .withConverter( fromFirestore: City.fromFirestore, toFirestore: (City city, options) => city.toFirestore(), ) .doc("LA"); await docRef.set(city);
Java
Python
Python
C
// This is not yet supported.
Node.js
// Node.js uses JavaScript objects
Go
PHP
// This isn't supported in PHP.
Unity
DocumentReference docRef = db.Collection("cities").Document("LA"); City city = new City { Name = "Los Angeles", State = "CA", Country = "USA", Capital = false, Population = 3950000L }; docRef.SetAsync(city);
C#
Ruby
// This isn't supported in Ruby.
Agrega un documento
Cuando usas set()
para crear un documento, debes especificar un ID para el documento que vas a crear. Por ejemplo:
API modular web
import { doc, setDoc } from "firebase/firestore"; await setDoc(doc(db, "cities", "new-city-id"), data);
API con espacio de nombres web
db.collection("cities").doc("new-city-id").set(data);
Swift
db.collection("cities").document("new-city-id").setData(data)
Objective‑C
[[[self.db collectionWithPath:@"cities"] documentWithPath:@"new-city-id"] setData:data];
Kotlin KTX
db.collection("cities").document("new-city-id").set(data)
Java
db.collection("cities").document("new-city-id").set(data);
Dart
db.collection("cities").doc("new-city-id").set({"name": "Chicago"});
Java
Python
Python
C
db->Collection("cities").Document("SF").Set({/*some data*/});
Node.js
Go
PHP
PHP
Para obtener más información sobre la instalación y creación de un cliente de Cloud Firestore, consulta las bibliotecas cliente de Cloud Firestore.
Unity
db.Collection("cities").Document("new-city-id").SetAsync(city);
C#
Ruby
Pero a veces no hay un ID significativo para el documento y es
más conveniente dejar que Cloud Firestore genere automáticamente un ID. Para ello,
llama a los métodos add()
específicos para cada lenguaje:
API modular web
Usa el método addDoc()
:
import { collection, addDoc } from "firebase/firestore"; // Add a new document with a generated id. const docRef = await addDoc(collection(db, "cities"), { name: "Tokyo", country: "Japan" }); console.log("Document written with ID: ", docRef.id);
API con espacio de nombres web
Usa el método add()
:
// Add a new document with a generated id. db.collection("cities").add({ name: "Tokyo", country: "Japan" }) .then((docRef) => { console.log("Document written with ID: ", docRef.id); }) .catch((error) => { console.error("Error adding document: ", error); });
Swift
Usa el método addDocument()
:
// Add a new document with a generated id. do { let ref = try await db.collection("cities").addDocument(data: [ "name": "Tokyo", "country": "Japan" ]) print("Document added with ID: \(ref.documentID)") } catch { print("Error adding document: \(error)") }
Objective‑C
Usa el método addDocumentWithData:
:
// Add a new document with a generated id. __block FIRDocumentReference *ref = [[self.db collectionWithPath:@"cities"] addDocumentWithData:@{ @"name": @"Tokyo", @"country": @"Japan" } completion:^(NSError * _Nullable error) { if (error != nil) { NSLog(@"Error adding document: %@", error); } else { NSLog(@"Document added with ID: %@", ref.documentID); } }];
Kotlin KTX
Usa el método add()
:
// Add a new document with a generated id. val data = hashMapOf( "name" to "Tokyo", "country" to "Japan", ) db.collection("cities") .add(data) .addOnSuccessListener { documentReference -> Log.d(TAG, "DocumentSnapshot written with ID: ${documentReference.id}") } .addOnFailureListener { e -> Log.w(TAG, "Error adding document", e) }
Java
Usa el método add()
:
// Add a new document with a generated id. Map<String, Object> data = new HashMap<>(); data.put("name", "Tokyo"); data.put("country", "Japan"); db.collection("cities") .add(data) .addOnSuccessListener(new OnSuccessListener<DocumentReference>() { @Override public void onSuccess(DocumentReference documentReference) { Log.d(TAG, "DocumentSnapshot written with ID: " documentReference.getId()); } }) .addOnFailureListener(new OnFailureListener() { @Override public void onFailure(@NonNull Exception e) { Log.w(TAG, "Error adding document", e); } });
Dart
Usa el método add()
:
// Add a new document with a generated id. final data = {"name": "Tokyo", "country": "Japan"}; db.collection("cities").add(data).then((documentSnapshot) => print("Added Data with ID: ${documentSnapshot.id}"));
Java
Usa el método add()
:
Python
Usa el método add()
:
Python
Usa el método add()
:
C
Usa el método Add()
:
db->Collection("cities").Add({/*some data*/});
Node.js
Usa el método add()
:
Go
Usa el método Add()
:
PHP
Usa el método add()
:
PHP
Para obtener más información sobre la instalación y creación de un cliente de Cloud Firestore, consulta las bibliotecas cliente de Cloud Firestore.
Unity
Usa el método AddAsync()
:
Dictionary<string, object> city = new Dictionary<string, object> { { "Name", "Tokyo" }, { "Country", "Japan" } }; db.Collection("cities").AddAsync(city).ContinueWithOnMainThread(task => { DocumentReference addedDocRef = task.Result; Debug.Log(String.Format("Added document with ID: {0}.", addedDocRef.Id)); });
C#
Usa el método AddAsync()
:
Ruby
Usa el método add()
:
En algunos casos, puede ser útil crear una referencia de documento con un ID generado automáticamente y, luego, usar la referencia más adelante. Para este caso de uso, puedes llamar a
doc()
:
API modular web
import { collection, doc, setDoc } from "firebase/firestore"; // Add a new document with a generated id const newCityRef = doc(collection(db, "cities")); // later... await setDoc(newCityRef, data);
API con espacio de nombres web
// Add a new document with a generated id. var newCityRef = db.collection("cities").doc(); // later... newCityRef.set(data);
Swift
let newCityRef = db.collection("cities").document() // later... newCityRef.setData([ // ... ])
Objective‑C
FIRDocumentReference *newCityRef = [[self.db collectionWithPath:@"cities"] documentWithAutoID]; // later... [newCityRef setData:@{ /* ... */ }];
Kotlin KTX
val data = HashMap<String, Any>() val newCityRef = db.collection("cities").document() // Later... newCityRef.set(data)
Java
Map<String, Object> data = new HashMap<>(); DocumentReference newCityRef = db.collection("cities").document(); // Later... newCityRef.set(data);
Dart
// Add a new document with a generated id. final data = <String, dynamic>{}; final newCityRef = db.collection("cities").doc(); // Later... newCityRef.set(data);
Java
Python
Python
C
DocumentReference new_city_ref = db->Collection("cities").Document();
Node.js
Go
PHP
PHP
Para obtener más información sobre la instalación y creación de un cliente de Cloud Firestore, consulta las bibliotecas cliente de Cloud Firestore.
Unity
DocumentReference addedDocRef = db.Collection("cities").Document(); Debug.Log(String.Format("Added document with ID: {0}.", addedDocRef.Id)); addedDocRef.SetAsync(city).ContinueWithOnMainThread(task => { Debug.Log(String.Format( "Added data to the {0} document in the cities collection.", addedDocRef.Id)); });
C#
Ruby
En segundo plano, .add(...)
y .doc().set(...)
son completamente equivalentes, por lo que puedes usar lo que te resulte más conveniente.
Actualiza un documento
Para actualizar algunos campos de un documento sin reemplazarlo por completo, usa
los métodos update()
específicos para cada lenguaje:
API modular web
Usa el método updateDoc()
:
import { doc, updateDoc } from "firebase/firestore"; const washingtonRef = doc(db, "cities", "DC"); // Set the "capital" field of the city 'DC' await updateDoc(washingtonRef, { capital: true });
API con espacio de nombres web
Usa el método update()
:
var washingtonRef = db.collection("cities").doc("DC"); // Set the "capital" field of the city 'DC' return washingtonRef.update({ capital: true }) .then(() => { console.log("Document successfully updated!"); }) .catch((error) => { // The document probably doesn't exist. console.error("Error updating document: ", error); });
Swift
Usa el método updateData()
:
let washingtonRef = db.collection("cities").document("DC") // Set the "capital" field of the city 'DC' do { try await washingtonRef.updateData([ "capital": true ]) print("Document successfully updated") } catch { print("Error updating document: \(error)") }
Objective‑C
Usa el método updateData:
:
FIRDocumentReference *washingtonRef = [[self.db collectionWithPath:@"cities"] documentWithPath:@"DC"]; // Set the "capital" field of the city [washingtonRef updateData:@{ @"capital": @YES } completion:^(NSError * _Nullable error) { if (error != nil) { NSLog(@"Error updating document: %@", error); } else { NSLog(@"Document successfully updated"); } }];
Kotlin KTX
Usa el método update()
:
val washingtonRef = db.collection("cities").document("DC") // Set the "isCapital" field of the city 'DC' washingtonRef .update("capital", true) .addOnSuccessListener { Log.d(TAG, "DocumentSnapshot successfully updated!") } .addOnFailureListener { e -> Log.w(TAG, "Error updating document", e) }
Java
Usa el método update()
:
DocumentReference washingtonRef = db.collection("cities").document("DC"); // Set the "isCapital" field of the city 'DC' washingtonRef .update("capital", true) .addOnSuccessListener(new OnSuccessListener<Void>() { @Override public void onSuccess(Void aVoid) { Log.d(TAG, "DocumentSnapshot successfully updated!"); } }) .addOnFailureListener(new OnFailureListener() { @Override public void onFailure(@NonNull Exception e) { Log.w(TAG, "Error updating document", e); } });
Dart
Usa el método update()
:
final washingtonRef = db.collection("cites").doc("DC"); washingtonRef.update({"capital": true}).then( (value) => print("DocumentSnapshot successfully updated!"), onError: (e) => print("Error updating document $e"));
Java
Usa el método update()
:
Python
Usa el método update()
:
Python
Usa el método update()
:
C
Usa el método Update()
:
DocumentReference washington_ref = db->Collection("cities").Document("DC"); // Set the "capital" field of the city "DC". washington_ref.Update({{"capital", FieldValue::Boolean(true)}});
Node.js
Usa el método update()
:
Go
Usa el método Update()
:
PHP
Usa el método update()
:
PHP
Para obtener más información sobre la instalación y creación de un cliente de Cloud Firestore, consulta las bibliotecas cliente de Cloud Firestore.
Unity
Usa el método UpdateAsync()
:
DocumentReference cityRef = db.Collection("cities").Document("new-city-id"); Dictionary<string, object> updates = new Dictionary<string, object> { { "Capital", false } }; cityRef.UpdateAsync(updates).ContinueWithOnMainThread(task => { Debug.Log( "Updated the Capital field of the new-city-id document in the cities collection."); }); // You can also update a single field with: cityRef.UpdateAsync("Capital", false);
C#
Usa el método UpdateAsync()
:
Ruby
Usa el método update()
:
Marca de tiempo del servidor
Puedes configurar un campo en tu documento para una marca de tiempo de servidor que haga un seguimiento de cuándo el servidor recibe la actualización.
API modular web
import { updateDoc, serverTimestamp } from "firebase/firestore"; const docRef = doc(db, 'objects', 'some-id'); // Update the timestamp field with the value from the server const updateTimestamp = await updateDoc(docRef, { timestamp: serverTimestamp() });
API con espacio de nombres web
var docRef = db.collection('objects').doc('some-id'); // Update the timestamp field with the value from the server var updateTimestamp = docRef.update({ timestamp: firebase.firestore.FieldValue.serverTimestamp() });
Swift
do { try await db.collection("objects").document("some-id").updateData([ "lastUpdated": FieldValue.serverTimestamp(), ]) print("Document successfully updated") } catch { print("Error updating document: \(error)") }
Objective‑C
[[[self.db collectionWithPath:@"objects"] documentWithPath:@"some-id"] updateData:@{ @"lastUpdated": [FIRFieldValue fieldValueForServerTimestamp] } completion:^(NSError * _Nullable error) { if (error != nil) { NSLog(@"Error updating document: %@", error); } else { NSLog(@"Document successfully updated"); } }];
Kotlin KTX
// If you're using custom Kotlin objects in Android, add an @ServerTimestamp // annotation to a Date field for your custom object classes. This indicates // that the Date field should be treated as a server timestamp by the object mapper. val docRef = db.collection("objects").document("some-id") // Update the timestamp field with the value from the server val updates = hashMapOf<String, Any>( "timestamp" to FieldValue.serverTimestamp(), ) docRef.update(updates).addOnCompleteListener { }
Java
// If you're using custom Java objects in Android, add an @ServerTimestamp // annotation to a Date field for your custom object classes. This indicates // that the Date field should be treated as a server timestamp by the object mapper. DocumentReference docRef = db.collection("objects").document("some-id"); // Update the timestamp field with the value from the server Map<String,Object> updates = new HashMap<>(); updates.put("timestamp", FieldValue.serverTimestamp()); docRef.update(updates).addOnCompleteListener(new OnCompleteListener<Void>() { // ... // ...
Dart
final docRef = db.collection("objects").doc("some-id"); final updates = <String, dynamic>{ "timestamp": FieldValue.serverTimestamp(), }; docRef.update(updates).then( (value) => print("DocumentSnapshot successfully updated!"), onError: (e) => print("Error updating document $e"));
Java
Python
Python
C
DocumentReference doc_ref = db->Collection("objects").Document("some-id"); doc_ref.Update({{"timestamp", FieldValue::ServerTimestamp()}}) .OnCompletion([](const Future<void>& future) { // ... });
Node.js
Go
PHP
PHP
Para obtener más información sobre la instalación y creación de un cliente de Cloud Firestore, consulta las bibliotecas cliente de Cloud Firestore.
Unity
DocumentReference cityRef = db.Collection("cities").Document("new-city-id"); cityRef.UpdateAsync("Timestamp", FieldValue.ServerTimestamp) .ContinueWithOnMainThread(task => { Debug.Log( "Updated the Timestamp field of the new-city-id document in the cities " "collection."); });
C#
Ruby
Cuando actualizas varios campos de marca de tiempo en una transacción, cada campo recibe el mismo valor de marca de tiempo del servidor.
Actualiza los campos en objetos anidados
Si tu documento contiene objetos anidados, puedes usar la “notación de puntos” para
hacer referencia a los campos anidados dentro del documento cuando llames a update()
:
API modular web
import { doc, setDoc, updateDoc } from "firebase/firestore"; // Create an initial document to update. const frankDocRef = doc(db, "users", "frank"); await setDoc(frankDocRef, { name: "Frank", favorites: { food: "Pizza", color: "Blue", subject: "recess" }, age: 12 }); // To update age and favorite color: await updateDoc(frankDocRef, { "age": 13, "favorites.color": "Red" });
API con espacio de nombres web
// Create an initial document to update. var frankDocRef = db.collection("users").doc("frank"); frankDocRef.set({ name: "Frank", favorites: { food: "Pizza", color: "Blue", subject: "recess" }, age: 12 }); // To update age and favorite color: db.collection("users").doc("frank").update({ "age": 13, "favorites.color": "Red" }) .then(() => { console.log("Document successfully updated!"); });
Swift
// Create an initial document to update. let frankDocRef = db.collection("users").document("frank") do { try await frankDocRef.setData([ "name": "Frank", "favorites": [ "food": "Pizza", "color": "Blue", "subject": "recess" ], "age": 12 ]) // To update age and favorite color: try await frankDocRef.updateData([ "age": 13, "favorites.color": "Red" ]) print("Document successfully updated") } catch { print("Error updating document: \(error)") }
Objective‑C
// Create an initial document to update. FIRDocumentReference *frankDocRef = [[self.db collectionWithPath:@"users"] documentWithPath:@"frank"]; [frankDocRef setData:@{ @"name": @"Frank", @"favorites": @{ @"food": @"Pizza", @"color": @"Blue", @"subject": @"recess" }, @"age": @12 }]; // To update age and favorite color: [frankDocRef updateData:@{ @"age": @13, @"favorites.color": @"Red", } completion:^(NSError * _Nullable error) { if (error != nil) { NSLog(@"Error updating document: %@", error); } else { NSLog(@"Document successfully updated"); } }];
Kotlin KTX
// Assume the document contains: // { // name: "Frank", // favorites: { food: "Pizza", color: "Blue", subject: "recess" } // age: 12 // } // // To update age and favorite color: db.collection("users").document("frank") .update( mapOf( "age" to 13, "favorites.color" to "Red", ), )
Java
// Assume the document contains: // { // name: "Frank", // favorites: { food: "Pizza", color: "Blue", subject: "recess" } // age: 12 // } // // To update age and favorite color: db.collection("users").document("frank") .update( "age", 13, "favorites.color", "Red" );
Dart
// Assume the document contains: // { // name: "Frank", // favorites: { food: "Pizza", color: "Blue", subject: "recess" } // age: 12 // } db .collection("users") .doc("frank") .update({"age": 13, "favorites.color": "Red"});
Java
Python
Python
C
// Assume the document contains: // { // name: "Frank", // favorites: { food: "Pizza", color: "Blue", subject: "recess" } // age: 12 // } // // To update age and favorite color: db->Collection("users").Document("frank").Update({ {"age", FieldValue::Integer(13)}, {"favorites.color", FieldValue::String("red")}, });
Node.js
Go
PHP
PHP
Para obtener más información sobre la instalación y creación de un cliente de Cloud Firestore, consulta las bibliotecas cliente de Cloud Firestore.
Unity
DocumentReference frankDocRef = db.Collection("users").Document("frank"); Dictionary<string, object> initialData = new Dictionary<string, object> { { "Name", "Frank" }, { "Age", 12 } }; Dictionary<string, object> favorites = new Dictionary<string, object> { { "Food", "Pizza" }, { "Color", "Blue" }, { "Subject", "Recess" }, }; initialData.Add("Favorites", favorites); frankDocRef.SetAsync(initialData).ContinueWithOnMainThread(task => { // Update age and favorite color Dictionary<string, object> updates = new Dictionary<string, object> { { "Age", 13 }, { "Favorites.Color", "Red" }, }; // Asynchronously update the document return frankDocRef.UpdateAsync(updates); }).ContinueWithOnMainThread(task => { Debug.Log( "Updated the age and favorite color fields of the Frank document in " "the users collection."); });
C#
Ruby
La notación de puntos te permite actualizar un solo campo anidado sin reemplazar otro campo anidado. Si actualizas un campo anidado sin notación de puntos, reemplazarás todo el campo del mapa, por ejemplo:
Web
// Create our initial doc db.collection("users").doc("frank").set({ name: "Frank", favorites: { food: "Pizza", color: "Blue", subject: "Recess" }, age: 12 }).then(function() { console.log("Frank created"); }); // Update the doc without using dot notation. // Notice the map value for favorites. db.collection("users").doc("frank").update({ favorites: { food: "Ice Cream" } }).then(function() { console.log("Frank food updated"); }); /* Ending State, favorite.color and favorite.subject are no longer present: /users /frank { name: "Frank", favorites: { food: "Ice Cream", }, age: 12 } */
Actualiza elementos de un array
Si tu documento contiene un campo de array, puedes usar arrayUnion()
y arrayRemove()
para agregar y quitar elementos. Con arrayUnion()
, se pueden agregar elementos a un array, pero solo si aún no están presentes. arrayRemove()
permite quitar todas
las instancias de cada elemento dado.
API modular web
import { doc, updateDoc, arrayUnion, arrayRemove } from "firebase/firestore"; const washingtonRef = doc(db, "cities", "DC"); // Atomically add a new region to the "regions" array field. await updateDoc(washingtonRef, { regions: arrayUnion("greater_virginia") }); // Atomically remove a region from the "regions" array field. await updateDoc(washingtonRef, { regions: arrayRemove("east_coast") });
API con espacio de nombres web
var washingtonRef = db.collection("cities").doc("DC"); // Atomically add a new region to the "regions" array field. washingtonRef.update({ regions: firebase.firestore.FieldValue.arrayUnion("greater_virginia") }); // Atomically remove a region from the "regions" array field. washingtonRef.update({ regions: firebase.firestore.FieldValue.arrayRemove("east_coast") });
Swift
let washingtonRef = db.collection("cities").document("DC") // Atomically add a new region to the "regions" array field. washingtonRef.updateData([ "regions": FieldValue.arrayUnion(["greater_virginia"]) ]) // Atomically remove a region from the "regions" array field. washingtonRef.updateData([ "regions": FieldValue.arrayRemove(["east_coast"]) ])
Objective‑C
FIRDocumentReference *washingtonRef = [[self.db collectionWithPath:@"cities"] documentWithPath:@"DC"]; // Atomically add a new region to the "regions" array field. [washingtonRef updateData:@{ @"regions": [FIRFieldValue fieldValueForArrayUnion:@[@"greater_virginia"]] }]; // Atomically remove a new region to the "regions" array field. [washingtonRef updateData:@{ @"regions": [FIRFieldValue fieldValueForArrayRemove:@[@"east_coast"]] }];
Kotlin KTX
val washingtonRef = db.collection("cities").document("DC") // Atomically add a new region to the "regions" array field. washingtonRef.update("regions", FieldValue.arrayUnion("greater_virginia")) // Atomically remove a region from the "regions" array field. washingtonRef.update("regions", FieldValue.arrayRemove("east_coast"))
Java
DocumentReference washingtonRef = db.collection("cities").document("DC"); // Atomically add a new region to the "regions" array field. washingtonRef.update("regions", FieldValue.arrayUnion("greater_virginia")); // Atomically remove a region from the "regions" array field. washingtonRef.update("regions", FieldValue.arrayRemove("east_coast"));
Dart
final washingtonRef = db.collection("cities").doc("DC"); // Atomically add a new region to the "regions" array field. washingtonRef.update({ "regions": FieldValue.arrayUnion(["greater_virginia"]), }); // Atomically remove a region from the "regions" array field. washingtonRef.update({ "regions": FieldValue.arrayRemove(["east_coast"]), });
Java
Python
Python
C
// This is not yet supported.
Node.js
Go
// Not supported yet
PHP
PHP
Para obtener más información sobre la instalación y creación de un cliente de Cloud Firestore, consulta las bibliotecas cliente de Cloud Firestore.
Unity
// This is not yet supported in the Unity SDK
C#
Ruby
// Not supported yet
Incrementa un valor numérico
Puedes aumentar o disminuir un valor de campo numérico como se muestra en el siguiente ejemplo. Una operación de incremento aumenta o disminuye el valor actual del campo según la cantidad dada.
API modular web
import { doc, updateDoc, increment } from "firebase/firestore"; const washingtonRef = doc(db, "cities", "DC"); // Atomically increment the population of the city by 50. await updateDoc(washingtonRef, { population: increment(50) });
API con espacio de nombres web
var washingtonRef = db.collection('cities').doc('DC'); // Atomically increment the population of the city by 50. washingtonRef.update({ population: firebase.firestore.FieldValue.increment(50) });
Swift
let washingtonRef = db.collection("cities").document("DC") // Atomically increment the population of the city by 50. // Note that increment() with no arguments increments by 1. washingtonRef.updateData([ "population": FieldValue.increment(Int64(50)) ])
Objective‑C
FIRDocumentReference *washingtonRef = [[self.db collectionWithPath:@"cities"] documentWithPath:@"DC"]; // Atomically increment the population of the city by 50. // Note that increment() with no arguments increments by 1. [washingtonRef updateData:@{ @"population": [FIRFieldValue fieldValueForIntegerIncrement:50] }];
Kotlin KTX
val washingtonRef = db.collection("cities").document("DC") // Atomically increment the population of the city by 50. washingtonRef.update("population", FieldValue.increment(50))
Java
DocumentReference washingtonRef = db.collection("cities").document("DC"); // Atomically increment the population of the city by 50. washingtonRef.update("population", FieldValue.increment(50));
Dart
var washingtonRef = db.collection('cities').doc('DC'); // Atomically increment the population of the city by 50. washingtonRef.update( {"population": FieldValue.increment(50)}, );
Java
Python
Python
C
// This is not yet supported.
Node.js
Go
PHP
PHP
Para obtener más información sobre la instalación y creación de un cliente de Cloud Firestore, consulta las bibliotecas cliente de Cloud Firestore.
Unity
// This is not yet supported in the Unity SDK.
C#
Ruby
Las operaciones de incremento son útiles para implementar contadores, pero ten en cuenta que puedes actualizar un documento individual solo una vez por segundo. Si necesitas actualizar tu contador por encima de esta frecuencia, consulta la página Contadores distribuidos.