Creazione di un eseguibile

Per questa demo, useremo pkg strumento a riga di comando. Sei libero di scegliere nexe o un altro di tua scelta, ma io trovo pkg più facile da usare. Prima di tutto, dobbiamo installare pkg globalmente usando il comando npm. Puoi anche installarlo localmente per usare l’interfaccia CLI programmaticamente.

$ npm install --global pkg

Una volta che il pacchetto è installato globalmente, si ottiene il comando pkg per creare gli eseguibili. Il comando pkg ha bisogno di un file di input che è un programma JavaScript di ingresso che verrà eseguito quando l’utente fa doppio clic sul file eseguibile generato. Altre opzioni della linea di comando controllano come viene generato il file eseguibile.

File di ingresso

Il percorso del file di ingresso viene fornito attraverso l’argomento <input> come il comando $ pkg server.js nel nostro caso che è un percorso locale. Ma possiamo anche fornire il percorso a package.json e il comando pkg userà la proprietà bin del package.json per individuare il percorso del file JavaScript di entrata. Se viene fornito il percorso di una directory, allora il comando pkg cerca il file package.json di quella directory utilizzando la sua proprietà bin.

Assets

Assets sono risorse statiche come i file .html, .js, .css, .png, .json che dovrebbero essere inclusi nell’eseguibile. Per istruire pkg a includere tali file nell’eseguibile, dobbiamo fornire questi percorsi di file attraverso la proprietà pkg.assets del package.json. Il suo valore è un pattern glob o un array di pattern glob.

💡 In questo caso, il package.json dovrebbe essere il percorso di input in modo che pkg possa scegliere assets che sono necessari per essere inclusi nell’eseguibile.

Quando un eseguibile viene creato, pkg includerà il file JavaScript di input insieme alle risorse statiche in un unico file eseguibile. Qui è dove le cose diventano un po’ complicate. Poiché tutti i file del progetto sono ora impacchettati in un singolo file, i percorsi relativi dei file perdono il loro significato e così anche la struttura delle cartelle.

Ma in fase di esecuzione (quando l’eseguibile è in esecuzione), questi file sono organizzati in un file system virtuale chiamato file system snapshot. Di solito, questi file in fase di esecuzione hanno il prefisso /snapshot/ (o C:\snapshot\ in windows) nel loro percorso come se si trovassero all’interno della directory /snapshot del sistema.

Ma puoi tranquillamente localizzare un file asset nell’eseguibile (in fase di esecuzione) usando il metodo path.join e la variabile __dirname per costruire un percorso relativo come path.join( __dirname, './www/main.js' ). Il percorso funzionerà bene come se aveste un vero percorso di directory in un vero file system. Per saperne di più sul filesystem snapshot, leggi questa documentazione.

💡 Attenzione. Durante il processo di compilazione, pkg guarda le dichiarazioni require() nel codice e include automaticamente questi file come risorse statiche. Pertanto, potrebbe non essere necessario specificare tali file come risorse statiche nel package.json. Tuttavia, ci sono alcune avvertenze come spiegato qui.

Targets

Possiamo generare un file eseguibile per un sistema specifico usando il flag della riga di comando --targets. Il valore di questo flag è una stringa nel formato <node>-<platform>-<arch>. Potrebbe anche essere un elenco separato da virgole di questo modello per puntare a più architetture di sistema. Potresti anche usare il campo pkg.targets del package.json per specificare questi valori.

Il valore node è un target di versione maggiore del nodo. Il valore platform è il nome del sistema operativo di destinazione e potrebbe essere uno di questi freebsd, linux, alpine, macos, win. Il valore arch è l’architettura del processore di destinazione e potrebbe essere uno di questi x64, x86, armv6, armv7.

Potremmo omettere uno di questi valori dalla specifica di destinazione. In questo caso, pkg usa il suo valore dalla configurazione corrente del sistema. Possiamo usare 'host' come valore per il --targets nel qual caso tutti questi valori sono ottenuti dalla configurazione di sistema corrente.

Output

Tenteremo di creare file eseguibili per i sistemi operativi macOS e Windows, specialmente per l’architettura del processore x64. Poiché il nostro punto d’ingresso è server.js, useremo la proprietà bin del package.json per indicare il suo percorso di file. Inoltre, menzioneremo tutti i percorsi dei file all’interno di node_modules e src come risorse statiche poiché il nostro server.js dipende da esso. Considerando tutti questi requisiti, il nostro package.json appare come segue.

Per generare i file eseguibili binari, abbiamo bisogno di eseguire il comando pkg . poiché vogliamo che pkg usi il file package.json dalla directory corrente per individuare il file di input, le risorse e gli obiettivi. Potremmo anche usare il comando pkg package.json che fa la stessa cosa.

Una volta che questo comando viene eseguito, pkg scarica i binari appropriati di Node.js in base ai valori targets e li mette nella cache in una directory specificata dalla variabile d’ambiente PKG_CACHE_PATH in modo che la prossima volta che si incontrano gli stessi obiettivi, pkg possa usare i file binari nella cache.

Una volta scaricati tutti i file binari, pkg genera i file eseguibili nella directory corrente. Il nome e l’estensione di questi file sono decisi da pkg e normalmente assomigliano a <package>-<target>.<ext> dove package è il valore name nel package.json.

Tuttavia, possiamo controllare lo schema dei nomi e la directory di output usando i valori delle opzioni --output o --out-path. Useremo il flag --output per specificare la directory di output e il nome del file eseguibile.

$ pkg --output build/web .

Il comando qui sopra genera i seguenti file nella directory build.

node-js-executable
└── build
├── web-node10-win.exe (37.4mb)
└── web-node12-macos (43.4mb)

Ora puoi fare doppio clic su uno qualsiasi di questi file (secondo la tua macchina) e si aprirà una pagina web nel browser di sistema predefinito visualizzando i driver della formula uno.