Transaction basics in Firebase - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to start a transaction in Firebase.

Firebase

db.runTransaction([1]);

Drag options to blanks, or click blank then click option'

AupdateData

BtransactionFunction

CcommitTransaction

DstartTransaction

Attempts:

3 left

💡 Hint

Common Mistakes

Passing a string instead of a function.

Using method names that do not exist on the database object.

The runTransaction method requires a function that defines the transaction operations. This function is passed as an argument.

2fill in blank

medium

Complete the code to get a document reference inside a transaction.

Firebase

const docRef = db.collection('users').doc([1]);

Drag options to blanks, or click blank then click option'

ArefId

Btransaction

CdocData

DuserId

Attempts:

3 left

💡 Hint

Common Mistakes

Using the transaction object instead of the document ID.

Passing undefined or wrong variable names.

The doc() method requires the document ID, which is usually stored in a variable like userId.

3fill in blank

hard

Fix the error in reading data inside the transaction function.

Firebase

return transaction.get(docRef).then(doc => {
  if (!doc.exists) {
    throw new Error('Document does not exist');
  }
  const newCount = doc.data().count [1] 1;
  transaction.update(docRef, { count: newCount });
});

Drag options to blanks, or click blank then click option'

A+

B+=

C-

D*

Attempts:

3 left

💡 Hint

Common Mistakes

Using += inside an expression causes syntax errors.

Using subtraction or multiplication instead of addition.

To increase the count by 1, use the + operator. The += operator cannot be used inside expressions like this.

4fill in blank

hard

Fill both blanks to correctly update a field and commit the transaction.

Firebase

transaction.[1](docRef, { [2]: newValue });

Drag options to blanks, or click blank then click option'

Aupdate

Bset

Ccount

Dvalue

Attempts:

3 left

💡 Hint

Common Mistakes

Using set which replaces the whole document.

Using incorrect field names.

The update method changes specific fields. Here, the field count is updated with newValue.

5fill in blank

hard

Fill all three blanks to complete the transaction function that increments a user's score.

Firebase

db.runTransaction(async (transaction) => {
  const docRef = db.collection('users').doc([1]);
  const doc = await transaction.get(docRef);
  if (!doc.exists) {
    throw new Error('User not found');
  }
  const newScore = doc.data().[2] [3] 1;
  transaction.update(docRef, { score: newScore });
});

Drag options to blanks, or click blank then click option'

AuserId

Bscore

C+

Dcount

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong variable names for document ID or field.

Using incorrect operators like - or *.

The document ID is userId. The field to increment is score, and the operator to add 1 is +.

Practice

1. What is the main purpose of using a transaction in Firebase?

easy

A. To speed up data retrieval

B. To ensure data changes are safe and consistent

C. To store large files

D. To send notifications to users

Solution

1. Step 1: Understand transaction purpose

   Transactions are designed to keep data changes safe and consistent when multiple users might update the same data.

2. Step 2: Eliminate unrelated options

   Speeding up retrieval, storing files, or sending notifications are not the main goals of transactions.

3. Final Answer:

   To ensure data changes are safe and consistent -> Option B

4. Quick Check:

   Transaction purpose = safe and consistent data [OK]

Hint: Transactions protect data integrity during concurrent updates [OK]

Common Mistakes:

• Thinking transactions speed up data retrieval
• Confusing transactions with file storage
• Assuming transactions send notifications

2. Which of the following is the correct way to start a transaction in Firebase Realtime Database?

easy

A. database.ref('path').transaction(updateFunction)

B. database.ref('path').setTransaction(updateFunction)

C. database.transaction('path', updateFunction)

D. database.ref('path').runTransaction(updateFunction)

Solution

1. Step 1: Recall Firebase transaction syntax

   The correct method to start a transaction is calling transaction() on a database reference.

2. Step 2: Check each option

   database.ref('path').transaction(updateFunction) uses ref('path').transaction(updateFunction), which is correct. Options A, B, and D use incorrect method names or call patterns.

3. Final Answer:

   database.ref('path').transaction(updateFunction) -> Option A

4. Quick Check:

   Correct method is .transaction() on ref [OK]

Hint: Use .transaction() on a database reference to start [OK]

Common Mistakes:

• Using .setTransaction() which does not exist
• Calling transaction directly on database object
• Using .runTransaction() which is invalid

3. Consider this transaction code snippet:

database.ref('counter').transaction(currentValue => {
  if (currentValue === null) {
    return 1;
  } else {
    return currentValue + 1;
  }
});

What will be the value of 'counter' after this transaction if it was initially 5?

medium

A. 6

B. 1

C. null

D. 5

Solution

1. Step 1: Analyze the transaction function logic

   The function checks if the current value is null; if so, it returns 1. Otherwise, it returns currentValue + 1.

2. Step 2: Apply initial value 5

   Since currentValue is 5 (not null), the function returns 5 + 1 = 6.

3. Final Answer:

   6 -> Option A

4. Quick Check:

   5 + 1 = 6 [OK]

Hint: If value exists, transaction adds 1; else sets to 1 [OK]

Common Mistakes:

• Assuming value stays the same
• Confusing null check logic
• Returning 1 regardless of current value

4. What is wrong with this Firebase transaction code?

database.ref('score').transaction(() => {
  database.ref('score').set(10);
  return 20;
});

medium

A. You cannot return a value in a transaction function

B. Calling set() inside transaction causes an error

C. Reads must happen before writes inside the transaction function

D. Transaction function must be async

Solution

1. Step 1: Understand transaction function rules

   All reads must happen before any writes inside the transaction function to ensure consistency.

2. Step 2: Identify the problem in code

   The code calls set(10) inside the transaction function before returning a new value, which violates the rule.

3. Final Answer:

   Reads must happen before writes inside the transaction function -> Option C

4. Quick Check:

   Transaction rule: read before write [OK]

Hint: Do all reads before any writes inside transaction function [OK]

Common Mistakes:

• Calling set() inside transaction function
• Returning a value is allowed and required
• Thinking transaction function must be async

5. You want to increment a user's points only if their current points are less than 100. Which transaction function correctly implements this logic?

database.ref('users/user1/points').transaction(currentPoints => {
  // Your code here
});

hard

A. if (currentPoints === null) { return 0; } else { return 100; }

B. if (currentPoints >= 100) { return currentPoints + 1; } else { return currentPoints; }

C. return currentPoints + 1;

D. if (currentPoints === null || currentPoints < 100) { return (currentPoints || 0) + 1; } else { return currentPoints; }

Solution

1. Step 1: Understand the condition to increment points

   Points should increment only if currentPoints is less than 100 or if it is null (no points yet).

2. Step 2: Check each option logic

   if (currentPoints === null || currentPoints < 100) { return (currentPoints || 0) + 1; } else { return currentPoints; } increments points by 1 if currentPoints is null or less than 100, else returns currentPoints unchanged. This matches the requirement. if (currentPoints >= 100) { return currentPoints + 1; } else { return currentPoints; } increments when points are 100 or more, which is wrong. return currentPoints + 1; always increments ignoring the limit. if (currentPoints === null) { return 0; } else { return 100; } resets points incorrectly.

3. Final Answer:

   if (currentPoints === null || currentPoints < 100) { return (currentPoints || 0) + 1; } else { return currentPoints; } -> Option D

4. Quick Check:

   Increment only if points < 100 or null [OK]

Hint: Check null or less than 100 before incrementing [OK]

Common Mistakes:

• Incrementing points when already 100 or more
• Ignoring null initial value
• Resetting points instead of incrementing