Google is committed to advancing racial equity for Black communities. See how.
Questa pagina è stata tradotta dall'API Cloud Translation.
Switch to English

Inizia con Cloud Firestore

Questa guida rapida mostra come configurare Cloud Firestore, aggiungere dati e quindi visualizzare i dati appena aggiunti nella console di Firebase.

Crea un database Cloud Firestore

  1. Se non lo hai già fatto, crea un progetto Firebase: nella console Firebase , fai clic su Aggiungi progetto , quindi segui le istruzioni sullo schermo per creare un progetto Firebase o per aggiungere servizi Firebase a un progetto GCP esistente.

  2. Accedi alla sezione Cloud Firestore della console Firebase . Ti verrà chiesto di selezionare un progetto Firebase esistente. Segui il flusso di lavoro di creazione del database.

  3. Seleziona una modalità di avvio per le regole di sicurezza di Cloud Firestore:

    Modalità di prova

    Ottimo per iniziare con le librerie dei client mobili e Web, ma consente a chiunque di leggere e sovrascrivere i tuoi dati. Dopo il test, assicurati di rivedere la sezione Proteggi i tuoi dati .

    Per iniziare con il Web, iOS o Android SDK, seleziona la modalità di prova.

    Modalità bloccata

    Nega tutte le letture e le scritture da client mobili e Web. I server delle applicazioni autenticati (C #, Go, Java, Node.js, PHP, Python o Ruby) possono ancora accedere al database.

    Per iniziare con la libreria client del server C #, Go, Java, Node.js, PHP, Python o Ruby, seleziona la modalità bloccata.

  4. Seleziona una posizione per il tuo database.

    • Questa impostazione di posizione è la posizione delle risorse di Google Cloud Platform (GCP) predefinita del progetto. Tieni presente che questa posizione verrà utilizzata per i servizi GCP nel tuo progetto che richiedono un'impostazione della posizione, in particolare, il tuo bucket Cloud Storage predefinito e la tua app App Engine (che è richiesta se utilizzi Cloud Scheduler).

    • Se non sei in grado di selezionare una posizione, il progetto ha già una posizione della risorsa GCP predefinita. È stato impostato durante la creazione del progetto o durante la configurazione di un altro servizio che richiede un'impostazione della posizione.

  5. Fare clic su Fine .

Quando abiliti Cloud Firestore, abilita anche l'API in Cloud API Manager .

Configura il tuo ambiente di sviluppo

Aggiungi le dipendenze e le librerie client richieste alla tua app.

ragnatela
  1. Segui le istruzioni per aggiungere Firebase alla tua app web .
  2. Aggiungi le librerie Firebase e Cloud Firestore alla tua app:
    <script src="https://www.gstatic.com/firebasejs/7.21.0/firebase-app.js"></script>
    <script src="https://www.gstatic.com/firebasejs/7.21.0/firebase-firestore.js"></script>
    L'SDK Cloud Firestore è disponibile anche come pacchetto npm.
    npm install firebase@7.21.0 --save
    
    Dovrai richiedere manualmente sia Firebase che Cloud Firestore.
    const firebase = require("firebase");
    // Required for side-effects
    require("firebase/firestore");
    
iOS
  1. Segui le istruzioni per aggiungere Firebase alla tua app iOS .
  2. Aggiungi il pod Cloud Firestore al tuo Podfile
    pod 'Firebase/Firestore'
    
    # Optionally, include the Swift extensions if you're using Swift.
    pod 'FirebaseFirestoreSwift'
    
  3. Salva il file ed esegui l' pod install .

Giava

  1. Segui le istruzioni per aggiungere Firebase alla tua app Android .
  2. Nel tuo file build.gradle livello di build.gradle , assicurati di includere il repository Maven di Google in entrambe le sezioni buildscript e allprojects .
  3. Aggiungi la libreria Android di Cloud Firestore al file Gradle del modulo (a livello di app) (in genere app/build.gradle ):
    implementation 'com.google.firebase:firebase-firestore:21.6.0'

Kotlin + KTX

  1. Segui le istruzioni per aggiungere Firebase alla tua app Android .
  2. Nel tuo file build.gradle livello di build.gradle , assicurati di includere il repository Maven di Google in entrambe le sezioni buildscript e allprojects .
  3. Aggiungi la libreria Android di Cloud Firestore al file Gradle del modulo (a livello di app) (in genere app/build.gradle ):
    implementation 'com.google.firebase:firebase-firestore-ktx:21.6.0'
Giava
  1. Aggiungi Firebase Admin SDK alla tua app:
    • Utilizzo di Gradle:
      compile 'com.google.firebase:firebase-admin:7.0.0'
      
    • Utilizzando Maven:
      <dependency>
        <groupId>com.google.firebase</groupId>
        <artifactId>firebase-admin</artifactId>
        <version>7.0.0</version>
      </dependency>
           
  2. Segui le istruzioni di seguito per inizializzare Cloud Firestore con le credenziali appropriate nel tuo ambiente.
Pitone
  1. Aggiungi Firebase Admin SDK alla tua app Python:
    pip install --upgrade firebase-admin
  2. Segui le istruzioni di seguito per inizializzare Cloud Firestore con le credenziali appropriate nel tuo ambiente.
C ++
  1. Segui le istruzioni per aggiungere Firebase al tuo progetto C ++ .
  2. Interfaccia C ++ per Android.
    • Dipendenze di grado. Aggiungere quanto segue al file Gradle del modulo (a livello di app) (di solito app/build.gradle ):
              android.defaultConfig.externalNativeBuild.cmake {
                arguments "-DFIREBASE_CPP_SDK_DIR=$gradle.firebase_cpp_sdk_dir"
              }
      
              apply from: "$gradle.firebase_cpp_sdk_dir/Android/firebase_dependencies.gradle"
              firebaseCpp.dependencies {
                // earlier entries
                auth
                firestore
              }
              
    • Dipendenze binarie. Allo stesso modo, il metodo consigliato per ottenere le dipendenze binarie è quello di aggiungere quanto segue al CMakeLists.txt del file:
              add_subdirectory(${FIREBASE_CPP_SDK_DIR} bin/ EXCLUDE_FROM_ALL)
              set(firebase_libs firebase_auth firebase_firestore firebase_app)
              # Replace the target name below with the actual name of your target,
              # for example, "native-lib".
              target_link_libraries(${YOUR_TARGET_NAME_HERE} "${firebase_libs}")
              
  3. Per configurare l' integrazione desktop , vedi Aggiungere Firebase al progetto C ++ .
Unità
  1. Segui le istruzioni per aggiungere Firebase al tuo progetto Unity .
  2. Interfaccia Unity per Android.
  3. Quando crei per Android, abilita ProGuarding per evitare il limite DEX di Android. A tale scopo, nell'editor di Unity:

    1. Seleziona File> Impostazioni build
    2. Passa da "Piattaforma" a "Android" e fai clic su "Cambia piattaforma"
    3. Fai clic su "Impostazioni lettore ..."
    4. Nell'interfaccia utente principale di Unity, in "Impostazioni per Android", seleziona "Impostazioni di pubblicazione"
    5. Nella sezione "Minimizza", modifica le impostazioni di rilascio e di debug da "Nessuno" a "ProGuard"
Node.js
  1. Aggiungi Firebase Admin SDK alla tua app:
    npm install firebase-admin --save
  2. Segui le istruzioni riportate di seguito per inizializzare Cloud Firestore con le credenziali appropriate nel tuo ambiente.
Partire
  1. Aggiungi Firebase Admin SDK alla tua app Go:
    go get firebase.google.com/go
    
  2. Segui le istruzioni di seguito per inizializzare Cloud Firestore con le credenziali appropriate nel tuo ambiente.
PHP
  1. Le librerie client del server Cloud Firestore (Java, Node.js, Python, Go, PHP, C # e Ruby) utilizzano le credenziali predefinite dell'applicazione Google per l'autenticazione.
    • Per eseguire l'autenticazione dal tuo ambiente di sviluppo, imposta la variabile di ambiente GOOGLE_APPLICATION_CREDENTIALS in modo che punti a un file chiave dell'account di servizio JSON. È possibile creare un file chiave nella pagina Credenziali della console API .
      export GOOGLE_APPLICATION_CREDENTIALS="path/to/your/keyfile.json"
    • Nel tuo ambiente di produzione, non è necessario autenticarti se esegui la tua applicazione su App Engine o Compute Engine, utilizzando lo stesso progetto che utilizzi per Cloud Firestore. Altrimenti, configura un account di servizio .
  2. Installa e abilita l' estensione gRPC per PHP, che ti servirà per utilizzare la libreria client.
  3. Aggiungi la libreria PHP di Cloud Firestore alla tua app:
    composer require google/cloud-firestore
C #
  1. Le librerie client del server Cloud Firestore (Java, Node.js, Python, Go, PHP, C # e Ruby) utilizzano le credenziali predefinite dell'applicazione Google per l'autenticazione.
    • Per eseguire l'autenticazione dal tuo ambiente di sviluppo, imposta la variabile di ambiente GOOGLE_APPLICATION_CREDENTIALS in modo che punti a un file di chiave dell'account di servizio JSON. È possibile creare un file chiave nella pagina Credenziali della console API .
      export GOOGLE_APPLICATION_CREDENTIALS="path/to/your/keyfile.json"
    • Nel tuo ambiente di produzione, non è necessario autenticarti se esegui la tua applicazione su App Engine o Compute Engine, utilizzando lo stesso progetto che utilizzi per Cloud Firestore. Altrimenti, configura un account di servizio .
  2. Aggiungere la libreria cloud FireStore C # per la vostra applicazione nel .csproj del file:
    <ItemGroup>
      <PackageReference Include="Google.Cloud.Firestore" Version="1.1.0-beta01" />
    </ItemGroup>
  3. Aggiungere la seguente al Program.cs file:
    using Google.Cloud.Firestore;
Rubino
  1. Le librerie client del server Cloud Firestore (Java, Node.js, Python, Go, PHP, C # e Ruby) utilizzano le credenziali predefinite dell'applicazione Google per l'autenticazione.
    • Per eseguire l'autenticazione dal tuo ambiente di sviluppo, imposta la variabile di ambiente GOOGLE_APPLICATION_CREDENTIALS in modo che punti a un file chiave dell'account di servizio JSON. È possibile creare un file chiave nella pagina Credenziali della console API .
      export GOOGLE_APPLICATION_CREDENTIALS="path/to/your/keyfile.json"
    • Nel tuo ambiente di produzione, non è necessario autenticarti se esegui la tua applicazione su App Engine o Compute Engine, utilizzando lo stesso progetto che utilizzi per Cloud Firestore. Altrimenti, configura un account di servizio .
  2. Aggiungi la libreria Ruby di Cloud Firestore alla tua app nel tuo Gemfile :
    gem "google-cloud-firestore"
  3. Installa le dipendenze dal tuo Gemfile usando:
    bundle install

Inizializza Cloud Firestore

Inizializza un'istanza di Cloud Firestore:

ragnatela
// Initialize Cloud Firestore through Firebase
firebase.initializeApp({
  apiKey: '### FIREBASE API KEY ###',
  authDomain: '### FIREBASE AUTH DOMAIN ###',
  projectId: '### CLOUD FIRESTORE PROJECT ID ###'
});

var db = firebase.firestore();
I valori per `initializeApp` possono essere trovati nella` firebaseConfig` della tua app web. Per rendere persistenti i dati quando il dispositivo perde la connessione, vedere la documentazione relativa all'abilitazione dei dati offline .
Swift
import Firebase

FirebaseApp.configure()

let db = Firestore.firestore()
Obiettivo-C
@import Firebase;

// Use Firebase library to configure APIs
[FIRApp configure];

FIRFirestore *defaultFirestore = [FIRFirestore firestore];
  

Giava

// Access a Cloud Firestore instance from your Activity
FirebaseFirestore db = FirebaseFirestore.getInstance();

Kotlin + KTX

// Access a Cloud Firestore instance from your Activity
val db = Firebase.firestore
Giava
L'SDK di Cloud Firestore viene inizializzato in modi diversi a seconda del tuo ambiente. Di seguito sono riportati i metodi più comuni. Per un riferimento completo, consulta Inizializzare l'SDK di amministrazione .
  • Inizializza su Google Cloud Platform
    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();
    
  • Inizializza sul tuo server

    Per utilizzare Firebase Admin SDK sul tuo server, utilizza un account di servizio .

    Vai a IAM e amministrazione> Account di servizio nella console di Cloud Platform. Genera una nuova chiave privata e salva il file JSON. Quindi utilizza il file per inizializzare l'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();
    
  • Pitone
    L'SDK di Cloud Firestore viene inizializzato in modi diversi a seconda del tuo ambiente. Di seguito sono riportati i metodi più comuni. Per un riferimento completo, consulta Inizializzazione di Admin SDK .
  • Inizializza su Google Cloud Platform
    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, {
      'projectId': project_id,
    })
    
    db = firestore.client()
    
  • Inizializza sul tuo server

    Per utilizzare Firebase Admin SDK sul tuo server, utilizza un account di servizio .

    Vai a IAM e amministrazione> Account di servizio nella console di Cloud Platform. Genera una nuova chiave privata e salva il file JSON. Quindi utilizza il file per inizializzare l'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')
    firebase_admin.initialize_app(cred)
    
    db = firestore.client()
    
  • C ++
    // Make sure the call to `Create()` happens some time before you call Firestore::GetInstance().
    App::Create();
    Firestore* db = Firestore::GetInstance();
    
    Node.js
    L'SDK di Cloud Firestore viene inizializzato in modi diversi a seconda del tuo ambiente. Di seguito sono riportati i metodi più comuni. Per un riferimento completo, consulta Inizializzazione di Admin SDK .
    • Inizializza su Cloud Functions
      const admin = require('firebase-admin');
      admin.initializeApp();
      
      const db = admin.firestore();
      
      
    • Inizializza su Google Cloud Platform
      const admin = require('firebase-admin');
      
      admin.initializeApp({
        credential: admin.credential.applicationDefault()
      });
      
      const db = admin.firestore();
      
    • Inizializza sul tuo server

      Per utilizzare Firebase Admin SDK sul tuo server (o qualsiasi altro ambiente Node.js), utilizza un account di servizio . Vai a IAM e amministrazione> Account di servizio nella console di Cloud Platform. Genera una nuova chiave privata e salva il file JSON. Quindi utilizza il file per inizializzare l'SDK:

      const admin = require('firebase-admin');
      
      const serviceAccount = require('./path/to/serviceAccountKey.json');
      
      admin.initializeApp({
        credential: admin.credential.cert(serviceAccount)
      });
      
      const db = admin.firestore();
      
      
    Partire
    L'SDK di Cloud Firestore viene inizializzato in modi diversi a seconda del tuo ambiente. Di seguito sono riportati i metodi più comuni. Per un riferimento completo, consulta Inizializzare l'SDK di amministrazione .
  • Inizializza su Google Cloud Platform
    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()
    
  • Inizializza sul tuo server

    Per utilizzare Firebase Admin SDK sul tuo server, utilizza un account di servizio .

    Vai a IAM e amministrazione> Account di servizio nella console di Cloud Platform. Genera una nuova chiave privata e salva il file JSON. Quindi utilizza il file per inizializzare l'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
    use Google\Cloud\Firestore\FirestoreClient;
    
    /**
     * Initialize Cloud Firestore with default project ID.
     * ```
     * initialize();
     * ```
     */
    function initialize()
    {
        // Create the Cloud Firestore client
        $db = new FirestoreClient();
        printf('Created Cloud Firestore client with default project ID.' . PHP_EOL);
    }
    
    Unità
    using Firebase.Firestore;
    using Firebase.Extensions;
    FirebaseFirestore db = FirebaseFirestore.DefaultInstance;
    
    C #
    FirestoreDb db = FirestoreDb.Create(project);
    Console.WriteLine("Created Cloud Firestore client with project ID: {0}", project);
    
    Rubino
    require "google/cloud/firestore"
    
    firestore = Google::Cloud::Firestore.new project_id: project_id
    
    puts "Created Cloud Firestore client with given project ID."
    

    Aggiungi dati

    Cloud Firestore archivia i dati in Documents, che vengono archiviati nelle raccolte. Cloud Firestore crea raccolte e documenti implicitamente la prima volta che aggiungi dati al documento. Non è necessario creare esplicitamente raccolte o documenti.

    Crea una nuova raccolta e un documento utilizzando il seguente codice di esempio.

    ragnatela
    db.collection("users").add({
        first: "Ada",
        last: "Lovelace",
        born: 1815
    })
    .then(function(docRef) {
        console.log("Document written with ID: ", docRef.id);
    })
    .catch(function(error) {
        console.error("Error adding document: ", error);
    });
    
    Swift
    // Add a new document with a generated ID
    var ref: DocumentReference? = nil
    ref = db.collection("users").addDocument(data: [
        "first": "Ada",
        "last": "Lovelace",
        "born": 1815
    ]) { err in
        if let err = err {
            print("Error adding document: \(err)")
        } else {
            print("Document added with ID: \(ref!.documentID)")
        }
    }
    
    Obiettivo-C
    // Add a new document with a generated ID
    __block FIRDocumentReference *ref =
        [[self.db collectionWithPath:@"users"] addDocumentWithData:@{
          @"first": @"Ada",
          @"last": @"Lovelace",
          @"born": @1815
        } completion:^(NSError * _Nullable error) {
          if (error != nil) {
            NSLog(@"Error adding document: %@", error);
          } else {
            NSLog(@"Document added with ID: %@", ref.documentID);
          }
        }];
      

    Giava

    // Create a new user with a first and last name
    Map<String, Object> user = new HashMap<>();
    user.put("first", "Ada");
    user.put("last", "Lovelace");
    user.put("born", 1815);
    
    // Add a new document with a generated ID
    db.collection("users")
            .add(user)
            .addOnSuccessListener(new OnSuccessListener<DocumentReference>() {
                @Override
                public void onSuccess(DocumentReference documentReference) {
                    Log.d(TAG, "DocumentSnapshot added with ID: " + documentReference.getId());
                }
            })
            .addOnFailureListener(new OnFailureListener() {
                @Override
                public void onFailure(@NonNull Exception e) {
                    Log.w(TAG, "Error adding document", e);
                }
            });
    

    Kotlin + KTX

    // Create a new user with a first and last name
    val user = hashMapOf(
            "first" to "Ada",
            "last" to "Lovelace",
            "born" to 1815
    )
    
    // Add a new document with a generated ID
    db.collection("users")
        .add(user)
        .addOnSuccessListener { documentReference ->
            Log.d(TAG, "DocumentSnapshot added with ID: ${documentReference.id}")
        }
        .addOnFailureListener { e ->
            Log.w(TAG, "Error adding document", e)
        }
    
    Giava
    DocumentReference docRef = db.collection("users").document("alovelace");
    // Add document data  with id "alovelace" using a hashmap
    Map<String, Object> data = new HashMap<>();
    data.put("first", "Ada");
    data.put("last", "Lovelace");
    data.put("born", 1815);
    //asynchronously write data
    ApiFuture<WriteResult> result = docRef.set(data);
    // ...
    // result.get() blocks on response
    System.out.println("Update time : " + result.get().getUpdateTime());
      
    Pitone
    doc_ref = db.collection(u'users').document(u'alovelace')
    doc_ref.set({
        u'first': u'Ada',
        u'last': u'Lovelace',
        u'born': 1815
    })
      
    C ++
    // Add a new document with a generated ID
    Future<DocumentReference> user_ref =
        db->Collection("users").Add({{"first", FieldValue::String("Ada")},
                                     {"last", FieldValue::String("Lovelace")},
                                     {"born", FieldValue::Integer(1815)}});
    
    user_ref.OnCompletion([](const Future<DocumentReference>& future) {
      if (future.error() == Error::kErrorOk) {
        std::cout << "DocumentSnapshot added with ID: " << future.result()->id()
                  << '\n';
      } else {
        std::cout << "Error adding document: " << future.error_message() << '\n';
      }
    });
      
    Node.js
    const docRef = db.collection('users').doc('alovelace');
    
    await docRef.set({
      first: 'Ada',
      last: 'Lovelace',
      born: 1815
    });
      
    Partire
    _, _, err := client.Collection("users").Add(ctx, map[string]interface{}{
    	"first": "Ada",
    	"last":  "Lovelace",
    	"born":  1815,
    })
    if err != nil {
    	log.Fatalf("Failed adding alovelace: %v", err)
    }
      
    PHP
    $docRef = $db->collection('users')->document('lovelace');
    $docRef->set([
        'first' => 'Ada',
        'last' => 'Lovelace',
        'born' => 1815
    ]);
    printf('Added data to the lovelace document in the users collection.' . PHP_EOL);
      
    Unità
    DocumentReference docRef = db.Collection("users").Document("alovelace");
    Dictionary<string, object> user = new Dictionary<string, object>
    {
    	{ "First", "Ada" },
    	{ "Last", "Lovelace" },
    	{ "Born", 1815 },
    };
    docRef.SetAsync(user).ContinueWithOnMainThread(task => {
    	Debug.Log("Added data to the alovelace document in the users collection.");
    });
      
    C #
    DocumentReference docRef = db.Collection("users").Document("alovelace");
    Dictionary<string, object> user = new Dictionary<string, object>
    {
        { "First", "Ada" },
        { "Last", "Lovelace" },
        { "Born", 1815 }
    };
    await docRef.SetAsync(user);
      
    Rubino
    doc_ref = firestore.doc "users/alovelace"
    
    doc_ref.set(
      first: "Ada",
      last:  "Lovelace",
      born:  1815
    )
    
    puts "Added data to the alovelace document in the users collection."
      

    Ora aggiungi un altro documento alla raccolta degli users . Si noti che questo documento include una coppia chiave-valore (secondo nome) che non appare nel primo documento. I documenti in una raccolta possono contenere diversi set di informazioni.

    ragnatela
    // Add a second document with a generated ID.
    db.collection("users").add({
        first: "Alan",
        middle: "Mathison",
        last: "Turing",
        born: 1912
    })
    .then(function(docRef) {
        console.log("Document written with ID: ", docRef.id);
    })
    .catch(function(error) {
        console.error("Error adding document: ", error);
    });
    
    Swift
    // Add a second document with a generated ID.
    ref = db.collection("users").addDocument(data: [
        "first": "Alan",
        "middle": "Mathison",
        "last": "Turing",
        "born": 1912
    ]) { err in
        if let err = err {
            print("Error adding document: \(err)")
        } else {
            print("Document added with ID: \(ref!.documentID)")
        }
    }
    
    Obiettivo-C
    // Add a second document with a generated ID.
    __block FIRDocumentReference *ref =
        [[self.db collectionWithPath:@"users"] addDocumentWithData:@{
          @"first": @"Alan",
          @"middle": @"Mathison",
          @"last": @"Turing",
          @"born": @1912
        } completion:^(NSError * _Nullable error) {
          if (error != nil) {
            NSLog(@"Error adding document: %@", error);
          } else {
            NSLog(@"Document added with ID: %@", ref.documentID);
          }
        }];
      

    Giava

    // Create a new user with a first, middle, and last name
    Map<String, Object> user = new HashMap<>();
    user.put("first", "Alan");
    user.put("middle", "Mathison");
    user.put("last", "Turing");
    user.put("born", 1912);
    
    // Add a new document with a generated ID
    db.collection("users")
            .add(user)
            .addOnSuccessListener(new OnSuccessListener<DocumentReference>() {
                @Override
                public void onSuccess(DocumentReference documentReference) {
                    Log.d(TAG, "DocumentSnapshot added with ID: " + documentReference.getId());
                }
            })
            .addOnFailureListener(new OnFailureListener() {
                @Override
                public void onFailure(@NonNull Exception e) {
                    Log.w(TAG, "Error adding document", e);
                }
            });
    

    Kotlin + KTX

    // Create a new user with a first, middle, and last name
    val user = hashMapOf(
            "first" to "Alan",
            "middle" to "Mathison",
            "last" to "Turing",
            "born" to 1912
    )
    
    // Add a new document with a generated ID
    db.collection("users")
        .add(user)
        .addOnSuccessListener { documentReference ->
            Log.d(TAG, "DocumentSnapshot added with ID: ${documentReference.id}")
        }
        .addOnFailureListener { e ->
            Log.w(TAG, "Error adding document", e)
        }
    
    Giava
    DocumentReference docRef = db.collection("users").document("aturing");
    // Add document data with an additional field ("middle")
    Map<String, Object> data = new HashMap<>();
    data.put("first", "Alan");
    data.put("middle", "Mathison");
    data.put("last", "Turing");
    data.put("born", 1912);
    
    ApiFuture<WriteResult> result = docRef.set(data);
    System.out.println("Update time : " + result.get().getUpdateTime());
      
    Pitone
    doc_ref = db.collection(u'users').document(u'aturing')
    doc_ref.set({
        u'first': u'Alan',
        u'middle': u'Mathison',
        u'last': u'Turing',
        u'born': 1912
    })
      
    C ++
    db->Collection("users")
        .Add({{"first", FieldValue::String("Alan")},
              {"middle", FieldValue::String("Mathison")},
              {"last", FieldValue::String("Turing")},
              {"born", FieldValue::Integer(1912)}})
        .OnCompletion([](const Future<DocumentReference>& future) {
          if (future.error() == Error::kErrorOk) {
            std::cout << "DocumentSnapshot added with ID: "
                      << future.result()->id() << '\n';
          } else {
            std::cout << "Error adding document: " << future.error_message()
                      << '\n';
          }
        });
      
    Node.js
    const aTuringRef = db.collection('users').doc('aturing');
    
    await aTuringRef.set({
      'first': 'Alan',
      'middle': 'Mathison',
      'last': 'Turing',
      'born': 1912
    });
      
    Partire
    _, _, err = client.Collection("users").Add(ctx, map[string]interface{}{
    	"first":  "Alan",
    	"middle": "Mathison",
    	"last":   "Turing",
    	"born":   1912,
    })
    if err != nil {
    	log.Fatalf("Failed adding aturing: %v", err)
    }
      
    PHP
    $docRef = $db->collection('users')->document('aturing');
    $docRef->set([
        'first' => 'Alan',
        'middle' => 'Mathison',
        'last' => 'Turing',
        'born' => 1912
    ]);
    printf('Added data to the aturing document in the users collection.' . PHP_EOL);
      
    Unità
    DocumentReference docRef = db.Collection("users").Document("aturing");
    Dictionary<string, object> user = new Dictionary<string, object>
    {
    	{ "First", "Alan" },
    	{ "Middle", "Mathison" },
    	{ "Last", "Turing" },
    	{ "Born", 1912 }
    };
    docRef.SetAsync(user).ContinueWithOnMainThread(task => {
    	Debug.Log("Added data to the aturing document in the users collection.");
    });
      
    C #
    DocumentReference docRef = db.Collection("users").Document("aturing");
    Dictionary<string, object> user = new Dictionary<string, object>
    {
        { "First", "Alan" },
        { "Middle", "Mathison" },
        { "Last", "Turing" },
        { "Born", 1912 }
    };
    await docRef.SetAsync(user);
      
    Rubino
    doc_ref = firestore.doc "users/aturing"
    
    doc_ref.set(
      first:  "Alan",
      middle: "Mathison",
      last:   "Turing",
      born:   1912
    )
    
    puts "Added data to the aturing document in the users collection."
      

    Leggere i dati

    Per verificare rapidamente di aver aggiunto dati a Cloud Firestore, utilizza il visualizzatore di dati nella console di Firebase .

    È inoltre possibile utilizzare il metodo "get" per recuperare l'intera raccolta.

    ragnatela
    db.collection("users").get().then((querySnapshot) => {
        querySnapshot.forEach((doc) => {
            console.log(`${doc.id} => ${doc.data()}`);
        });
    });
    
    Swift
    db.collection("users").getDocuments() { (querySnapshot, err) in
        if let err = err {
            print("Error getting documents: \(err)")
        } else {
            for document in querySnapshot!.documents {
                print("\(document.documentID) => \(document.data())")
            }
        }
    }
    
    Obiettivo-C
    [[self.db collectionWithPath:@"users"]
        getDocumentsWithCompletion:^(FIRQuerySnapshot * _Nullable snapshot,
                                     NSError * _Nullable error) {
          if (error != nil) {
            NSLog(@"Error getting documents: %@", error);
          } else {
            for (FIRDocumentSnapshot *document in snapshot.documents) {
              NSLog(@"%@ => %@", document.documentID, document.data);
            }
          }
        }];
      

    Giava

    db.collection("users")
            .get()
            .addOnCompleteListener(new OnCompleteListener<QuerySnapshot>() {
                @Override
                public void onComplete(@NonNull Task<QuerySnapshot> task) {
                    if (task.isSuccessful()) {
                        for (QueryDocumentSnapshot document : task.getResult()) {
                            Log.d(TAG, document.getId() + " => " + document.getData());
                        }
                    } else {
                        Log.w(TAG, "Error getting documents.", task.getException());
                    }
                }
            });
    

    Kotlin + KTX

    db.collection("users")
            .get()
            .addOnSuccessListener { result ->
                for (document in result) {
                    Log.d(TAG, "${document.id} => ${document.data}")
                }
            }
            .addOnFailureListener { exception ->
                Log.w(TAG, "Error getting documents.", exception)
            }
    
    Giava
    // asynchronously retrieve all users
    ApiFuture<QuerySnapshot> query = db.collection("users").get();
    // ...
    // query.get() blocks on response
    QuerySnapshot querySnapshot = query.get();
    List<QueryDocumentSnapshot> documents = querySnapshot.getDocuments();
    for (QueryDocumentSnapshot document : documents) {
      System.out.println("User: " + document.getId());
      System.out.println("First: " + document.getString("first"));
      if (document.contains("middle")) {
        System.out.println("Middle: " + document.getString("middle"));
      }
      System.out.println("Last: " + document.getString("last"));
      System.out.println("Born: " + document.getLong("born"));
    }
      
    Pitone
    users_ref = db.collection(u'users')
    docs = users_ref.stream()
    
    for doc in docs:
        print(f'{doc.id} => {doc.to_dict()}')
      
    C ++
    Future<QuerySnapshot> users = db->Collection("users").Get();
    users.OnCompletion([](const Future<QuerySnapshot>& future) {
      if (future.error() == Error::kErrorOk) {
        for (const DocumentSnapshot& document : future.result()->documents()) {
          std::cout << document << '\n';
        }
      } else {
        std::cout << "Error getting documents: " << future.error_message()
                  << '\n';
      }
    });
      
    Node.js
    const snapshot = await db.collection('users').get();
    snapshot.forEach((doc) => {
      console.log(doc.id, '=>', doc.data());
    });
      
    Partire
    iter := client.Collection("users").Documents(ctx)
    for {
    	doc, err := iter.Next()
    	if err == iterator.Done {
    		break
    	}
    	if err != nil {
    		log.Fatalf("Failed to iterate: %v", err)
    	}
    	fmt.Println(doc.Data())
    }
      
    PHP
    $usersRef = $db->collection('users');
    $snapshot = $usersRef->documents();
    foreach ($snapshot as $user) {
        printf('User: %s' . PHP_EOL, $user->id());
        printf('First: %s' . PHP_EOL, $user['first']);
        if (!empty($user['middle'])) {
            printf('Middle: %s' . PHP_EOL, $user['middle']);
        }
        printf('Last: %s' . PHP_EOL, $user['last']);
        printf('Born: %d' . PHP_EOL, $user['born']);
        printf(PHP_EOL);
    }
    printf('Retrieved and printed out all documents from the users collection.' . PHP_EOL);
      
    Unità
    CollectionReference usersRef = db.Collection("users");
    usersRef.GetSnapshotAsync().ContinueWithOnMainThread(task =>
    {
      QuerySnapshot snapshot = task.Result;
      foreach (DocumentSnapshot document in snapshot.Documents)
      {
        Debug.Log(String.Format("User: {0}", document.Id));
        Dictionary<string, object> documentDictionary = document.ToDictionary();
        Debug.Log(String.Format("First: {0}", documentDictionary["First"]));
        if (documentDictionary.ContainsKey("Middle"))
        {
          Debug.Log(String.Format("Middle: {0}", documentDictionary["Middle"]));
        }
    
        Debug.Log(String.Format("Last: {0}", documentDictionary["Last"]));
        Debug.Log(String.Format("Born: {0}", documentDictionary["Born"]));
      }
    
      Debug.Log("Read all data from the users collection.");
    });
      
    C #
    CollectionReference usersRef = db.Collection("users");
    QuerySnapshot snapshot = await usersRef.GetSnapshotAsync();
    foreach (DocumentSnapshot document in snapshot.Documents)
    {
        Console.WriteLine("User: {0}", document.Id);
        Dictionary<string, object> documentDictionary = document.ToDictionary();
        Console.WriteLine("First: {0}", documentDictionary["First"]);
        if (documentDictionary.ContainsKey("Middle"))
        {
            Console.WriteLine("Middle: {0}", documentDictionary["Middle"]);
        }
        Console.WriteLine("Last: {0}", documentDictionary["Last"]);
        Console.WriteLine("Born: {0}", documentDictionary["Born"]);
        Console.WriteLine();
    }
      
    Rubino
    users_ref = firestore.col "users"
    users_ref.get do |user|
      puts "#{user.document_id} data: #{user.data}."
    end
      

    Proteggi i tuoi dati

    Se utilizzi l'SDK Web, Android o iOS, utilizza Firebase Authentication e le regole di sicurezza di Cloud Firestore per proteggere i tuoi dati in Cloud Firestore.

    Ecco alcuni set di regole di base che puoi utilizzare per iniziare. Puoi modificare le tue regole di sicurezza nella scheda Regole della console.

    Autenticazione richiesta

    // Allow read/write access on all documents to any user signed in to the application
    service cloud.firestore {
      match /databases/{database}/documents {
        match /{document=**} {
          allow read, write: if request.auth != null;
        }
      }
    }
    

    Modalità bloccata

    // Deny read/write access to all users under any conditions
    service cloud.firestore {
      match /databases/{database}/documents {
        match /{document=**} {
          allow read, write: if false;
        }
      }
    }
    

    Modalità di prova

    // Allow read/write access to all users under any conditions
    // Warning: **NEVER** use this rule set in production; it allows
    // anyone to overwrite your entire database.
    service cloud.firestore {
      match /databases/{database}/documents {
        match /{document=**} {
          allow read, write: if true;
        }
      }
    }
    

    Se stai utilizzando uno degli SDK del server, utilizza Identity and Access Management (IAM) per proteggere i tuoi dati in Cloud Firestore.

    Guarda un video tutorial

    Per una guida dettagliata su come iniziare a utilizzare le librerie client Web e mobili di Cloud Firestore, guarda uno dei seguenti tutorial video:

    ragnatela
    iOS
    Android

    Puoi trovare altri video nel canale YouTube di Firebase.

    Prossimi passi

    Approfondisci le tue conoscenze con i seguenti argomenti:

    • Codelab : impara a utilizzare Cloud Firestore in un'app reale seguendo il codelab per Android , iOS o Web .
    • Modello di dati : scopri di più su come sono strutturati i dati in Cloud Firestore, inclusi dati gerarchici e sottoraccolte.
    • Aggiungi dati : ulteriori informazioni sulla creazione e l'aggiornamento dei dati in Cloud Firestore.
    • Ottieni dati : scopri di più su come recuperare i dati.
    • Esegui query semplici e composte : scopri come eseguire query semplici e composte.
    • Ordinare e limitare le query Scopri come ordinare e limitare i dati restituiti dalle tue query.