Applikationer med Firebase Auth och Realtime Database · Lektion

Samarbetsbaserad dataredigering

Implementera funktioner som låter flera användare redigera och visa delade data i realtid med hjälp av Firebase-synkronisering

Lektion 3 av 411 steg

Samarbetsbaserad dataredigering är en gratis lektion i Applikationer med Firebase Auth och Realtime Database på CoddyKit. Detta är lektion 3 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Applikationer med Firebase Auth och Realtime Database, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Applikationer med Firebase Auth och Realtime Database innehåller totalt 4 lektioner.

Vad är samarbetsredigering?

Föreställ er att flera personer arbetar med samma dokument eller delade lista samtidigt. Det är samarbetsredigering!

Användarna ser varandras ändringar direkt.
Ingen råkar skriva över någon annans arbete.
Alla har den senaste informationen.

Firebase Realtime Database passar perfekt för detta eftersom tjänsten är byggd för snabbhet och synkronisering i realtid.

Fördelarna med Firebase i realtid

Den främsta styrkan hos Firebase Realtime Database är möjligheten att synkronisera data mellan alla anslutna klienter på millisekunder. Detta är grundläggande för samarbetsfunktioner.

Omedelbara uppdateringar: Ändringar som görs av en användare skickas omedelbart till de andra.
Stöd för offlinearbete: Data kan redigeras offline och synkroniseras när anslutningen återupprättas.
Skalbart: Tjänsten hanterar många samtidiga användare utan komplex backendlogik.

Det gör det mycket enklare att bygga chattappar, delade att-göra-listor eller samarbetsbaserade whiteboardtavlor.

Strukturera data för samarbete

För delade data strukturerar ni dem ofta under en gemensam överordnad nod. Till exempel ett chattrum eller ett dokument:

/chatRooms/room123/messages/
/documents/docABC/content/
/sharedTasks/taskXYZ/assignees/

Varje användare som interagerar med dessa data lyssnar efter uppdateringar på sökvägarna. Säkerhetsregler är avgörande här för att definiera vem som får läsa och skriva.

Lyssna efter uppdateringar i realtid

Klienter prenumererar på datasökvägar och får automatiskt uppdateringar. Här är ett konceptuellt kodexempel (JavaScript-liknande) som visar hur en klient kan lyssna efter ändringar i en delad räknare:

const db = firebase.database();
const counterRef = db.ref('sharedCounter');

counterRef.on('value', (snapshot) => {
  const currentCount = snapshot.val();
  console.log('Current count:', currentCount);
});

Alla ändringar i /sharedCounter som görs av en klient aktiverar den här lyssnaren direkt.

const db = firebase.database();
const counterRef = db.ref('sharedCounter');

counterRef.on('value', (snapshot) => {
  const currentCount = snapshot.val();
  console.log('Current count:', currentCount);
});

Utmaningen: samtidiga skrivningar

Vad händer om två användare försöker uppdatera samma data exakt samtidigt? Detta kallas ett kapplöpningstillstånd.

Föreställ er en delad räknare. Användare A läser 10, lägger till 1 och skriver 11. Samtidigt läser användare B 10, lägger till 1 och skriver 11. Räknaren borde vara 12, men blir i stället 11 eftersom den ena uppdateringen skriver över den andra.

Simulera ett kapplöpningstillstånd

Den här Java-koden simulerar två trådar som försöker öka en delad räknare utan korrekt synkronisering. Kör den flera gånger och observera det slutliga värdet – det kanske inte alltid blir 2000!

public class Main {
  private static int counter = 0;

  public static void main(String[] args) throws InterruptedException {
    Thread t1 = new Thread(() -> {
      for (int i = 0; i < 1000; i++) {
        counter++;
      }
    });

    Thread t2 = new Thread(() -> {
      for (int i = 0; i < 1000; i++) {
        counter++;
      }
    });

    t1.start();
    t2.start();

    t1.join();
    t2.join();

    System.out.println("Final Counter: " + counter);
  }
}

Lös problemet med Firebase-transaktioner

Firebase Realtime Database erbjuder transaktioner för att förhindra dessa kapplöpningstillstånd. En transaktion säkerställer att en uppdatering är atomär – den slutförs helt eller misslyckas, och inga andra skrivningar kan störa den under tiden.

Den fungerar så här:

Läser de aktuella data.
Tillämpar era ändringar på dessa data.
Skriver tillbaka de nya data, men ENDAST om originaldata inte har ändrats sedan de lästes.

Om data har ändrats försöker transaktionen igen.

Implementera en transaktion

Här är en konceptuell transaktion som säkert ökar en delad räknare (JavaScript-liknande). Metoden runTransaction tar en uppdateringsfunktion.

const db = firebase.database();
const counterRef = db.ref('sharedCounter');

counterRef.transaction((currentData) => {
  // If data doesn't exist, start at 0
  if (currentData === null) {
    return 1;
  }
  // Increment the existing value
  return currentData + 1;
}).then((result) => {
  if (result.committed) {
    console.log('Counter incremented successfully!');
  } else {
    console.log('Transaction aborted or failed.');
  }
}).catch((error) => {
  console.error('Transaction error:', error);
});

Detta garanterar att räknaren ökas korrekt, även när många användare arbetar samtidigt.

const db = firebase.database();
const counterRef = db.ref('sharedCounter');

counterRef.transaction((currentData) => {
  // If data doesn't exist, start at 0
  if (currentData === null) {
    return 1;
  }
  // Increment the existing value
  return currentData + 1;
}).then((result) => {
  if (result.committed) {
    console.log('Counter incremented successfully!');
  } else {
    console.log('Transaction aborted or failed.');
  }
}).catch((error) => {
  console.error('Transaction error:', error);
});

Transaktionslogik förklarad

Kärnan i en transaktion är uppdateringsfunktionen: (currentData) => { ... }.

currentData: Detta är värdet på servern i det ögonblick då transaktionen försöker genomföras.
Returvärde: Det som funktionen returnerar blir det nya värde som Firebase försöker skriva.
Att returnera undefined eller null: Om ni returnerar undefined eller null avbryts transaktionen och inga ändringar skrivs.

Firebase hanterar logiken för nya försök om currentData ändras mellan er läsning och försöket att genomföra transaktionen.

Snabbtest om transaktioner

Ni bygger en app för gemensamt skapande av teckningar. Användare kan lägga till ett nytt penseldrag på en delad canvas. Vilken Firebase-funktion är viktigast för att säkerställa att två användare som ritar exakt samtidigt inte skriver över varandras ändringar i listan över penseldrag?

Besvara frågan i den interaktiva lektionen

Repetition: samarbetsredigering

I den här lektionen har vi gått igenom hur Firebase Realtime Database driver program för samarbetsredigering. Vi har lärt oss:

Firebases synkronisering i realtid passar perfekt för gemensamma upplevelser.
Det är viktigt att strukturera data korrekt för att möjliggöra gemensam åtkomst.
Kapplöpningstillstånd kan uppstå vid samtidiga skrivningar.
Firebase Transactions är lösningen för att säkert uppdatera delade data och säkerställa integriteten även när många användare arbetar samtidigt.

Med transaktioner kan du bygga robusta samarbetsfunktioner där användare kan arbeta tillsammans utan problem.

Gratis att börja

Lär dig Applikationer med Firebase Auth och Realtime Database med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 11
Lektioner: 44

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Samarbetsbaserad dataredigering” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Applikationer med Firebase Auth och Realtime Database, inklusive ”Samarbetsbaserad dataredigering”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Applikationer med Firebase Auth och Realtime Database innehåller totalt 4 lektioner.

Vad lär jag mig i ”Samarbetsbaserad dataredigering”?

Implementera funktioner som låter flera användare redigera och visa delade data i realtid med hjälp av Firebase-synkronisering Ni övar på Applikationer med Firebase Auth och Realtime Database med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Applikationer med Firebase Auth och Realtime Database?

Du behöver inga förkunskaper. Utbildningen i Applikationer med Firebase Auth och Realtime Database på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.

Hur lång tid tar lektionen ”Samarbetsbaserad dataredigering”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Applikationer med Firebase Auth och Realtime Database-lektionen?

Ja. Varje Applikationer med Firebase Auth och Realtime Database-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Applikationer med Firebase Auth och Realtime Database