Utvikling av Electron-skrivebordsapper · leksjon

Arbeide med native-moduler

Lær hvordan De kan integrere og bruke eksisterende native Node.js-moduler (C/C++) i Electron-applikasjonen Deres for ytelseskritiske oppgaver.

Leksjon 1 av 411 trinn

Arbeide med native-moduler er en gratis leksjon i Utvikling av Electron-skrivebordsapper på CoddyKit. Dette er leksjon 1 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Utvikling av Electron-skrivebordsapper, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Utvikling av Electron-skrivebordsapper inneholder totalt 4 leksjoner.

Hva er native-moduler?

Velkommen! I dag skal vi utforske native-moduler i Electron. Dette er spesielle Node.js-moduler skrevet i C eller C++.

Se på dem som kraftige utvidelser som lar JavaScript-koden din samhandle direkte med operativsystemet på et lavere nivå eller utføre beregninger med høy hastighet.

Hvorfor bruke native-moduler?

Native-moduler brukes til spesifikke, kritiske oppgaver:

Ytelse: For CPU-intensive operasjoner som JavaScript kan ha problemer med å håndtere.
Tilgang til operativsystemet på lavt nivå: Samhandling med maskinvare eller bestemte operativsystemfunksjoner som ikke eksponeres av Node.js eller Electrons standard-API-er.
Eksisterende C/C++-biblioteker: Gjenbruk av etablerte, optimaliserte C/C++-biblioteker direkte i Electron-applikasjonen.

Node.js-tillegg i Electron

Electron bruker Node.js internt. Det betyr at alle native Node.js-tillegg (en C/C++-modul kompilert for Node.js) også kan brukes i Electron-applikasjonen din.

Vanligvis laster du inn disse modulene i hovedprosessen, siden den har full tilgang til Node.js-API-et. Deretter eksponerer du nødvendige funksjoner for renderer-prosessen via IPC eller preload-skript (som vi dekker i senere leksjoner).

Forutsetninger for bygging

For å bygge native moduler trenger De noen verktøy installert på systemet:

Python: Versjon 2.7 (for node-gyp).
C/C++-kompilator: For eksempel Visual Studio (Windows), Xcode Command Line Tools (macOS) eller build-essential (Linux).
node-gyp: Et plattformuavhengig kommandolinjeverktøy skrevet i Node.js for kompilering av native addon-moduler.

Forklaring av `node-gyp`

node-gyp er avgjørende for utvikling av native moduler. Verktøyet tar konfigurasjonsfiler (binding.gyp) og bruker dem til å generere plattformspesifikke bygge filer (for eksempel Makefiles eller Visual Studio-prosjekter).

Dette gjør at C/C++-koden kan kompileres riktig for operativsystemet og Node.js-versjonen Deres, slik at det opprettes en .node-fil som Node.js (og Electron) kan laste inn.

Grunnleggende struktur (konsept)

Et prosjekt med en native modul inneholder vanligvis:

C/C++-kildefiler: Kjernelogikken Deres.
binding.gyp: En konfigurasjonsfil for node-gyp som angir hvordan C/C++-koden Deres skal kompileres.
package.json: Definerer modulen og avhengighetene dens.

Kompileringsprosessen gjør C/C++-koden om til en .node-fil, som i praksis er et delt bibliotek.

Installasjon og kompilering

Når De installerer en npm-pakke som inneholder en native modul, kjører npm automatisk node-gyp rebuild for Dem.

Denne kommandoen kompilerer den native koden for den spesifikke Node.js- og Electron-versjonen Deres og oppretter .node-filen i en katalog som ./build/Release/ eller ./build/Debug/.

Lasting i Electron

Når en native modul er kompilert, kan den lastes inn i Electron-applikasjonen Deres ved hjelp av standardfunksjonen require() i Node.js.

De angir ganske enkelt den kompilerte .node-filen. Dette gjøres vanligvis i hovedprosessen i Electron, eller i et preload-skript for renderer-prosessen hvis De trenger å eksponere funksjonaliteten der på en sikker måte.

Bruke en native modul (JS-eksempel)

Slik kan De bruke en tenkt native modul i JavaScript-koden til Electron-applikasjonen Deres. Vi simulerer funksjonaliteten i dette kjørbare eksempelet.

const path = require('path');

// In a real Electron app, you'd require the compiled .node file.
// Example: const myNativeAddon = require(path.join(__dirname, 'build/Release/myaddon.node'));

// For this runnable example, we'll simulate a native module interface.
const myNativeAddon = {
  greet: (name) => {
    return `Hello from native code, ${name}!`;
  },
  add: (a, b) => {
    console.log('Performing fast native addition...');
    return a + b;
  }
};

console.log("Electron app script running...");

// Use the functions exposed by the 'native' module
const greeting = myNativeAddon.greet("CoddyKit User");
console.log(greeting);

const sum = myNativeAddon.add(15, 25);
console.log(`The sum of 15 and 25 is: ${sum}`);

console.log("Script finished.");

Hurtigsjekk

Hvilket av følgende er IKKE en hovedgrunn til å bruke native moduler i Electron?

Besvar den i den interaktive leksjonen

Oppsummering og neste steg

Godt jobbet! De har lært om native moduler i Node.js i Electron:

De er C/C++-kode kompilert til .node-filer.
De brukes til ytelse, samhandling med operativsystemet og integrasjon med C/C++-biblioteker.
node-gyp er det viktigste verktøyet for kompilering.
De lastes inn ved hjelp av require() i JavaScript.

Deretter skal vi se på hvordan De oppretter Tray-applikasjoner og merker – enda en måte å utnytte native funksjoner på!

Gratis å komme i gang

Lær deg JavaScript med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 12
Leksjoner: 47

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Arbeide med native-moduler» gratis?

Ja – hele teksten i «Arbeide med native-moduler» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Utvikling av Electron-skrivebordsapper-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Utvikling av Electron-skrivebordsapper inneholder totalt 4 leksjoner.

Hva lærer jeg i «Arbeide med native-moduler»?

Lær hvordan De kan integrere og bruke eksisterende native Node.js-moduler (C/C++) i Electron-applikasjonen Deres for ytelseskritiske oppgaver. Du øver på Utvikling av Electron-skrivebordsapper med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Utvikling av Electron-skrivebordsapper?

Ingen tidligere erfaring er nødvendig. Utvikling av Electron-skrivebordsapper på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 1 av 4.

Hvor lang tid tar leksjonen «Arbeide med native-moduler»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Utvikling av Electron-skrivebordsapper-leksjonen?

Ja. Alle Utvikling av Electron-skrivebordsapper-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

← Tilbake til Utvikling av Electron-skrivebordsapper