इस पेज का अनुवाद Cloud Translation API से किया गया है.
Switch to English

डेटा की बचत

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

डेटा को बचाने के तरीके

सेट messages/users/<username> जैसे किसी निर्धारित पथ पर डेटा लिखें या बदलें
अपडेट करें सभी डेटा को प्रतिस्थापित किए बिना परिभाषित पथ के लिए कुछ कुंजियों को अपडेट करें
धक्का दें डेटाबेस में डेटा की एक सूची में जोड़ें । हर बार जब आप किसी सूची में एक नया नोड धक्का देते हैं, तो आपका डेटाबेस एक अद्वितीय कुंजी उत्पन्न करता है, जैसे messages/users/<unique-user-id>/<username>
लेन-देन जटिल डेटा के साथ काम करते समय लेनदेन का उपयोग करें जो समवर्ती अपडेट द्वारा दूषित हो सकता है

डेटा की बचत

मूल डेटाबेस लेखन ऑपरेशन एक सेट है जो उस मार्ग पर किसी भी मौजूदा डेटा को बदलने के लिए निर्दिष्ट डेटाबेस संदर्भ में नया डेटा बचाता है। सेट को समझने के लिए, हम एक सरल ब्लॉगिंग ऐप बनाएंगे। आपके एप्लिकेशन का डेटा इस डेटाबेस संदर्भ में संग्रहीत है:

जावा
final FirebaseDatabase database = FirebaseDatabase.getInstance();
DatabaseReference ref = database.getReference("server/saving-data/fireblog");
Node.js
// Import Admin SDK
var admin = require("firebase-admin");

// Get a database reference to our blog
var db = admin.database();
var 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);
Node.js
var 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 ऑब्जेक्ट को डेटाबेस में सहेजा जाता है, तो ऑब्जेक्ट गुण स्वचालित रूप से एक नेस्टेड फ़ैशन में डेटाबेस चाइल्ड स्थानों पर मैप किए जाते हैं। अब यदि आप URL https://docs-examples.firebaseio.com/server/saving-data/fireblog/users/alanisawesome/full_name पर नेविगेट करते हैं, तो हम "एलन ट्यूरिंग" मान देखेंगे। आप सीधे बच्चे के स्थान पर भी डेटा सहेज सकते हैं:

जावा
usersRef.child("alanisawesome").setValueAsync(new User("June 23, 1912", "Alan Turing"));
usersRef.child("gracehop").setValueAsync(new User("December 9, 1906", "Grace Hopper"));
Node.js
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);
Node.js
var 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)
}

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

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

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

usersRef.updateChildrenAsync(userUpdates);
Node.js
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);
Node.js
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 Admin 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.");
    }
  }
});
Node.js
dataRef.set("I'm writing data", function(error) {
  if (error) {
    alert("Data could not be saved." + error);
  } else {
    alert("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 लिखते हैं, तो उनमें से एक पोस्ट को दूसरे द्वारा हटा दिया जाएगा।

इसे हल करने के लिए, फायरबेस क्लाइंट एक 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"));
Node.js
var postsRef = ref.child("posts");

var 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 and Go में, कॉलिंग push() का पैटर्न push() और फिर तुरंत कॉलिंग set() इतना सामान्य है कि Firebase SDK आपको डेटा को पास करके उन्हें संयोजित करने देता है सीधे सेट करने के लिए push() करने के push() निम्नानुसार है:

जावा
// No Java equivalent
Node.js
// 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() नए डेटा पथ के लिए एक संदर्भ लौटाएगा, जिसका उपयोग आप कुंजी प्राप्त करने या डेटा सेट करने के लिए कर सकते हैं। निम्न कोड के परिणामस्वरूप उपरोक्त उदाहरण के समान डेटा होगा, लेकिन अब हम उस अद्वितीय कुंजी तक पहुंच बना लेंगे जो उत्पन्न हुई थी:

जावा
// 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();
Node.js
// Generate a reference to a new location and add some data using push()
var newPostRef = postsRef.push();

// Get the unique key generated by push()
var 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() संदर्भ से अद्वितीय कुंजी का मूल्य प्राप्त कर सकते हैं।

डेटा पुनर्प्राप्त करने के अगले भाग में, हम सीखेंगे कि इस डेटा को फायरबेस डेटाबेस से कैसे पढ़ें।

लेनदेन डेटा की बचत

जब जटिल डेटा के साथ काम करना, जो समवर्ती संशोधनों, जैसे वृद्धिशील काउंटरों द्वारा दूषित हो सकता है, तो एसडीके एक लेनदेन ऑपरेशन प्रदान करता है।

जावा और Node.js में, आप लेनदेन ऑपरेशन को दो कॉलबैक देते हैं: एक अपडेट फ़ंक्शन और एक वैकल्पिक पूर्ण कॉलबैक। पायथन और गो में, लेनदेन संचालन अवरुद्ध है और इसलिए यह केवल अपडेट फ़ंक्शन को स्वीकार करता है।

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

जावा
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");
  }
});
Node.js
var upvotesRef = db.ref("server/saving-data/fireblog/posts/-JRHTHaIs-jNPLXOQivY/upvotes");
upvotesRef.transaction(function (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 क्लाइंट किसी भी सक्रिय डेटा का अपना आंतरिक संस्करण बनाए रखते हैं। जब डेटा लिखा जाता है, तो इसे पहले इस स्थानीय संस्करण में लिखा जाता है। क्लाइंट तब उस डेटा को डेटाबेस के साथ और अन्य क्लाइंट के साथ 'सर्वश्रेष्ठ प्रयास' के आधार पर सिंक्रोनाइज़ करता है।

नतीजतन, डेटाबेस को सभी लिखते हैं स्थानीय घटनाओं को तुरंत ट्रिगर किया जाएगा, इससे पहले कि कोई डेटा भी डेटाबेस को लिखा गया है। इसका मतलब यह है कि जब आप फायरबेस का उपयोग करके एप्लिकेशन लिखते हैं, तो आपका ऐप नेटवर्क विलंबता या इंटरनेट कनेक्टिविटी की परवाह किए बिना उत्तरदायी रहेगा।

एक बार कनेक्टिविटी बहाल होने के बाद, हम घटनाओं का उपयुक्त सेट प्राप्त करेंगे ताकि ग्राहक बिना किसी कस्टम कोड लिखने के बिना, वर्तमान सर्वर स्थिति के साथ "पकड़ता है"।

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

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