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

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

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

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

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

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

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

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

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

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

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

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

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

{
  "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
नोड.जे.एस
// 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();
नोड.जे.एस
// 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() संदर्भ से अद्वितीय कुंजी का मूल्य प्राप्त कर सकते हैं।

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

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

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

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");
  }
});
नोड.जे.एस
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 लिखेंगे, जिसके परिणामस्वरूप दो के बजाय एक वृद्धि होगी।

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

फायरबेस नोड.जेएस और जावा क्लाइंट किसी भी सक्रिय डेटा का अपना आंतरिक संस्करण बनाए रखते हैं। जब डेटा लिखा जाता है, तो उसे पहले इस स्थानीय संस्करण में लिखा जाता है। क्लाइंट तब उस डेटा को डेटाबेस और अन्य क्लाइंट के साथ 'सर्वोत्तम प्रयास' के आधार पर सिंक्रनाइज़ करता है।

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

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

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

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