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

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

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

सेट डेटा को परिभाषित पथ पर लिखें या बदलें, जैसे 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
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);
Node.js
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 ऑब्जेक्ट डेटाबेस में सहेजा जाता है, तो ऑब्जेक्ट गुण स्वचालित रूप से नेस्टेड फैशन में डेटाबेस चाइल्ड स्थानों पर मैप किए जाते हैं। अब यदि आप 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
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);
Node.js
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)
}

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

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

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

usersRef.updateChildrenAsync(userUpdates);
Node.js
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);
Node.js
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 में, यदि आप जानना चाहते हैं कि आपका डेटा कब सबमिट किया गया है, तो आप एक पूर्ण कॉलबैक जोड़ सकते हैं। इन एसडीके में सेट और अपडेट दोनों विधियां एक वैकल्पिक पूर्ण कॉलबैक लेती हैं जिसे तब कहा जाता है जब डेटाबेस को लिखने के लिए प्रतिबद्ध किया गया हो। यदि किसी कारण से कॉल असफल रही, तो कॉलबैक को एक त्रुटि ऑब्जेक्ट पास किया जाता है जो दर्शाता है कि विफलता क्यों हुई। पायथन और गो एडमिन एसडीके में, सभी लिखने के तरीके अवरुद्ध हो रहे हैं। यही है, लिखने के तरीके तब तक वापस नहीं आते जब तक कि लेखन डेटाबेस के लिए प्रतिबद्ध न हो।

जावा
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', (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 को एक साथ लिखते हैं, तो एक पोस्ट दूसरे द्वारा हटा दी जाएगी।

इसे हल करने के लिए, फायरबेस क्लाइंट एक 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
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)
}

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

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

जावास्क्रिप्ट, पायथन और गो में, push() और फिर तुरंत set() को कॉल करने का पैटर्न इतना सामान्य है कि फायरबेस एसडीके आपको डेटा को सीधे 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()
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 डेटाबेस से कैसे पढ़ा जाए।

लेन-देन संबंधी डेटा सहेजना

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

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

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

जावा
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
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 का उपयोग करके कोई एप्लिकेशन लिखते हैं, तो नेटवर्क विलंबता या इंटरनेट कनेक्टिविटी की परवाह किए बिना आपका ऐप उत्तरदायी रहेगा।

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

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

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