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 de configurar, agregar o actualizar documentos individuales en Cloud Firestore. Si deseas escribir datos de manera masiva, consulta Transacciones y escrituras en lotes.
Configura un documento
Para crear o reemplazar un solo documento, usa el método set()
:
Web versión 9
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" });
Web versión 8
// 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
// Add a new document in collection "cities" db.collection("cities").document("LA").setData([ "name": "Los Angeles", "state": "CA", "country": "USA" ]) { err in if let err = err { print("Error writing document: \(err)") } else { print("Document successfully written!") } }
Objective‑C
// 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!"); } }];
Java
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); } });
Kotlin+KTX
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
Python
Python
C++
// 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
Go
PHP
$data = [ 'name' => 'Los Angeles', 'state' => 'CA', 'country' => 'USA' ]; $db->collection('samples/php/cities')->document('LA')->set($data);
Unity
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#
DocumentReference docRef = db.Collection("cities").Document("LA"); Dictionary<string, object> city = new Dictionary<string, object> { { "name", "Los Angeles" }, { "state", "CA" }, { "country", "USA" } }; await docRef.SetAsync(city);
Ruby
Si el documento no existe, se creará. Si el documento existe, su contenido se reemplazará con los datos proporcionados, a menos que especifiques que los datos se deberían combinar en el documento existente, de la siguiente manera:
Web versión 9
import { doc, setDoc } from "firebase/firestore"; const cityRef = doc(db, 'cities', 'BJ'); setDoc(cityRef, { capital: true }, { merge: true });
Web versión 8
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) { // ... }];
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());
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
Python
Python
C++
db->Collection("cities").Document("BJ").Set( {{"capital", FieldValue::Boolean(true)}}, SetOptions::Merge());
Node.js
Go
PHP
$cityRef = $db->collection('samples/php/cities')->document('BJ'); $cityRef->set([ 'capital' => true ], ['merge' => true]);
Unity
DocumentReference docRef = db.Collection("cities").Document("LA"); Dictionary<string, object> update = new Dictionary<string, object> { { "capital", false } }; docRef.SetAsync(update, SetOptions.MergeAll);
C#
DocumentReference docRef = db.Collection("cities").Document("LA"); Dictionary<string, object> update = new Dictionary<string, object> { { "capital", false } }; await docRef.SetAsync(update, SetOptions.MergeAll);
Ruby
Si no estás seguro de la existencia del documento, 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, strings, booleanos, números, fechas y nulos. Cloud Firestore siempre almacena los números como dobles, independientemente del tipo de número que uses en tu código.
Web versión 9
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);
Web versión 8
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" ] ] ] db.collection("data").document("one").setData(docData) { err in if let err = err { print("Error writing document: \(err)") } else { print("Document successfully written!") } }
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!"); } }];
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); } });
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
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
$data = [ 'stringExample' => 'Hello World', 'booleanExample' => true, 'numberExample' => 3.14159265, 'dateExample' => new Timestamp(new DateTime()), 'arrayExample' => array(5, true, 'hello'), 'nullExample' => null, 'objectExample' => ['a' => 5, 'b' => true], 'documentReferenceExample' => $db->collection('samples/php/data')->document('two'), ]; $db->collection('samples/php/data')->document('one')->set($data); printf('Set multiple data-type data for the one document in the data collection.' . PHP_EOL);
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#
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 }, }; ArrayList arrayExample = new ArrayList(); arrayExample.Add(5); arrayExample.Add(true); arrayExample.Add("Hello"); docData.Add("arrayExample", arrayExample); Dictionary<string, object> objectExample = new Dictionary<string, object> { { "a", 5 }, { "b", true }, }; docData.Add("objectExample", objectExample); await docRef.SetAsync(docData);
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:
Web versión 9
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); } };
Web versión 8
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.
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; } }
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
Python
Python
C++
// This is not yet supported.
Node.js
// Node.js uses JavaScript objects
Go
PHP
// This isn't supported in PHP
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#
[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; } }
Ruby
// This isn't supported in Ruby
Web versión 9
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"));
Web versión 8
// 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.
Java
City city = new City("Los Angeles", "CA", "USA", false, 5000000L, Arrays.asList("west_coast", "sorcal")); db.collection("cities").document("LA").set(city);
Kotlin+KTX
val city = City("Los Angeles", "CA", "USA", false, 5000000L, listOf("west_coast", "socal")) db.collection("cities").document("LA").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 = 3900000L }; docRef.SetAsync(city);
C#
DocumentReference docRef = db.Collection("cities").Document("LA"); City city = new City { Name = "Los Angeles", State = "CA", Country = "USA", Capital = false, Population = 3900000L }; await docRef.SetAsync(city);
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:
Web versión 9
import { doc, setDoc } from "firebase/firestore"; await setDoc(doc(db, "cities", "new-city-id"), data);
Web versión 8
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];
Java
db.collection("cities").document("new-city-id").set(data);
Kotlin+KTX
db.collection("cities").document("new-city-id").set(data)
Java
Python
Python
C++
db->Collection("cities").Document("SF").Set({/*some data*/});
Node.js
Go
PHP
$db->collection('samples/php/cities')->document('new-city-id')->set($data);
Unity
db.Collection("cities").Document("new-city-id").SetAsync(city);
C#
await db.Collection("cities").Document("new-city-id").SetAsync(city);
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 hacerlo,
llama a add()
:
Web versión 9
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);
Web versión 8
// 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
// Add a new document with a generated id. var ref: DocumentReference? = nil ref = db.collection("cities").addDocument(data: [ "name": "Tokyo", "country": "Japan" ]) { err in if let err = err { print("Error adding document: \(err)") } else { print("Document added with ID: \(ref!.documentID)") } }
Objective‑C
// 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); } }];
Java
// 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); } });
Kotlin+KTX
// 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
Python
Python
C++
db->Collection("cities").Add({/*some data*/});
Node.js
Go
PHP
$data = [ 'name' => 'Tokyo', 'country' => 'Japan' ]; $addedDocRef = $db->collection('samples/php/cities')->add($data); printf('Added document with ID: %s' . PHP_EOL, $addedDocRef->id());
Unity
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#
Dictionary<string, object> city = new Dictionary<string, object> { { "Name", "Tokyo" }, { "Country", "Japan" } }; DocumentReference addedDocRef = await db.Collection("cities").AddAsync(city); Console.WriteLine("Added document with ID: {0}.", addedDocRef.Id);
Ruby
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()
:
Web versión 9
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);
Web versión 8
// 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:@{ /* ... */ }];
Java
Map<String, Object> data = new HashMap<>(); DocumentReference newCityRef = db.collection("cities").document(); // Later... newCityRef.set(data);
Kotlin+KTX
val data = HashMap<String, Any>() val newCityRef = db.collection("cities").document() // Later... newCityRef.set(data)
Java
Python
Python
C++
DocumentReference new_city_ref = db->Collection("cities").Document();
Node.js
Go
PHP
$addedDocRef = $db->collection('samples/php/cities')->newDocument(); printf('Added document with ID: %s' . PHP_EOL, $addedDocRef->id()); $addedDocRef->set($data);
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#
DocumentReference addedDocRef = db.Collection("cities").Document(); Console.WriteLine("Added document with ID: {0}.", addedDocRef.Id); await addedDocRef.SetAsync(city);
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
el método update()
:
Web versión 9
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 });
Web versión 8
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
let washingtonRef = db.collection("cities").document("DC") // Set the "capital" field of the city 'DC' washingtonRef.updateData([ "capital": true ]) { err in if let err = err { print("Error updating document: \(err)") } else { print("Document successfully updated") } }
Objective‑C
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"); } }];
Java
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); } });
Kotlin+KTX
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
Python
Python
C++
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
Go
PHP
$cityRef = $db->collection('samples/php/cities')->document('DC'); $cityRef->update([ ['path' => 'capital', 'value' => true] ]);
Unity
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#
DocumentReference cityRef = db.Collection("cities").Document("new-city-id"); Dictionary<string, object> updates = new Dictionary<string, object> { { "Capital", false } }; await cityRef.UpdateAsync(updates); // You can also update a single field with: await cityRef.UpdateAsync("Capital", false);
Ruby
Marca de tiempo del servidor
Puedes configurar un campo en tu documento para una marca de tiempo de servidor que haga un seguimiento de cuando el servidor recibe la actualización.
Web versión 9
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() });
Web versión 8
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
db.collection("objects").document("some-id").updateData([ "lastUpdated": FieldValue.serverTimestamp(), ]) { err in if let err = err { print("Error updating document: \(err)") } else { print("Document successfully updated") } }
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"); } }];
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>() { // ... // ...
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
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
$docRef = $db->collection('samples/php/objects')->document('some-id'); $docRef->update([ ['path' => 'timestamp', 'value' => FieldValue::serverTimestamp()] ]);
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#
DocumentReference cityRef = db.Collection("cities").Document("new-city-id"); await cityRef.UpdateAsync("Timestamp", Timestamp.GetCurrentTimestamp());
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 de 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()
:
Web versión 9
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" });
Web versión 8
// 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") frankDocRef.setData([ "name": "Frank", "favorites": [ "food": "Pizza", "color": "Blue", "subject": "recess" ], "age": 12 ]) // To update age and favorite color: db.collection("users").document("frank").updateData([ "age": 13, "favorites.color": "Red" ]) { err in if let err = err { print("Error updating document: \(err)") } else { print("Document successfully updated") } }
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"); } }];
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" );
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
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
// Create an initial document to update $frankRef = $db->collection('samples/php/users')->document('frank'); $frankRef->set([ 'first' => 'Frank', 'last' => 'Franklin', 'favorites' => ['food' => 'Pizza', 'color' => 'Blue', 'subject' => 'Recess'], 'age' => 12 ]); // Update age and favorite color $frankRef->update([ ['path' => 'age', 'value' => 13], ['path' => 'favorites.color', 'value' => 'Red'] ]);
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#
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); await frankDocRef.SetAsync(initialData); // Update age and favorite color Dictionary<string, object> updates = new Dictionary<string, object> { { "Age", 13 }, { "Favorites.Color", "Red" }, }; // Asynchronously update the document await frankDocRef.UpdateAsync(updates);
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.
Web versión 9
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") });
Web versión 8
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"]] }];
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"));
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
Python
Python
C++
// This is not yet supported.
Node.js
Go
// Not supported yet
PHP
$cityRef = $db->collection('samples/php/cities')->document('DC'); // Atomically add a new region to the "regions" array field. $cityRef->update([ ['path' => 'regions', 'value' => FieldValue::arrayUnion(['greater_virginia'])] ]); // Atomically remove a region from the "regions" array field. $cityRef->update([ ['path' => 'regions', 'value' => FieldValue::arrayRemove(['east_coast'])] ]);
Unity
// This is not yet supported in the Unity SDK
C#
DocumentReference washingtonRef = db.Collection("cities").Document("DC"); // Atomically add a new region to the "regions" array field. await washingtonRef.UpdateAsync("Regions", FieldValue.ArrayUnion("greater_virginia")); // Atomically remove a region from the "regions" array field. await washingtonRef.UpdateAsync("Regions", FieldValue.ArrayRemove("east_coast"));
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.
Web versión 9
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) });
Web versión 8
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] }];
Java
DocumentReference washingtonRef = db.collection("cities").document("DC"); // Atomically increment the population of the city by 50. washingtonRef.update("population", FieldValue.increment(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
Python
Python
C++
// This is not yet supported.
Node.js
Go
PHP
$cityRef = $db->collection('samples/php/cities')->document('DC'); // Atomically increment the population of the city by 50. $cityRef->update([ ['path' => 'regions', 'value' => FieldValue::increment(50)] ]);
Unity
// This is not yet supported in the Unity SDK.
C#
DocumentReference washingtonRef = db.Collection("cities").Document("DC"); // Atomically increment the population of the city by 50. await washingtonRef.UpdateAsync("Regions", FieldValue.Increment(50));
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.