Check out what’s new from Firebase@ Google I/O 2021, and join our alpha program for early access to the new Remote Config personalization feature. Learn more

התחל לעבוד עם Cloud Firestore

התחלה מהירה זו מראה לך כיצד להגדיר את Cloud Firestore, להוסיף נתונים ואז להציג את הנתונים שהוספת זה עתה במסוף Firebase.

צור מסד נתונים של Cloud Firestore

  1. אם עדיין לא עשית זאת, צור פרויקט Firebase: במסוף Firebase , לחץ על הוסף פרויקט ולאחר מכן עקוב אחר ההוראות שעל המסך כדי ליצור פרויקט Firebase או כדי להוסיף שירותי Firebase לפרויקט GCP קיים.

  2. נווט לחלק ענן Firestore במסוף Firebase . תתבקש לבחור פרויקט Firebase קיים. עקוב אחר זרימת העבודה ליצירת מסד נתונים.

  3. בחר מצב התחלה לכללי האבטחה שלך ב- Cloud Firestore:

    מצב מבחן

    טוב להתחלה עם ספריות הלקוחות הניידים והאינטרנט, אך מאפשר לכל אחד לקרוא ולהחליף את הנתונים שלך. לאחר הבדיקה, הקפד לעיין בסעיף אבטחת הנתונים שלך .

    כדי להתחיל לעבוד עם האינטרנט, iOS או Android SDK, בחר במצב בדיקה.

    מצב נעול

    מכחיש את כל הקריאה והכתיבה מלקוחות ניידים ואינטרנט. שרתי היישומים המאומתים שלך (C #, Go, Java, Node.js, PHP, Python או Ruby) עדיין יכולים לגשת למסד הנתונים שלך.

    כדי להתחיל בספריית הלקוחות של שרת C #, Go, Java, Node.js, PHP, Python או Ruby, בחר במצב נעול.

  4. בחר מיקום עבור מסד הנתונים שלך.

    • הגדרת מיקום זו היא מיקום המשאב המשמש כברירת מחדל של Google Cloud Platform (GCP) של הפרויקט שלך. שים לב כי מיקום זה ישמש עבור שירותי GCP בפרויקט שלך הדורשים הגדרת מיקום, במיוחד דלי אחסון הענן המוגדרים כברירת מחדל ואפליקציית App Engine שלך (דבר הנדרש אם אתה משתמש ב- Scheduler Cloud).

    • אם אינך מצליח לבחור מיקום, לפרויקט שלך כבר יש מיקום ברירת מחדל למשאבי GCP. הוא הוגדר במהלך יצירת הפרויקט או בעת הגדרת שירות אחר הדורש הגדרת מיקום.

  5. לחץ על סיום .

כאשר אתה מפעיל את Cloud Firestore, הוא גם מאפשר את ה- API במנהל ה- API של Cloud .

הגדר את סביבת הפיתוח שלך

הוסף את התלות הנדרשת וספריות הלקוחות לאפליקציה שלך.

אינטרנט v8

  1. עקוב אחר ההוראות כדי להוסיף את Firebase לאפליקציית האינטרנט שלך .
  2. הוסף את ספריות Firebase ו- Cloud Firestore לאפליקציה שלך:
    <script src="https://www.gstatic.com/firebasejs/8.6.7/firebase-app.js"></script>
    <script src="https://www.gstatic.com/firebasejs/8.6.7/firebase-firestore.js"></script>
    SDK Cloud Firestore זמין גם כחבילת npm.
    npm install firebase@8.6.7 --save
    
    יהיה עליך לדרוש באופן ידני גם את Firebase וגם את Cloud Firestore.
    const firebase = require("firebase");
    // Required for side-effects
    require("firebase/firestore");
    

אינטרנט v9

  1. עקוב אחר ההוראות כדי להוסיף את Firebase לאפליקציית האינטרנט שלך .
  2. ה- SDK של Cloud Firestore זמין כחבילת npm.
    npm install firebase@9.0.0-beta.2 --save
    
    יהיה עליך לייבא גם את Firebase וגם את Cloud Firestore.
    import { initializeApp } from "firebase/app";
    import { getFirestore } from "firebase/firestore";
    
iOS
  1. עקוב אחר ההוראות כדי להוסיף את Firebase לאפליקציית iOS שלך .
  2. הוסף את תרמיל Cloud Firestore ל- Podfile
    pod 'Firebase/Firestore'
    
    # Optionally, include the Swift extensions if you're using Swift.
    pod 'FirebaseFirestoreSwift'
    
    שלך
  3. שמור את הקובץ והפעל pod install .

ג'אווה

  1. עקוב אחר ההוראות כדי להוסיף את Firebase לאפליקציית Android שלך .
  2. באמצעות אנדרואיד ה- BoM של Firebase , הכריזו על התלות בספריית אנדרואיד Cloud Firestore בקובץ app/build.gradle (ברמת האפליקציה) שלכם במודול (בדרך כלל app/build.gradle ).
    dependencies {
        // Import the BoM for the Firebase platform
        implementation platform('com.google.firebase:firebase-bom:28.1.0')
    
        // Declare the dependency for the Cloud Firestore library
        // When using the BoM, you don't specify versions in Firebase library dependencies
        implementation 'com.google.firebase:firebase-firestore'
    }
    

    על ידי שימוש ב- Firebase Android BoM , האפליקציה שלך תשתמש תמיד בגרסאות תואמות של ספריות Android ל- Firebase.

    (חלופי) הצהיר על תלות בספריית Firebase מבלי להשתמש ב- BoM

    אם תבחר שלא להשתמש ב- Firebase BoM, עליך לציין כל גרסת ספריית Firebase בשורת התלות שלה.

    שים לב שאם אתה משתמש בספריות Firebase מרובות באפליקציה שלך, אנו ממליצים בחום להשתמש ב- BoM לניהול גרסאות ספרייה, מה שמבטיח שכל הגרסאות תואמות.

    dependencies {
        // Declare the dependency for the Cloud Firestore library
        // When NOT using the BoM, you must specify versions in Firebase library dependencies
        implementation 'com.google.firebase:firebase-firestore:23.0.1'
    }
    

Kotlin + KTX

  1. עקוב אחר ההוראות כדי להוסיף את Firebase לאפליקציית Android שלך .
  2. באמצעות Firebase Android BoM , הצהירו על התלות בספריית אנדרואיד Cloud Firestore בקובץ app/build.gradle המודול שלכם (ברמת האפליקציה) (בדרך כלל app/build.gradle ).
    dependencies {
        // Import the BoM for the Firebase platform
        implementation platform('com.google.firebase:firebase-bom:28.1.0')
    
        // Declare the dependency for the Cloud Firestore library
        // When using the BoM, you don't specify versions in Firebase library dependencies
        implementation 'com.google.firebase:firebase-firestore-ktx'
    }
    

    על ידי שימוש ב- Firebase Android BoM , היישום שלך ישתמש תמיד בגרסאות תואמות של ספריות Android ל- Firebase.

    (חלופי) הצהיר על תלות בספריית Firebase מבלי להשתמש ב- BoM

    אם תבחר לא להשתמש ב- Firebase BoM, עליך לציין כל גרסת ספריית Firebase בשורת התלות שלה.

    שים לב שאם אתה משתמש בספריות Firebase מרובות באפליקציה שלך, אנו ממליצים בחום להשתמש ב- BoM לניהול גרסאות ספרייה, מה שמבטיח שכל הגרסאות תואמות.

    dependencies {
        // Declare the dependency for the Cloud Firestore library
        // When NOT using the BoM, you must specify versions in Firebase library dependencies
        implementation 'com.google.firebase:firebase-firestore-ktx:23.0.1'
    }
    
ג'אווה
  1. הוסף את ה- SDK לניהול ה- Firebase לאפליקציה שלך:
    • באמצעות Gradle :
      compile 'com.google.firebase:firebase-admin:7.3.0'
      
    • באמצעות Maven:
      <dependency>
        <groupId>com.google.firebase</groupId>
        <artifactId>firebase-admin</artifactId>
        <version>7.3.0</version>
      </dependency>
           
  2. עקוב אחר ההוראות שלהלן כדי לאתחל את Cloud Firestore עם האישורים המתאימים בסביבתך.
פִּיתוֹן
  1. הוסף את ה- SDK לניהול Firebase לאפליקציית Python שלך:
    pip install --upgrade firebase-admin
  2. עקוב אחר ההוראות שלהלן כדי לאתחל את Cloud Firestore עם האישורים המתאימים בסביבתך.
C ++
  1. עקוב אחר ההוראות כדי להוסיף את Firebase לפרויקט C ++ שלך .
  2. ממשק C ++ לאנדרואיד.
    • תלות דרגתית. הוסף את הדברים הבאים למודול שלך (ברמת האפליקציה) קובץ Gradle (בדרך כלל 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
              }
              
    • תלות בינארית. באופן דומה, הדרך המומלצת כדי לקבל את התלות בינארי היא להוסיף את הטקסט הבא לקובץ CMakeLists.txt קובץ:
              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. להגדרת שילוב שולחן העבודה , ראה הוסף Firebase לפרויקט C ++ שלך .
אַחְדוּת
  1. עקוב אחר ההוראות כדי להוסיף את Firebase לפרויקט Unity שלך .
  2. ממשק אחדות לאנדרואיד.
  3. בעת בניית Android, הפעל את ProGuarding כדי להימנע ממגבלת Android DEX. לשם כך, בעורך האחדות:

    1. בחר קובץ> הגדרות בנייה
    2. החלף 'פלטפורמה' ל- 'Android' ולחץ על 'החלף פלטפורמה'
    3. לחץ על 'הגדרות נגן ...'
    4. בממשק המשתמש הראשי של Unity, תחת 'הגדרות ל- Android', בחר 'הגדרות פרסום'
    5. בקטע 'צמצם', שנה את הגדרות השחרור והניפוי באגים מ'אין 'ל'פרוגארד'
Node.js
  1. הוסף את ה- SDK של מנהל המערכת של Firebase לאפליקציה שלך:
    npm install firebase-admin --save
  2. עקוב אחר ההוראות שלהלן כדי לאתחל את Cloud Firestore עם האישורים המתאימים בסביבתך.
ללכת
  1. הוסף את ה- SDK לניהול Firebase לאפליקציית Go שלך:
    go get firebase.google.com/go
    
  2. עקוב אחר ההוראות שלהלן כדי לאתחל את Cloud Firestore עם האישורים המתאימים בסביבתך.
PHP
  1. ספריות לקוח השרת Cloud Firestore (Java, Node.js, Python, Go, PHP, C # ו- Ruby) משתמשות באישורי ברירת המחדל של יישום Google לצורך אימות.
    • כדי לאמת מסביבת הפיתוח שלך, הגדר את משתנה הסביבה GOOGLE_APPLICATION_CREDENTIALS כך שיצביע על קובץ מפתח חשבון JSON. אתה יכול ליצור קובץ מפתח בדף אישורי ה- API Console .
      export GOOGLE_APPLICATION_CREDENTIALS="path/to/your/keyfile.json"
    • בסביבת הייצור שלך, אינך צריך לאמת אם אתה מריץ את היישום שלך ב- App Engine או ב- Compute Engine, תוך שימוש באותו פרויקט שבו אתה משתמש עבור Cloud Firestore. אחרת, הגדר חשבון שירות .
  2. התקן והפעל את סיומת gRPC עבור PHP, אשר תצטרך להשתמש בספריית הלקוחות.
  3. הוסף את ספריית ה- Cloud Firestore PHP לאפליקציה שלך:
    composer require google/cloud-firestore
C #
  1. ספריות לקוח השרת Cloud Firestore (Java, Node.js, Python, Go, PHP, C # ו- Ruby) משתמשות באישורי ברירת המחדל של יישום Google לצורך אימות.
    • כדי לאמת מסביבת הפיתוח שלך, הגדר את משתנה הסביבה GOOGLE_APPLICATION_CREDENTIALS כך שיצביע על קובץ מפתח חשבון JSON. אתה יכול ליצור קובץ מפתח בדף אישורי ה- API Console .
      export GOOGLE_APPLICATION_CREDENTIALS="path/to/your/keyfile.json"
    • בסביבת הייצור שלך, אינך צריך לאמת אם אתה מפעיל את היישום שלך ב- App Engine או ב- Compute Engine, תוך שימוש באותו פרויקט שבו אתה משתמש עבור Cloud Firestore. אחרת, הגדר חשבון שירות .
  2. מוסיפים את הספרייה # ענן Firestore C לאפליקציה שלך שלך .csproj הקובץ:
    <ItemGroup>
      <PackageReference Include="Google.Cloud.Firestore" Version="1.1.0-beta01" />
    </ItemGroup>
  3. הוסף את הדברים הבאים לקובץ Program.cs שלך:
    using Google.Cloud.Firestore;
אוֹדֶם
  1. ספריות לקוח השרת Cloud Firestore (Java, Node.js, Python, Go, PHP, C # ו- Ruby) משתמשות באישורי ברירת המחדל של יישום Google לצורך אימות.
    • כדי לאמת מסביבת הפיתוח שלך, הגדר את משתנה הסביבה GOOGLE_APPLICATION_CREDENTIALS כך שיצביע על קובץ מפתח חשבון JSON. אתה יכול ליצור קובץ מפתח בדף אישורי ה- API Console .
      export GOOGLE_APPLICATION_CREDENTIALS="path/to/your/keyfile.json"
    • בסביבת הייצור שלך, אינך צריך לאמת אם אתה מפעיל את היישום שלך ב- App Engine או ב- Compute Engine, תוך שימוש באותו פרויקט שבו אתה משתמש עבור Cloud Firestore. אחרת, הגדר חשבון שירות .
  2. הוסף את ספריית Cloud Firestore Ruby לאפליקציה שלך Gemfile שלך:
    gem "google-cloud-firestore"
  3. התקן תלות Gemfile שלך באמצעות:
    bundle install

(אופציונלי) אב טיפוס ובדיקה באמצעות חבילת אמולטור מקומית של Firebase

למפתחים ניידים, לפני שנדבר על האופן שבו האפליקציה שלך כותבת וקוראת מ- Cloud Firestore, בואו להציג קבוצה של כלים שבהם תוכלו להשתמש כדי ליצור אב-טיפוס ולבדוק את הפונקציונליות של Cloud Firestore: Firebase Local Emulator Suite. אם אתה מנסה מודלי נתונים שונים, מבצע אופטימיזציה של כללי האבטחה שלך או עובד על מנת למצוא את הדרך החסכונית ביותר לקיים אינטראקציה עם ה- back-end, היכולת לעבוד באופן מקומי מבלי לפרוס שירותים חיים יכולה להיות רעיון נהדר.

אמולטור של Cloud Firestore הוא חלק מחבילת ה- Emulator המקומית, המאפשרת לאפליקציה שלך לקיים אינטראקציה עם תוכן מסדי הנתונים המדומה שלך ולהגדיר אותו, כמו גם את משאבי הפרויקט המדויקים שלך (פונקציות, מסדי נתונים אחרים וכללי אבטחה).

השימוש באמולטור Cloud Firestore כולל רק כמה צעדים:

  1. הוספת שורת קוד לתצורת הבדיקה של האפליקציה שלך כדי להתחבר לאמולטור.
  2. משורש ספריית הפרויקטים המקומית שלך, הפעלת firebase emulators:start .
  3. שיחות מקוד האב-טיפוס של האפליקציה שלך באמצעות SDK של פלטפורמת ה- Cloud Firestore כרגיל.

ניתן לקבל הדרכה מפורטת הכוללת את Cloud Firestore ו- Cloud Features . אתה צריך גם להסתכל במבוא של Local Emulator Suite .

אתחל את ענן Firestore

אתחל מופע של Cloud Firestore:

אינטרנט v8

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

var db = firebase.firestore();
הערכים של 'initializeApp' נמצאים ב- 'firebaseConfig' של אפליקציית האינטרנט שלך. כדי לעמוד בנתונים כאשר המכשיר מאבד את חיבורו, עיין בתיעוד אפשר נתונים לא מקוונים .

אינטרנט v9

// Initialize Cloud Firestore through Firebase
import { initializeApp } from "firebase/app"
import { getFirestore } from "firebase/firestore"
const firebaseApp = initializeApp({
  apiKey: '### FIREBASE API KEY ###',
  authDomain: '### FIREBASE AUTH DOMAIN ###',
  projectId: '### CLOUD FIRESTORE PROJECT ID ###'
});

const db = getFirestore();
הערכים של 'initializeApp' נמצאים ב- 'firebaseConfig' של אפליקציית האינטרנט שלך. כדי לעמוד בנתונים כאשר המכשיר מאבד את חיבורו, עיין בתיעוד אפשר נתונים לא מקוונים .
מָהִיר
import Firebase
FirebaseApp.configure()

let db = Firestore.firestore()
מטרה-ג
@import Firebase;

// Use Firebase library to configure APIs
[FIRApp configure];
  
FIRFirestore *defaultFirestore = [FIRFirestore firestore];

ג'אווה

// 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
ג'אווה
SDK Cloud Firestore מאותחל בדרכים שונות בהתאם לסביבתך. להלן השיטות הנפוצות ביותר. לקבלת התייחסות מלאה, ראה אתחול SDK לניהול המערכת .
  • אתחל ב- 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();
    
  • אתחל בשרת משלך

    כדי להשתמש ב- Firebase Admin SDK בשרת משלך, השתמש בחשבון שירות .

    עבור אל IAM & admin> חשבונות שירות במסוף פלטפורמת הענן. צור מפתח פרטי חדש ושמור את קובץ JSON. ואז השתמש בקובץ כדי לאתחל את ה- 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();
    
  • פִּיתוֹן
    SDK Cloud Firestore מאותחל בדרכים שונות בהתאם לסביבתך. להלן השיטות הנפוצות ביותר. לקבלת התייחסות מלאה, ראה אתחול SDK לניהול המערכת .
  • אתחל ב- 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()
    
  • אתחל בשרת משלך

    כדי להשתמש ב- Firebase Admin SDK בשרת משלך, השתמש בחשבון שירות .

    עבור אל IAM & admin> חשבונות שירות במסוף פלטפורמת הענן. צור מפתח פרטי חדש ושמור את קובץ JSON. ואז השתמש בקובץ כדי לאתחל את ה- 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
    SDK Cloud Firestore מאותחל בדרכים שונות בהתאם לסביבתך. להלן השיטות הנפוצות ביותר. לקבלת התייחסות מלאה, ראה אתחול SDK לניהול המערכת .
    • אתחל את פונקציות הענן
      const admin = require('firebase-admin');
      admin.initializeApp();
      
      const db = admin.firestore();
      
    • אתחל ב- Google Cloud Platform
      const admin = require('firebase-admin');
      admin.initializeApp({
        credential: admin.credential.applicationDefault()
      });
      
      const db = admin.firestore();
    • אתחל בשרת משלך

      כדי להשתמש ב- Firebase Admin SDK בשרת משלך (או בכל סביבת Node.js אחרת), השתמש בחשבון שירות . עבור אל IAM & admin> חשבונות שירות במסוף פלטפורמת הענן. צור מפתח פרטי חדש ושמור את קובץ JSON. ואז השתמש בקובץ כדי לאתחל את ה- SDK:

      const admin = require('firebase-admin');
      const serviceAccount = require('./path/to/serviceAccountKey.json');
      
      admin.initializeApp({
        credential: admin.credential.cert(serviceAccount)
      });
      
      const db = admin.firestore();
      
    ללכת
    SDK Cloud Firestore מאותחל בדרכים שונות בהתאם לסביבתך. להלן השיטות הנפוצות ביותר. לקבלת התייחסות מלאה, ראה אתחול SDK לניהול המערכת .
  • אתחל ב- 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()
    
  • אתחל בשרת משלך

    כדי להשתמש ב- Firebase Admin SDK בשרת משלך, השתמש בחשבון שירות .

    עבור אל IAM & admin> חשבונות שירות במסוף פלטפורמת הענן. צור מפתח פרטי חדש ושמור את קובץ JSON. ואז השתמש בקובץ כדי לאתחל את ה- 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.
     * ```
     * setup_client_create();
     * ```
     */
    function setup_client_create()
    {
        // Create the Cloud Firestore client
        $db = new FirestoreClient();
        printf('Created Cloud Firestore client with default project ID.' . PHP_EOL);
    }
    אַחְדוּת
    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);
    אוֹדֶם
    require "google/cloud/firestore"
    
    firestore = Google::Cloud::Firestore.new project_id: project_id
    
    puts "Created Cloud Firestore client with given project ID."

    הוסף נתונים

    Cloud Firestore מאחסן נתונים במסמכים, המאוחסנים באוספים. Cloud Firestore יוצר אוספים ומסמכים באופן מרומז בפעם הראשונה שאתה מוסיף נתונים למסמך. אינך צריך ליצור במפורש אוספים או מסמכים.

    צור אוסף ומסמך חדש באמצעות קוד הדוגמה הבא.

    אינטרנט v8

    db.collection("users").add({
        first: "Ada",
        last: "Lovelace",
        born: 1815
    })
    .then((docRef) => {
        console.log("Document written with ID: ", docRef.id);
    })
    .catch((error) => {
        console.error("Error adding document: ", error);
    });

    אינטרנט v9

    import { collection, addDoc } from "firebase/firestore"; 
    
    try {
      const docRef = await addDoc(collection(db, "users"), {
        first: "Ada",
        last: "Lovelace",
        born: 1815
      });
      console.log("Document written with ID: ", docRef.id);
    } catch (e) {
      console.error("Error adding document: ", e);
    }
    מָהִיר
    // 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)")
        }
    }
    מטרה-ג
    // 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);
          }
        }];

    ג'אווה

    // 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)
        }
    ג'אווה
    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());
    פִּיתוֹן
    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
    });
    ללכת
    _, _, 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('samples/php/users')->document('lovelace');
    $docRef->set([
        'first' => 'Ada',
        'last' => 'Lovelace',
        'born' => 1815
    ]);
    printf('Added data to the lovelace document in the users collection.' . PHP_EOL);
    אַחְדוּת
    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);
    אוֹדֶם
    doc_ref = firestore.doc "#{collection_path}/alovelace"
    
    doc_ref.set(
      {
        first: "Ada",
        last:  "Lovelace",
        born:  1815
      }
    )
    
    puts "Added data to the alovelace document in the users collection."

    כעת הוסף מסמך נוסף לאוסף users . שים לב שמסמך זה כולל צמד ערכי מפתח (שם אמצעי) שלא מופיע במסמך הראשון. מסמכים באוסף יכולים להכיל סטים שונים של מידע.

    אינטרנט v8

    // Add a second document with a generated ID.
    db.collection("users").add({
        first: "Alan",
        middle: "Mathison",
        last: "Turing",
        born: 1912
    })
    .then((docRef) => {
        console.log("Document written with ID: ", docRef.id);
    })
    .catch((error) => {
        console.error("Error adding document: ", error);
    });

    אינטרנט v9

    // Add a second document with a generated ID.
    import { addDoc, collection } from "firebase/firestore"; 
    
    try {
      const docRef = await addDoc(collection(db, "users"), {
        first: "Alan",
        middle: "Mathison",
        last: "Turing",
        born: 1912
      });
    
      console.log("Document written with ID: ", docRef.id);
    } catch (e) {
      console.error("Error adding document: ", e);
    }
    מָהִיר
    // 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)")
        }
    }
    מטרה-ג
    // 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);
          }
        }];

    ג'אווה

    // 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)
        }
    ג'אווה
    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());
    פִּיתוֹן
    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
    });
    ללכת
    _, _, 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('samples/php/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);
    אַחְדוּת
    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);
    אוֹדֶם
    doc_ref = firestore.doc "#{collection_path}/aturing"
    
    doc_ref.set(
      {
        first:  "Alan",
        middle: "Mathison",
        last:   "Turing",
        born:   1912
      }
    )
    
    puts "Added data to the aturing document in the users collection."

    קרא נתונים

    כדי לוודא במהירות שהוספת נתונים ל- Cloud Firestore, השתמש במציג הנתונים במסוף Firebase .

    אתה יכול גם להשתמש בשיטת "קבל" כדי לאחזר את כל האוסף.

    אינטרנט v8

    db.collection("users").get().then((querySnapshot) => {
        querySnapshot.forEach((doc) => {
            console.log(`${doc.id} => ${doc.data()}`);
        });
    });

    אינטרנט v9

    import { collection, getDocs } from "firebase/firestore"; 
    
    const querySnapshot = await getDocs(collection(db, "users"));
    querySnapshot.forEach((doc) => {
      console.log(`${doc.id} => ${doc.data()}`);
    });
    מָהִיר
    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())")
            }
        }
    }
    מטרה-ג
    [[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);
            }
          }
        }];

    ג'אווה

    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)
            }
    ג'אווה
    // 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"));
    }
    פִּיתוֹן
    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());
    });
    ללכת
    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('samples/php/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);
    אַחְדוּת
    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();
    }
    אוֹדֶם
    users_ref = firestore.col collection_path
    users_ref.get do |user|
      puts "#{user.document_id} data: #{user.data}."
    end

    אבטח את הנתונים שלך

    אם אתה משתמש ב- SDK באינטרנט, ב- Android או ב- iOS, השתמש באימות Firebase ובכללי האבטחה של Cloud Firestore כדי לאבטח את הנתונים שלך ב- Cloud Firestore.

    להלן מספר קבוצות כללים בסיסיות בהן תוכל להשתמש כדי להתחיל. באפשרותך לשנות את כללי האבטחה בכרטיסיה כללים במסוף.

    חובה לאמת

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

    מצב נעול

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

    מצב מבחן

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

    אם אתה משתמש באחד מ- SDK של השרת, השתמש בניהול זהות וגישה (IAM) כדי לאבטח את הנתונים שלך ב- Cloud Firestore.

    צפו במדריך וידאו

    לקבלת הנחיות מפורטות לתחילת העבודה עם ספריות Cloud Firestore לנייד ולקוחות אינטרנט, צפו באחת ממדריכי הווידאו הבאים:

    אינטרנט v8

    iOS
    דְמוּי אָדָם

    תוכל למצוא סרטונים נוספים בערוץ YouTube של Firebase.

    הצעדים הבאים

    העמיק את הידע שלך בנושאים הבאים: