डेटा की बचत की जा रही है

इस दस्तावेज़ में आपके Firebase रीयल टाइम डेटाबेस में डेटा लिखने के चार तरीके बताए गए हैं: सेट, अपडेट, पुश, और लेन-देन से जुड़ी सहायता.

डेटा सेव करने के तरीके

डेटा सहेजा जा रहा है

डेटाबेस राइट करने की बेसिक कार्रवाई एक ऐसा सेट है जो तय किए गए डेटाबेस के रेफ़रंस में, उस पाथ के मौजूदा डेटा की जगह नया डेटा सेव करता है. सेट समझने के लिए, हम एक आसान ब्लॉगिंग ऐप्लिकेशन बनाएंगे. आपके ऐप्लिकेशन का डेटा, डेटाबेस के इस रेफ़रंस में सेव किया जाता है:

final FirebaseDatabase database = FirebaseDatabase.getInstance();
DatabaseReference ref = database.getReference("server/saving-data/fireblog");

// Import Admin SDK
const { getDatabase } = require('firebase-admin/database');

// Get a database reference to our blog
const db = getDatabase();
const ref = db.ref('server/saving-data/fireblog');

# Import database module.
from firebase_admin import db

# Get a database reference to our blog.
ref = db.reference('server/saving-data/fireblog')

// Create a database client from App.
client, err := app.Database(ctx)
if err != nil {
	log.Fatalln("Error initializing database client:", err)
}

// Get a database reference to our blog.
ref := client.NewRef("server/saving-data/fireblog")

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

सबसे पहले, अपने उपयोगकर्ता के डेटा का डेटाबेस रेफ़रंस बनाएं. इसके बाद, उपयोगकर्ता ऑब्जेक्ट को डेटाबेस में उपयोगकर्ता के उपयोगकर्ता नाम, पूरे नाम, और जन्मदिन के साथ सेव करने के लिए, set() / setValue() का इस्तेमाल करें. आपके पास किसी स्ट्रिंग, संख्या, बूलियन, null, अरे या कोई भी JSON ऑब्जेक्ट को पास करने का विकल्प होता है. null को पास करने से, बताई गई जगह का डेटा हट जाएगा. इस मामले में, आपको इसे एक ऑब्जेक्ट पास करना होगा:

public static class User {

  public String date_of_birth;
  public String full_name;
  public String nickname;

  public User(String dateOfBirth, String fullName) {
    // ...
  }

  public User(String dateOfBirth, String fullName, String nickname) {
    // ...
  }

}

DatabaseReference usersRef = ref.child("users");

Map<String, User> users = new HashMap<>();
users.put("alanisawesome", new User("June 23, 1912", "Alan Turing"));
users.put("gracehop", new User("December 9, 1906", "Grace Hopper"));

usersRef.setValueAsync(users);

const usersRef = ref.child('users');
usersRef.set({
  alanisawesome: {
    date_of_birth: 'June 23, 1912',
    full_name: 'Alan Turing'
  },
  gracehop: {
    date_of_birth: 'December 9, 1906',
    full_name: 'Grace Hopper'
  }
});

users_ref = ref.child('users')
users_ref.set({
    'alanisawesome': {
        'date_of_birth': 'June 23, 1912',
        'full_name': 'Alan Turing'
    },
    'gracehop': {
        'date_of_birth': 'December 9, 1906',
        'full_name': 'Grace Hopper'
    }
})

// User is a json-serializable type.
type User struct {
	DateOfBirth string `json:"date_of_birth,omitempty"`
	FullName    string `json:"full_name,omitempty"`
	Nickname    string `json:"nickname,omitempty"`
}

usersRef := ref.Child("users")
err := usersRef.Set(ctx, map[string]*User{
	"alanisawesome": {
		DateOfBirth: "June 23, 1912",
		FullName:    "Alan Turing",
	},
	"gracehop": {
		DateOfBirth: "December 9, 1906",
		FullName:    "Grace Hopper",
	},
})
if err != nil {
	log.Fatalln("Error setting value:", err)
}

जब JSON ऑब्जेक्ट को डेटाबेस में सेव किया जाता है, तो ऑब्जेक्ट की प्रॉपर्टी, नेस्ट किए गए तरीके से डेटाबेस चाइल्ड लोकेशन के साथ अपने-आप मैप हो जाती हैं. अब यूआरएल https://docs-examples.firebaseio.com/server/saving-data/fireblog/users/alanisawesome/full_name पर जाने पर, हमें "Alan Turing" वैल्यू दिखेगी. चाइल्ड लोकेशन पर भी डेटा सेव किया जा सकता है:

usersRef.child("alanisawesome").setValueAsync(new User("June 23, 1912", "Alan Turing"));
usersRef.child("gracehop").setValueAsync(new User("December 9, 1906", "Grace Hopper"));

const usersRef = ref.child('users');
usersRef.child('alanisawesome').set({
  date_of_birth: 'June 23, 1912',
  full_name: 'Alan Turing'
});
usersRef.child('gracehop').set({
  date_of_birth: 'December 9, 1906',
  full_name: 'Grace Hopper'
});

users_ref.child('alanisawesome').set({
    'date_of_birth': 'June 23, 1912',
    'full_name': 'Alan Turing'
})
users_ref.child('gracehop').set({
    'date_of_birth': 'December 9, 1906',
    'full_name': 'Grace Hopper'
})

if err := usersRef.Child("alanisawesome").Set(ctx, &User{
	DateOfBirth: "June 23, 1912",
	FullName:    "Alan Turing",
}); err != nil {
	log.Fatalln("Error setting value:", err)
}

if err := usersRef.Child("gracehop").Set(ctx, &User{
	DateOfBirth: "December 9, 1906",
	FullName:    "Grace Hopper",
}); err != nil {
	log.Fatalln("Error setting value:", err)
}

ऊपर दिए गए दो उदाहरणों - दोनों वैल्यू को एक ही समय पर ऑब्जेक्ट के तौर पर लिखना और उन्हें चाइल्ड लोकेशन में अलग-अलग लिखना - इस वजह से, आपके डेटाबेस में एक जैसा डेटा सेव हो जाएगा:

{
  "users": {
    "alanisawesome": {
      "date_of_birth": "June 23, 1912",
      "full_name": "Alan Turing"
    },
    "gracehop": {
      "date_of_birth": "December 9, 1906",
      "full_name": "Grace Hopper"
    }
  }
}

पहला उदाहरण, डेटा देखने वाले क्लाइंट पर सिर्फ़ एक इवेंट को ट्रिगर करेगा, जबकि दूसरा उदाहरण दो इवेंट को ट्रिगर करेगा. ध्यान रखें कि अगर usersRef में पहले से ही डेटा मौजूद है, तो पहला तरीका उसे ओवरराइट कर देगा. हालांकि, दूसरा तरीका सिर्फ़ हर अलग चाइल्ड नोड की वैल्यू में बदलाव करेगा, जबकि usersRef के दूसरे चाइल्ड नोड में कोई बदलाव नहीं करेंगे.

सेव किया गया डेटा अपडेट हो रहा है

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

DatabaseReference hopperRef = usersRef.child("gracehop");
Map<String, Object> hopperUpdates = new HashMap<>();
hopperUpdates.put("nickname", "Amazing Grace");

hopperRef.updateChildrenAsync(hopperUpdates);

const usersRef = ref.child('users');
const hopperRef = usersRef.child('gracehop');
hopperRef.update({
  'nickname': 'Amazing Grace'
});

hopper_ref = users_ref.child('gracehop')
hopper_ref.update({
    'nickname': 'Amazing Grace'
})

hopperRef := usersRef.Child("gracehop")
if err := hopperRef.Update(ctx, map[string]interface{}{
	"nickname": "Amazing Grace",
}); err != nil {
	log.Fatalln("Error updating child:", err)
}

इससे ग्रेस का डेटा अपडेट हो जाएगा, ताकि उसका कोई दूसरा नाम शामिल किया जा सके. अगर आपने अपडेट के बजाय यहां सेट करें का उपयोग किया होता, तो इससे full_name और date_of_birth दोनों को आपके hopperRef से हटा दिया जाता.

Firebase रीयल टाइम डेटाबेस, मल्टी-पाथ अपडेट के साथ भी काम करता है. इसका मतलब है कि अब आपके डेटाबेस में, अपडेट की वैल्यू एक ही समय पर कई जगहों पर अपडेट की जा सकती हैं. इस बेहतरीन सुविधा की मदद से, डेटा को फिर से सामान्य बनाने में मदद मिलती है. मल्टी-पाथ अपडेट का इस्तेमाल करके, एक ही समय पर ग्रेस और एलन दोनों के लिए निकनेम जोड़े जा सकते हैं:

Map<String, Object> userUpdates = new HashMap<>();
userUpdates.put("alanisawesome/nickname", "Alan The Machine");
userUpdates.put("gracehop/nickname", "Amazing Grace");

usersRef.updateChildrenAsync(userUpdates);

const usersRef = ref.child('users');
usersRef.update({
  'alanisawesome/nickname': 'Alan The Machine',
  'gracehop/nickname': 'Amazing Grace'
});

users_ref.update({
    'alanisawesome/nickname': 'Alan The Machine',
    'gracehop/nickname': 'Amazing Grace'
})

if err := usersRef.Update(ctx, map[string]interface{}{
	"alanisawesome/nickname": "Alan The Machine",
	"gracehop/nickname":      "Amazing Grace",
}); err != nil {
	log.Fatalln("Error updating children:", err)
}

इस अपडेट के बाद, ऐलन और ग्रेस, दोनों के निकनेम जोड़ दिए गए हैं:

{
  "users": {
    "alanisawesome": {
      "date_of_birth": "June 23, 1912",
      "full_name": "Alan Turing",
      "nickname": "Alan The Machine"
    },
    "gracehop": {
      "date_of_birth": "December 9, 1906",
      "full_name": "Grace Hopper",
      "nickname": "Amazing Grace"
    }
  }
}

ध्यान दें कि शामिल पाथ के साथ ऑब्जेक्ट लिखकर ऑब्जेक्ट अपडेट करने की कोशिश करने पर, अलग व्यवहार होगा. आइए देखें कि ग्रेस और ऐलन को इस तरीके से अपडेट करने पर क्या होता है:

Map<String, Object> userNicknameUpdates = new HashMap<>();
userNicknameUpdates.put("alanisawesome", new User(null, null, "Alan The Machine"));
userNicknameUpdates.put("gracehop", new User(null, null, "Amazing Grace"));

usersRef.updateChildrenAsync(userNicknameUpdates);

const usersRef = ref.child('users');
usersRef.update({
  'alanisawesome': {
    'nickname': 'Alan The Machine'
  },
  'gracehop': {
    'nickname': 'Amazing Grace'
  }
});

users_ref.update({
    'alanisawesome': {
        'nickname': 'Alan The Machine'
    },
    'gracehop': {
        'nickname': 'Amazing Grace'
    }
})

if err := usersRef.Update(ctx, map[string]interface{}{
	"alanisawesome": &User{Nickname: "Alan The Machine"},
	"gracehop":      &User{Nickname: "Amazing Grace"},
}); err != nil {
	log.Fatalln("Error updating children:", err)
}

इसकी वजह से, पूरा /users नोड अलग हो जाता है:

{
  "users": {
    "alanisawesome": {
      "nickname": "Alan The Machine"
    },
    "gracehop": {
      "nickname": "Amazing Grace"
    }
  }
}

पूरा होने पर कॉलबैक जोड़ना

Node.js और Java एडमिन SDK में, अगर आपको यह जानना है कि आपका डेटा कब जनरेट हुआ है, तो आपके पास पूरा होने वाला कॉलबैक जोड़ने का विकल्प होता है. इन SDK टूल में, सेट और अपडेट करने के तरीकों को वैकल्पिक तौर पर पूरा करने के लिए एक कॉलबैक का इस्तेमाल किया जाता है. इसे तब कॉल किया जाता है, जब डेटाबेस के डेटा में बदलाव का डेटा इकट्ठा किया जाता है. अगर किसी वजह से कॉल पूरा नहीं हो सका, तो कॉलबैक को गड़बड़ी का एक ऑब्जेक्ट दिया जाता है. इस ऑब्जेक्ट में, गड़बड़ी की वजह के बारे में बताया जाता है. Python और Go एडमिन SDK में, लिखने के सभी तरीके ब्लॉक किए जा रहे हैं. इसका मतलब है कि जब तक डेटाबेस से डेटा को एक्सपोर्ट नहीं किया जाता, तब तक डेटा लिखने के तरीके नहीं लौटाए जाते.

DatabaseReference dataRef = ref.child("data");
dataRef.setValue("I'm writing data", new DatabaseReference.CompletionListener() {
  @Override
  public void onComplete(DatabaseError databaseError, DatabaseReference databaseReference) {
    if (databaseError != null) {
      System.out.println("Data could not be saved " + databaseError.getMessage());
    } else {
      System.out.println("Data saved successfully.");
    }
  }
});

dataRef.set('I\'m writing data', (error) => {
  if (error) {
    console.log('Data could not be saved.' + error);
  } else {
    console.log('Data saved successfully.');
  }
});

डेटा की सूचियां सेव की जा रही हैं

डेटा की सूचियां बनाते समय, इस बात का ध्यान रखना ज़रूरी है कि ज़्यादातर ऐप्लिकेशन एक से ज़्यादा उपयोगकर्ताओं का इस्तेमाल करते हैं. साथ ही, इसके हिसाब से अपनी सूची के स्ट्रक्चर में बदलाव करना भी ज़रूरी है. ऊपर दिए गए उदाहरण को ध्यान में रखते हुए, आपके ऐप्लिकेशन में ब्लॉग पोस्ट जोड़ते हैं. आपका पहला इरादा अपने-आप बढ़ने वाले पूर्णांक इंडेक्स वाले बच्चों को स्टोर करने के लिए सेट का इस्तेमाल करना हो सकता है, जैसे कि:

// NOT RECOMMENDED - use push() instead!
{
  "posts": {
    "0": {
      "author": "gracehop",
      "title": "Announcing COBOL, a New Programming Language"
    },
    "1": {
      "author": "alanisawesome",
      "title": "The Turing Machine"
    }
  }
}

अगर कोई उपयोगकर्ता नई पोस्ट जोड़ता है, तो उसे /posts/2 के तौर पर सेव किया जाएगा. ऐसा तब होता है, जब सिर्फ़ एक लेखक पोस्ट जोड़ रहा हो, लेकिन आपके साथ मिलकर काम करने वाले ब्लॉगिंग ऐप्लिकेशन में, एक ही समय पर कई उपयोगकर्ता पोस्ट जोड़ सकते हैं. अगर दो लेखक एक साथ /posts/2 को लिखते हैं, तो इनमें से एक पोस्ट को दूसरा मिटा देगा.

इसे ठीक करने के लिए, Firebase क्लाइंट एक push() फ़ंक्शन उपलब्ध कराते हैं, जो हर नए चाइल्ड के लिए एक यूनीक कुंजी जनरेट करता है. यूनीक चाइल्ड कुंजियों का इस्तेमाल करके, कई क्लाइंट एक ही समय में बच्चों को एक ही जगह से जोड़ सकते हैं. इससे उन्हें लिखने के दौरान होने वाली समस्याओं की चिंता नहीं करनी पड़ती.

public static class Post {

  public String author;
  public String title;

  public Post(String author, String title) {
    // ...
  }

}

DatabaseReference postsRef = ref.child("posts");

DatabaseReference newPostRef = postsRef.push();
newPostRef.setValueAsync(new Post("gracehop", "Announcing COBOL, a New Programming Language"));

// We can also chain the two calls together
postsRef.push().setValueAsync(new Post("alanisawesome", "The Turing Machine"));

const newPostRef = postsRef.push();
newPostRef.set({
  author: 'gracehop',
  title: 'Announcing COBOL, a New Programming Language'
});

// we can also chain the two calls together
postsRef.push().set({
  author: 'alanisawesome',
  title: 'The Turing Machine'
});

posts_ref = ref.child('posts')

new_post_ref = posts_ref.push()
new_post_ref.set({
    'author': 'gracehop',
    'title': 'Announcing COBOL, a New Programming Language'
})

# We can also chain the two calls together
posts_ref.push().set({
    'author': 'alanisawesome',
    'title': 'The Turing Machine'
})

// Post is a json-serializable type.
type Post struct {
	Author string `json:"author,omitempty"`
	Title  string `json:"title,omitempty"`
}

postsRef := ref.Child("posts")

newPostRef, err := postsRef.Push(ctx, nil)
if err != nil {
	log.Fatalln("Error pushing child node:", err)
}

if err := newPostRef.Set(ctx, &Post{
	Author: "gracehop",
	Title:  "Announcing COBOL, a New Programming Language",
}); err != nil {
	log.Fatalln("Error setting value:", err)
}

// We can also chain the two calls together
if _, err := postsRef.Push(ctx, &Post{
	Author: "alanisawesome",
	Title:  "The Turing Machine",
}); err != nil {
	log.Fatalln("Error pushing child node:", err)
}

यूनीक कुंजी, टाइमस्टैंप पर आधारित होती है. इसलिए, सूची में मौजूद आइटम, समय के हिसाब से अपने-आप क्रम में लग जाते हैं. Firebase हर ब्लॉग पोस्ट के लिए एक खास कुंजी जनरेट करता है. इसलिए, अगर कई उपयोगकर्ता एक ही समय पर पोस्ट जोड़ते हैं, तो लिखने में कोई गड़बड़ी नहीं होगी. आपका डेटाबेस डेटा अब कुछ ऐसा दिखता है:

{
  "posts": {
    "-JRHTHaIs-jNPLXOQivY": {
      "author": "gracehop",
      "title": "Announcing COBOL, a New Programming Language"
    },
    "-JRHTHaKuITFIhnj02kE": {
      "author": "alanisawesome",
      "title": "The Turing Machine"
    }
  }
}

JavaScript, Python, और Go में, push() को कॉल करने और फिर set() को तुरंत कॉल करने का पैटर्न इतना आम है कि Firebase SDK टूल की मदद से, डेटा को सीधे push() पर सेट करने के लिए इस तरह से पास करके, उन्हें आपस में जोड़ा जा सकता है:

// No Java equivalent

// This is equivalent to the calls to push().set(...) above
postsRef.push({
  author: 'gracehop',
  title: 'Announcing COBOL, a New Programming Language'
});;

# This is equivalent to the calls to push().set(...) above
posts_ref.push({
    'author': 'gracehop',
    'title': 'Announcing COBOL, a New Programming Language'
})

if _, err := postsRef.Push(ctx, &Post{
	Author: "gracehop",
	Title:  "Announcing COBOL, a New Programming Language",
}); err != nil {
	log.Fatalln("Error pushing child node:", err)
}

push() से जनरेट की गई खास कुंजी हासिल करना

push() को कॉल करने पर, आपको नए डेटा पाथ का रेफ़रंस दिखेगा. इसका इस्तेमाल, पासकोड पाने या इस डेटा को सेट करने के लिए किया जा सकता है. इस कोड का इस्तेमाल करने पर, ऊपर दिए गए उदाहरण जैसा ही डेटा मिलेगा. हालांकि, अब हमारे पास जनरेट की गई यूनीक कुंजी का ऐक्सेस होगा:

// Generate a reference to a new location and add some data using push()
DatabaseReference pushedPostRef = postsRef.push();

// Get the unique ID generated by a push()
String postId = pushedPostRef.getKey();

// Generate a reference to a new location and add some data using push()
const newPostRef = postsRef.push();

// Get the unique key generated by push()
const postId = newPostRef.key;

# Generate a reference to a new location and add some data using push()
new_post_ref = posts_ref.push()

# Get the unique key generated by push()
post_id = new_post_ref.key

// Generate a reference to a new location and add some data using Push()
newPostRef, err := postsRef.Push(ctx, nil)
if err != nil {
	log.Fatalln("Error pushing child node:", err)
}

// Get the unique key generated by Push()
postID := newPostRef.Key

जैसा कि आपको दिख रहा है, आपको अपनी push() पहचान फ़ाइल से, यूनीक कुंजी की वैल्यू मिल सकती है.

डेटा वापस पाना के अगले सेक्शन में, हम Firebase डेटाबेस से इस डेटा को पढ़ने का तरीका जानेंगे.

लेन-देन से जुड़ा डेटा सेव किया जा रहा है

इंक्रीमेंटल काउंटर जैसे जटिल डेटा के साथ काम करने के दौरान SDK टूल, ट्रांज़ैक्शन ऑपरेशन की सुविधा देता है. इस डेटा में, एक साथ कई बदलाव करने की वजह से गड़बड़ी हो सकती है.

Java और Node.js में, ट्रांज़ैक्शन ऑपरेशन को दो कॉलबैक देते हैं: एक अपडेट फ़ंक्शन और दूसरा, पूरा करने वाला वैकल्पिक कॉलबैक. Python और Go में, लेन-देन की कार्रवाई ब्लॉक हो रही है. इसलिए, यह सिर्फ़ अपडेट फ़ंक्शन को स्वीकार करता है.

अपडेट फ़ंक्शन, डेटा की मौजूदा स्थिति को तर्क के तौर पर लेता है और आपको जिस नई स्थिति में बदलाव करना है उसे दिखाना चाहिए. उदाहरण के लिए, अगर किसी ब्लॉग पोस्ट को पसंद किए जाने की संख्या को बढ़ाना है, तो आपको यह तरीका अपनाना होगा:

DatabaseReference upvotesRef = ref.child("server/saving-data/fireblog/posts/-JRHTHaIs-jNPLXOQivY/upvotes");
upvotesRef.runTransaction(new Transaction.Handler() {
  @Override
  public Transaction.Result doTransaction(MutableData mutableData) {
    Integer currentValue = mutableData.getValue(Integer.class);
    if (currentValue == null) {
      mutableData.setValue(1);
    } else {
      mutableData.setValue(currentValue + 1);
    }

    return Transaction.success(mutableData);
  }

  @Override
  public void onComplete(
      DatabaseError databaseError, boolean committed, DataSnapshot dataSnapshot) {
    System.out.println("Transaction completed");
  }
});

const upvotesRef = db.ref('server/saving-data/fireblog/posts/-JRHTHaIs-jNPLXOQivY/upvotes');
upvotesRef.transaction((current_value) => {
  return (current_value || 0) + 1;
});

def increment_votes(current_value):
    return current_value + 1 if current_value else 1

upvotes_ref = db.reference('server/saving-data/fireblog/posts/-JRHTHaIs-jNPLXOQivY/upvotes')
try:
    new_vote_count = upvotes_ref.transaction(increment_votes)
    print('Transaction completed')
except db.TransactionAbortedError:
    print('Transaction failed to commit')

fn := func(t db.TransactionNode) (interface{}, error) {
	var currentValue int
	if err := t.Unmarshal(&currentValue); err != nil {
		return nil, err
	}
	return currentValue + 1, nil
}

ref := client.NewRef("server/saving-data/fireblog/posts/-JRHTHaIs-jNPLXOQivY/upvotes")
if err := ref.Transaction(ctx, fn); err != nil {
	log.Fatalln("Transaction failed to commit:", err)
}

ऊपर दिए गए उदाहरण से यह पता चलता है कि काउंटर null है या उसमें अब तक बढ़ोतरी नहीं हुई है. इसकी वजह यह है कि अगर कोई डिफ़ॉल्ट वैल्यू नहीं लिखी गई है, तो ट्रांज़ैक्शन को null की मदद से कॉल किया जा सकता है.

अगर ऊपर दिया गया कोड, ट्रांज़ैक्शन फ़ंक्शन के बिना चलाया गया था और दो क्लाइंट ने इसे एक साथ बढ़ाने की कोशिश की थी, तो वे दोनों नई वैल्यू के रूप में 1 लिखेंगे. इससे, दो के बजाय एक बढ़ोतरी हो जाएगी.

नेटवर्क कनेक्टिविटी और ऑफ़लाइन राइट्स

Firebase Node.js और Java क्लाइंट, किसी भी चालू डेटा का अपना इंटरनल वर्शन मैनेज करते हैं. डेटा लिखे जाने के बाद, उसे सबसे पहले इस लोकल वर्शन में लिखा जाता है. इसके बाद, क्लाइंट उस डेटा को डेटाबेस और अन्य क्लाइंट के साथ 'बेहतर कोशिश' के आधार पर सिंक करता है.

इस वजह से, डेटाबेस में लिखे जाने वाले सभी डेटा, डेटाबेस में डेटा लिखे जाने से पहले ही लोकल इवेंट को ट्रिगर कर देंगे. इसका मतलब है कि जब Firebase का इस्तेमाल करके कोई ऐप्लिकेशन लिखा जाता है, तब आपका ऐप्लिकेशन रिस्पॉन्सिव रहेगा. भले ही, नेटवर्क में इंतज़ार का समय या इंटरनेट कनेक्टिविटी कैसी भी हो.

कनेक्टिविटी फिर से शुरू होने के बाद, हमें इवेंट का सही सेट मिलेगा, ताकि क्लाइंट, सर्वर की मौजूदा स्थिति के साथ "कैच" हो जाए और इसके लिए हमें कोई कस्टम कोड लिखने की ज़रूरत न पड़े.

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

Firebase रीयल टाइम डेटाबेस में सुरक्षा की एक भाषा होती है. इसकी मदद से, यह तय किया जा सकता है कि आपके डेटा के अलग-अलग नोड को पढ़ने और उनमें बदलाव करने का ऐक्सेस किन उपयोगकर्ताओं के पास है. इस बारे में ज़्यादा जानने के लिए, अपना डेटा सुरक्षित करना लेख पढ़ें.