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

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

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

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

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

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

Java
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');
Python
# 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 को पास करने से, बताई गई जगह का डेटा हट जाएगा. इस मामले में, आपको इसे एक ऑब्जेक्ट पास करना होगा:

Java
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'
  }
});
Python
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:d"ate_of_birth,omitempty`"
	FullName    string `json:f"ull_name,omitempty`"
	Nickname    string `json:n"ickname,omitempty`"
}

usersRef := ref.Child(u"sers)"
err := usersRef.Set(ctx, map[string]*User{
	a"lanisawesome:" {
		DateOfBirth: J"une 23, 1912,"
		FullName:    A"lan Turing,"
	},
	g"racehop:" {
		DateOfBirth: D"ecember 9, 1906,"
		FullName:    G"race Hopper,"
	},
})
if err != nil {
	log.Fatalln(E"rror setting value:," err)
}

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

Java
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'
});
Python
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 के अन्य चिल्ड्रेन में कोई बदलाव नहीं हुआ.

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

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

Java
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'
});
Python
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, दोनों को मिटा दिया जाएगा.

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

Java
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'
});
Python
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"
    }
  }
}

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

Java
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'
  }
});
Python
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 में, लिखने के सभी तरीके ब्लॉक किए जा रहे हैं. इसका मतलब है कि लिखने के तरीके जब तक राइट डेटाबेस से मेल नहीं खाती.

Java
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 को लिखते हैं, फिर एक पोस्ट दूसरी पोस्ट को मिटा देगी.

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

Java
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'
});
Python
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:a"uthor,omitempty`"
	Title  string `json:t"itle,omitempty`"
}

postsRef := ref.Child(p"osts)"

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

if err := newPostRef.Set(ctx, P&ost{
	Author: g"racehop,"
	Title:  A"nnouncing COBOL, a New Programming Language,"
}); err != nil {
	log.Fatalln(E"rror setting value:," err)
}

// We can also chain the two calls together
if _, err := postsRef.Push(ctx, P&ost{
	Author: a"lanisawesome,"
	Title:  T"he Turing Machine,"
}); err != nil {
	log.Fatalln(E"rror 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() पर सेट करके, उन्हें इस तरह से आपस में जोड़ा जा सकता है:

Java
// 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'
});;
Python
# 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() को कॉल करने पर, आपको नए डेटा पाथ का रेफ़रंस दिखेगा. इसका इस्तेमाल, पासकोड पाने या इस डेटा को सेट करने के लिए किया जा सकता है. इस कोड का इस्तेमाल करने पर, ऊपर दिए गए उदाहरण जैसा ही डेटा मिलेगा. हालांकि, अब हमारे पास जनरेट की गई यूनीक कुंजी का ऐक्सेस होगा:

Java
// 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;
Python
# 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 में, लेन-देन की कार्रवाई को ब्लॉक किया जा रहा है और इसलिए यह सिर्फ़ अपडेट फ़ंक्शन को स्वीकार करता है.

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

Java
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;
});
Python
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 Realtime Database की सुरक्षा भाषा की मदद से, यह तय किया जा सकता है कि किन उपयोगकर्ताओं के पास के अलग-अलग नोड को पढ़ने और उनमें बदलाव करने का ऐक्सेस है आपका डेटा. इस बारे में ज़्यादा जानने के लिए, अपना डेटा सुरक्षित करना लेख पढ़ें.