Comunicación entre procesos (IPC)
Aprenda a implementar canales seguros de comunicación entre los procesos principal y de renderizado mediante los módulos IPC de Electron, como `ipcMain` e `ipcRenderer`.
Comunicación entre procesos (IPC) es una lección gratuita de Electron Desktop App Development en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Electron Desktop App Development, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Electron Desktop App Development incluye 4 lecciones en total.
Partes de esta lección aún no han sido traducidas y se muestran en inglés.
What is IPC in Electron?
In Electron, your application runs across two main types of processes: the Main Process and Renderer Processes.
- The Main Process manages the app's lifecycle and interacts with the operating system.
- Renderer Processes (web pages) display your UI and run your web code.
They can't directly access each other's resources or global variables. This is where Inter-Process Communication (IPC) comes in!
Why IPC is Essential
Imagine your Renderer Process needs to:
- Read a file from the user's computer.
- Open a native dialog box.
- Perform a heavy task without freezing the UI.
These actions require access to Node.js modules or the OS, which are restricted to the Main Process for security and stability. IPC provides a safe way for these processes to talk to each other.
IPC Core Modules: ipcMain & ipcRenderer
Electron provides two special modules for IPC:
ipcMain: Used in the Main Process to listen for and send messages.ipcRenderer: Used in Renderer Processes to send messages to the main process and listen for replies.
These modules are the backbone of communication between your Electron app's different parts.
Renderer to Main: One-Way Send
The most common communication is from a Renderer Process to the Main Process. You can send a message using ipcRenderer.send().
This is useful for triggering native actions or requesting data from the main process without needing an immediate reply in the renderer.
Code: Renderer to Main (Client)
Here's how your renderer.js would send a message when a button is clicked. You'd also need an index.html with a button (<button id="myButton">) that loads this script.
const { ipcRenderer } = require('electron');
document.addEventListener('DOMContentLoaded', () => {
const btn = document.getElementById('myButton');
if (btn) {
btn.addEventListener('click', () => {
ipcRenderer.send('channel-name', 'Hello from Renderer!');
console.log('Renderer sent message.');
});
}
});Code: Renderer to Main (Server)
This is the main.js code. It sets up the Electron window and uses ipcMain.on() to listen for messages on the specified 'channel-name'.
Note: nodeIntegration and contextIsolation are simplified here. For secure apps, use preload scripts.
const { app, BrowserWindow, ipcMain } = require('electron');
const path = require('path');
let mainWindow;
function createWindow() {
mainWindow = new BrowserWindow({
width: 800,
height: 600,
webPreferences: {
nodeIntegration: true, // Simplified for demo
contextIsolation: false // Simplified for demo
}
});
mainWindow.loadFile('index.html');
// Open the DevTools.
// mainWindow.webContents.openDevTools()
}
app.whenReady().then(() => {
createWindow();
app.on('activate', () => {
if (BrowserWindow.getAllWindows().length === 0) {
createWindow();
}
});
});
app.on('window-all-closed', () => {
if (process.platform !== 'darwin') {
app.quit();
}
});
// Handle messages from the renderer process
ipcMain.on('channel-name', (event, message) => {
console.log('Main process received:', message);
// Acknowledge or perform an action
});Main to Renderer: One-Way Send
The Main Process can also send messages to a Renderer Process using mainWindow.webContents.send().
This is useful for pushing updates from the main process (e.g., progress updates, data changes) to the UI without the renderer having to request them.
Code: Main to Renderer (Server)
This main.js will send a message to the renderer once the window has finished loading. This time, the ipcMain isn't listening, but sending!
const { app, BrowserWindow } = require('electron');
const path = require('path');
let mainWindow;
function createWindow() {
mainWindow = new BrowserWindow({
width: 800,
height: 600,
webPreferences: {
nodeIntegration: true,
contextIsolation: false
}
});
mainWindow.loadFile('index.html');
// Send a message to the renderer after the window is ready
mainWindow.webContents.on('did-finish-load', () => {
mainWindow.webContents.send('main-channel', 'Update from Main!');
console.log('Main sent message to renderer.');
});
mainWindow.on('closed', () => {
mainWindow = null;
});
}
app.whenReady().then(() => {
createWindow();
app.on('activate', () => {
if (BrowserWindow.getAllWindows().length === 0) {
createWindow();
}
});
});
app.on('window-all-closed', () => {
if (process.platform !== 'darwin') {
app.quit();
}
});Code: Main to Renderer (Client)
In your renderer.js, you'll use ipcRenderer.on() to listen for messages coming from the main process. We'll display it in a <div id="messageDisplay">.
const { ipcRenderer } = require('electron');
document.addEventListener('DOMContentLoaded', () => {
const messageDiv = document.getElementById('messageDisplay');
if (messageDiv) {
ipcRenderer.on('main-channel', (event, message) => {
messageDiv.innerText = `Received: ${message}`;
console.log('Renderer received:', message);
});
}
});Request/Reply with Invoke & Handle
For more complex interactions where the Renderer needs a response from the Main Process, Electron offers a request/reply pattern.
ipcRenderer.invoke(channel, ...args): Sends a message from renderer and waits for a response.ipcMain.handle(channel, listener): In the main process, sets up a handler function that processes the request and returns a value (or a Promise that resolves to a value).
This allows for more structured and asynchronous communication.
Quick Check: IPC Methods
Which of the following statements about Electron's IPC modules are TRUE?
Recap: Inter-Process Communication
Great job! You've learned the fundamentals of Electron's Inter-Process Communication.
- IPC is vital for Main and Renderer Processes to safely interact.
ipcMainandipcRendererare the core modules.- One-way communication uses
ipcRenderer.send()(Renderer to Main) andwebContents.send()(Main to Renderer). - For request/reply patterns,
ipcRenderer.invoke()andipcMain.handle()provide a robust solution.
You're now ready to build more interactive and powerful Electron applications!
Preguntas frecuentes
¿La lección «Comunicación entre procesos (IPC)» es gratis?
Sí — el texto completo de «Comunicación entre procesos (IPC)» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Electron Desktop App Development, actualiza a CoddyKit PRO. El curso de Electron Desktop App Development incluye 4 lecciones en total.
¿Qué aprenderé en «Comunicación entre procesos (IPC)»?
Aprenda a implementar canales seguros de comunicación entre los procesos principal y de renderizado mediante los módulos IPC de Electron, como `ipcMain` e `ipcRenderer`. Practicas Electron Desktop App Development con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar Electron Desktop App Development?
No se requiere experiencia previa. Electron Desktop App Development en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.
¿Cuánto tiempo toma la lección «Comunicación entre procesos (IPC)»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de Electron Desktop App Development?
Sí. Cada lección de Electron Desktop App Development incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Proceso principal frente a proceso de renderizado
- Comunicación entre procesos (IPC)
- Empaquetado de su aplicación Electron
- Gestión de varias ventanas