Bootcamp i backendutveckling med Node.js · Lektion

Principer för GraphQL API-design

Lär dig grunderna i GraphQL, inklusive scheman, queries, mutationer och prenumerationer, för flexibel API-design.

Lektion 2 av 411 steg

Principer för GraphQL API-design är en gratis lektion i Bootcamp i backendutveckling med Node.js på CoddyKit. Detta är lektion 2 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Bootcamp i backendutveckling med Node.js, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Bootcamp i backendutveckling med Node.js innehåller totalt 4 lektioner.

Vad är GraphQL?

Välkommen till GraphQL API Design! GraphQL är ett kraftfullt frågespråk för dina API:er och en runtime för att hantera dessa frågor med dina befintliga data.

Se det som ett sätt för klienter, till exempel din mobilapp, att be om exakt de data de behöver – varken mer eller mindre. Det är ett alternativ till traditionella REST API:er.

Principer för GraphQL API-design — illustration 1

GraphQL jämfört med REST API:er

REST API:er har vanligtvis flera endpoints, där varje endpoint returnerar en fast datastruktur, medan GraphQL använder en enda endpoint.

REST: Leder ofta till over-fetching (att mer data hämtas än vad som behövs) eller under-fetching (att flera förfrågningar behövs för relaterade data).
GraphQL: Löser detta genom att låta klienter ange datastrukturen, vilket minskar antalet nätverksförfrågningar och förbättrar effektiviteten.

Kärnan: GraphQL-schema

I centrum för varje GraphQL API finns dess schema. Schemat definierar hela API:ets funktioner: vilka data som kan efterfrågas, vilka data som kan ändras och vilka datatyper som finns.

Det fungerar som ett kontrakt mellan klienten och servern och säkerställer att båda sidor förstår vilka operationer och datastrukturer som finns tillgängliga.

Schema Definition Language (SDL)

GraphQL-scheman skrivs med Schema Definition Language (SDL). Det är ett enkelt och intuitivt språk för att definiera typer och operationer.

Vi tittar på ett grundläggande exempel där typen User definieras med några fält:

type User {
  id: ID!
  name: String!
  email: String
  age: Int
}

Förstå SDL-typer

I det föregående exemplet:

type User: Definierar en ny objekttyp med namnet User.
id: ID!: id är ett fält av typen ID. ! betyder att fältet är icke-nullbart (alltid finns).
String, Int, ID: Detta är skalärtyper, GraphQL:s inbyggda grundläggande datatyper.
Du kan också definiera anpassade objekttyper, till exempel Post eller Comment.

Rottyp: Query

Rottypen Query är speciell. Den definierar alla ingångspunkter för att läsa data från ditt API. Se dem som REST:s GET-operationer.

Så här kan du lägga till operationer för att hämta användare eller en enskild användare med hjälp av ID:

type Query {
  users: [User!]!
  user(id: ID!): User
}

type User {
  id: ID!
  name: String!
  email: String
  age: Int
}

Köra en GraphQL-fråga

När typen Query har definierats kan klienter begära data. De anger vilka fält de vill ha från de tillgängliga operationerna. På så sätt undviker du over-fetching!

Så här hämtar du alla användares namn och ID:n:

query GetUsers {
  users {
    id
    name
  }
}

Rottyp: Mutation

Rottypen Mutation definierar alla ingångspunkter för att skriva eller ändra data i ditt API. De motsvarar REST-operationerna 'POST', 'PUT', 'PATCH' och 'DELETE'.

Mutationer tar ofta emot indataparametrar och returnerar det ändrade objektet.

type Mutation {
  createUser(name: String!, email: String, age: Int): User!
  updateUser(id: ID!, name: String, email: String, age: Int): User
  deleteUser(id: ID!): Boolean!
}

Köra en GraphQL-mutation

På samma sätt som med frågor skickar klienter mutationer för att ändra data. De anger mutationens namn, dess argument och vilka fält i resultatet de vill få tillbaka.

Här är ett exempel på hur du skapar en ny användare:

mutation CreateNewUser {
  createUser(name: "Alice", email: "alice@example.com", age: 30) {
    id
    name
    email
  }
}

Snabbkontroll av schemadesign

Granska följande utdrag ur ett GraphQL-schema. Vilka påståenden om det är SANNINGSENLIGA?

type Book {
  id: ID!
  title: String!
  author: Author!
}

type Author {
  id: ID!
  name: String!
  books: [Book!]
}

type Query {
  books: [Book!]!
  book(id: ID!): Book
  authors: [Author!]!
}

type Mutation {
  createBook(title: String!, authorId: ID!): Book!
}

Besvara frågan i den interaktiva lektionen

Sammanfattning och nästa steg

Bra jobbat! Du har lärt dig de grundläggande principerna för GraphQL API-design:

GraphQL låter klienter begära specifika data.
Schema Definition Language (SDL) definierar API:ets kontrakt.
Objekttyper definierar datastrukturer.
Rottypen Query hanterar hämtning av data.
Rottypen Mutation hanterar ändring av data.

Härnäst går vi igenom hur du bygger en GraphQL-server med Apollo för att omsätta dessa designer i praktiken!

Gratis att börja

Lär dig JavaScript 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: 22
Lektioner: 92

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Principer för GraphQL API-design” gratis?

Ja – hela texten till ”Principer för GraphQL API-design” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Bootcamp i backendutveckling med Node.js, kan Ni uppgradera till CoddyKit PRO. Kursen i Bootcamp i backendutveckling med Node.js innehåller totalt 4 lektioner.

Vad lär jag mig i ”Principer för GraphQL API-design”?

Lär dig grunderna i GraphQL, inklusive scheman, queries, mutationer och prenumerationer, för flexibel API-design. Ni övar på Bootcamp i backendutveckling med Node.js 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 Bootcamp i backendutveckling med Node.js?

Du behöver inga förkunskaper. Utbildningen i Bootcamp i backendutveckling med Node.js 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 2 av 4.

Hur lång tid tar lektionen ”Principer för GraphQL API-design”?

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 Bootcamp i backendutveckling med Node.js-lektionen?

Ja. Varje Bootcamp i backendutveckling med Node.js-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

Introduktion till serverless med Node.js
Principer för GraphQL API-design
Bygg en GraphQL-server med Apollo
GraphQL-prenumerationer för realtidsdata

← Tillbaka till Bootcamp i backendutveckling med Node.js