React Native Vorlage

Todo-App Backend-Vorlage
React Native — Schema, API & KI-Leitfaden

Ein produktionsbereites React Native Todo Backend-Schema und Starter-Kit auf Back4app: ER-Diagramm, Datenwörterbuch, JSON-Schema, API-Spielplatz, JavaScript/React Native Codebeispiele, offline-first Anheftung und ein One-Click KI-Agent Prompt zur Bereitstellung in Minuten.

Wichtige Erkenntnisse

Auf dieser Seite erhalten Sie ein produktionsbereites Schema, einen One-Click KI-Prompt und schrittweise React Native-Code — damit Sie eine Todo-App ohne Backend-Entwicklung bereitstellen können.

  1. In Minuten bereitstellenFügen Sie die AI-Agent-Eingabeaufforderung ein und erhalten Sie eine laufende App mit Frontend, Backend und Datenbank.
  2. Standardmäßig sicherRow-Level-ACLs stellen sicher, dass jeder Benutzer nur seine eigenen Todos sieht.
  3. React Native-native SDKParse React Native SDK mit async/await, lokalem Pinnen und Live Queries sofort einsatzbereit.
  4. REST + GraphQLbeide APIs werden automatisch generiert; keine benutzerdefinierten Endpunkte zu schreiben.
  5. Zwei Klassen_User (eingebaute Authentifizierung) und Todo (Aufgaben mit Titel, erledigt, Fälligkeitsdatum, Priorität, Eigentümer).

Was ist die React Native Todo App Backend-Vorlage?

Die React Native Todo App Backend-Vorlage ist ein vorgefertigtes, produktionsbereites Backend-Schema, das auf Back4app gehostet wird. Es bietet Ihnen zwei Datenbankklassen (_User und Todo), besitzbasierte ACLs, REST- und GraphQL-APIs sowie eine Ein-Klick-AI-Agent-Eingabeaufforderung — damit Sie eine React Native-App verbinden und in Minuten anstelle von Tagen eine funktionierende Todo-App mit Offline-Unterstützung bereitstellen können.

Am besten geeignet für:

React Native-EntwicklerExpo & Bare-WorkflowOffline-first mobile AppsMVP-StartsPlattformübergreifend iOS & Android

Übersicht

Eine Todo-App ist einer der häufigsten Ausgangspunkte für das Erlernen der Backend-Entwicklung. Im Hintergrund benötigt sie Benutzerregistrierung, Aufgaben-CRUD, besitzbasierten Zugriffskontrolle und optional Echtzeitsynchronisierung sowie Offline-Unterstützung.

Das folgende Schema definiert zwei Klassen — _User (integriert) und Todo — die durch einen Pointer verbunden sind. Mit dem Parse React Native SDK (Back4app) können Sie direkt aus Ihrem JavaScript oder TypeScript-Code mit diesem Backend interagieren — Abfragen, Erstellen, Aktualisieren und Löschen von Objekten sowie das Anheften für Offline — ohne eine benutzerdefinierte API-Schicht zu schreiben.

Warum Ihr React Native Todo-Backend mit Back4app erstellen?

Back4app bietet Ihnen ein fertiges Backend und das Parse React Native SDK, sodass Sie sich auf UX und Leistung konzentrieren können, anstatt sich um REST-Verkabelung und Authentifizierung zu kümmern.

  • Offline-first & Synchronisierung: Pin Todo-Objekte im lokalen Datenspeicher, sodass die Liste offline funktioniert und synchronisiert, wenn die App wieder online ist — ideal für mobile Anwendungen.
  • Komponenten & Hooks: Verwenden Sie das SDK mit React-Hooks und -Kontext; halten Sie den Zustand mit Parse-Abfragen und Live Queries für Echtzeitaktualisierungen synchron.
  • Plattformübergreifend, ein Backend: Dasselbe Schema und dieselben APIs für iOS und Android; ideal für React Native-Teams, die Expo oder den Bare-Workflow verwenden.

Ideal für React Native-Entwickler, die Expo oder den Bare-Workflow verwenden — ein Backend, beide Plattformen.

Kernvorteile

Ein produktionsbereites Todo-Backend, damit Sie schneller liefern und sich auf Ihre App konzentrieren können.

Schneller liefern, kein Backend-Code

REST- und GraphQL-APIs sowie ein einsatzbereites Schema — verbinden Sie Ihre App und legen Sie los.

Standardmäßig sicher

ACLs und Berechtigungen auf Klassenebene, damit Benutzer nur auf ihre eigenen Daten zugreifen können.

Echtzeit-Updates

Live Queries über WebSockets für sofortige UI-Updates.

Integrierte Authentifizierung

Benutzerregistrierung, -anmeldung und Sitzungsverwaltung sofort einsatzbereit — keine benutzerdefinierte Authentifizierungsschicht.

Offline-Funktionalität

Lokales Pinnen hält Daten offline verfügbar und synchronisiert, wenn Sie sich wieder verbinden.

In Minuten bereitstellen

Verwenden Sie den KI-Agenten, um Ihre Todo-App aus dieser Vorlage zu erstellen und bereitzustellen.

Bereit, es auszuprobieren?

Lassen Sie den Back4app KI-Agenten Ihr Todo-App-Backend erstellen, das React Native-Frontend verbinden und bereitstellen – alles aus einem einzigen Prompt.

Kostenlos starten – 50 KI-Agenten-Prompts/Monat, keine Kreditkarte erforderlich

Technologiestack

Alles, was dieses Todo-App-Template auf einen Blick antreibt.

Frontend
React Native
Backend
Back4app
Datenbank
MongoDB
Authentifizierung
Authentifizierung & Zugriffskontrolle
APIs
REST & GraphQL
Bereitstellung
KI-Agent / Dashboard

ER-Diagramm

Entitäts-Beziehungsdiagramm für das React Native Todo-App-Datenmodell.

Diagrammquelle anzeigen
Mermaid
erDiagram
    _User {
        String objectId PK
        String username
        String email
        String password
        Date createdAt
        Date updatedAt
    }

    Todo {
        String objectId PK
        String title
        Boolean done
        Date dueDate
        Number priority
        Pointer owner FK
        Date createdAt
        Date updatedAt
    }

    _User ||--o{ Todo : "owns"

Integrationsfluss

Auth-to-CRUD-Sequenz: wie Ihre React Native-App mit Back4app kommuniziert – anmelden, dann Todos abfragen und erstellen.

Diagrammquelle anzeigen
Mermaid
sequenceDiagram
  participant User
  participant App as React Native App
  participant Back4app as Back4app Cloud

  User->>App: Login
  App->>Back4app: Parse.User.logIn(username, password)
  Back4app-->>App: Session token
  App-->>User: Logged in

  User->>App: Load todos
  App->>Back4app: new Parse.Query('Todo').find()
  Back4app-->>App: Array of Todo
  App-->>User: Show list

  User->>App: Create todo
  App->>Back4app: todo.save()
  Back4app-->>App: Todo (objectId)
  App-->>User: Updated list

Datenwörterbuch

Vollständige Feldreferenz für jede Klasse im Schema.

FeldTypBeschreibungErforderlich
objectIdStringAuto-generated unique identifierauto
titleStringShort description of the task
doneBooleanWhether the task is completed
dueDateDateOptional deadline for the task
priorityNumberPriority level (1 = high, 3 = low)
ownerPointer<_User>User who owns this task
createdAtDateAuto-generated creation timestampauto
updatedAtDateAuto-generated last-update timestampauto

8 Felder in Todo

Sicherheit & Berechtigungen

Wie Eigentum, ACLs und Klassenberechtigungen Daten in diesem Schema schützen.

Zeilenebene ACLs

Jede Todo erhält eine ACL, die mit ihrem Eigentümer verknüpft ist. Nur der Ersteller kann seine eigenen Aufgaben lesen, aktualisieren oder löschen.

Klassenebene Berechtigungen

CLPs beschränken, welche Rollen oder Benutzer Objekte auf Klassenebene erstellen, lesen, aktualisieren oder löschen können — Ihre erste Verteidigungslinie.

Pointer-basiertes Eigentum

Der Eigentümer-Pointer verknüpft jede Todo mit seinem _User. Cloud Code-Trigger können das Eigentum automatisch festlegen und ACLs beim Speichern durchsetzen.

Schema (JSON)

Rohe JSON-Schema-Definition — kopieren und in Ihrer Back4app-App verwenden oder über die API importieren.

JSON
{
  "classes": [
    {
      "className": "Todo",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "title": {
          "type": "String",
          "required": true
        },
        "done": {
          "type": "Boolean",
          "required": false,
          "defaultValue": false
        },
        "dueDate": {
          "type": "Date",
          "required": false
        },
        "priority": {
          "type": "Number",
          "required": false,
          "defaultValue": 3
        },
        "owner": {
          "type": "Pointer",
          "targetClass": "_User",
          "required": false
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "_User",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "username": {
          "type": "String",
          "required": true
        },
        "email": {
          "type": "String",
          "required": true
        },
        "password": {
          "type": "String",
          "required": true
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    }
  ]
}

Mit AI-Agenten erstellen

Verwenden Sie den Back4app AI-Agenten, um eine echte Todo-App aus dieser Vorlage zu erstellen: Er wird das Frontend, das Backend (dieses Schema, Authentifizierung und APIs) erstellen und bereitstellen — keine manuelle Einrichtung. Die folgende Eingabeaufforderung beschreibt diesen Todo-Stack, damit der Agent eine produktionsbereite App auf einmal generieren kann.

Back4app AI-Agent
Bereit zum Erstellen
Create a Todo app on Back4app with this exact schema and behavior.

Schema:
1. _User (use Back4app built-in): username (String, required), email (String, required), password (String, required); objectId, createdAt, updatedAt (system).
2. Todo: title (String, required), done (Boolean, default: false), dueDate (Date, optional), priority (Number, default: 3; 1=high, 2=medium, 3=low), owner (Pointer to _User; set to current user on create); objectId, createdAt, updatedAt (system).

Security:
- Set ACLs on every Todo so only the owner has read and write. No public read/write.
- On create, set Todo.owner to the current user (e.g. via Cloud Code beforeSave or client-side).
- Use Class-Level Permissions so only authenticated users can create/read/update/delete Todo.

Auth:
- Sign-up (username, email, password) and login; support logout/session.
- After login, the app should only show and allow CRUD for the current user's todos.

Behavior:
- Full CRUD for Todo: create, list (only owner's), get one, update (toggle done, edit title, dueDate, priority), delete.
- List todos with sort (e.g. by priority then dueDate or createdAt). Default priority for new todos: 3 (low).

Deliver:
- Create the Back4app app with the schema above, ACLs, and any Cloud Code needed (e.g. beforeSave on Todo to set owner).
- Generate the frontend and connect it to this backend; deploy so the app is runnable end-to-end.

Drücken Sie die Schaltfläche unten, um den Agenten mit der vorausgefüllten Eingabeaufforderung dieser Vorlage zu öffnen.

In wenigen Minuten bereitstellen50 kostenlose Eingabeaufforderungen / MonatKeine Kreditkarte erforderlich

API-Spielplatz

Testen Sie die REST- und GraphQL-Endpunkte für das Todo-Schema. Antworten aus den obigen Beispieldaten — kein Back4app-Konto erforderlich.

Playground wird geladen…

Verwendet dasselbe Todo-Schema wie diese Vorlage.

Schritt-für-Schritt React Native Integration

Verbinden Sie sich mit Ihrem Back4app Backend von einer React Native App aus mit dem Parse React Native SDK.

  1. Schritt 1: Installieren Sie das Parse React Native SDK

    Fügen Sie das Parse React Native SDK (oder React-native-Parse) mit npm oder yarn zu Ihrem Projekt hinzu.

    JavaScript
    npm install parse --save
    # or: yarn add parse
  2. Schritt 2: Initialisieren Sie Parse in Ihrer App

    Initialisieren Sie das Parse SDK in Ihrem App-Einstieg (z.B. App.js oder index.js) mit Ihrer Anwendungs-ID, Server-URL und JavaScript Schlüssel.

    JavaScript
    import Parse from 'parse/react-native';
    
    Parse.setAsyncStorage(AsyncStorage);
    Parse.initialize('YOUR_APP_ID', 'YOUR_JS_KEY');
    Parse.serverURL = 'https://parseapi.back4app.com';
    
  3. Schritt 3: Alle Todos abfragen

    Erstellen Sie eine Parse Abfrage für die Todo-Klasse, fügen Sie eine aufsteigende Sortierung nach Priorität hinzu und rufen Sie find() (oder findWithCount()) auf.

    JavaScript
    async function getTodos() {
      const query = new Parse.Query('Todo').ascending('priority');
      const results = await query.find();
      return results;
    }
  4. Schritt 4: Ein Todo erstellen

    Erstellen Sie ein neues Parse.Object('Todo'), setzen Sie Titel, erledigt und Priorität, und rufen Sie dann save() auf.

    JavaScript
    async function createTodo(title, priority = 3) {
      const Todo = Parse.Object.extend('Todo');
      const todo = new Todo();
      todo.set('title', title);
      todo.set('done', false);
      todo.set('priority', priority);
      await todo.save();
      return todo;
    }
  5. Schritt 5: Todos aktualisieren und löschen

    Holen Sie ein Todo anhand der objectId, setzen Sie die Felder und rufen Sie save() auf, um zu aktualisieren, oder rufen Sie destroy() auf, um zu löschen.

    JavaScript
    async function markDone(objectId) {
      const query = new Parse.Query('Todo');
      const todo = await query.get(objectId);
      todo.set('done', true);
      await todo.save();
    }
    
    async function deleteTodo(objectId) {
      const query = new Parse.Query('Todo');
      const todo = await query.get(objectId);
      await todo.destroy();
    }

Zustandsverwaltung

Verwenden Sie React-Hooks (useState, useReducer, useContext) oder einen kleinen Store, um den Zustand der Todo-Liste zu halten und das Parse SDK aufzurufen.

Vollständiges JavaScript/TypeScript Datenmodell

Kopiere einen vollständigen Todo-Typ und Hilfsfunktionen für typensichere Serialisierung mit dem Parse SDK.

JavaScript
/** @typedef {{ objectId?: string, title: string, done: boolean, dueDate?: string, priority: number, owner?: { objectId: string }, createdAt?: string, updatedAt?: string }} Todo */

/**
 * @param {Parse.Object} obj
 * @returns {Todo}
 */
function todoFromParse(obj) {
  return {
    objectId: obj.id,
    title: obj.get('title'),
    done: obj.get('done') ?? false,
    dueDate: obj.get('dueDate')?.toISOString?.() ?? undefined,
    priority: obj.get('priority') ?? 3,
    owner: obj.get('owner') ? { objectId: obj.get('owner').id } : undefined,
    createdAt: obj.get('createdAt')?.toISOString?.() ?? undefined,
    updatedAt: obj.get('updatedAt')?.toISOString?.() ?? undefined,
  };
}

Offline-First & Lokaler Datenspeicher

Verwende pinAll() und unpin, damit Daten offline verfügbar sind und synchronisiert werden, wenn du wieder online bist.

Das Parse React Native SDK unterstützt einen lokalen Datenspeicher. Nachdem du Todo-Objekte abgerufen hast, pinne sie, damit die Liste offline verfügbar ist; führe dieselbe Abfrage mit fromLocalDatastore() aus, wenn das Gerät offline ist. Wenn die App wieder online ist, speichere Änderungen und synchronisiere.

Unten: Ergebnisse nach dem Abrufen pinnen und unpin, wenn du keine lokalen Kopien mehr benötigst.

JavaScript
// Pin todos after fetch (offline-first)
async function fetchAndPinTodos() {
  const query = new Parse.Query('Todo').ascending('priority');
  const results = await query.find();
  await Parse.Object.pinAll(results);
  // When offline, read from local datastore:
  // const localQuery = new Parse.Query('Todo').fromLocalDatastore();
  // const localResults = await localQuery.find();
}

async function unpinAllTodos() {
  await Parse.Object.unpinAll('Todo');
}

Häufig gestellte Fragen

Häufige Fragen zum Backend-Template der Todo-App.

Von Entwicklern weltweit vertraut

Schließe dich der Community an, die die Zukunft von Apps gestaltet

G2 Users Love Us Badge

Bereit, deine Todo-App zu erstellen?

Starte dein React Native Projekt in wenigen Minuten. Keine Kreditkarte erforderlich.

Mit AI-Agent erstellen