Applikationer med Firebase Auth och Realtime Database · Lektion

Strukturera dina data

Upptäck bästa praxis för att organisera och strukturera dina NoSQL-data för att optimera prestanda och skalbarhet

Lektion 3 av 412 steg

Strukturera dina data ä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.

Introduktion till datastrukturering

Välkommen till lektionen om hur du strukturerar dina data i Firebase Realtime Database! Hur du organiserar dina data är avgörande för prestanda och skalbarhet.

En välstrukturerad databas gör det enklare att effektivt söka efter, uppdatera och skydda din information, särskilt när applikationen växer.

JSON-trädet och sökvägar

Firebase Realtime Database lagrar data som ett stort JSON-träd. Allt är en nod som kan nås via en unik sökväg.

Tänk på det som ett filsystem: /users/user123/profile/name. Den här sökvägen pekar på en specifik del av data i trädet.

Undvik djup nästning

En vanlig fallgrop är att nästla data för djupt. När du hämtar data från en överordnad nod hämtar Firebase ALLA dess underordnade noder.

Djup nästning kan leda till:

Stora, onödiga datahämtningar
Långsammare sökningar
Komplexa säkerhetsregler

Här är ett exempel på en djupt nästlad struktur:

{ "users": {
  "user123": {
    "name": "Alice",
    "posts": {
      "postA": {
        "title": "My First Post",
        "comments": {
          "comment1": {
            "text": "Great post!"
          }
        }
      }
    }
  }
}}

Platta ut dina data

I stället för djup nästning kan du "platta ut" dina data. Det innebär att du organiserar relaterade men separata delar av data i separata noder på toppnivå.

Därefter kan du länka samman dessa delar med hjälp av ID:n. På så sätt hämtar du bara de data som du uttryckligen efterfrågar.

Listor med unika nycklar

Firebase Realtime Database fungerar bäst med objekt i stället för arrayer när du lagrar listor med objekt. Varje objekt bör ha en unik nyckel.

Firebase tillhandahåller push(), som automatiskt genererar unika, tidsbaserade nycklar. Det passar perfekt för dynamiska listor, till exempel inlägg eller meddelanden.

Dåligt (array):

[
  { "name": "Alice" },
  { "name": "Bob" }
]

Bra (objekt med nycklar):

{
  "users": {
    "-M_aBc123": { "name": "Alice" },
    "-M_xYz456": { "name": "Bob" }
  }
}

Bättre struktur: användare och inlägg

Låt oss tillämpa utplattning på vårt exempel med användare och inlägg. I stället för att nästla inlägg under användare skapar vi separata samlingar på toppnivå:

/users för användarprofiler
/posts för alla inlägg

Länka dem med hjälp av userId i inläggsobjektet.

{
  "users": {
    "user123": {
      "name": "Alice",
      "email": "alice@example.com"
    },
    "user456": {
      "name": "Bob",
      "email": "bob@example.com"
    }
  },
  "posts": {
    "postA": {
      "title": "Hello World",
      "content": "My first post.",
      "authorId": "user123",
      "timestamp": 1678886400000
    },
    "postB": {
      "title": "Firebase Tips",
      "content": "Awesome database!",
      "authorId": "user123",
      "timestamp": 1678972800000
    }
  }
}

Kodexempel: skriva utplattade data

Det här JavaScript-exemplet visar konceptuellt hur du skulle skriva en användare och ett inlägg med den utplattade strukturen. Det använder en simulerad databas i demonstrationssyfte.

function main() {
  const db = {
    ref: (path) => ({
      set: (value) => console.log(`SET ${path}:`, JSON.stringify(value, null, 2)),
      push: () => ({
        key: `mockId_${Math.random().toString(36).substring(7)}`,
        set: (value) => console.log(`PUSH ${path}/${this.key}:`, JSON.stringify(value, null, 2))
      })
    })
  };

  const userId = "user123";
  const user = {
    name: "Alice",
    email: "alice@example.com"
  };
  db.ref(`users/${userId}`).set(user);

  const newPostRef = db.ref("posts").push();
  const postId = newPostRef.key;
  const post = {
    title: "My First Post",
    content: "This is the content of my first post.",
    authorId": userId,
    timestamp: Date.now()
  };
  newPostRef.set(post);

  console.log("User and Post data created (conceptually).");
  console.log("User ID:", userId);
  console.log("Post ID:", postId);
}

main();

Användarspecifika och offentliga data

Överväg att separera data som är privata för en användare från data som är offentliga eller delade.

Privata: Lagras under /users/{uid}/private_data (till exempel inställningar och utkast).
Offentliga/delade: Lagras i en samling på toppnivå (till exempel /public_posts och /chat_rooms).

Den här separeringen förenklar säkerhetsreglerna och effektiviserar dataåtkomsten.

Välj bra nycklar

Nycklar är avgörande för att navigera bland dina data. Bra nycklar är:

Unika: Nödvändigt för att identifiera specifika data.
Korta: Minskar lagringsbehov och bandbredd.
Beskrivande (om de är anpassade): Underlättar läsbarheten, men bör vara kortfattade.

Firebase-genererade ID:n från push() är utmärkta för unika, ordnade och korta nycklar.

Exempel: fan-out-data (kortfattat)

För starkt relationsbaserade data som behöver uppdateras på flera platser samtidigt (till exempel när en användares namn visas i profilen och i alla användarens inlägg) kan du överväga en så kallad "fan-out"-strategi.

Det innebär att data skrivs till flera platser i en enda operation. Vi går igenom detta mer i avancerade lektioner, men det är ett viktigt struktureringsmönster.

Frågesport om datastrukturering

Vilka av följande rekommenderas som bästa praxis när du strukturerar data i Firebase Realtime Database?

Besvara frågan i den interaktiva lektionen

Sammanfattning: datastrukturering

I den här lektionen gick vi igenom viktig bästa praxis för att strukturera dina data i Firebase Realtime Database:

Undvik djup nästning: Det leder till ineffektiv datahämtning.
Platta ut dina data: Använd separata noder på toppnivå och länka samman dem med ID:n.
Använd unika nycklar för listor: Firebase-ID:n från push() är idealiska.
Separera offentliga och privata data: För bättre säkerhet och åtkomstkontroll.
Välj bra nycklar: Korta, unika och beskrivande.

Dessa principer hjälper dig att bygga skalbara Firebase-applikationer med god prestanda!

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 ”Strukturera dina data” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Applikationer med Firebase Auth och Realtime Database, inklusive ”Strukturera dina data”, 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 ”Strukturera dina data”?

Upptäck bästa praxis för att organisera och strukturera dina NoSQL-data för att optimera prestanda och skalbarhet 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 ”Strukturera dina data”?

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