Cloud Firestore का इस्तेमाल शुरू करना

इस शुरुआती लेख में, Cloud Firestore को सेट अप करने, डेटा जोड़ने, और Firebase कंसोल में हाल ही में जोड़े गए डेटा को देखने का तरीका बताया गया है.

Cloud Firestore डेटाबेस बनाना

  1. अगर आपने पहले से कोई Firebase प्रोजेक्ट नहीं बनाया है, तो एक Firebase प्रोजेक्ट बनाएं: Firebase कंसोल में, प्रोजेक्ट जोड़ें पर क्लिक करें. इसके बाद, Firebase प्रोजेक्ट बनाने या किसी मौजूदा Google Cloud प्रोजेक्ट में Firebase की सेवाएं जोड़ने के लिए, स्क्रीन पर दिए गए निर्देशों का पालन करें.

  2. Firebase कंसोल में अपना प्रोजेक्ट खोलें. बाएं पैनल में, बिल्ड को बड़ा करें. इसके बाद, Firestore डेटाबेस चुनें.

  3. डेटाबेस बनाएं पर क्लिक करें.

  4. अपने डेटाबेस के लिए कोई जगह चुनें.

    अगर आपको कोई जगह नहीं दिख रही है, तो इसका मतलब है कि आपके प्रोजेक्ट का "डिफ़ॉल्ट Google Cloud संसाधनों के लिए जगह" पहले से सेट है. आपके प्रोजेक्ट के कुछ संसाधन (जैसे, डिफ़ॉल्ट Cloud Firestore इंस्टेंस), जगह की जानकारी की एक ही डिपेंडेंसी शेयर करते हैं. साथ ही, प्रोजेक्ट बनाते समय या जगह की जानकारी की डिपेंडेंसी शेयर करने वाली किसी अन्य सेवा को सेट अप करते समय, उनकी जगह की जानकारी सेट की जा सकती है.

  5. अपने Cloud Firestore Security Rules के लिए, शुरू करने का मोड चुनें:

    टेस्ट मोड

    मोबाइल और वेब क्लाइंट लाइब्रेरी का इस्तेमाल शुरू करने के लिए अच्छा है. हालांकि, इससे कोई भी आपका डेटा पढ़ सकता है और उसमें बदलाव कर सकता है. जांच करने के बाद, अपने डेटा को सुरक्षित रखें सेक्शन की समीक्षा करना न भूलें.

    वेब, Apple प्लैटफ़ॉर्म या Android SDK टूल का इस्तेमाल शुरू करने के लिए, टेस्ट मोड चुनें.

    लॉक मोड

    मोबाइल और वेब क्लाइंट से सभी रीड और राइट को अस्वीकार करता है. पुष्टि किए गए आपके ऐप्लिकेशन सर्वर (C#, Go, Java, Node.js, PHP, Python या Ruby) अब भी आपके डेटाबेस को ऐक्सेस कर सकते हैं.

    C#, Go, Java, Node.js, PHP, Python या Ruby के लिए क्लाइंट लाइब्रेरी का इस्तेमाल शुरू करने के लिए, लॉक किया गया मोड चुनें.

    Cloud Firestore Security Rules का आपका शुरुआती सेट, आपके डिफ़ॉल्ट Cloud Firestore डेटाबेस पर लागू होगा. अगर आपने अपने प्रोजेक्ट के लिए कई डेटाबेस बनाए हैं, तो हर डेटाबेस के लिए Cloud Firestore Security Rules को डिप्लॉय किया जा सकता है.

  6. बनाएं पर क्लिक करें.

Cloud Firestore को चालू करने पर, यह Cloud API मैनेजर में भी एपीआई को चालू कर देता है.

डेवलपमेंट एनवायरमेंट सेट अप करना

अपने ऐप्लिकेशन में ज़रूरी डिपेंडेंसी और क्लाइंट लाइब्रेरी जोड़ें.

Web

  1. अपने वेब ऐप्लिकेशन में Firebase जोड़ने के लिए, निर्देशों का पालन करें.
  2. अपने ऐप्लिकेशन में Firebase और Cloud Firestore लाइब्रेरी जोड़ें: 
    <script src="https://www.gstatic.com/firebasejs/11.0.2/firebase-app-compat.js"></script>
<script src="https://www.gstatic.com/firebasejs/11.0.2/firebase-firestore-compat.js"></script>
     Cloud Firestore SDK टूल, एनपीएम पैकेज के तौर पर भी उपलब्ध है. 
    npm install firebase@11.0.2 --save
     आपको Firebase और Cloud Firestore, दोनों को मैन्युअल तरीके से ज़रूरी करना होगा. 
    import firebase from "firebase/compat/app";
// Required for side-effects
import "firebase/firestore";

Web

  1. अपने वेब ऐप्लिकेशन में Firebase जोड़ने के लिए, निर्देशों का पालन करें.
  2. Cloud Firestore SDK टूल, npm पैकेज के तौर पर उपलब्ध है. 
    npm install firebase@11.0.2 --save
     आपको Firebase और Cloud Firestore, दोनों को इंपोर्ट करना होगा. 
    import { initializeApp } from "firebase/app";
import { getFirestore } from "firebase/firestore";
iOS+

अपने Apple ऐप्लिकेशन में Firebase जोड़ने के लिए, निर्देशों का पालन करें.

Firebase डिपेंडेंसी इंस्टॉल और मैनेज करने के लिए, Swift Package Manager का इस्तेमाल करें.

  1. Xcode में, अपना ऐप्लिकेशन प्रोजेक्ट खोलकर, फ़ाइल > Swift पैकेज > पैकेज की डिपेंडेंसी जोड़ें पर जाएं.
  2. जब कहा जाए, तब Firebase के Apple प्लैटफ़ॉर्म के SDK टूल का रिपॉज़िटरी जोड़ें:
    3.   https://github.com/firebase/firebase-ios-sdk
  3. Firestore लाइब्रेरी चुनें.
  4. प्रोसेस पूरी होने के बाद, Xcode बैकग्राउंड में आपकी डिपेंडेंसी को अपने-आप हल और डाउनलोड करना शुरू कर देगा.
Android
  1. अपने Android ऐप्लिकेशन में Firebase जोड़ने के लिए, निर्देशों का पालन करें.
  2. Firebase Android BoM का इस्तेमाल करके, अपनी मॉड्यूल (ऐप्लिकेशन-लेवल) Gradle फ़ाइल (आम तौर पर app/build.gradle.kts या app/build.gradle) में, Android के लिए Cloud Firestore लाइब्रेरी की डिपेंडेंसी का एलान करें. 
    dependencies {
    // Import the BoM for the Firebase platform
    implementation(platform("com.google.firebase:firebase-bom:33.7.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 का इस्तेमाल करने पर, आपका ऐप्लिकेशन हमेशा Firebase Android लाइब्रेरी के काम करने वाले वर्शन का इस्तेमाल करेगा.

    (विकल्प) BoM का इस्तेमाल किए बिना, Firebase लाइब्रेरी की डिपेंडेंसी का एलान करें

    अगर 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:25.1.1")
}

    क्या आपको Kotlin के लिए कोई लाइब्रेरी मॉड्यूल चाहिए? अक्टूबर 2023 में रिलीज़ होने वाले वर्शन से, Kotlin और Java, दोनों डेवलपर मुख्य लाइब्रेरी मॉड्यूल का इस्तेमाल कर सकते हैं. ज़्यादा जानकारी के लिए, इस पहल के बारे में अक्सर पूछे जाने वाले सवाल देखें.

Dart

  1. अगर आपने अब तक ऐसा नहीं किया है, तो अपने Flutter ऐप्लिकेशन में Firebase को कॉन्फ़िगर और शुरू करें.
  2. प्लग इन इंस्टॉल करने के लिए, अपने Flutter प्रोजेक्ट के रूट से यह कमांड चलाएं: 
    flutter pub add cloud_firestore
  3. इसके बाद, अपना Flutter ऐप्लिकेशन फिर से बनाएं: 
    flutter run
  4. ज़रूरी नहीं: पहले से संकलित फ़्रेमवर्क को शामिल करके, iOS और macOS के लिए ऐप्लिकेशन बनाने में लगने वाले समय को कम करें.

    फ़िलहाल, iOS के लिए Firestore SDK टूल, ऐसे कोड पर निर्भर करता है जिसे Xcode में बनाने में पांच मिनट से ज़्यादा समय लग सकता है. बिल्ड में लगने वाले समय को काफ़ी कम करने के लिए, पहले से संकलित किए गए वर्शन का इस्तेमाल किया जा सकता है. इसके लिए, अपनी Podfile में target 'Runner' do ब्लॉक में यह लाइन जोड़ें:

    target 'Runner' do
  use_frameworks!
  use_modular_headers!

  pod 'FirebaseFirestore',
    :git => 'https://github.com/invertase/firestore-ios-sdk-frameworks.git',
    :tag => 'IOS_SDK_VERSION'

  flutter_install_all_ios_pods File.dirname(File.realpath(__FILE__))
  target 'RunnerTests' do
    inherit! :search_paths
  end
end

    IOS_SDK_VERSION को firebase_core की firebase_sdk_version.rb फ़ाइल में बताए गए Firebase iOS SDK टूल के वर्शन से बदलें. अगर firebase_core के सबसे नए वर्शन का इस्तेमाल नहीं किया जा रहा है, तो इस फ़ाइल को अपने लोकल Pub पैकेज कैश मेमोरी (आम तौर पर ~/.pub-cache) में ढूंढें.

    इसके अलावा, पक्का करें कि आपने CocoaPods को 1.9.1 या इससे बेहतर वर्शन पर अपग्रेड किया हो: 

    gem install cocoapods

    ज़्यादा जानकारी के लिए, GitHub पर समस्या देखें.

Java
  1. अपने ऐप्लिकेशन में Firebase Admin SDK टूल जोड़ें:
    • Gradle का इस्तेमाल करना: 
      compile 'com.google.firebase:firebase-admin:1.32.0'
    • Maven का इस्तेमाल करना: 
      <dependency>
  <groupId>com.google.firebase</groupId>
  <artifactId>firebase-admin</artifactId>
  <version>1.32.0</version>
</dependency>
  2. अपने इनवायरनमेंट में सही क्रेडेंशियल के साथ Cloud Firestore को शुरू करने के लिए, नीचे दिए गए निर्देशों का पालन करें.
Python
  1. अपने Python ऐप्लिकेशन में Firebase Admin SDK टूल जोड़ें: 
    pip install --upgrade firebase-admin
  2. अपने इनवायरनमेंट में सही क्रेडेंशियल के साथ Cloud Firestore को शुरू करने के लिए, नीचे दिए गए निर्देशों का पालन करें.
C++
  1. अपने C++ प्रोजेक्ट में Firebase जोड़ने के लिए, निर्देशों का पालन करें.
  2. Android के लिए C++ इंटरफ़ेस.
    • Gradle डिपेंडेंसी. अपने मॉड्यूल (ऐप्लिकेशन-लेवल) की 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. डेस्कटॉप इंटिग्रेशन सेट अप करने के लिए, अपने C++ प्रोजेक्ट में Firebase जोड़ें लेख पढ़ें.
Unity
  1. अपने Unity प्रोजेक्ट में Firebase जोड़ने के लिए, निर्देशों का पालन करें.
  2. Android बिल्ड को छोटा करने के लिए, अपने प्रोजेक्ट को कॉन्फ़िगर करने के लिए Unity इंटरफ़ेस का इस्तेमाल करें.

    3. Error while merging dex archives मैसेज से बचने के लिए, आपको बिल्ड को छोटा करना होगा.

    • यह विकल्प, प्लेयर सेटिंग > Android > पब्लिश करने की सेटिंग > छोटा करें में देखा जा सकता है.
    • Unity के अलग-अलग वर्शन में विकल्प अलग-अलग हो सकते हैं. इसलिए, Unity का आधिकारिक दस्तावेज़ और Firebase Unity Build की गड़बड़ी को डीबग करने के लिए बनी गाइड देखें.
    • अगर छोटा करने की सुविधा चालू करने के बाद भी, रेफ़रंस वाले तरीकों की संख्या तय सीमा से ज़्यादा है, तो multidex को इनमें चालू करें:
      • mainTemplate.gradle अगर प्लेयर सेटिंग में कस्टम Gradle टेंप्लेट चालू है
      • या, अगर एक्सपोर्ट किए गए प्रोजेक्ट को बनाने के लिए Android Studio का इस्तेमाल किया जाता है, तो मॉड्यूल-लेवल build.gradle फ़ाइल.
Node.js
  1. अपने ऐप्लिकेशन में Firebase Admin SDK टूल जोड़ें: 
    npm install firebase-admin --save
  2. अपने इनवायरनमेंट में सही क्रेडेंशियल के साथ Cloud Firestore को शुरू करने के लिए, नीचे दिए गए निर्देशों का पालन करें.
शुरू करें
  1. अपने Go ऐप्लिकेशन में Firebase Admin SDK टूल जोड़ें: 
    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 सेवा खाते की कुंजी फ़ाइल पर ले जाने के लिए सेट करें. एपीआई कंसोल के क्रेडेंशियल पेज पर जाकर, पासकोड वाली फ़ाइल बनाई जा सकती है. 
      export GOOGLE_APPLICATION_CREDENTIALS="path/to/your/keyfile.json"
    • अगर आपने अपने ऐप्लिकेशन को Cloud Firestore के लिए इस्तेमाल किए गए प्रोजेक्ट का इस्तेमाल करके, App Engine या Compute Engine पर चलाया है, तो आपको अपने प्रोडक्शन एनवायरमेंट में पुष्टि करने की ज़रूरत नहीं है. अगर ऐसा नहीं है, तो सेवा खाता सेट अप करें.
  2. PHP के लिए, gRPC एक्सटेंशन को इंस्टॉल और चालू करें.
  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 सेवा खाते की कुंजी फ़ाइल पर ले जाने के लिए सेट करें. एपीआई कंसोल के क्रेडेंशियल पेज पर जाकर, पासकोड वाली फ़ाइल बनाई जा सकती है. 
      export GOOGLE_APPLICATION_CREDENTIALS="path/to/your/keyfile.json"
    • अगर आपने अपने ऐप्लिकेशन को Cloud Firestore के लिए इस्तेमाल किए गए प्रोजेक्ट का इस्तेमाल करके, App Engine या Compute Engine पर चलाया है, तो आपको अपने प्रोडक्शन एनवायरमेंट में पुष्टि करने की ज़रूरत नहीं है. अगर ऐसा नहीं है, तो सेवा खाता सेट अप करें.
  2. अपनी .csproj फ़ाइल में, अपने ऐप्लिकेशन में Cloud Firestore C# लाइब्रेरी जोड़ें: 
    <ItemGroup>
  <PackageReference Include="Google.Cloud.Firestore" Version="1.1.0-beta01" />
</ItemGroup>
  3. अपनी Program.cs फ़ाइल में यह कोड जोड़ें: 
    using Google.Cloud.Firestore;
Ruby
  1. Cloud Firestore सर्वर क्लाइंट लाइब्रेरी (Java, Node.js, Python, Go, PHP, C#, और Ruby), पुष्टि करने के लिए Google ऐप्लिकेशन के डिफ़ॉल्ट क्रेडेंशियल का इस्तेमाल करती हैं.
    • अपने डेवलपमेंट एनवायरमेंट से पुष्टि करने के लिए, GOOGLE_APPLICATION_CREDENTIALS एनवायरमेंट वैरिएबल को JSON सेवा खाते की कुंजी फ़ाइल पर ले जाने के लिए सेट करें. एपीआई कंसोल के क्रेडेंशियल पेज पर जाकर, पासकोड वाली फ़ाइल बनाई जा सकती है. 
      export GOOGLE_APPLICATION_CREDENTIALS="path/to/your/keyfile.json"
    • अगर आपने अपने ऐप्लिकेशन को Cloud Firestore के लिए इस्तेमाल किए गए प्रोजेक्ट का इस्तेमाल करके, App Engine या Compute Engine पर चलाया है, तो आपको अपने प्रोडक्शन एनवायरमेंट में पुष्टि करने की ज़रूरत नहीं है. अगर ऐसा नहीं है, तो सेवा खाता सेट अप करें.
  2. Gemfile में अपने ऐप्लिकेशन में Cloud Firestore Ruby लाइब्रेरी जोड़ें: 
    gem "google-cloud-firestore"
  3. Gemfile से डिपेंडेंसी इंस्टॉल करने के लिए, इनका इस्तेमाल करें: 
    bundle install

(ज़रूरी नहीं) Firebase Local Emulator Suite की मदद से प्रोटोटाइप बनाना और जांच करना

मोबाइल डेवलपर के लिए, Cloud Firestore में आपका ऐप्लिकेशन कैसे लिखता है और पढ़ता है, इस बारे में बात करने से पहले, Cloud Firestore की सुविधा के प्रोटोटाइप बनाने और उसकी जांच करने के लिए इस्तेमाल किए जा सकने वाले टूल के बारे में बताते हैं: Firebase Local Emulator Suite. अगर आपको अलग-अलग डेटा मॉडल आज़माने हैं, अपनी सुरक्षा के नियमों को ऑप्टिमाइज़ करना है या बैक-एंड के साथ इंटरैक्ट करने का सबसे किफ़ायती तरीका ढूंढना है, तो लाइव सेवाओं को डिप्लॉय किए बिना, स्थानीय तौर पर काम करना एक अच्छा आइडिया हो सकता है.

Cloud Firestore एमुलेटर, Local Emulator Suite का हिस्सा होता है. इससे आपके ऐप्लिकेशन को, एमुलेट किए गए डेटाबेस के कॉन्टेंट और कॉन्फ़िगरेशन के साथ-साथ, एमुलेट किए गए प्रोजेक्ट के रिसॉर्स (फ़ंक्शन, अन्य डेटाबेस, और सुरक्षा नियम) के साथ इंटरैक्ट करने में मदद मिलती है.

Cloud Firestore एमुलेटर का इस्तेमाल करने के लिए, ये चरण पूरे करें:

  1. एम्युलेटर से कनेक्ट करने के लिए, अपने ऐप्लिकेशन के टेस्ट कॉन्फ़िगरेशन में कोड की एक लाइन जोड़ना.
  2. अपनी लोकल प्रोजेक्ट डायरेक्ट्री के रूट से, firebase emulators:start चलाएं.
  3. हमेशा की तरह, Cloud Firestore प्लैटफ़ॉर्म के SDK टूल का इस्तेमाल करके, अपने ऐप्लिकेशन के प्रोटोटाइप कोड से कॉल करना.

Cloud Firestore और Cloud Functions से जुड़ा ज़्यादा जानकारी वाला वॉकथ्रू उपलब्ध है. आपको Local Emulator Suite के बारे में जानकारी भी देखनी चाहिए.

Cloud Firestore शुरू करें

Cloud Firestore का इंस्टेंस शुरू करना:

Web

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

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

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


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

FIREBASE_CONFIGURATION को अपने वेब ऐप्लिकेशन के firebaseConfig से बदलें.

डिवाइस का इंटरनेट कनेक्शन बंद होने पर भी डेटा सेव रखने के लिए, ऑफ़लाइन डेटा चालू करना दस्तावेज़ देखें.

Web

import firebase from "firebase/app";
import "firebase/firestore";

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

// Initialize Firebase
firebase.initializeApp(firebaseConfig);


// Initialize Cloud Firestore and get a reference to the service
const db = firebase.firestore();

FIREBASE_CONFIGURATION को अपने वेब ऐप्लिकेशन के firebaseConfig से बदलें.

डिवाइस का इंटरनेट कनेक्शन बंद होने पर भी डेटा सेव रखने के लिए, ऑफ़लाइन डेटा चालू करना दस्तावेज़ देखें.

Swift
ध्यान दें: यह प्रॉडक्ट, watchOS और ऐप्लिकेशन क्लिप टारगेट पर उपलब्ध नहीं है. 
import FirebaseCore
import FirebaseFirestore
 
FirebaseApp.configure()

let db = Firestore.firestore()
AppDelegate.swift
Objective-C
ध्यान दें: यह प्रॉडक्ट, watchOS और ऐप्लिकेशन क्लिप टारगेट पर उपलब्ध नहीं है. 
@import FirebaseCore;
@import FirebaseFirestore;

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

Kotlin

// Access a Cloud Firestore instance from your Activity
 
val db = Firebase.firestore
DocSnippets.kt

Java

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

Dart

db = FirebaseFirestore.instance;
Java
आपके एनवायरमेंट के हिसाब से, Cloud Firestore SDK टूल को अलग-अलग तरीकों से शुरू किया जाता है. सबसे ज़्यादा इस्तेमाल किए जाने वाले तरीके यहां दिए गए हैं. पूरी जानकारी के लिए, एडमिन SDK टूल को शुरू करना देखें.
  • 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();
  • अपने सर्वर पर शुरू करना

    अपने सर्वर पर Firebase Admin SDK टूल का इस्तेमाल करने के लिए, सर्विस खाते का इस्तेमाल करें.

    Google Cloud Console में, आईएएम और एडमिन > सेवा खाते पर जाएं. एक नई निजी कुंजी जनरेट करें और 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();
    • Python
    आपके एनवायरमेंट के हिसाब से, Cloud Firestore SDK टूल को अलग-अलग तरीकों से शुरू किया जाता है. सबसे ज़्यादा इस्तेमाल किए जाने वाले तरीके यहां दिए गए हैं. पूरी जानकारी के लिए, एडमिन SDK टूल को शुरू करना देखें.
  • Google Cloud से शुरू करें 
    import firebase_admin
from firebase_admin import firestore

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

    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()
    firestore.py
  • अपने सर्वर पर शुरू करना

    अपने सर्वर पर Firebase Admin SDK टूल का इस्तेमाल करने के लिए, सर्विस खाते का इस्तेमाल करें.

    Google Cloud Console में, आईएएम और एडमिन > सेवा खाते पर जाएं. एक नई निजी कुंजी जनरेट करें और 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')

app = firebase_admin.initialize_app(cred)

db = firestore.client()
    firestore.py

    • Python

    आपके एनवायरमेंट के हिसाब से, Cloud Firestore SDK टूल को अलग-अलग तरीकों से शुरू किया जाता है. सबसे ज़्यादा इस्तेमाल किए जाने वाले तरीके यहां दिए गए हैं. पूरी जानकारी के लिए, एडमिन SDK टूल को शुरू करना देखें.
  • 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()
    firestore_async.py

    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()
    firestore_async.py
  • अपने सर्वर पर शुरू करना

    अपने सर्वर पर Firebase Admin SDK टूल का इस्तेमाल करने के लिए, सर्विस खाते का इस्तेमाल करें.

    Google Cloud Console में, आईएएम और एडमिन > सेवा खाते पर जाएं. एक नई निजी कुंजी जनरेट करें और JSON फ़ाइल सेव करें. इसके बाद, 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()
    firestore_async.py
    • C++
    // Make sure the call to `Create()` happens some time before you call Firestore::GetInstance().
App::Create();
Firestore* db = Firestore::GetInstance();
    AppDelegate.mm
    Node.js
    आपके एनवायरमेंट के हिसाब से, Cloud Firestore SDK टूल को अलग-अलग तरीकों से शुरू किया जाता है. सबसे ज़्यादा इस्तेमाल किए जाने वाले तरीके यहां दिए गए हैं. पूरी जानकारी के लिए, एडमिन SDK टूल को शुरू करना देखें.
    • Cloud Functions से शुरू करें 
      const { initializeApp, applicationDefault, cert } = require('firebase-admin/app');
const { getFirestore, Timestamp, FieldValue, Filter } = require('firebase-admin/firestore');
       
      initializeApp();

const db = getFirestore();

      index.js
    • 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();
      index.js
    • अपने सर्वर पर शुरू करना

      अपने सर्वर (या किसी अन्य Node.js एनवायरमेंट) पर Firebase Admin SDK टूल का इस्तेमाल करने के लिए, सेवा खाते का इस्तेमाल करें. Google Cloud Console में, आईएएम और एडमिन > सेवा खाते पर जाएं. एक नई निजी कुंजी जनरेट करें और JSON फ़ाइल सेव करें. इसके बाद, 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();

      index.js
    शुरू करें
    आपके एनवायरमेंट के हिसाब से, Cloud Firestore SDK टूल को अलग-अलग तरीकों से शुरू किया जाता है. सबसे ज़्यादा इस्तेमाल किए जाने वाले तरीके यहां दिए गए हैं. पूरी जानकारी के लिए, एडमिन SDK टूल को शुरू करना देखें.
  • 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()
  • अपने सर्वर पर शुरू करना

    अपने सर्वर पर Firebase Admin SDK टूल का इस्तेमाल करने के लिए, सर्विस खाते का इस्तेमाल करें.

    Google Cloud Console में, आईएएम और एडमिन > सेवा खाते पर जाएं. एक नई निजी कुंजी जनरेट करें और 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

    PHP

    Cloud Firestore क्लाइंट को इंस्टॉल करने और बनाने के बारे में ज़्यादा जानने के लिए, 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);
    }
}
    setup_client_create.php
    Unity
    using Firebase.Firestore;
using Firebase.Extensions;
     
    FirebaseFirestore db = FirebaseFirestore.DefaultInstance;
    C#

    C#

    Cloud Firestore क्लाइंट को इंस्टॉल करने और बनाने के बारे में ज़्यादा जानने के लिए, Cloud Firestore क्लाइंट लाइब्रेरी देखें. 

    FirestoreDb db = FirestoreDb.Create(project);
Console.WriteLine("Created Cloud Firestore client with project ID: {0}", project);
    Program.cs
    Ruby
    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."
    quickstart.rb

    डेटा जोड़ें

    Cloud Firestore, दस्तावेज़ों में डेटा सेव करता है. ये दस्तावेज़, कलेक्शन में सेव होते हैं. Cloud Firestore, दस्तावेज़ में पहली बार डेटा जोड़ने पर, अपने-आप कलेक्शन और दस्तावेज़ बनाता है. आपको साफ़ तौर पर संग्रह या दस्तावेज़ बनाने की ज़रूरत नहीं है.

    यहां दिए गए उदाहरण के कोड का इस्तेमाल करके, नया कलेक्शन और दस्तावेज़ बनाएं.

    Web

    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_ada_lovelace.js

    Web

    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);
});
    test.firestore.js
    Swift
    ध्यान दें: यह प्रॉडक्ट, watchOS और ऐप्लिकेशन क्लिप टारगेट पर उपलब्ध नहीं है. 
    // Add a new document with a generated ID
do {
  let ref = try await db.collection("users").addDocument(data: [
    "first": "Ada",
    "last": "Lovelace",
    "born": 1815
  ])
  print("Document added with ID: \(ref.documentID)")
} catch {
  print("Error adding document: \(error)")
}
    ViewController.swift
    Objective-C
    ध्यान दें: यह प्रॉडक्ट, watchOS और ऐप्लिकेशन क्लिप टारगेट पर उपलब्ध नहीं है. 
    // 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);
      }
    }];
    ViewController.m

    Kotlin

    // 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)
    }
    DocSnippets.kt

    Java

    // 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);
            }
        });
    DocSnippets.java

    Dart

    // Create a new user with a first and last name
final user = <String, dynamic>{
  "first": "Ada",
  "last": "Lovelace",
  "born": 1815
};

// Add a new document with a generated ID
db.collection("users").add(user).then((DocumentReference doc) =>
    print('DocumentSnapshot added with ID: ${doc.id}'));
    firestore.dart
    Java
    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());
    Quickstart.java
    Python
    doc_ref = db.collection("users").document("alovelace")
doc_ref.set({"first": "Ada", "last": "Lovelace", "born": 1815})
    snippets.py

    Python

    doc_ref = db.collection("users").document("alovelace")
await doc_ref.set({"first": "Ada", "last": "Lovelace", "born": 1815})
    snippets.py
    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()
              << std::endl;
  } else {
    std::cout << "Error adding document: " << future.error_message() << std::endl;
  }
});
    snippets.cpp
    Node.js
    const docRef = db.collection('users').doc('alovelace');

await docRef.set({
  first: 'Ada',
  last: 'Lovelace',
  born: 1815
});
    index.js
    शुरू करें
    _, _, 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)
}
    main.go
    PHP

    PHP

    Cloud Firestore क्लाइंट को इंस्टॉल करने और बनाने के बारे में ज़्यादा जानने के लिए, Cloud Firestore क्लाइंट लाइब्रेरी देखें. 

    $docRef = $db->collection('samples/php/users')->document('alovelace');
$docRef->set([
    'first' => 'Ada',
    'last' => 'Lovelace',
    'born' => 1815
]);
printf('Added data to the lovelace document in the users collection.' . PHP_EOL);
    setup_dataset.php
    Unity
    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);
    Program.cs
    Ruby
    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."
    quickstart.rb

    अब users कलेक्शन में एक और दस्तावेज़ जोड़ें. ध्यान दें कि इस दस्तावेज़ में एक की-वैल्यू पेयर (मध्य नाम) शामिल है, जो पहले दस्तावेज़ में नहीं दिखता. किसी कलेक्शन में मौजूद दस्तावेज़ों में, जानकारी के अलग-अलग सेट हो सकते हैं.

    Web

    // 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_alan_turing.js

    Web

    // 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);
});
    test.firestore.js
    Swift
    ध्यान दें: यह प्रॉडक्ट, watchOS और ऐप्लिकेशन क्लिप टारगेट पर उपलब्ध नहीं है. 
    // Add a second document with a generated ID.
do {
  let ref = try await db.collection("users").addDocument(data: [
    "first": "Alan",
    "middle": "Mathison",
    "last": "Turing",
    "born": 1912
  ])
  print("Document added with ID: \(ref.documentID)")
} catch {
  print("Error adding document: \(error)")
}
    ViewController.swift
    Objective-C
    ध्यान दें: यह प्रॉडक्ट, watchOS और ऐप्लिकेशन क्लिप टारगेट पर उपलब्ध नहीं है. 
    // 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);
      }
    }];
    ViewController.m

    Kotlin

    // 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)
    }
    DocSnippets.kt

    Java

    // 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);
            }
        });
    DocSnippets.java

    Dart

    // Create a new user with a first and last name
final user = <String, dynamic>{
  "first": "Alan",
  "middle": "Mathison",
  "last": "Turing",
  "born": 1912
};

// Add a new document with a generated ID
db.collection("users").add(user).then((DocumentReference doc) =>
    print('DocumentSnapshot added with ID: ${doc.id}'));
    firestore.dart
    Java
    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());
    Quickstart.java
    Python
    doc_ref = db.collection("users").document("aturing")
doc_ref.set({"first": "Alan", "middle": "Mathison", "last": "Turing", "born": 1912})
    snippets.py

    Python

    doc_ref = db.collection("users").document("aturing")
await doc_ref.set(
    {"first": "Alan", "middle": "Mathison", "last": "Turing", "born": 1912}
)
    snippets.py
    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() << std::endl;
      } else {
        std::cout << "Error adding document: " << future.error_message()
                  << std::endl;
      }
    });
    snippets.cpp
    Node.js
    const aTuringRef = db.collection('users').doc('aturing');

await aTuringRef.set({
  'first': 'Alan',
  'middle': 'Mathison',
  'last': 'Turing',
  'born': 1912
});
    index.js
    शुरू करें
    _, _, 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)
}
    main.go
    PHP

    PHP

    Cloud Firestore क्लाइंट को इंस्टॉल करने और बनाने के बारे में ज़्यादा जानने के लिए, Cloud Firestore क्लाइंट लाइब्रेरी देखें. 

    $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);
    setup_dataset.php
    Unity
    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);
    Program.cs
    Ruby
    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."
    quickstart.rb

    डेटा पढ़ना

    Firebase कंसोल में डेटा व्यूअर का इस्तेमाल करके, तुरंत पुष्टि करें कि आपने Cloud Firestore में डेटा जोड़ा है.

    पूरे कलेक्शन को वापस पाने के लिए, "get" तरीके का भी इस्तेमाल किया जा सकता है.

    Web

    import { collection, getDocs } from "firebase/firestore"; 

const querySnapshot = await getDocs(collection(db, "users"));
querySnapshot.forEach((doc) => {
  console.log(`${doc.id} => ${doc.data()}`);
});
    get_all_users.js

    Web

    db.collection("users").get().then((querySnapshot) => {
    querySnapshot.forEach((doc) => {
        console.log(`${doc.id} => ${doc.data()}`);
    });
});
    test.firestore.js
    Swift
    ध्यान दें: यह प्रॉडक्ट, watchOS और ऐप्लिकेशन क्लिप टारगेट पर उपलब्ध नहीं है. 
    do {
  let snapshot = try await db.collection("users").getDocuments()
  for document in snapshot.documents {
    print("\(document.documentID) => \(document.data())")
  }
} catch {
  print("Error getting documents: \(error)")
}
    ViewController.swift
    Objective-C
    ध्यान दें: यह प्रॉडक्ट, watchOS और ऐप्लिकेशन क्लिप टारगेट पर उपलब्ध नहीं है. 
    [[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);
        }
      }
    }];
    ViewController.m

    Kotlin

    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)
    }
    DocSnippets.kt

    Java

    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());
                }
            }
        });
    DocSnippets.java

    Dart

    await db.collection("users").get().then((event) {
  for (var doc in event.docs) {
    print("${doc.id} => ${doc.data()}");
  }
});
    firestore.dart
    Java
    // 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"));
}
    Quickstart.java
    Python
    users_ref = db.collection("users")
docs = users_ref.stream()

for doc in docs:
    print(f"{doc.id} => {doc.to_dict()}")
    snippets.py

    Python

    users_ref = db.collection("users")
docs = users_ref.stream()

async for doc in docs:
    print(f"{doc.id} => {doc.to_dict()}")
    snippets.py
    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 << std::endl;
    }
  } else {
    std::cout << "Error getting documents: " << future.error_message()
              << std::endl;
  }
});
    snippets.cpp
    Node.js
    const snapshot = await db.collection('users').get();
snapshot.forEach((doc) => {
  console.log(doc.id, '=>', doc.data());
});
    index.js
    शुरू करें
    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())
}
    main.go
    PHP

    PHP

    Cloud Firestore क्लाइंट को इंस्टॉल करने और बनाने के बारे में ज़्यादा जानने के लिए, Cloud Firestore क्लाइंट लाइब्रेरी देखें. 

    $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);
    setup_dataset_read.php
    Unity
    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();
}
    Program.cs
    Ruby
    users_ref = firestore.col collection_path
users_ref.get do |user|
  puts "#{user.document_id} data: #{user.data}."
end
    quickstart.rb

    अपना डेटा सुरक्षित करना

    अगर वेब, Android या Apple प्लैटफ़ॉर्म SDK टूल का इस्तेमाल किया जा रहा है, तो Cloud Firestore में अपने डेटा को सुरक्षित रखने के लिए, Firebase पुष्टि करने की सुविधा और Cloud Firestore Security Rules का इस्तेमाल करें.

    यहां कुछ बुनियादी नियमों के सेट दिए गए हैं. इनका इस्तेमाल करके, नियम बनाने की प्रोसेस शुरू की जा सकती है. कंसोल के नियमों वाले टैब में जाकर, सुरक्षा के नियमों में बदलाव किया जा सकता है.

    पुष्टि करना ज़रूरी है

    // Allow read/write access to a document keyed by the user's UID
service cloud.firestore {
  match /databases/{database}/documents {
    match /users/{uid} {
      allow read, write: if request.auth != null && request.auth.uid == uid;
    }
  }
}

    लॉक मोड

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

    अपने वेब, Android या iOS ऐप्लिकेशन को प्रोडक्शन में डिप्लॉय करने से पहले, यह पक्का करें कि सिर्फ़ आपके ऐप्लिकेशन क्लाइंट आपके Cloud Firestore डेटा को ऐक्सेस कर सकें. App Check का दस्तावेज़ देखें.

    अगर किसी सर्वर एसडीके टूल का इस्तेमाल किया जा रहा है, तो Cloud Firestore में अपने डेटा को सुरक्षित रखने के लिए, आइडेंटिटी और ऐक्सेस मैनेजमेंट (IAM) का इस्तेमाल करें.

    वीडियो ट्यूटोरियल देखना

    Cloud Firestore मोबाइल क्लाइंट लाइब्रेरी का इस्तेमाल शुरू करने के बारे में ज़्यादा जानकारी पाने के लिए, इनमें से कोई एक वीडियो ट्यूटोरियल देखें:

    वेब
    iOS+
    Android

    Firebase के YouTube चैनल पर आपको और वीडियो मिल सकते हैं.

    अगले चरण

    इन विषयों के बारे में ज़्यादा जानें: