Electron-Einführung
Electronist ein Open-Source-Framework, dasChromium (Browser-Engine) + Node.js (Server-/Systemfunktionen)in eine Desktop-Anwendungshülle einbettet, sodass Sie mitHTML/CSS/JSplattformübergreifende Desktop-Anwendungen (Windows, macOS, Linux) schreiben können.
Wichtige Punkte:
- Frontend übernimmt die UI (Renderer-Prozess: wie Browser-Tabs).
- Hauptprozess (Main) verwaltet den App-Lebenszyklus, Fenster und native API-Aufrufe.
- Beide durchIPC (Inter-Process Communication)Interaktion.
- Kann letztendlich verpackt werden in
.exe、.app、.debund andere Installationsdateien.
Electron wurde von GitHub entwickelt und gepflegt, ursprünglich erstellt, um den Atom-Editor zu bauen.
Kurz gesagt:Electron = Chromium + Node.js + Native APIs
- Chromium: Bietet eine leistungsstarke Rendering-Engine, die für die Anzeige der UI verantwortlich ist.
- Node.js: Bietet Backend-Funktionen mit Zugriff auf das Dateisystem, das Netzwerk usw.
- Native APIs: Bietet Funktionen auf Betriebssystemebene wie Menüs, Benachrichtigungen, Tray usw.

Warum Electron wählen
Electron ermöglicht Webentwicklern, Desktop-Apps zu erstellen, ohne eine neue Sprache lernen zu müssen, was die Hürde für die Desktop-Entwicklung erheblich senkt.
- Leicht zu erlernen: Webentwickler können eine Vielzahl von Frontend-Fähigkeiten/-Komponenten/-Ökosystemen wiederverwenden (React/Vue/Angular/TS/CSS).
- Plattformübergreifend: Einmal schreiben, für drei Plattformen bauen (obwohl Systemunterschiede Anpassungen erfordern).
- Leistungsstarke lokale Funktionen: Direkter Zugriff auf das Dateisystem, Prozesse und System-APIs, ohne native Sprachbindungen schreiben zu müssen (Node.js reicht für die überwiegende Mehrheit der Szenarien aus).
- Ausgereiftes Ökosystem: Eine Fülle fertiger Bibliotheken, Vorlagen und Paketierungswerkzeuge (Electron Builder / Forge usw.).
- Geeignet für Werkzeuganwendungen: Editoren, Kommunikationswerkzeuge, Produktivitätssoftware, Debugging-Werkzeuge usw.
Die Designphilosophie von Electron lautet "Write Once, Run Everywhere."
Entwickler müssen nur eine Codebasis schreiben, um Anwendungen für Windows, macOS und Linux zu generieren.
Kernvorteile:
- Desktop-Apps mit vertrauten Web-Technologie-Stacks entwickeln.
- Kein Erlernen plattformspezifischer Sprachen erforderlich (wie C++, Objective-C, Swift).
- Einheitliche Entwicklungserfahrung und Codebasis.
- Schnelle Iteration und Bereitstellung.
Anwendungsszenarien
Electron eignet sich für die folgenden Arten der Desktop-Anwendungsentwicklung:
- Entwicklungstools / Editoren: Code-Editoren, Terminals, Debugger (z. B. VS Code, Postman).
- Instant Messaging/Soziale Netzwerke: Chat-Clients (z. B. Discord, Slack).
- Plattformübergreifender Desktop-Client: Wenn Sie ein Webprodukt schnell in eine Desktop-Version umwandeln müssen.
- Prototypen und interne Tools: Interne Unternehmensbetriebstools, Daten-Dashboards, Admin-Konsolen.
- Apps mit hohen UI-/Interaktionsanforderungen, aber ohne extreme Performance-Empfindlichkeit.。
Ungeeignete Szenarien: Projekte, die äußerst empfindlich auf CPU/GPU/Speicher reagieren, eine optimale native Erfahrung erfordern oder Mobile-First sind (z. B. umfangreiches Grafik-Rendering, Spiele mit extrem niedriger Latenz).
Was Electron leisten kann
Electron bietet umfangreiche Desktop-Funktionen. Hier sind die wichtigsten Funktionen, die es unterstützt:
- Fenster, Menüs, System-Tray, Benachrichtigungen (Systembenachrichtigungen) öffnen.
- Dateien lesen/schreiben, mit lokalen Datenbanken arbeiten (SQLite, LevelDB usw.).
- Lokale Befehle/Binärdateien aufrufen, Kindprozesse starten.
- Native Dialoge (Dateien öffnen/speichern), Zwischenablage, Drag-and-Drop, globale Tastenkürzel verwenden.
- Auto-Update, Hot Reload, Paketierung und Verteilung implementieren.
- Lokale oder entfernte Webseiten laden, mit Unterstützung moderner Webtechnologien (WebGL, WebRTC usw.).
- Native Module integrieren (C++/Node Native Addons), zur Anbindung an Hardware- oder Systemfunktionen.
Kernkonzepte (technische Grundlagen)
Das Verständnis der folgenden Kernkonzepte ist der Schlüssel zur Beherrschung der Electron-Entwicklung:
- HauptprozessHauptprozess: Einstiegspunkt von Electron, verantwortlich für das Erstellen von BrowserWindow, die Verwaltung des Anwendungslebenszyklus und nativer APIs. Läuft als Einzelinstanz (Node.js verfügbar).
- Renderer-ProzessRenderer-Prozess: Jedes BrowserWindow entspricht einem Renderer, der Webseiten (Chromium) ausführt und nicht direkt auf Node zugreift (eingeschränkte APIs können über preload bereitgestellt werden).
- Preload-Skript & contextIsolationPreload: Es wird empfohlen, preload zu verwenden, um eingeschränkte APIs in den Renderer zu injizieren, und contextIsolation zu aktivieren, um die Sicherheit zu erhöhen.
- IPC (ipcMain / ipcRenderer / contextBridge)IPC: Kommunikationsmechanismus zwischen dem Haupt- und dem Renderer-Prozess.
- Packaging-Tool: Electron Builder / Electron Forge / electron-packager usw., verwendet zur Erstellung von Installationspaketen und automatischen Updates.
- Auto-Updater: Implementiert automatische App-Updates (erfordert Server-/Publish-Konfiguration).
Sicherheitsüberlegungen
Electron vereint Browser- und Node.js-Fähigkeiten, daher ist die Sicherheitskonfiguration entscheidend.
Niemals direkt im Renderer aktivieren
nodeIntegration: true, was standardmäßig deaktiviert ist, um zu verhindern, dass XSS zur Ausführung beliebiger Systembefehle führt.
- VerwendungcontextIsolation + preload + contextBridgeMinimale, kontrollierte APIs bereitstellen.
- Externe Inhalte (Remote-URLs) strikt validieren / sandboxen.
- Eingaben wie Dateipfade und Shell-Befehle strikt validieren, um Command Injection zu vermeiden.
- Verwenden Sie CSP, wann immer möglich, deaktivieren Sie eval und vermeiden Sie nicht vertrauenswürdige Skripte von Drittanbietern.
Vorteile und Einschränkungen von Electron
Dieser Abschnitt bietet eine umfassende Analyse von Electron sowohl hinsichtlich der Vorteile als auch der Einschränkungen und hilft Ihnen, eine sinnvolle Technologieentscheidung zu treffen.
Hauptvorteile
Im Folgenden sind die Kernstärken von Electron im Vergleich zu anderen Ansätzen der Desktop-Entwicklung aufgeführt:
1. Komfort der plattformübergreifenden Entwicklung
Mit Electron können Entwickler dieselbe Codebasis verwenden, um Apps für Windows, macOS und Linux zu erstellen:
Beispiel
// Derselbe Code kann auf drei Plattformen ausgeführt werden
const { app, BrowserWindow } = require('electron');
// Funktion zum Erstellen des Hauptfensters
function createWindow() {
const win = new BrowserWindow({
width: 800, // Fensterbreite (Pixel)
height: 600 // Fensterhöhe (Pixel)
});
// Lokale HTML-Datei laden
win.loadFile('index.html');
}
// Fenster erstellen, nachdem die App bereit ist
app.whenReady().then(createWindow);
Kosteneinsparungen:
- Kein Bedarf, drei Codebasen zu pflegen.
- Teams müssen nicht Technologien zur Entwicklung mehrerer Plattformen beherrschen.
- Einheitliche Test- und Bereitstellungsprozesse.
- Schnellere Feature-Iteration.
2. Vorteile des Web-Technologie-Stacks
- Reichhaltiges Ökosystem: Millionen von Paketen auf npm verfügbar.
- Ausgereiftes Framework: Moderne Frontend-Frameworks wie React, Vue, Angular können verwendet werden.
- Hohe Entwicklungseffizienz: Hot Reload, DevTools, umfangreiche Debugging-Tools.
- Reichlicher Talentpool: Riesiger Pool an Web-Entwicklern, einfach einzustellen.
- Schnelle Prototyping-Entwicklung: Vorhandene Web-Komponenten und -Bibliotheken nutzen.
3. Unterstützung leistungsstarker Funktionen
- Vollständige Node.js-Funktionen (Dateisystem, Netzwerk, Prozesse usw.).
- Native Desktop-Funktionen (Menüs, Benachrichtigungen, System-Tray usw.).
- Automatischer Aktualisierungsmechanismus.
- Hardware-Zugriff (Kamera, USB-Geräte usw.).
- Offline-Arbeitsfähigkeit.
4. Aktive Community und Ökosystem
- Umfassende offizielle Dokumentation.
- Eine große Anzahl von Open-Source-Projekten, die als Referenz verfügbar sind.
- Umfangreiche Tools und Bibliotheken von Drittanbietern.
- Aktive Community-Unterstützung.
Hauptbeschränkungen
Das Verständnis der Einschränkungen von Electron hilft festzustellen, ob es für Ihr Projekt geeignet ist:
1. Performance-Overhead
Electron-Anwendungen müssen Chromium und Node.js gleichzeitig ausführen, was zusätzlichen Performance-Overhead mit sich bringt:
- Speicherverbrauch: Eine leere Electron-Anwendung verbraucht typischerweise 50-100MB Speicher.
- CPU-Auslastung: Rendering-Engine und JavaScript-Ausführung sind im Vergleich zu nativen Apps weniger effizient.
- Startzeit: Längere Startzeit im Vergleich zu nativen Apps.
Vergleich zwischen nativen Apps und Electron-Apps:
| Vergleichsdimension | Native Anwendung | Electron-Anwendung |
|---|---|---|
| Speicherverbrauch | 10-30MB | 80-200MB |
| Startzeit | < 1 second | 2-5 Sekunden |
2. Große Installationspaketgröße
Jede Electron-Anwendung muss die vollständige Chromium- und Node.js-Laufzeitumgebung bündeln:
- Windows: ~50-70MB (unkomprimiert).
- macOS: ~60-80MB (unkomprimiert).
- Linux: ~55-75MB (unkomprimiert).
Das bedeutet, dass selbst einfache Apps keinen Installer haben, der kleiner als 50MB ist.
3. Sicherheitsüberlegungen
Da Electron sowohl Browser- als auch Node.js-Funktionen besitzt, kann eine Fehlkonfiguration Sicherheitsrisiken erzeugen:
- XSS-Angriffe könnten dazu führen, dass Rechte auf Systemebene ausgenutzt werden.
- Kontextisolierung und Sandboxing müssen sorgfältig konfiguriert werden.
- Sicherheitsprobleme bei Drittanbieter-Abhängigkeiten.
4. Unterschiede im nativen Erlebnis
Obwohl native erscheinende Benutzeroberflächen simuliert werden können, bleiben in einigen Bereichen Unterschiede bestehen:
- Systemeigene Steuerelemente können nicht perfekt simuliert werden.
- Einige Funktionen auf Systemebene sind schwierig zu implementieren.
- Plattformspezifische Interaktionskonventionen erfordern zusätzlichen Aufwand.
Empfehlung zur Abwägung
Die folgende Tabelle hilft Ihnen zu entscheiden, ob Electron für Ihre Projektanforderungen geeignet ist:
| Faktor | Gewicht | Beschreibung |
|---|---|---|
| Entwicklungseffizienz | Hoch | Electron ist am effizientesten, wenn das Team Web-Erfahrung hat. |
| Plattformübergreifende Anforderungen | Hoch | Wenn Unterstützung für mehrere Plattformen benötigt wird, ist Electron eine erstklassige Wahl. |
| Plattformanforderungen | Mittel | Für allgemeine Apps akzeptabel, außer in dieser Hinsicht. |
| Empfindlichkeit gegenüber Paketgröße | Mittel | 50-100MB sind in modernen Netzwerkumgebungen akzeptabel. |
| Sicherheitsanforderungen | Hoch | Sicherheits-Best-Practices müssen strikt eingehalten werden |
Vergleich mit anderen ähnlichen Tools
Electron ist nicht die einzige Option. Hier ist ein Vergleich der gängigen Ansätze für die Desktop-Entwicklung:
Wenn Sie ein Frontend-/Full-Stack-Entwickler sind undWebprodukte oder -tools schnell auf den Desktop bringen müssen, während Sie direkt Systemfunktionen nutzen., ist Electron eine äußerst produktive Wahl mit niedriger Einstiegshürde.
Wenn Sie jedoch strenge Anforderungen an Größe, Speicher oder ein ultimatives natives Erlebnis haben, sollten Sie Tauri, Flutter oder native Frameworks als Alternativen in Betracht ziehen.
-
Tauri
- Kern: Rust + systemeigene WebView (WebView2 / WebKit).
- Vorteile: geringe Größe, niedrige Speichernutzung, gute Sicherheit, geeignet für Apps, die auf Leichtigkeit und Leistung ausgerichtet sind.
- Geeignet für: Desktop-Apps, die Webtechnologien nutzen möchten, aber extrem kleine Größe benötigen oder leistungssensibel sind.
- Vergleich: Wenn Sie das Node.js-Ökosystem schnell wiederverwenden möchten, ist Electron bequemer; wenn Ihnen geringe Größe wichtig ist, wählen Sie Tauri.
-
NW.js
- Ähnlicher Ursprung wie Electron (ebenfalls Chromium + Node), aber mit einem anderen API-Stil.
- Die Community und die Tools von Electron sind aktiver.
-
Neutralino
- Extrem leichtgewichtig, verwendet die System-WebView und bietet weniger Funktionen als Electron.
- Besser geeignet für einfache Tools oder kleine Desktop-Apps.
-
Flutter Desktop
- Mit Dart/Flutter gerendert, mit guter nativer Performance und hoher UI-Konsistenz.
- Geeignet für Projekte, die eine einheitliche plattformübergreifende UI/Performance benötigen, erfordert jedoch das Neuerlernen des UI-Frameworks (nicht Webtechnologie).
-
React Native for Windows/Mac / .NET MAUI / Qt
- Ein nativerer Weg der Desktop-Entwicklung, geeignet für Projekte mit hohen Anforderungen an Systemintegration, Performance und native Nutzererfahrung.
Auswahlvorschläge:
- Möchten Sie schnell ein Web-Produkt in eine Desktop-App verwandeln, oder ist das Team hauptsächlich Web-Frontend →Electron。
- Wenn Sie eine kleinere Größe / einen geringeren Ressourcenverbrauch wünschen →Tauri/Neutralino。
- Wenn Sie native UI & hohe Leistung anstreben →Flutter/Native/Qt。
Häufige Leistungs- und Größenprobleme
Hier sind einige praktische Tipps zur Optimierung der Leistung und Größe von Electron-Apps:
- Beim Packen aktivierenasarKann Ressourcen zusammenführen (Kompatibilität mit nativen Modulen beachten).
- Lazy Loading verwenden, initiale Rendering-Ressourcen reduzieren und schwere Ressourcen, die vom Hauptfenster geladen werden, minimieren.
- Vermeiden Sie schwere CPU-intensive Aufgaben im Renderer; verwenden SieChild-Prozess / Worker / natives Modul。
- VerwendungEinzelinstanz, und passen Sie das Aktivieren/Deaktivieren der Hardwarebeschleunigung je nach Situation an.
- Abhängigkeiten optimieren: unnötige npm-Pakete reduzieren, riesige Frontend-Bibliotheken vermeiden (oder On-Demand-Laden verwenden).
Schnellstart-Beispiele
Lernen Sie die Grundstruktur von Electron schnell anhand eines minimalen Projekts kennen.
Projektdateistruktur:
my-electron-app/ ├─ package.json # 项目配置与依赖 ├─ main.js # 主进程入口 ├─ preload.js # 预加载脚本(安全暴露 API) └─ index.html # 渲染进程界面
package.json(Minimale Konfiguration):
Beispiel
"name": "my-electron-app",
"version": "0.1.0",
"main": "main.js", // Hauptprozess-Einstiegsdatei angeben
"scripts": {
"start": "electron ." // npm start startet die Anwendung
},
"devDependencies": {
"electron": "latest" // Electron als Entwicklungsabhängigkeit
}
}
main.js(Hauptprozess):
Beispiel
const { app, BrowserWindow } = require('electron');
const path = require('path');
// Hauptfenster erstellen
function createWindow() {
const win = new BrowserWindow({
width: 900,
height: 600,
webPreferences: {
preload: path.join(__dirname, 'preload.js'), // Pfad zum Preload-Skript
contextIsolation: true, // Kontextisolierung aktivieren (empfohlen)
nodeIntegration: false // Node-Integration deaktivieren, um die Sicherheit zu verbessern
}
});
win.loadFile('index.html');
}
// Fenster erstellen, nachdem die App bereit ist
app.whenReady().then(createWindow);
// macOS: Wenn alle Fenster geschlossen sind, die Anwendung nicht beenden (gemäß den macOS-Konventionen).
app.on('window-all-closed', () => {
if (process.platform !== 'darwin') app.quit();
});
preload.js(Kontrollierte API-Offenlegung):
Beispiel
const { contextBridge, ipcRenderer } = require('electron');
// Eine sichere API über contextBridge für den Renderer-Prozess bereitstellen.
// Der Renderer-Prozess kann über window.electronAPI darauf zugreifen
contextBridge.exposeInMainWorld('electronAPI', {
// Nachricht an den Hauptprozess senden (nur auf der Whitelist stehende Kanäle erlaubt)
send: (channel, data) => {
const validChannels = ['ping']; // Whitelist: erlaubte Kanäle
if (validChannels.includes(channel)) {
ipcRenderer.send(channel, data);
}
},
// Nachrichten vom Hauptprozess empfangen (nur auf der Whitelist stehende Kanäle erlaubt)
on: (channel, func) => {
const validChannels = ['pong']; // Whitelist: erlaubte Kanäle
if (validChannels.includes(channel)) {
// Ereignisparameter entfernen, nur Geschäftsdaten an den Callback übergeben
ipcRenderer.on(channel, (event, ...args) => func(...args));
}
}
});
index.html(Renderer-Prozess-Schnittstelle):
Beispiel
<html>
<body>
<h1>Hallo Electron</h1>
<button id="ping">Hauptprozess anpingen</button>
<script>
// Auf die Schaltfläche klicken, um eine Ping-Nachricht an den Hauptprozess zu senden
document.getElementById('ping').addEventListener('click', () => {
window.electronAPI.send('ping', { time: Date.now() });
});
// Auf die Pong-Nachricht hören, die vom Hauptprozess zurückgesendet wird
window.electronAPI.on('pong', (msg) => alert('Pong empfangen: ' + JSON.stringify(msg)));
</script>
</body>
</html>
Auf IPC im Hauptprozess lauschen (zu main.js hinzufügen):
Beispiel
const { ipcMain } = require('electron');
// Auf Ping-Nachrichten vom Renderer-Prozess lauschen, mit Pong antworten
ipcMain.on('ping', (event, data) => {
console.log('Ping empfangen, Daten:', data);
event.sender.send('pong', { reply: 'ok', received: data });
});
Ausführen:
# 安装依赖 npm install # 启动应用 npm start
Paketierung und Verteilung
Nach der Entwicklung benötigen Sie ein Paketierungstool, um die App an Benutzer zu verteilen.
Vergleich gängiger Paketierungstools:
| Werkzeuge | Funktionen | Anwendbare Szenarien |
|---|---|---|
| Electron Builder | Leistungsstark, unterstützt Auto-Updates und Multi-Plattform-Installer. | Produktionsprojekte, die eine vollständige Distributionslösung erfordern |
| Electron Forge | Entwicklerfreundlich, mit integrierten Vorlagen und Build-Prozessen | Schnellstart für neue Projekte |
| electron-packager | Erstellt nur Pakete, kein Installationsprogramm. | Einfache Packaging-Anforderungen |
Übliche Packaging-Schritte:
- Konfiguration
package.jsons build-Feld (oder die Konfiguration des jeweiligen Tools verwenden). - Verwenden Sie CI/CD, um für verschiedene Plattformen zu bauen (Windows erfordert Packaging in einer Windows-Umgebung oder die Nutzung eines Cross-Compile-Dienstes).
- Stellen Sie einen Update-Server bereit oder verwenden Sie GitHub Releases + electron-updater.
Praktische Ratschläge und Checkliste für Best Practices
Die folgenden Empfehlungen stammen aus realer Projekterfahrung und können Ihnen helfen, häufige Fallstricke zu vermeiden:
- Zu Beginn: Die Nutzung von TypeScript + Packaging-Gerüst (Forge/Builder) spart künftige Wartungskosten.
- Sicherheit: Erzwungen
contextIsolation: true, minimiere die API, die dem Renderer ausgesetzt wird. - Architektur: Geschäftslogik im Renderer (UI) oder in Backend-Diensten unterbringen und System-/Berechtigungsoperationen über den Hauptprozess kapseln.
- Upgrades: Verwenden Sie electron-updater für automatische Updates, achten Sie jedoch auf Signierungs- und Release-Strategien (macOS erfordert Signierung, und Windows benötigt ebenfalls Codesignierung).
- Tests: Testen Sie auf echten Maschinen über mehrere Plattformen hinweg (insbesondere Dateiberechtigungen, Pfade, Umgebungsvariablen).
- Ressourcen: Überprüfen Sie regelmäßig Chromium- und Electron-Versionen und achten Sie auf Sicherheitspatches (Chromium-Sicherheitslücken können Ihre Anwendung beeinträchtigen).
Wann Electron nicht verwendet werden sollte
Die folgenden Szenarien sind für Electron nicht zu empfehlen:
- Sie benötigen extrem geringen Speicherverbrauch oder einen sehr kleinen Installer (z. B. eingebettete Geräte oder minimalistische Tools).
- Sie benötigen eine erstklassige native UI und native Leistung (z. B. AAA-Spiele oder komplexes CAD).
- Wenn das Team mit Webtechnologien nicht vertraut ist, aber mit nativer Entwicklung vertraut ist, könnte ein natives Framework besser geeignet sein.
Empfohlene Lernpfade und Ressourcen
Wenn Sie die folgende Roadmap Schritt für Schritt befolgen, können Sie die Electron-Entwicklung systematisch meistern:
- Lernen Sie die Grundlagen von Node.js und Frontend (HTML/CSS/JS)/Frameworks (React/Vue).
- Lesen Sie die offizielle Electron-Dokumentation (Main/Renderer/Preload/IPC/Security Guide).
- Erstellen Sie ein minimales Beispiel (das obige Beispiel) und experimentieren Sie mit IPC, Dateioperationen und Fenstersteuerung.
- Lernen und verwenden Sie Packaging-Tools (Electron Builder / Forge).
- Lesen Sie Tutorials zu Sicherheits-Best-Practices, automatischen Updates und Codesignierung.
- Orientieren Sie sich an ausgereiften Open-Source-Electron-Projekten (z. B. den Quellcodeausschnitten von VS Code), um die Architektur zu lernen.