Adicionar dados ao Cloud Firestore

Existem várias maneiras de gravar dados no Cloud Firestore:

  • Defina os dados de um documento dentro de uma coleção, especificando explicitamente um identificador de documento.
  • Adicione um novo documento a uma coleção. Neste caso, o Cloud Firestore gera automaticamente o identificador do documento.
  • Crie um documento vazio com um identificador gerado automaticamente e atribua dados a ele posteriormente.

Este guia explica como usar a definição, adição ou atualização de documentos individuais no Cloud Firestore. Se você quiser gravar dados em massa, consulte Transações e gravações em lote .

Antes de você começar

Consulte Primeiros passos com o Cloud Firestore para criar um banco de dados do Cloud Firestore.

Inicializar o Cloud Firestore

Inicialize uma instância do Cloud Firestore:

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

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

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


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

Substitua FIREBASE_CONFIGURATION pelo firebaseConfig do seu aplicativo da web.

Para persistir os dados quando o dispositivo perder a conexão, consulte a documentação Ativar dados off-line .

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();

Substitua FIREBASE_CONFIGURATION pelo firebaseConfig do seu aplicativo da web.

Para persistir os dados quando o dispositivo perder a conexão, consulte a documentação Ativar dados off-line .

Observação: este produto não está disponível em destinos watchOS e App Clip.
import FirebaseCore
import FirebaseFirestore
FirebaseApp.configure()

let db = Firestore.firestore()
Observação: este produto não está disponível em destinos watchOS e App Clip.
@import FirebaseCore;
@import FirebaseFirestore;

// Use Firebase library to configure APIs
[FIRApp configure];
 
FIRFirestore *defaultFirestore = [FIRFirestore firestore];
// Access a Cloud Firestore instance from your Activity
val db = Firebase.firestore
// Access a Cloud Firestore instance from your Activity
FirebaseFirestore db = FirebaseFirestore.getInstance();
db = FirebaseFirestore.instance;
O SDK do Cloud Firestore é inicializado de diferentes maneiras dependendo do seu ambiente. Abaixo estão os métodos mais comuns. Para obter uma referência completa, consulte Inicializar o Admin SDK .
  • Inicializar no Google Cloud
    import com.google.auth.oauth2.GoogleCredentials;
    import com.google.cloud.firestore.Firestore;

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

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

    Firestore db = FirestoreClient.getFirestore();
  • Inicialize em seu próprio servidor

    Para usar o SDK Admin do Firebase em seu próprio servidor, use uma conta de serviço .

    Acesse IAM e administrador > Contas de serviço no console do Google Cloud. Gere uma nova chave privada e salve o arquivo JSON. Em seguida, use o arquivo para inicializar o 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();
  • O SDK do Cloud Firestore é inicializado de diferentes maneiras dependendo do seu ambiente. Abaixo estão os métodos mais comuns. Para obter uma referência completa, consulte Inicializar o Admin SDK .
  • Inicializar no Google Cloud
    import firebase_admin
    from firebase_admin import firestore

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

    Uma credencial padrão do aplicativo existente também pode ser usada para inicializar o 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()
  • Inicialize em seu próprio servidor

    Para usar o SDK Admin do Firebase em seu próprio servidor, use uma conta de serviço .

    Acesse IAM e administrador > Contas de serviço no console do Google Cloud. Gere uma nova chave privada e salve o arquivo JSON. Em seguida, use o arquivo para inicializar o 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()
  • O SDK do Cloud Firestore é inicializado de diferentes maneiras dependendo do seu ambiente. Abaixo estão os métodos mais comuns. Para obter uma referência completa, consulte Inicializar o Admin SDK .
  • Inicializar no Google Cloud
    import firebase_admin
    from firebase_admin import firestore_async

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

    Uma credencial padrão do aplicativo existente também pode ser usada para inicializar o 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()
  • Inicialize em seu próprio servidor

    Para usar o SDK Admin do Firebase em seu próprio servidor, use uma conta de serviço .

    Acesse IAM e administrador > Contas de serviço no console do Google Cloud. Gere uma nova chave privada e salve o arquivo JSON. Em seguida, use o arquivo para inicializar o SDK:

    import firebase_admin
    from firebase_admin import credentials
    from firebase_admin import firestore_async

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

    app
    = firebase_admin.initialize_app(cred)

    db
    = firestore_async.client()
  • // Make sure the call to `Create()` happens some time before you call Firestore::GetInstance().
    App::Create();
    Firestore* db = Firestore::GetInstance();
    O SDK do Cloud Firestore é inicializado de diferentes maneiras dependendo do seu ambiente. Abaixo estão os métodos mais comuns. Para obter uma referência completa, consulte Inicializar o Admin SDK .
    • Inicializar no Cloud Functions
      const { initializeApp, applicationDefault, cert } = require('firebase-admin/app');
      const { getFirestore, Timestamp, FieldValue, Filter } = require('firebase-admin/firestore');
      initializeApp();

      const db = getFirestore();
    • Inicializar no 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();
    • Inicialize em seu próprio servidor

      Para usar o SDK Admin do Firebase em seu próprio servidor (ou em qualquer outro ambiente Node.js), use uma conta de serviço . Acesse IAM e administrador > Contas de serviço no console do Google Cloud. Gere uma nova chave privada e salve o arquivo JSON. Em seguida, use o arquivo para inicializar o 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();
    O SDK do Cloud Firestore é inicializado de diferentes maneiras dependendo do seu ambiente. Abaixo estão os métodos mais comuns. Para obter uma referência completa, consulte Inicializar o Admin SDK .
  • Inicializar no Google Cloud
    import (
     
    "log"

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

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

    client
    , err := app.Firestore(ctx)
    if err != nil {
      log
    .Fatalln(err)
    }
    defer client
    .Close()
  • Inicialize em seu próprio servidor

    Para usar o SDK Admin do Firebase em seu próprio servidor, use uma conta de serviço .

    Acesse IAM e administrador > Contas de serviço no console do Google Cloud. Gere uma nova chave privada e salve o arquivo JSON. Em seguida, use o arquivo para inicializar o SDK:

    import (
     
    "log"

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

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

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

    Para obter mais informações sobre como instalar e criar um cliente Cloud Firestore, consulte Bibliotecas de cliente Cloud Firestore .

    use Google\Cloud\Firestore\FirestoreClient;

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

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

    C#

    Para obter mais informações sobre como instalar e criar um cliente Cloud Firestore, consulte Bibliotecas de cliente Cloud Firestore .

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

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

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

    Definir um documento

    Para criar ou substituir um único documento, use os seguintes métodos set() específicos do idioma:

    Use o 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"
    });

    Use o 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);
    });

    Use o método setData() :

    Observação: este produto não está disponível em destinos watchOS e App Clip.
    // 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)")
    }

    Use o método setData: ::

    Observação: este produto não está disponível em destinos watchOS e App Clip.
    // 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!");
     
    }
    }];

    Use o 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) }

    Use o 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);
               
    }
           
    });

    Use o 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"));

    Use o método set() :

    // Create a Map to store the data we want to set
    Map<String, Object> docData = new HashMap<>();
    docData
    .put("name", "Los Angeles");
    docData
    .put("state", "CA");
    docData
    .put("country", "USA");
    docData
    .put("regions", Arrays.asList("west_coast", "socal"));
    // Add a new document (asynchronously) in collection "cities" with id "LA"
    ApiFuture<WriteResult> future = db.collection("cities").document("LA").set(docData);
    // ...
    // future.get() blocks on response
    System.out.println("Update time : " + future.get().getUpdateTime());

    Use o método set() :

    data = {"name": "Los Angeles", "state": "CA", "country": "USA"}

    # Add a new doc in collection 'cities' with ID 'LA'
    db
    .collection("cities").document("LA").set(data)

    Use o método set() :

    data = {"name": "Los Angeles", "state": "CA", "country": "USA"}

    # Add a new doc in collection 'cities' with ID 'LA'
    await db
    .collection("cities").document("LA").set(data)

    Use o 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;
         
    }
       
    });

    Use o método set() :

    const data = {
      name
    : 'Los Angeles',
      state
    : 'CA',
      country
    : 'USA'
    };

    // Add a new document in collection "cities" with ID 'LA'
    const res = await db.collection('cities').doc('LA').set(data);

    Use o método Set() :


    import (
           
    "context"
           
    "log"

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

    func addDocAsMap
    (ctx context.Context, client *firestore.Client) error {
            _
    , err := client.Collection("cities").Doc("LA").Set(ctx, map[string]interface{}{
                   
    "name":    "Los Angeles",
                   
    "state":   "CA",
                   
    "country": "USA",
           
    })
           
    if err != nil {
                   
    // Handle any errors in an appropriate way, such as returning them.
                    log
    .Printf("An error has occurred: %s", err)
           
    }

           
    return err
    }

    Use o método set() :

    PHP

    Para obter mais informações sobre como instalar e criar um cliente Cloud Firestore, consulte Bibliotecas de cliente Cloud Firestore .

    $data = [
       
    'name' => 'Los Angeles',
       
    'state' => 'CA',
       
    'country' => 'USA'
    ];
    $db
    ->collection('samples/php/cities')->document('LA')->set($data);

    Use o 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.");
    });

    Use o 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" }
    };
    await docRef
    .SetAsync(city);

    Use o método set() :

    city_ref = firestore.doc "#{collection_path}/LA"

    data
    = {
      name
    :    "Los Angeles",
      state
    :   "CA",
      country
    : "USA"
    }

    city_ref
    .set data

    Caso o documento não exista, ele será criado. Se o documento existir, seu conteúdo será substituído pelos dados recém-fornecidos, a menos que você especifique que os dados devem ser mesclados no documento existente, como segue:

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

    const cityRef = doc(db, 'cities', 'BJ');
    setDoc
    (cityRef, { capital: true }, { merge: true });
    var cityRef = db.collection('cities').doc('BJ');

    var setWithMerge = cityRef.set({
        capital
    : true
    }, { merge: true });
    Observação: este produto não está disponível em destinos watchOS e App Clip.
    // Update one field, creating the document if it does not exist.
    db.collection("cities").document("BJ").setData([ "capital": true ], merge: true)
    Observação: este produto não está disponível em destinos watchOS e App Clip.
    // 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) {
           
    // ...
         
    }];
    // 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())
    // 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());
    // 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));
    // asynchronously update doc, create the document if missing
    Map<String, Object> update = new HashMap<>();
    update
    .put("capital", true);

    ApiFuture<WriteResult> writeResult =
        db
    .collection("cities").document("BJ").set(update, SetOptions.merge());
    // ...
    System.out.println("Update time : " + writeResult.get().getUpdateTime());
    city_ref = db.collection("cities").document("BJ")

    city_ref
    .set({"capital": True}, merge=True)
    city_ref = db.collection("cities").document("BJ")

    await city_ref
    .set({"capital": True}, merge=True)
    db->Collection("cities").Document("BJ").Set(
       
    {{"capital", FieldValue::Boolean(true)}}, SetOptions::Merge());
    const cityRef = db.collection('cities').doc('BJ');

    const res = await cityRef.set({
      capital
    : true
    }, { merge: true });

    import (
           
    "context"
           
    "log"

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

    func updateDocCreateIfMissing
    (ctx context.Context, client *firestore.Client) error {
            _
    , err := client.Collection("cities").Doc("BJ").Set(ctx, map[string]interface{}{
                   
    "capital": true,
           
    }, firestore.MergeAll)

           
    if err != nil {
                   
    // Handle any errors in an appropriate way, such as returning them.
                    log
    .Printf("An error has occurred: %s", err)
           
    }

           
    return err
    }

    PHP

    Para obter mais informações sobre como instalar e criar um cliente Cloud Firestore, consulte Bibliotecas de cliente Cloud Firestore .

    $cityRef = $db->collection('samples/php/cities')->document('BJ');
    $cityRef
    ->set([
       
    'capital' => true
    ], ['merge' => true]);
    DocumentReference docRef = db.Collection("cities").Document("LA");
    Dictionary<string, object> update = new Dictionary<string, object>
    {
           
    { "capital", false }
    };
    docRef
    .SetAsync(update, SetOptions.MergeAll);
    DocumentReference docRef = db.Collection("cities").Document("LA");
    Dictionary<string, object> update = new Dictionary<string, object>
    {
       
    { "capital", false }
    };
    await docRef
    .SetAsync(update, SetOptions.MergeAll);
    city_ref = firestore.doc "#{collection_path}/LA"
    city_ref
    .set({ capital: false }, merge: true)

    Se você não tiver certeza se o documento existe, passe a opção de mesclar os novos dados com qualquer documento existente para evitar a substituição de documentos inteiros. Para documentos contendo mapas, observe que especificar um conjunto com um campo contendo um mapa vazio substituirá o campo de mapa do documento de destino.

    Tipos de dados

    O Cloud Firestore permite gravar vários tipos de dados em um documento, incluindo strings, booleanos, números, datas, nulos e matrizes e objetos aninhados. O Cloud Firestore sempre armazena números duplos, independentemente do tipo de número usado no código.

    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);
    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!");
    });
    Observação: este produto não está disponível em destinos watchOS e App Clip.
    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)")
    }
    Observação: este produto não está disponível em destinos watchOS e App Clip.
    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!");
         
    }
       
    }];
    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) }
    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);
               
    }
           
    });
    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"));
    Map<String, Object> docData = new HashMap<>();
    docData
    .put("stringExample", "Hello, World");
    docData
    .put("booleanExample", false);
    docData
    .put("numberExample", 3.14159265);
    docData
    .put("nullExample", null);

    ArrayList<Object> arrayExample = new ArrayList<>();
    Collections.addAll(arrayExample, 5L, true, "hello");
    docData
    .put("arrayExample", arrayExample);

    Map<String, Object> objectExample = new HashMap<>();
    objectExample
    .put("a", 5L);
    objectExample
    .put("b", true);

    docData
    .put("objectExample", objectExample);

    ApiFuture<WriteResult> future = db.collection("data").document("one").set(docData);
    System.out.println("Update time : " + future.get().getUpdateTime());
    data = {
       
    "stringExample": "Hello, World!",
       
    "booleanExample": True,
       
    "numberExample": 3.14159265,
       
    "dateExample": datetime.datetime.now(tz=datetime.timezone.utc),
       
    "arrayExample": [5, True, "hello"],
       
    "nullExample": None,
       
    "objectExample": {"a": 5, "b": True},
    }

    db
    .collection("data").document("one").set(data)
    data = {
       
    "stringExample": "Hello, World!",
       
    "booleanExample": True,
       
    "numberExample": 3.14159265,
       
    "dateExample": datetime.datetime.now(tz=datetime.timezone.utc),
       
    "arrayExample": [5, True, "hello"],
       
    "nullExample": None,
       
    "objectExample": {"a": 5, "b": True},
    }

    await db
    .collection("data").document("one").set(data)
    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;
         
    }
       
    });
    const data = {
      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
    : true
     
    }
    };

    const res = await db.collection('data').doc('one').set(data);

    import (
           
    "context"
           
    "log"
           
    "time"

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

    func addDocDataTypes
    (ctx context.Context, client *firestore.Client) error {
            doc
    := make(map[string]interface{})
            doc
    ["stringExample"] = "Hello world!"
            doc
    ["booleanExample"] = true
            doc
    ["numberExample"] = 3.14159265
            doc
    ["dateExample"] = time.Now()
            doc
    ["arrayExample"] = []interface{}{5, true, "hello"}
            doc
    ["nullExample"] = nil
            doc
    ["objectExample"] = map[string]interface{}{
                   
    "a": 5,
                   
    "b": true,
           
    }

            _
    , err := client.Collection("data").Doc("one").Set(ctx, doc)
           
    if err != nil {
                   
    // Handle any errors in an appropriate way, such as returning them.
                    log
    .Printf("An error has occurred: %s", err)
           
    }

           
    return err
    }

    PHP

    Para obter mais informações sobre como instalar e criar um cliente Cloud Firestore, consulte Bibliotecas de cliente Cloud Firestore .

    $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);
    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);
    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);
    doc_ref = firestore.doc "#{collection_path}/one"

    data
    = {
      stringExample
    :  "Hello, World!",
      booleanExample
    : true,
      numberExample
    :  3.14159265,
      dateExample
    :    DateTime.now,
      arrayExample
    :   [5, true, "hello"],
      nullExample
    :    nil,
      objectExample
    :  {
        a
    : 5,
        b
    : true
     
    }
    }

    doc_ref
    .set data

    Objetos personalizados

    Usar objetos Map ou Dictionary para representar seus documentos geralmente não é muito conveniente, portanto, o Cloud Firestore oferece suporte à gravação de documentos com classes personalizadas. O Cloud Firestore converte os objetos em tipos de dados compatíveis.

    Usando classes personalizadas, você poderia reescrever o exemplo inicial conforme mostrado:

    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);
       
    }
    };
    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);
       
    }
    };
    Observação: este produto não está disponível em destinos watchOS e App Clip.
    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
     
    }

    }
    Observação: este produto não está disponível em destinos watchOS e App Clip.
    // This isn't supported in Objective-C.
     
    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,
    )

    Cada classe personalizada deve ter um construtor público que não aceita argumentos. Além disso, a classe deve incluir um getter público para cada propriedade.

    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;
       
    }

    }
    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,
       
    };
     
    }
    }
    public City() {
     
    // Must have a public no-argument constructor
    }

    // Initialize all fields of a city
    public City(
       
    String name,
       
    String state,
       
    String country,
       
    Boolean capital,
       
    Long population,
       
    List<String> regions) {
     
    this.name = name;
     
    this.state = state;
     
    this.country = country;
     
    this.capital = capital;
     
    this.population = population;
     
    this.regions = regions;
    }
    class City:
       
    def __init__(self, name, state, country, capital=False, population=0, regions=[]):
            self
    .name = name
            self
    .state = state
            self
    .country = country
            self
    .capital = capital
            self
    .population = population
            self
    .regions = regions

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

       
    def to_dict(self):
           
    # ...

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


    class City:
       
    def __init__(self, name, state, country, capital=False, population=0, regions=[]):
            self
    .name = name
            self
    .state = state
            self
    .country = country
            self
    .capital = capital
            self
    .population = population
            self
    .regions = regions

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

       
    def to_dict(self):
           
    # ...

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


    // This is not yet supported.
    // Node.js uses JavaScript objects

    // City represents a city.
    type
    City struct {
           
    Name       string   `firestore:"name,omitempty"`
           
    State      string   `firestore:"state,omitempty"`
           
    Country    string   `firestore:"country,omitempty"`
           
    Capital    bool     `firestore:"capital,omitempty"`
           
    Population int64    `firestore:"population,omitempty"`
           
    Regions    []string `firestore:"regions,omitempty"`
    }

    PHP

    Para obter mais informações sobre como instalar e criar um cliente Cloud Firestore, consulte Bibliotecas de cliente Cloud Firestore .

    class City
    {
       
    /** @var string */
       
    public $name;
       
    /** @var string */
       
    public $state;
       
    /** @var string */
       
    public $country;
       
    /** @var bool */
       
    public $capital;
       
    /** @var int */
       
    public $population;
       
    /** @var array<string> */
       
    public $regions;

       
    /**
         * @param array<string> $regions
         */

       
    public function __construct(
           
    string $name,
           
    string $state,
           
    string $country,
           
    bool $capital = false,
           
    int $population = 0,
            array $regions
    = []
       
    ) {
            $this
    ->name = $name;
            $this
    ->state = $state;
            $this
    ->country = $country;
            $this
    ->capital = $capital;
            $this
    ->population = $population;
            $this
    ->regions = $regions;
       
    }

       
    /**
         * @param array<mixed> $source
         */

       
    public static function fromArray(array $source): City
       
    {
           
    // implementation of fromArray is excluded for brevity
           
    # ...
       
    }

       
    /**
         * @return array<mixed>
         */

       
    public function toArray(): array
       
    {
           
    // implementation of toArray is excluded for brevity
           
    # ...
       
    }

       
    public function __toString()
       
    {
           
    // implementation of __toString is excluded for brevity
           
    # ...
       
    }
    }
    [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; }
    }
    [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; }
    }
    // This isn't supported in Ruby
    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"));
    // Set with cityConverter
    db
    .collection("cities").doc("LA")
     
    .withConverter(cityConverter)
     
    .set(new City("Los Angeles", "CA", "USA"));
    Observação: este produto não está disponível em destinos watchOS e App Clip.
    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)")
    }
    Observação: este produto não está disponível em destinos watchOS e App Clip.
    // This isn't supported in Objective-C.
     
    val city = City(
       
    "Los Angeles",
       
    "CA",
       
    "USA",
       
    false,
       
    5000000L,
        listOf
    ("west_coast", "socal"),
    )
    db
    .collection("cities").document("LA").set(city)
    City city = new City("Los Angeles", "CA", "USA",
           
    false, 5000000L, Arrays.asList("west_coast", "sorcal"));
    db
    .collection("cities").document("LA").set(city);
    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);
    City city =
       
    new City("Los Angeles", "CA", "USA", false, 3900000L, Arrays.asList("west_coast", "socal"));
    ApiFuture<WriteResult> future = db.collection("cities").document("LA").set(city);
    // block on response if required
    System.out.println("Update time : " + future.get().getUpdateTime());
    city = City(name="Los Angeles", state="CA", country="USA")
    db
    .collection("cities").document("LA").set(city.to_dict())
    city = City(name="Los Angeles", state="CA", country="USA")
    await db
    .collection("cities").document("LA").set(city.to_dict())
    // This is not yet supported.
    // Node.js uses JavaScript objects

    import (
           
    "context"
           
    "log"

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

    func addDocAsEntity
    (ctx context.Context, client *firestore.Client) error {
            city
    := City{
                   
    Name:    "Los Angeles",
                   
    Country: "USA",
           
    }
            _
    , err := client.Collection("cities").Doc("LA").Set(ctx, city)
           
    if err != nil {
                   
    // Handle any errors in an appropriate way, such as returning them.
                    log
    .Printf("An error has occurred: %s", err)
           
    }

           
    return err
    }
    // This isn't supported in PHP.
    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);
    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);
    // This isn't supported in Ruby.

    Adicionar um documento

    Ao usar set() para criar um documento, você deve especificar um ID para o documento a ser criado. Por exemplo:

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

    await setDoc
    (doc(db, "cities", "new-city-id"), data);
    db.collection("cities").doc("new-city-id").set(data);
    Observação: este produto não está disponível em destinos watchOS e App Clip.
    db.collection("cities").document("new-city-id").setData(data)
    Observação: este produto não está disponível em destinos watchOS e App Clip.
    [[[self.db collectionWithPath:@"cities"] documentWithPath:@"new-city-id"]
        setData
    :data];
    db.collection("cities").document("new-city-id").set(data)
    db.collection("cities").document("new-city-id").set(data);
    db.collection("cities").doc("new-city-id").set({"name": "Chicago"});
    db.collection("cities").document("new-city-id").set(data);
    db.collection("cities").document("new-city-id").set(data)
    await db.collection("cities").document("new-city-id").set(data)
    db->Collection("cities").Document("SF").Set({/*some data*/});
    await db.collection('cities').doc('new-city-id').set(data);

    import (
           
    "context"
           
    "log"

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

    func addDocWithID
    (ctx context.Context, client *firestore.Client) error {
           
    var data = make(map[string]interface{})

            _
    , err := client.Collection("cities").Doc("new-city-id").Set(ctx, data)
           
    if err != nil {
                   
    // Handle any errors in an appropriate way, such as returning them.
                    log
    .Printf("An error has occurred: %s", err)
           
    }

           
    return err
    }

    PHP

    Para obter mais informações sobre como instalar e criar um cliente Cloud Firestore, consulte Bibliotecas de cliente Cloud Firestore .

    $db->collection('samples/php/cities')->document('new-city-id')->set($data);
    db.Collection("cities").Document("new-city-id").SetAsync(city);
    await db.Collection("cities").Document("new-city-id").SetAsync(city);
    city_ref = firestore.doc "#{collection_path}/new-city-id"
    city_ref
    .set data

    Mas às vezes não há um ID significativo para o documento e é mais conveniente permitir que o Cloud Firestore gere automaticamente um ID para você. Você pode fazer isso chamando os seguintes métodos add() específicos da linguagem:

    Use o 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);

    Use o 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);
    });

    Use o método addDocument() :

    Observação: este produto não está disponível em destinos watchOS e App Clip.
    // 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)")
    }

    Use o método addDocumentWithData: ::

    Observação: este produto não está disponível em destinos watchOS e App Clip.
    // 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);
         
    }
       
    }];

    Use o 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)
       
    }

    Use o 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);
               
    }
           
    });

    Use o 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}"));

    Use o método add() :

    // Add document data with auto-generated id.
    Map<String, Object> data = new HashMap<>();
    data
    .put("name", "Tokyo");
    data
    .put("country", "Japan");
    ApiFuture<DocumentReference> addedDocRef = db.collection("cities").add(data);
    System.out.println("Added document with ID: " + addedDocRef.get().getId());

    Use o método add() :

    city = {"name": "Tokyo", "country": "Japan"}
    update_time
    , city_ref = db.collection("cities").add(city)
    print(f"Added document with id {city_ref.id}")

    Use o método add() :

    city = City(name="Tokyo", state=None, country="Japan")
    await db
    .collection("cities").add(city.to_dict())

    Use o método Add() :

    db->Collection("cities").Add({/*some data*/});

    Use o método add() :

    // Add a new document with a generated id.
    const res = await db.collection('cities').add({
      name
    : 'Tokyo',
      country
    : 'Japan'
    });

    console
    .log('Added document with ID: ', res.id);

    Use o método Add() :


    import (
           
    "context"
           
    "log"

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

    func addDocWithoutID
    (ctx context.Context, client *firestore.Client) error {
            _
    , _, err := client.Collection("cities").Add(ctx, map[string]interface{}{
                   
    "name":    "Tokyo",
                   
    "country": "Japan",
           
    })
           
    if err != nil {
                   
    // Handle any errors in an appropriate way, such as returning them.
                    log
    .Printf("An error has occurred: %s", err)
           
    }

           
    return err
    }

    Use o método add() :

    PHP

    Para obter mais informações sobre como instalar e criar um cliente Cloud Firestore, consulte Bibliotecas de cliente Cloud Firestore .

    $data = [
       
    'name' => 'Tokyo',
       
    'country' => 'Japan'
    ];
    $addedDocRef
    = $db->collection('samples/php/cities')->add($data);
    printf
    ('Added document with ID: %s' . PHP_EOL, $addedDocRef->id());

    Use o 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));
    });

    Use o método AddAsync() :

    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);

    Use o método add() :

    data = {
      name
    :    "Tokyo",
      country
    : "Japan"
    }

    cities_ref
    = firestore.col collection_path

    added_doc_ref
    = cities_ref.add data
    puts
    "Added document with ID: #{added_doc_ref.document_id}."

    Em alguns casos, pode ser útil criar uma referência de documento com um ID gerado automaticamente e usar a referência posteriormente. Para este caso de uso, você pode chamar doc() :

    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);
    // Add a new document with a generated id.
    var newCityRef = db.collection("cities").doc();

    // later...
    newCityRef
    .set(data);
    Observação: este produto não está disponível em destinos watchOS e App Clip.
    let newCityRef = db.collection("cities").document()

    // later...
    newCityRef.setData([
     
    // ...
    ])
    Observação: este produto não está disponível em destinos watchOS e App Clip.
    FIRDocumentReference *newCityRef = [[self.db collectionWithPath:@"cities"] documentWithAutoID];
    // later...
    [newCityRef setData:@{ /* ... */ }];
    val data = HashMap<String, Any>()

    val newCityRef = db.collection("cities").document()

    // Later...
    newCityRef
    .set(data)
    Map<String, Object> data = new HashMap<>();

    DocumentReference newCityRef = db.collection("cities").document();

    // Later...
    newCityRef
    .set(data);
    // Add a new document with a generated id.
    final data = <String, dynamic>{};

    final newCityRef = db.collection("cities").doc();

    // Later...
    newCityRef
    .set(data);
    // Add document data after generating an id.
    DocumentReference addedDocRef = db.collection("cities").document();
    System.out.println("Added document with ID: " + addedDocRef.getId());

    // later...
    ApiFuture<WriteResult> writeResult = addedDocRef.set(data);
    new_city_ref = db.collection("cities").document()

    # later...
    new_city_ref
    .set(
       
    {
           
    # ...
       
    }
    )
    new_city_ref = db.collection("cities").document()

    # later...
    await new_city_ref
    .set(
       
    {
           
    # ...
       
    }
    )
    DocumentReference new_city_ref = db->Collection("cities").Document();
    const newCityRef = db.collection('cities').doc();

    // Later...
    const res = await newCityRef.set({
     
    // ...
    });

    import (
           
    "context"
           
    "log"

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

    func addDocAfterAutoGeneratedID
    (ctx context.Context, client *firestore.Client) error {
            data
    := City{
                   
    Name:    "Sydney",
                   
    Country: "Australia",
           
    }

           
    ref := client.Collection("cities").NewDoc()

           
    // later...
            _
    , err := ref.Set(ctx, data)
           
    if err != nil {
                   
    // Handle any errors in an appropriate way, such as returning them.
                    log
    .Printf("An error has occurred: %s", err)
           
    }

           
    return err
    }

    PHP

    Para obter mais informações sobre como instalar e criar um cliente Cloud Firestore, consulte Bibliotecas de cliente Cloud Firestore .

    $addedDocRef = $db->collection('samples/php/cities')->newDocument();
    printf
    ('Added document with ID: %s' . PHP_EOL, $addedDocRef->id());
    $addedDocRef
    ->set($data);
    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));
    });
    DocumentReference addedDocRef = db.Collection("cities").Document();
    Console.WriteLine("Added document with ID: {0}.", addedDocRef.Id);
    await addedDocRef
    .SetAsync(city);
    cities_ref = firestore.col collection_path

    added_doc_ref
    = cities_ref.doc
    puts
    "Added document with ID: #{added_doc_ref.document_id}."

    added_doc_ref
    .set data

    Nos bastidores, .add(...) e .doc().set(...) são completamente equivalentes, então você pode usar o que for mais conveniente.

    Atualizar um documento

    Para atualizar alguns campos de um documento sem substituir todo o documento, use os seguintes métodos update() específicos do idioma:

    Use o 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
    });

    Use o 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);
    });

    Use o método updateData() :

    Observação: este produto não está disponível em destinos watchOS e App Clip.
    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)")
    }

    Use o método updateData: ::

    Observação: este produto não está disponível em destinos watchOS e App Clip.
    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");
     
    }
    }];

    Use o 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) }

    Use o 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);
               
    }
           
    });

    Use o 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"));

    Use o método update() :

    // Update an existing document
    DocumentReference docRef = db.collection("cities").document("DC");

    // (async) Update one field
    ApiFuture<WriteResult> future = docRef.update("capital", true);

    // ...
    WriteResult result = future.get();
    System.out.println("Write result: " + result);

    Use o método update() :

    city_ref = db.collection("cities").document("DC")

    # Set the capital field
    city_ref
    .update({"capital": True})

    Use o método update() :

    city_ref = db.collection("cities").document("DC")

    # Set the capital field
    await city_ref
    .update({"capital": True})

    Use o 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)}});

    Use o método update() :

    const cityRef = db.collection('cities').doc('DC');

    // Set the 'capital' field of the city
    const res = await cityRef.update({capital: true});

    Use o método Update() :


    import (
           
    "context"
           
    "log"

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

    func updateDoc
    (ctx context.Context, client *firestore.Client) error {
           
    // ...

            _
    , err := client.Collection("cities").Doc("DC").Update(ctx, []firestore.Update{
                   
    {
                           
    Path:  "capital",
                           
    Value: true,
                   
    },
           
    })
           
    if err != nil {
                   
    // Handle any errors in an appropriate way, such as returning them.
                    log
    .Printf("An error has occurred: %s", err)
           
    }

           
    return err
    }

    Use o método update() :

    PHP

    Para obter mais informações sobre como instalar e criar um cliente Cloud Firestore, consulte Bibliotecas de cliente Cloud Firestore .

    $cityRef = $db->collection('samples/php/cities')->document('DC');
    $cityRef
    ->update([
       
    ['path' => 'capital', 'value' => true]
    ]);

    Use o 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);

    Use o método UpdateAsync() :

    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);

    Use o método update() :

    city_ref = firestore.doc "#{collection_path}/DC"
    city_ref
    .update({ capital: true })

    Carimbo de data e hora do servidor

    Você pode definir um campo em seu documento para um carimbo de data/hora do servidor que rastreia quando o servidor recebe a atualização.

    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()
    });
    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()
    });
    Observação: este produto não está disponível em destinos watchOS e App Clip.
    do {
      try await db
    .collection("objects").document("some-id").updateData([
       
    "lastUpdated": FieldValue.serverTimestamp(),
     
    ])
      print
    ("Document successfully updated")
    } catch {
      print
    ("Error updating document: \(error)")
    }
    Observação: este produto não está disponível em destinos watchOS e App Clip.
    [[[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");
     
    }
    }];
    // 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 { }
    // 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>() {
       
    // ...
       
    // ...
    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"));
    DocumentReference docRef = db.collection("objects").document("some-id");
    // Update the timestamp field with the value from the server
    ApiFuture<WriteResult> writeResult = docRef.update("timestamp", FieldValue.serverTimestamp());
    System.out.println("Update time : " + writeResult.get());
    city_ref = db.collection("objects").document("some-id")
    city_ref
    .update({"timestamp": firestore.SERVER_TIMESTAMP})
    city_ref = db.collection("objects").document("some-id")
    await city_ref
    .update({"timestamp": firestore.SERVER_TIMESTAMP})
    DocumentReference doc_ref = db->Collection("objects").Document("some-id");
    doc_ref
    .Update({{"timestamp", FieldValue::ServerTimestamp()}})
       
    .OnCompletion([](const Future<void>& future) {
         
    // ...
       
    });
    // Create a document reference
    const docRef = db.collection('objects').doc('some-id');

    // Update the timestamp field with the value from the server
    const res = await docRef.update({
      timestamp
    : FieldValue.serverTimestamp()
    });

    import (
           
    "context"
           
    "log"

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

    func updateDocServerTimestamp
    (ctx context.Context, client *firestore.Client) error {
           
    // ...

            _
    , err := client.Collection("objects").Doc("some-id").Set(ctx, map[string]interface{}{
                   
    "timestamp": firestore.ServerTimestamp,
           
    }, firestore.MergeAll)
           
    if err != nil {
                   
    // Handle any errors in an appropriate way, such as returning them.
                    log
    .Printf("An error has occurred: %s", err)
           
    }

           
    return err
    }

    PHP

    Para obter mais informações sobre como instalar e criar um cliente Cloud Firestore, consulte Bibliotecas de cliente Cloud Firestore .

    $docRef = $db->collection('samples/php/objects')->document('some-id');
    $docRef
    ->update([
       
    ['path' => 'timestamp', 'value' => FieldValue::serverTimestamp()]
    ]);
    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.");
           
    });
    DocumentReference cityRef = db.Collection("cities").Document("new-city-id");
    await cityRef
    .UpdateAsync("Timestamp", Timestamp.GetCurrentTimestamp());
    city_ref = firestore.doc "#{collection_path}/new-city-id"
    city_ref
    .update({ timestamp: firestore.field_server_time })

    Ao atualizar vários campos de carimbo de data/hora dentro de uma transação , cada campo recebe o mesmo valor de carimbo de data/hora do servidor.

    Atualizar campos em objetos aninhados

    Se o seu documento contiver objetos aninhados, você poderá usar a "notação de ponto" para fazer referência a campos aninhados no documento ao chamar update() :

    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"
    });
    // 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!");
    });
    Observação: este produto não está disponível em destinos watchOS e App Clip.
    // 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)")
    }
    Observação: este produto não está disponível em destinos watchOS e App Clip.
    // 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");
     
    }
    }];
    // 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",
           
    ),
       
    )
    // 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"
           
    );
    // 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"});
    // Create an initial document to update
    DocumentReference frankDocRef = db.collection("users").document("frank");
    Map<String, Object> initialData = new HashMap<>();
    initialData
    .put("name", "Frank");
    initialData
    .put("age", 12);

    Map<String, Object> favorites = new HashMap<>();
    favorites
    .put("food", "Pizza");
    favorites
    .put("color", "Blue");
    favorites
    .put("subject", "Recess");
    initialData
    .put("favorites", favorites);

    ApiFuture<WriteResult> initialResult = frankDocRef.set(initialData);
    // Confirm that data has been successfully saved by blocking on the operation
    initialResult
    .get();

    // Update age and favorite color
    Map<String, Object> updates = new HashMap<>();
    updates
    .put("age", 13);
    updates
    .put("favorites.color", "Red");

    // Async update document
    ApiFuture<WriteResult> writeResult = frankDocRef.update(updates);
    // ...
    System.out.println("Update time : " + writeResult.get().getUpdateTime());
    # Create an initial document to update
    frank_ref
    = db.collection("users").document("frank")
    frank_ref
    .set(
       
    {
           
    "name": "Frank",
           
    "favorites": {"food": "Pizza", "color": "Blue", "subject": "Recess"},
           
    "age": 12,
       
    }
    )

    # Update age and favorite color
    frank_ref
    .update({"age": 13, "favorites.color": "Red"})
    # Create an initial document to update
    frank_ref
    = db.collection("users").document("frank")
    await frank_ref
    .set(
       
    {
           
    "name": "Frank",
           
    "favorites": {"food": "Pizza", "color": "Blue", "subject": "Recess"},
           
    "age": 12,
       
    }
    )

    # Update age and favorite color
    await frank_ref
    .update({"age": 13, "favorites.color": "Red"})
    // 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")},
    });
    const initialData = {
      name
    : 'Frank',
      age
    : 12,
      favorites
    : {
        food
    : 'Pizza',
        color
    : 'Blue',
        subject
    : 'recess'
     
    }
    };

    // ...
    const res = await db.collection('users').doc('Frank').update({
      age
    : 13,
     
    'favorites.color': 'Red'
    });

    import (
           
    "context"
           
    "log"

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

    func updateDocNested
    (ctx context.Context, client *firestore.Client) error {
            initialData
    := map[string]interface{}{
                   
    "name": "Frank",
                   
    "age":  12,
                   
    "favorites": map[string]interface{}{
                           
    "food":    "Pizza",
                           
    "color":   "Blue",
                           
    "subject": "recess",
                   
    },
           
    }

           
    // ...

            _
    , err := client.Collection("users").Doc("frank").Set(ctx, map[string]interface{}{
                   
    "age": 13,
                   
    "favorites": map[string]interface{}{
                           
    "color": "Red",
                   
    },
           
    }, firestore.MergeAll)
           
    if err != nil {
                   
    // Handle any errors in an appropriate way, such as returning them.
                    log
    .Printf("An error has occurred: %s", err)
           
    }

           
    return err
    }

    PHP

    Para obter mais informações sobre como instalar e criar um cliente Cloud Firestore, consulte Bibliotecas de cliente Cloud Firestore .

    // 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']
    ]);
    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.");
    });
    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);
    # Create an initial document to update
    frank_ref
    = firestore.doc "#{collection_path}/frank"
    frank_ref
    .set(
     
    {
        name
    :      "Frank",
        favorites
    : {
          food
    :    "Pizza",
          color
    :   "Blue",
          subject
    : "Recess"
       
    },
        age
    :       12
     
    }
    )

    # Update age and favorite color
    frank_ref
    .update({ age: 13, "favorites.color": "Red" })

    A notação de ponto permite atualizar um único campo aninhado sem substituir outro campo aninhado. Se você atualizar um campo aninhado sem notação de ponto, você substituirá todo o campo do mapa, por exemplo:

    Rede

    // 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
            }
     */

    Atualizar elementos em um array

    Se o seu documento contiver um campo de array, você poderá usar arrayUnion() e arrayRemove() para adicionar e remover elementos. arrayUnion() adiciona elementos a um array, mas apenas elementos que ainda não estão presentes. arrayRemove() remove todas as instâncias de cada elemento fornecido.

    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")
    });
    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")
    });
    Observação: este produto não está disponível em destinos watchOS e App Clip.
    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"])
    ])
    Observação: este produto não está disponível em destinos watchOS e App Clip.
    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"]]
    }];
    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"))
    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"));
    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"]),
    });
    DocumentReference washingtonRef = db.collection("cities").document("DC");

    // Atomically add a new region to the "regions" array field.
    ApiFuture<WriteResult> arrayUnion =
        washingtonRef
    .update("regions", FieldValue.arrayUnion("greater_virginia"));
    System.out.println("Update time : " + arrayUnion.get());

    // Atomically remove a region from the "regions" array field.
    ApiFuture<WriteResult> arrayRm =
        washingtonRef
    .update("regions", FieldValue.arrayRemove("east_coast"));
    System.out.println("Update time : " + arrayRm.get());
    city_ref = db.collection("cities").document("DC")

    # Atomically add a new region to the 'regions' array field.
    city_ref
    .update({"regions": firestore.ArrayUnion(["greater_virginia"])})

    # // Atomically remove a region from the 'regions' array field.
    city_ref
    .update({"regions": firestore.ArrayRemove(["east_coast"])})
    city_ref = db.collection("cities").document("DC")

    # Atomically add a new region to the 'regions' array field.
    await city_ref
    .update({"regions": firestore.ArrayUnion(["greater_virginia"])})

    # // Atomically remove a region from the 'regions' array field.
    await city_ref
    .update({"regions": firestore.ArrayRemove(["east_coast"])})
    // This is not yet supported.
    // ...
    const washingtonRef = db.collection('cities').doc('DC');

    // Atomically add a new region to the "regions" array field.
    const unionRes = await washingtonRef.update({
      regions
    : FieldValue.arrayUnion('greater_virginia')
    });
    // Atomically remove a region from the "regions" array field.
    const removeRes = await washingtonRef.update({
      regions
    : FieldValue.arrayRemove('east_coast')
    });

    // To add or remove multiple items, pass multiple arguments to arrayUnion/arrayRemove
    const multipleUnionRes = await washingtonRef.update({
      regions
    : FieldValue.arrayUnion('south_carolina', 'texas')
     
    // Alternatively, you can use spread operator in ES6 syntax
     
    // const newRegions = ['south_carolina', 'texas']
     
    // regions: FieldValue.arrayUnion(...newRegions)
    });
    // Not supported yet

    PHP

    Para obter mais informações sobre como instalar e criar um cliente Cloud Firestore, consulte Bibliotecas de cliente Cloud Firestore .

    $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'])]
    ]);
    // This is not yet supported in the Unity SDK
     
    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"));
    // Not supported yet

    Incrementar um valor numérico

    Você pode aumentar ou diminuir um valor de campo numérico conforme mostrado no exemplo a seguir. Uma operação de incremento aumenta ou diminui o valor atual de um campo em um determinado valor.

    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)
    });
    var washingtonRef = db.collection('cities').doc('DC');

    // Atomically increment the population of the city by 50.
    washingtonRef
    .update({
        population
    : firebase.firestore.FieldValue.increment(50)
    });
    Observação: este produto não está disponível em destinos watchOS e App Clip.
    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))
    ])
    Observação: este produto não está disponível em destinos watchOS e App Clip.
    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]
    }];
    val washingtonRef = db.collection("cities").document("DC")

    // Atomically increment the population of the city by 50.
    washingtonRef
    .update("population", FieldValue.increment(50))
    DocumentReference washingtonRef = db.collection("cities").document("DC");

    // Atomically increment the population of the city by 50.
    washingtonRef
    .update("population", FieldValue.increment(50));
    var washingtonRef = db.collection('cities').doc('DC');

    // Atomically increment the population of the city by 50.
    washingtonRef
    .update(
     
    {"population": FieldValue.increment(50)},
    );
    DocumentReference washingtonRef = db.collection("cities").document("DC");

    // Atomically increment the population of the city by 50.
    final ApiFuture<WriteResult> updateFuture =
        washingtonRef
    .update("population", FieldValue.increment(50));
    washington_ref = db.collection("cities").document("DC")

    washington_ref
    .update({"population": firestore.Increment(50)})
    washington_ref = db.collection("cities").document("DC")

    await washington_ref
    .update({"population": firestore.Increment(50)})
    // This is not yet supported.
    // ...
    const washingtonRef = db.collection('cities').doc('DC');

    // Atomically increment the population of the city by 50.
    const res = await washingtonRef.update({
      population
    : FieldValue.increment(50)
    });
    import (
           
    "context"
           
    "fmt"

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

    // updateDocumentIncrement increments the population of the city document in the
    // cities collection by 50.
    func updateDocumentIncrement
    (projectID, city string) error {
           
    // projectID := "my-project"

            ctx
    := context.Background()

            client
    , err := firestore.NewClient(ctx, projectID)
           
    if err != nil {
                   
    return fmt.Errorf("firestore.NewClient: %w", err)
           
    }
            defer client
    .Close()

            dc
    := client.Collection("cities").Doc(city)
            _
    , err = dc.Update(ctx, []firestore.Update{
                   
    {Path: "population", Value: firestore.Increment(50)},
           
    })
           
    if err != nil {
                   
    return fmt.Errorf("Update: %w", err)
           
    }

           
    return nil
    }

    PHP

    Para obter mais informações sobre como instalar e criar um cliente Cloud Firestore, consulte Bibliotecas de cliente Cloud Firestore .

    $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)]
    ]);
    // This is not yet supported in the Unity SDK.
     
    DocumentReference washingtonRef = db.Collection("cities").Document("DC");

    // Atomically increment the population of the city by 50.
    await washingtonRef
    .UpdateAsync("Regions", FieldValue.Increment(50));
    city_ref = firestore.doc "#{collection_path}/DC"
    city_ref
    .update({ population: firestore.field_increment(50) })

    As operações de incremento são úteis para implementar contadores, mas lembre-se de que você pode atualizar um único documento apenas uma vez por segundo. Se você precisar atualizar seu contador acima dessa taxa, consulte a página Contadores distribuídos .