HILFE ZUM KNOTENPUNKT

Sequelize Node.js (Wie es für Entwickler funktioniert)

Veröffentlicht 29. September 2024

Teilen Sie:

Sequelize Node.JS

Einführung

In der Welt der modernen Webentwicklung erfordert das Erstellen skalierbarer und zuverlässiger Apps starke Tools und Bibliotheken, die Frontend- und Backend-Operationen effektiv handhaben können. Zwei solcher Dienstprogramme sind Sequelize und IronPDF, die in Kombination eine vollständige Lösung für die PDF-Erstellung und Datenbankverwaltung in Node.js-Anwendungen bieten.

Sequelize ist eine versprechenbasierte objektrelationale Abbildung (ORM) für Node.js, das die Arbeit mit SQL-Datenbanken einfach macht. Mit seiner breiten Unterstützung für SQL-Dialekte, einschließlich PostgreSQL, MySQL, SQLite und Microsoft SQL Server (MSSQL), Entwickler können JavaScript verwenden, um Modelle und Beziehungen zu erstellen. Sequelize verbessert die Entwicklererfahrung, indem es SQL-Datenbankabfragen in eine verständliche Syntax abstrahiert und komplexe Datenbankoperationen mit Funktionen wie Modellvalidierung, eager loading und Transaktionen optimiert.

Umgekehrt ist IronPDF eine robuste Bibliothek zur Erstellung von PDFs, die leicht mit Node.js-Anwendungen interagieren. Sie ermöglicht es Programmierern, Inhalte in PDF-Dokumenten hinzuzufügen, zu ändern und zu entfernen. Mit seiner außergewöhnlichen Fähigkeit, HTML-Informationen in PDF-Format zu konvertieren, ist IronPDF ein hervorragendes Werkzeug zur direkten Erstellung von dokumentbasierten Ausgaben aus Online-Anwendungen, wie Rechnungen und Berichten.

Was ist Sequelize Node.js?

Sequelize für Node.js ist eine leistungsstarke objektrelationale Zuordnung (ORM) das solide Transaktionsunterstützung bietet und zuverlässige sowie atomare Operationen auf Ihrer Datenbank gewährleistet. Durch die Nutzung des Sequelize-Modells können Entwickler ihre Datenstrukturen effizient definieren und damit interagieren. Funktionen wie Lazy Loading ermöglichen optimierte Datenbankabfragen, indem verwandte Daten nur bei Bedarf abgerufen werden. Der objektrelationale Mapper Sequelize vereinfacht die Interaktion mit Datenbanken durch Lazy Loading, was die Arbeit mit einer Beispieldatenbank oder einem Produktionssystem unkompliziert macht. Mit einfacher Konfiguration der Datenbank-Passwörter unterstützt Sequelize verschiedene Datenbanken, einschließlich MySQL-Datenbank, was es zu einer vielseitigen Wahl für Node.js-Anwendungen macht.

Sequelize Node.js (Wie es für Entwickler funktioniert): Abbildung 1 - Sequelize - Solide Transaktionsunterstützung

Funktionen von Sequelize Node.js

Ein beliebter objekt-relationaler Mapper (ORM) für Node.js namens Sequelize erleichtert die Arbeit mit relationalen Datenbanken und rohen SQL-Abfragen. Hier sind einige seiner herausragenden Eigenschaften:

Promises: Im Gegensatz zu herkömmlichen Callbacks verwendet Sequelize Promises für asynchrone Operationen, was zu saubererem, einfacher lesbarem Code führt.

Datenbankunterstützung: Es ermöglicht Ihnen, aus einer Vielzahl weit verbreiteter relationaler Datenbanken zu wählen, einschließlich PostgreSQL, MySQL, MariaDB, SQLite, Microsoft SQL Server und mehr.

Modelldefinition: Mithilfe von JavaScript-Objekten ermöglicht Sequelize das Definieren von Modellen, die auf Ihre Datenbanktabellen abgebildet werden. Infolgedessen ist das Schreiben von rohem SQL weniger notwendig, und die Datenmodellierung wird vereinfacht.

Assoziationen: Sequelize ist ziemlich gut im Umgang mit Tabellenbeziehungen. Sie können Beziehungen zwischen Ihren Modellen angeben, wie z. B. eins-zu-viele, viele-zu-viele und eins-zu-eins, und Sequelize wird die komplizierten SQL-Abfragen im Hintergrund verwalten.

Transaktionen: Bei der Durchführung mehrerer Datenbankoperationen sorgt die starke Transaktionsunterstützung von Sequelize für Datenkonsistenz.

Daten-Synchronisierung: Ihre Modelle und die Datenbankstruktur können automatisch mit Sequelize synchronisiert werden. Bei der Erstellung oder Aktualisierung von Tabellen auf Grundlage Ihrer Modelldefinitionen kann dies nützlich sein.

Migrationen: Sequelize bietet ein effektives Migrationssystem, mit dem Sie Änderungen an der Datenbankstruktur im Laufe der Zeit verwalten können. Die Aufrechterhaltung der Übereinstimmung zwischen Ihrer Datenbankstruktur und dem Anwendungs-Code ist entscheidend.

Validierungen: Bevor Daten in der Datenbank gespeichert werden, können Sie Validierungsregeln für Ihre Modelle festlegen, um die Datenintegrität zu gewährleisten.

Rohe Abfragen: Obwohl Sequelize die Verwendung seiner Abstraktionsschicht fördert, können Sie es auch verwenden, um rohe SQL-Abfragen auszuführen, wenn dies für bestimmte Arbeitslasten erforderlich ist.

Seeding: Aus Test- oder Entwicklungsgründen bietet Sequelize eine Möglichkeit, Ihre Datenbank mit einigen Startdaten zu füllen.

Scopes: Durch die Definition wiederverwendbarer Filter für Ihre Modellabfragen helfen Scopes Ihnen, die Abfrage komplexer Daten besser zu verwalten.

Dies sind nur einige der zahlreichen Funktionen von Sequelize. Es ist ein unschätzbares Werkzeug für Node.js-Entwickler, die mit relationalen Datenbanken arbeiten, aufgrund seiner umfassenden Funktionen.

Erstellen und konfigurieren Sie Sequelize in Node.js

Sie können diese Schritte verwenden, um Sequelize mit SQLite3 in einem Node.js-Projekt zu erstellen und zu konfigurieren:

Abhängigkeiten installieren

Installieren Sie die Sequelize CLI (Befehlszeilenschnittstelle), SQLite3 und Sequelize als Abhängigkeiten in Ihrem Projekt.

npm install sequelize 
npm install sqlite3 
npm install sequelize-cli

npm install sequelize 
npm install sqlite3 
npm install sequelize-cli

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'npm install sequelize npm install sqlite3 npm install sequelize-cli

VB C#

Sequelize initialisieren

Von Grund auf neu anfangen. Richten Sie die Projektstruktur und die Konfigurationsdateien mit Sequelize über die CLI ein.

npx sequelize-cli init

npx sequelize-cli init

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'npx sequelize-cli init

VB C#

Die Verzeichnisse und Dateien, die für Ihr Sequelize-Projekt erforderlich sind, werden durch den obigen Befehl erstellt.

Datenbank konfigurieren

Um die Datenbankverbindung einzurichten, bearbeiten Sie die Datei config.json. Ihre SQLite3-Konfiguration könnte folgendermaßen aussehen:

{
  "development": {
    "dialect": "sqlite",
    "storage": "./database/development.sqlite"
  },
  "test": {
    "dialect": "sqlite",
    "storage": ":memory:"
  },
  "production": {
    "dialect": "sqlite",
    "storage": "./database/production.sqlite"
  }
}

{
  "development": {
    "dialect": "sqlite",
    "storage": "./database/development.sqlite"
  },
  "test": {
    "dialect": "sqlite",
    "storage": ":memory:"
  },
  "production": {
    "dialect": "sqlite",
    "storage": "./database/production.sqlite"
  }
}

"development":
  If True Then
	"dialect": "sqlite", "storage": "./database/development.sqlite"
  End If
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
' , "test":
'  {
'	"dialect": "sqlite", "storage": ":memory:"
'  }
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
' , "production":
'  {
'	"dialect": "sqlite", "storage": "./database/production.sqlite"
'  }

VB C#

In dieser Konfiguration werden verschiedene SQLite-Datenbanken für die Test-, Produktions- und Entwicklungsumgebungen festgelegt.

Modelle erstellen

Verwenden Sie die CLI, um eine Datei für Sequelize-Modelle zu erstellen. Zum Beispiel, um ein Benutzermodell zu entwickeln:

npx sequelize-cli model:generate --name User --attributes firstName:string,lastName:string,email:string

npx sequelize-cli model:generate --name User --attributes firstName:string,lastName:string,email:string

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'npx sequelize-cli model:generate --name User --attributes firstName:string,lastName:string,email:string

VB C#

Dieser Befehl erstellt eine Migrationsdatei im Migrationsverzeichnis und eine Modelldatei. (user.js) im Verzeichnis "models".

Migrationen ausführen

Um Tabellen in der SQLite-Datenbank zu erstellen, führen Sie Migrationen durch.

npx sequelize-cli db:migrate

npx sequelize-cli db:migrate

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'npx sequelize-cli db:migrate

VB C#

Verwenden Sie Sequelize in der Anwendung

Sie können jetzt in Ihrer Node.js-Anwendung mit der SQLite-Datenbank über Sequelize interagieren. Hier ist ein Beispiel, wie Sie Sequelize einrichten und verwenden:

// Import Sequelize and model definitions
const { Sequelize, DataTypes } = require('sequelize');
const UserModel = require('./models/user');
// Create Sequelize instance
const sequelize = new Sequelize({
  dialect: 'sqlite',
  storage: './database/development.sqlite', // Path to SQLite database file
});
// Define models
const User = UserModel(sequelize, DataTypes);
// Synchronize models with the database
sequelize.sync({ force: true }) // Set force to true to drop existing tables
  .then(() => {
    console.log('Database synchronized');
  })
  .catch((error) => {
    console.error('Error synchronizing database:', error);
  });
// Example usage
(async () => {
  try {
    // Create a new user
    const user = await User.create({
      firstName: 'John',
      lastName: 'Doe',
      email: 'john@example.com',
    });
    console.log('User created:', user.toJSON());
    // Retrieve all users
    const users = await User.findAll();
    console.log('All users:', users.map((user) => user.toJSON()));
  } catch (error) {
    console.error('Error:', error);
  }
})();

// Import Sequelize and model definitions
const { Sequelize, DataTypes } = require('sequelize');
const UserModel = require('./models/user');
// Create Sequelize instance
const sequelize = new Sequelize({
  dialect: 'sqlite',
  storage: './database/development.sqlite', // Path to SQLite database file
});
// Define models
const User = UserModel(sequelize, DataTypes);
// Synchronize models with the database
sequelize.sync({ force: true }) // Set force to true to drop existing tables
  .then(() => {
    console.log('Database synchronized');
  })
  .catch((error) => {
    console.error('Error synchronizing database:', error);
  });
// Example usage
(async () => {
  try {
    // Create a new user
    const user = await User.create({
      firstName: 'John',
      lastName: 'Doe',
      email: 'john@example.com',
    });
    console.log('User created:', user.toJSON());
    // Retrieve all users
    const users = await User.findAll();
    console.log('All users:', users.map((user) => user.toJSON()));
  } catch (error) {
    console.error('Error:', error);
  }
})();

' Import Sequelize and model definitions
'INSTANT VB TODO TASK: The following line could not be converted:
const
	Private Sequelize, DataTypes } = require( 'sequelize');
Private const UserModel = require( './models/user');
' Create Sequelize instance
Private const sequelize = New Sequelize({ dialect: 'sqlite', storage: './database/development.sqlite'});
' Define models
Private const User = UserModel(sequelize, DataTypes)
' Synchronize models with the database
'INSTANT VB WARNING: The following constructor is declared outside of its associated class:
'ORIGINAL LINE: sequelize.sync({ force: true }).then(() =>
sequelize.s Sub New()
	console.log( 'Database synchronized');
End Sub
Private ).catch(([error]) =>
	console.error( '@Error synchronizing database:', @error);
)
' Example usage
'INSTANT VB TODO TASK: Lambda expressions and anonymous methods are not converted by Instant VB if local variables of the outer method are referenced within the anonymous method:
(async () =>
If True Then
	Try
		const user = Await User.create({ firstName: 'John', lastName: 'Doe', email: 'john@example.com'});
		console.log( 'User created:', user.toJSON());
		const users = Await User.findAll()
		console.log( 'All users:', users.map((user) => user.toJSON()));
	Catch e1 As [error]
		console.error( '@Error:', @error);
	End Try
End If
)()

VB C#

Dieser Code zeigt, wie man Modelle erstellt, sie mit der Datenbank synchronisiert, Sequelize mit SQLite3 konfiguriert und grundlegende Datenbankoperationen durchführt.

Sequelize Node.js (Wie es für Entwickler funktioniert): Abbildung 2 - Ausgabe der Sequelize-Anwendung

Erste Schritte

Um loszulegen, erstellen wir eine Beispielanwendung, die IronPDF und Sequelize Node.js JS verwendet, um ein PDF-Dokument mit dynamisch generierten Benutzer- oder Studentendaten zu erstellen. Dies ist ein umfassendes Schritt-für-Schritt-Anleitungsbuch.

Was ist IronPDF?

IronPDF ist ein Satz von Anwendungsbibliotheken, die entwickelt wurden, um die Erstellung, Bearbeitung und Verwaltung von PDF-Dateien zu vereinfachen. Mit diesem Tool können Entwickler Text und Bilder aus HTML-Dokumenten extrahieren, Kopfzeilen und Wasserzeichen hinzufügen, zahlreiche PDF-Dokumente zusammenführen und eine Vielzahl weiterer Aufgaben erledigen. Die umfassende Dokumentation von IronPDF und die intuitive API machen es Entwicklern einfach, automatisch hochwertige PDF-Dokumente zu erstellen. IronPDF umfasst alle Funktionen und Merkmale, die erforderlich sind, um Dokumenten-Workflows zu verbessern und erstklassige Benutzererfahrungen in verschiedenen Szenarien zu bieten, wie zum Beispiel beim Erstellen von Dokumentationen, Berichten und Rechnungen.

Sequelize Node.js (Wie es für Entwickler funktioniert): Abbildung 3 - IronPDF

Merkmale von IronPDF

HTML-zu-PDF-Konvertierung ist eine schnelle und einfache Methode, die jede Art von HTML-Text, einschließlich CSS und JavaScript, verarbeiten kann.

PDF-Dateien zusammenführen: Um Dokumentenverwaltungsaufgaben zu erleichtern, kombinieren Sie mehrere PDF-Dokumente zu einer einzelnen PDF-Datei.

Text- und Bilderextraktion: Entnehmen Sie Text und Bilder aus PDF-Dateien, um sie für zusätzliche Datenverarbeitung oder Analyse zu verwenden.

Wasserzeichen: Aus Sicherheits- oder Markenbildungsgründen können Sie Text- oder Bildwasserzeichen zu PDF-Seiten hinzufügen.

Kopf- und Fußzeile einfügen: Die Kopf- und Fußzeilen von PDF-Dokumenten ermöglichen es Ihnen, eine benutzerdefinierte Nachricht oder Seitennummern einzufügen.

IronPDF installieren

Um die IronPDF-Funktionalität zu aktivieren, installieren Sie die erforderlichen Node.js-Pakete mithilfe des Node-Package-Managers.

npm install @ironsoftware/ironpdf

npm install @ironsoftware/ironpdf

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'npm install @ironsoftware/ironpdf

VB C#

Sequelize-Objekt mit IronPDF Node.js integrieren

Die Integration von Sequelize mit IronPDF in einer Node.js-Anwendung ermöglicht es Ihnen, PDF-Dokumente basierend auf Daten zu erzeugen, die aus einer Datenbank stammen. Hier ist ein Beispiel für einen Code, der zeigt, wie dies erreicht werden kann.

const { Sequelize, DataTypes } = require('sequelize');
const IronPdf = require("@ironsoftware/ironpdf");
const document=IronPdf.PdfDocument;
var config=IronPdf.IronPdfGlobalConfig
// 1. Initialize Sequelize
const sequelize = new Sequelize({
  dialect: 'sqlite',
  storage: './database/data.sqlite', // Path to SQLite database file
});
// 2. Define Model
const User = sequelize.define('User', {
  firstName: {
    type: DataTypes.STRING,
    allowNull: false,
  },
  lastName: {
    type: DataTypes.STRING,
    allowNull: false,
  },
  email: {
    type: DataTypes.STRING,
    allowNull: false,
    unique: true,
    validate: {
      isEmail: true,
    },
  },
});
// 3. Synchronize Model with Database
sequelize.sync({ force: true }) // Set force to true to drop existing tables
  .then(() => {
    console.log('Database synchronized');
    // 4. Seed Database (optional)
    return User.bulkCreate([
      { firstName: 'John', lastName: 'Doe', email: 'john@example.com' },
      { firstName: 'Jane', lastName: 'Smith', email: 'jane@example.com' },
    ]);
  })
  .then(() => {
    // 5. Query Database and Generate PDF
    return User.findAll();
  })
  .then((users) => {
    // Create HTML content for PDF
    const htmlContent = `
      <html>
        <head>
          <title>User List</title>
        </head>
        <body>
          <h1>User List</h1>
          <ul>
            ${users.map((user) => `<li>${user.firstName} ${user.lastName} - ${user.email}</li>`).join('')}
          </ul>
        </body>
      </html>
    `;
    // Create PDF
    document.fromHtml(htmlContent).then((pdf) => {
      // Save PDF to file
      pdf.saveAs('user-list.pdf');
      console.log('PDF generated successfully');
    }).catch((error) => {
      console.error('Error generating PDF:', error);
    });
  })
  .catch((error) => {
    console.error('Error:', error);
  });

const { Sequelize, DataTypes } = require('sequelize');
const IronPdf = require("@ironsoftware/ironpdf");
const document=IronPdf.PdfDocument;
var config=IronPdf.IronPdfGlobalConfig
// 1. Initialize Sequelize
const sequelize = new Sequelize({
  dialect: 'sqlite',
  storage: './database/data.sqlite', // Path to SQLite database file
});
// 2. Define Model
const User = sequelize.define('User', {
  firstName: {
    type: DataTypes.STRING,
    allowNull: false,
  },
  lastName: {
    type: DataTypes.STRING,
    allowNull: false,
  },
  email: {
    type: DataTypes.STRING,
    allowNull: false,
    unique: true,
    validate: {
      isEmail: true,
    },
  },
});
// 3. Synchronize Model with Database
sequelize.sync({ force: true }) // Set force to true to drop existing tables
  .then(() => {
    console.log('Database synchronized');
    // 4. Seed Database (optional)
    return User.bulkCreate([
      { firstName: 'John', lastName: 'Doe', email: 'john@example.com' },
      { firstName: 'Jane', lastName: 'Smith', email: 'jane@example.com' },
    ]);
  })
  .then(() => {
    // 5. Query Database and Generate PDF
    return User.findAll();
  })
  .then((users) => {
    // Create HTML content for PDF
    const htmlContent = `
      <html>
        <head>
          <title>User List</title>
        </head>
        <body>
          <h1>User List</h1>
          <ul>
            ${users.map((user) => `<li>${user.firstName} ${user.lastName} - ${user.email}</li>`).join('')}
          </ul>
        </body>
      </html>
    `;
    // Create PDF
    document.fromHtml(htmlContent).then((pdf) => {
      // Save PDF to file
      pdf.saveAs('user-list.pdf');
      console.log('PDF generated successfully');
    }).catch((error) => {
      console.error('Error generating PDF:', error);
    });
  })
  .catch((error) => {
    console.error('Error:', error);
  });

'INSTANT VB TODO TASK: The following line could not be converted:
const
If True Then
	Sequelize, DataTypes } = require( 'sequelize');
const IronPdf = require("@ironsoftware/ironpdf")
const document=IronPdf.PdfDocument
'INSTANT VB WARNING: An assignment within expression was extracted from the following statement:
'ORIGINAL LINE: var config=IronPdf.IronPdfGlobalConfig const sequelize = new Sequelize({ dialect:
IronPdf.IronPdfGlobalConfig Const sequelize = New Sequelize({ dialect: 'sqlite', storage: './database/data.sqlite'});
Dim config As Dim=IronPdf.IronPdfGlobalConfig Const sequelize
' 2. Define Model
const User = sequelize.define( 'User', { firstName: { type: DataTypes.@STRING, allowNull: False}, lastName: { type: DataTypes.@STRING, allowNull: False}, email: { type: DataTypes.@STRING, allowNull: False, unique: True, validate: { isEmail: True}}});
' 3. Synchronize Model with Database
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'sequelize.sync({ force: True }).@then(() =>
'{
'	console.log('Database synchronized');
'	Return User.bulkCreate([{ firstName: 'John', lastName: 'Doe', email: 'john@example.com' }, { firstName: 'Jane', lastName: 'Smith', email: 'jane@example.com' },]);
'}
'INSTANT VB TODO TASK: Lambda expressions and anonymous methods are not converted by Instant VB if local variables of the outer method are referenced within the anonymous method:
).then(() =>
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'	document.fromHtml(htmlContent).@then((pdf) =>
'	{
'		pdf.saveAs('user-list.pdf');
'		console.log('PDF generated successfully');
'	}
'INSTANT VB TODO TASK: Lambda expressions and anonymous methods are not converted by Instant VB if local variables of the outer method are referenced within the anonymous method:
	).catch(([error]) =>

VB C#

Sequelize sollte initialisiert werden, indem eine Instanz erstellt und der Speicherort der SQLite-Datenbankdatei übergeben wird. Erstellen Sie ein User-Modell, indem Sie dessen Eigenschaften firstName, lastName und email definieren.

Modell- und Datenbanksynchronisation: Das Modell mit der Datenbank abgleichen. In diesem Fall werden vorhandene Tabellen gelöscht und mit der Option force: true neu erstellt.

Seed-Datenbank: Sie können bulkCreate verwenden() um optional die Datenbank mit einigen Anfangsdaten zu füllen.

Um Benutzerdaten abzurufen, das Benutzermodell in der Datenbank abfragen und ein PDF generieren. Als Nächstes schreiben Sie HTML-Inhalte, die die Benutzerliste als Beispiel verwenden. Zum Schluss speichern Sie die HTML Inhalt zur Erstellung einer Datei mit IronPDF und deren Ausgabe als PDF-Dokument.

Sequelize Node.js (Wie es für Entwickler funktioniert): Abbildung 4 - PDF-Ausgabe

Schlussfolgerung

Schließlich bietet die Kombination von Sequelize mit IronPDF in einer Node.js-Anwendung eine starke Möglichkeit, PDF-Dokumente spontan zu erstellen, indem Informationen aus einer Datenbank abgerufen werden. Entwickler können sich auf die Anwendungslogik konzentrieren, anstatt sich mit Datenbankkomplikationen zu beschäftigen, dank der ORM-Schicht von Sequelize, die die Komplexität von SQL-Abfragen und -Interaktionen abstrahiert. Dies erleichtert die Datenbankwartung.

Entwickler können mit Sequelize schnell Daten bearbeiten, Datenbankeinträge abfragen und strukturierte Informationen erhalten. Diese Integration eröffnet Möglichkeiten, verschiedene Arten von Berichten, Rechnungen, Abrechnungen und mehr direkt aus den Datenbankdaten zu erstellen, wenn sie mit IronPDF kombiniert wird, wodurch HTML-Informationen in PDF-Dokumente gerendert werden können.

IronPDF kann durch die Integration von IronPDF- und Iron Software-Technologien in Ihren Entwicklungsstack für Unternehmensanwendungen funktionsreiche, hochwertige Softwarelösungen für Kunden und Endnutzer gewährleisten. Diese solide Grundlage wird auch Projekte, Backend-Systeme und Prozessverbesserungen erleichtern. Jede IronSoftware sind für 749 $ erhältlich. Die umfangreiche Dokumentation, die lebendige Online-Entwicklergemeinschaft und die häufigen Upgrades dieser Technologien machen sie zu einer großartigen Wahl für zeitgenössische Softwareentwicklungsprojekte.

< PREVIOUS
NestJS Node.js (Wie es für Entwickler funktioniert)

NÄCHSTES >
hapi node js (Wie es für Entwickler funktioniert)