Node.js
npm

introduzione

Sintassi

• npm <comando> dove <comando> è uno di:
  • Aggiungi utente
  • Aggiungi utente
  • apihelp
  • autore
  • bidone
  • bug
  • c
  • nascondiglio
  • completamento
  • config
  • DDP
  • deduplicazione
  • disapprovare
  • docs
  • modificare
  • Esplorare
  • FAQ
  • trova
  • trovare-gonzi
  • ottenere
  • Aiuto
  • help-search
  • casa
  • io
  • installare
  • Informazioni
  • dentro
  • istallare
  • problemi
  • la
  • collegamento
  • elenco
  • ll
  • ln
  • accesso
  • ls
  • antiquato
  • proprietario
  • pacco
  • prefisso
  • fesso
  • pubblicare
  • r
  • rb
  • ricostruire
  • rimuovere
  • pronti contro termine
  • ricomincia
  • rm
  • radice
  • eseguire script
  • S
  • SE
  • ricerca
  • impostato
  • mostrare
  • shrinkwrap
  • stella
  • stelle
  • inizio
  • Stop
  • modulo
  • etichetta
  • test
  • tst
  • un
  • disinstallazione
  • scollegare
  • non pubblicato
  • Rimuovi da speciali
  • su
  • aggiornare
  • v
  • versione
  • vista
  • chi sono

Parametri

Installazione dei pacchetti

introduzione

Pacchetto è un termine utilizzato da npm per indicare gli strumenti che gli sviluppatori possono utilizzare per i loro progetti. Questo include tutto, dalle librerie e framework come jQuery e AngularJS ai runner di attività come Gulp.js. I pacchetti arriveranno in una cartella chiamata tipicamente node_modules , che conterrà anche un file package.json . Questo file contiene informazioni su tutti i pacchetti comprese eventuali dipendenze, che sono moduli aggiuntivi necessari per utilizzare un particolare pacchetto.

Npm utilizza la riga di comando per installare e gestire i pacchetti, quindi gli utenti che tentano di utilizzare npm dovrebbero avere familiarità con i comandi di base sul loro sistema operativo, ovvero: attraversare le directory e poter vedere il contenuto delle directory.

Installazione di NPM

Si noti che per installare i pacchetti, è necessario aver installato NPM.

Il modo consigliato per installare NPM è quello di utilizzare uno dei programmi di installazione dalla pagina di download Node.js. Puoi verificare se hai già installato node.js eseguendo il npm -v o npm version .

Dopo aver installato NPM tramite l'installer Node.js, assicurati di verificare la disponibilità di aggiornamenti. Questo perché NPM viene aggiornato più frequentemente rispetto all'installer Node.js. Per verificare la presenza di aggiornamenti, eseguire il seguente comando:

npm install npm@latest -g

Come installare i pacchetti

Per installare uno o più pacchetti, utilizzare quanto segue:

npm install <package-name>
# or
npm i <package-name>...

# e.g. to install lodash and express
npm install lodash express

Nota : questo installerà il pacchetto nella directory in cui si trova attualmente la riga di comando, quindi è importante verificare se è stata scelta la directory appropriata

Se hai già un file package.json nella directory di lavoro corrente e le dipendenze sono definite al suo interno, l' npm install risolverà e installerà automaticamente tutte le dipendenze elencate nel file. Puoi anche usare la versione abbreviata del comando di npm install che è: npm i

Se si desidera installare una versione specifica di un pacchetto, utilizzare:

npm install <name>@<version>

# e.g. to install version 4.11.1 of the package lodash
npm install [email protected]

Se si desidera installare una versione che corrisponde a un intervallo di versione specifico, utilizzare:

npm install <name>@<version range>

# e.g. to install a version which matches "version >= 4.10.1" and "version < 4.11.1"
# of the package lodash
npm install lodash@">=4.10.1 <4.11.1"

Se si desidera installare l'ultima versione, utilizzare:

npm install <name>@latest

I comandi sopra riportati cercheranno i pacchetti nel repository centrale di npm su npmjs.com . Se non stai cercando di installare dal registro di npm , sono supportate altre opzioni, come ad esempio:

# packages distributed as a tarball
npm install <tarball file>
npm install <tarball url>

# packages available locally
npm install <local path>

# packages available as a git repository
npm install <git remote url>

# packages available on GitHub
npm install <username>/<repository>

# packages available as gist (need a package.json)
npm install gist:<gist-id>

# packages from a specific repository
npm install --registry=http://myreg.mycompany.com <package name>

# packages from a related group of packages 
# See npm scope
npm install @<scope>/<name>(@<version>)

# Scoping is useful for separating private packages hosted on private registry from
# public ones by setting registry for specific scope
npm config set @mycompany:registry http://myreg.mycompany.com
npm install @mycompany/<package name>

Di solito, i moduli verranno installati localmente in una cartella denominata node_modules , che può essere trovata nella directory di lavoro corrente. Questa è la directory require() che userà per caricare i moduli al fine di renderli disponibili.

Se hai già creato un file package.json , puoi utilizzare l' --save (abbreviazione -S ) o una delle sue varianti per aggiungere automaticamente il pacchetto installato al tuo package.json come dipendenza. Se qualcun altro installa il pacchetto, npm leggerà automaticamente le dipendenze dal file package.json e installerà le versioni elencate. Nota che puoi ancora aggiungere e gestire le tue dipendenze modificando il file in un secondo momento, quindi di solito è una buona idea tenere traccia delle dipendenze, ad esempio usando:

npm install --save <name> # Install dependencies 
# or
npm install -S <name> # shortcut version --save 
# or
npm i -S <name>

Per installare i pacchetti e salvarli solo se sono necessari per lo sviluppo, non per eseguirli, non se sono necessari per l'esecuzione dell'applicazione, attenersi al seguente comando:

npm install --save-dev <name> # Install dependencies for development purposes
# or
npm install -D <name> # shortcut version --save-dev
# or
npm i -D <name>

Installare le dipendenze

Alcuni moduli non forniscono solo una libreria da utilizzare, ma forniscono anche uno o più binari che devono essere utilizzati tramite la riga di comando. Sebbene sia ancora possibile installare tali pacchetti localmente, è spesso preferibile installarli globalmente in modo da poter abilitare gli strumenti da riga di comando. In tal caso, npm collegherà automaticamente i file binari ai percorsi appropriati (ad esempio /usr/local/bin/<name> ) in modo che possano essere utilizzati dalla riga di comando. Per installare un pacchetto a livello globale, utilizzare:

npm install --global <name>
# or
npm install -g <name>
# or
npm i -g <name>

# e.g. to install the grunt command line tool
npm install -g grunt-cli

Se si desidera visualizzare un elenco di tutti i pacchetti installati e le relative versioni associate nello spazio di lavoro corrente, utilizzare:

npm list
npm list <name>

L'aggiunta di un argomento di nome opzionale può controllare la versione di un pacchetto specifico.

Nota: se si verificano problemi di autorizzazione durante il tentativo di installare un modulo npm a livello globale, resistere alla tentazione di eseguire sudo npm install -g ... per risolvere il problema. La concessione di script di terze parti per l'esecuzione sul sistema con privilegi elevati è pericolosa. Il problema dell'autorizzazione potrebbe significare che hai un problema con il modo in npm è stato installato npm . Se sei interessato a installare il nodo in ambienti utente sandbox, potresti provare a utilizzare nvm .

Se si dispone di strumenti di compilazione o altre dipendenze di solo sviluppo (ad esempio Grunt), è possibile che non si desideri averli in bundle con l'applicazione distribuita. Se questo è il caso, ti consigliamo di avere una dipendenza di sviluppo, che è elencata in package.json sotto devDependencies . Per installare un pacchetto come dipendenza solo per lo sviluppo, usa --save-dev (o -D ).

npm install --save-dev <name> // Install development dependencies which is not included in production 
# or
npm install -D <name>

Vedrai che il pacchetto viene quindi aggiunto alle devDependencies del tuo package.json .

Per installare le dipendenze di un progetto node.js scaricato / clonato, puoi semplicemente usarlo

npm install
# or
npm i

npm legge automaticamente le dipendenze da package.json e le installa.

NPM dietro un server proxy

Se l'accesso a Internet avviene tramite un server proxy, potrebbe essere necessario modificare i comandi di installazione di npm che accedono ai repository remoti. npm utilizza un file di configurazione che può essere aggiornato tramite la riga di comando:

npm config set

Puoi individuare le tue impostazioni proxy dal pannello delle impostazioni del browser. Dopo aver ottenuto le impostazioni del proxy (URL del server, porta, nome utente e password); è necessario configurare le configurazioni di npm come segue.

$ npm config set proxy http://<username>:<password>@<proxy-server-url>:<port>
$ npm config set https-proxy http://<username>:<password>@<proxy-server-url>:<port>

username , password , campi della port sono opzionali. Una volta impostati questi, l' npm install npm i -g , npm i -g ecc. npm i -g correttamente.

Ambiti e depositi

# Set the repository for the scope "myscope"
npm config set @myscope:registry http://registry.corporation.com

# Login at a repository and associate it with the scope "myscope"
npm adduser --registry=http://registry.corporation.com --scope=@myscope

# Install a package "mylib" from the scope "myscope"
npm install @myscope/mylib

Se il nome del proprio pacchetto inizia con @myscope e l'ambito "myscope" è associato a un repository differente, npm publish caricherà il pacchetto su quel repository.

Puoi anche mantenere queste impostazioni in un file .npmrc :

@myscope:registry=http://registry.corporation.com
//registry.corporation.com/:_authToken=xxxxxxxx-xxxx-xxxx-xxxxxxxxxxxxxxx

Questo è utile quando si automatizza la build su un server CI fe

Disinstallazione dei pacchetti

Per disinstallare uno o più pacchetti installati localmente, utilizzare:

npm uninstall <package name>

Il comando di disinstallazione per npm ha cinque alias che possono essere utilizzati anche:

npm remove <package name>
npm rm <package name>
npm r <package name>

npm unlink <package name>
npm un <package name>

Se si desidera rimuovere il pacchetto dal file package.json come parte della disinstallazione, utilizzare il flag --save (abbreviazione: -S ):

npm uninstall --save <package name>
npm uninstall -S <package name>

Per una dipendenza di sviluppo, usa il --save-dev (abbreviazione: -D ):

npm uninstall --save-dev <package name>
npm uninstall -D <package name>

Per una dipendenza opzionale, usa il --save-optional (abbreviazione: -O ):

npm uninstall --save-optional <package name>
npm uninstall -O <package name>

Per i pacchetti installati a livello globale utilizzare il flag --global (abbreviazione: -g ):

npm uninstall -g <package name>

Controllo delle versioni semantiche di base

Prima di pubblicare un pacchetto devi metterlo in versione. npm supporta il versioning semantico , questo significa che ci sono patch, versioni minori e principali .

Ad esempio, se il tuo pacchetto è alla versione 1.2.3 per cambiare versione devi:

1. patch release: npm version patch => 1.2.4
2. versione minore: npm version minor => 1.3.0
3. major release: npm version major => 2.0.0

Puoi anche specificare una versione direttamente con:

npm version 3.1.4 => 3.1.4

Quando imposti una versione del pacchetto usando uno dei comandi npm sopra, npm modificherà il campo versione del file package.json, lo impegnerà e creerà anche un nuovo tag Git con la versione preceduta da una "v", come se tu Ho emesso il comando:

git tag v3.1.4

A differenza di altri gestori di pacchetti come Bower, il registro di npm non si basa su tag Git creati per ogni versione. Ma, se ti piace usare i tag, dovresti ricordare di inserire il tag appena creato dopo aver scaricato la versione del pacchetto:

git push origin master (per inviare la modifica a package.json)

git push origin v3.1.4 (per spingere il nuovo tag)

Oppure puoi farlo in un colpo solo con:

git push origin master --tags

Impostazione di una configurazione del pacchetto

Le configurazioni del pacchetto Node.js sono contenute in un file chiamato package.json che puoi trovare alla radice di ogni progetto. È possibile impostare un nuovo file di configurazione chiamando:

npm init

Questo cercherà di leggere la directory di lavoro corrente per informazioni sul repository Git (se esiste) e le variabili di ambiente per provare e completare automaticamente alcuni dei valori segnaposto per te. In caso contrario, fornirà una finestra di dialogo di input per le opzioni di base.

Se desideri creare un package.json con i valori predefiniti, utilizza:

npm init --yes
# or
npm init -y 

Se stai creando un package.json per un progetto che non stai pubblicando come pacchetto npm (vale a dire esclusivamente per arrotondare le tue dipendenze), puoi trasmettere questo intento nel tuo file package.json :

1. Facoltativamente, imposta la proprietà private su true per impedire la pubblicazione accidentale.
2. Opzionalmente imposta la proprietà della license su "NON LICENZIATO" per negare agli altri il diritto di utilizzare il tuo pacchetto.

Per installare un pacchetto e salvarlo automaticamente nel pacchetto package.json , utilizzare:

npm install --save <package>

Il pacchetto e i metadati associati (come la versione del pacchetto) appariranno nelle dipendenze. Se si salva se come dipendenza di sviluppo (usando --save-dev ), il pacchetto apparirà invece nelle proprie devDependencies .

Con questo package.json bare-bones, si incontreranno messaggi di avvertimento durante l'installazione o l'aggiornamento di pacchetti, indicando che mancano una descrizione e il campo del repository. Mentre è sicuro ignorare questi messaggi, puoi eliminarli aprendo il pacchetto. Json in qualsiasi editor di testo e aggiungendo le seguenti linee all'oggetto JSON:

[...]
"description": "No description",
"repository": {
  "private": true
},
[...]

Pubblicare un pacchetto

Innanzitutto, assicurati di aver configurato il tuo pacchetto (come indicato in Configurazione di una configurazione del pacchetto ). Quindi, devi accedere a npmjs.

Se hai già un utente npm

npm login

Se non hai un utente

npm adduser

Per verificare che l'utente sia registrato nel client corrente

npm config ls

Dopodiché, quando il pacchetto è pronto per essere pubblicato, usa

npm publish

E hai finito.

Se è necessario pubblicare una nuova versione, assicurarsi di aggiornare la versione del pacchetto, come indicato nella versione semantica di base . Altrimenti, npm non ti permetterà di pubblicare il pacchetto.

{
    name: "package-name",
    version: "1.0.4"
}

Esecuzione di script

È possibile definire script nel package.json , ad esempio:

{
  "name": "your-package",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "author": "",
  "license": "ISC",
  "dependencies": {},
  "devDependencies": {},
  "scripts": {
    "echo": "echo hello!"
  }
}

Per eseguire lo script echo , eseguire npm run echo dalla riga di comando. Gli script arbitrari, come echo sopra, devono essere eseguiti con npm run <script name> . npm ha anche una serie di script ufficiali che vengono eseguiti in determinate fasi della vita del pacchetto (come preinstall ). Vedi qui per l'intera panoramica di come npm gestisce i campi di script.

Gli script npm sono usati più spesso per cose come l'avvio di un server, la costruzione del progetto e l'esecuzione di test. Ecco un esempio più realistico:

  "scripts": {
    "test": "mocha tests",
    "start": "pm2 start index.js"
  }

Nelle voci degli scripts , i programmi da riga di comando come mocha funzioneranno se installati globalmente o localmente. Se la voce della riga di comando non esiste nel PATH di sistema, npm controllerà anche i pacchetti installati localmente.

Se i tuoi script diventano molto lunghi, possono essere suddivisi in parti, come questo:

  "scripts": {
    "very-complex-command": "npm run chain-1 && npm run chain-2",
    "chain-1": "webpack",
    "chain-2": "node app.js"
  }

Rimozione di pacchetti estranei

Per rimuovere pacchetti estranei (i pacchetti installati ma non nell'elenco delle dipendenze), eseguire il seguente comando:

npm prune

Per rimuovere tutti i pacchetti dev aggiungere --production flag di produzione:

npm prune --production

Altro su di esso

Elenco dei pacchetti attualmente installati

Per generare una lista (vista ad albero) dei pacchetti attualmente installati, usare

npm list

ls , la e ll sono alias di comando lista . i comandi la e ll mostrano informazioni estese come descrizione e repository.

Opzioni

Il formato della risposta può essere modificato passando le opzioni.

npm list --json

• json - Mostra le informazioni in formato json
• lunga - Mostra informazioni estese
• parseable - Mostra l'elenco parseable invece dell'albero
• globale : mostra i pacchetti installati globalmente
• depth - Massima profondità di visualizzazione dell'albero delle dipendenze
• dev / development - Mostra devDependencies
• prod / production - Mostra dipendenze

Se vuoi, puoi anche andare alla pagina principale del pacchetto.

npm home <package name>

Aggiornamento di npm e pacchetti

Poiché npm stesso è un modulo Node.js, può essere aggiornato utilizzando se stesso.

Se il sistema operativo è Windows, deve essere in esecuzione il prompt dei comandi come amministratore

npm install -g npm@latest

Se vuoi verificare le versioni aggiornate puoi fare:

npm outdated

Per aggiornare un pacchetto specifico:

npm update <package name>

Questo aggiornerà il pacchetto alla versione più recente in base alle restrizioni in package.json

Nel caso in cui si desideri bloccare anche la versione aggiornata in package.json:

npm update <package name> --save

Bloccare i moduli su versioni specifiche

Per impostazione predefinita, npm installa l'ultima versione disponibile dei moduli in base alla versione semantica delle dipendenze. Questo può essere problematico se un autore di un modulo non aderisce a semere e introduce cambiamenti di rottura in un aggiornamento del modulo, per esempio.

Per bloccare la versione di ogni dipendenza (e le versioni delle relative dipendenze, ecc.) node_modules versione specifica installata localmente nella cartella node_modules , utilizzare

npm shrinkwrap

Questo creerà quindi un npm-shrinkwrap.json insieme al package.json che elenca le versioni specifiche delle dipendenze.

Impostazione per pacchetti installati globalmente

Puoi usare npm install -g per installare un pacchetto "globalmente". In genere ciò viene fatto per installare un eseguibile che è possibile aggiungere al percorso da eseguire. Per esempio:

npm install -g gulp-cli

Se aggiorni il tuo percorso, puoi chiamare direttamente gulp .

Su molti sistemi operativi, npm install -g tenterà di scrivere in una directory che l'utente potrebbe non essere in grado di scrivere come /usr/bin . Non si deve usare sudo npm install in questo caso poiché non v'è un possibile rischio per la sicurezza di eseguire script arbitrari con sudo e l'utente root può creare directory nella vostra casa che non è possibile scrivere al quale rende installazioni future più difficile.

Puoi dire a npm dove installare i moduli globali tramite il tuo file di configurazione, ~/.npmrc . Questo è chiamato il prefix che è possibile visualizzare con il npm prefix .

prefix=~/.npm-global-modules

Questo utilizzerà il prefisso ogni volta che si esegue npm install -g . È anche possibile utilizzare npm install --prefix ~/.npm-global-modules per impostare il prefisso durante l'installazione. Se il prefisso è uguale alla configurazione, non è necessario utilizzare -g .

Per poter utilizzare il modulo installato globalmente, deve essere sul tuo percorso:

export PATH=$PATH:~/.npm-global-modules/bin

Ora quando esegui npm install -g gulp-cli sarai in grado di usare gulp .

Nota: quando si npm install (senza -g ) il prefisso sarà la directory con package.json o la directory corrente se non si trova nessuno nella gerarchia. Questo crea anche una directory node_modules/.bin che ha gli eseguibili. Se si desidera utilizzare un eseguibile specifico per un progetto, non è necessario utilizzare npm install -g . È possibile utilizzare quello in node_modules/.bin .

Collegamento di progetti per il debugging e lo sviluppo più rapidi

Le dipendenze dei progetti di costruzione possono a volte essere un compito noioso. Invece di pubblicare una versione del pacchetto su NPM e installare la dipendenza per testare le modifiche, usa il npm link . npm link crea un npm link simbolico in modo che l'ultimo codice possa essere testato in un ambiente locale. Ciò rende più semplice testare gli strumenti globali e le dipendenze dei progetti, consentendo l'esecuzione del codice più recente prima di creare una versione pubblicata.

Testo guida

NAME
       npm-link - Symlink a package folder

SYNOPSIS
         npm link (in package dir)
         npm link [<@scope>/]<pkg>[@<version>]

         alias: npm ln

Passi per il collegamento delle dipendenze del progetto

Quando si crea il collegamento delle dipendenze, si noti che il nome del pacchetto è ciò che verrà referenziato nel progetto principale.

1. CD in una directory delle dipendenze (es: cd ../my-dep )
2. npm link
3. CD nel progetto che utilizzerà la dipendenza
4. npm link my-dep o if namespace npm link @namespace/my-dep

Passi per il collegamento di uno strumento globale

1. CD nella directory del progetto (es: cd eslint-watch )
2. npm link
3. Usa lo strumento
4. esw --quiet

Problemi che possono sorgere

I progetti di collegamento a volte possono causare problemi se la dipendenza o lo strumento globale sono già installati. npm uninstall (-g) <pkg> e quindi il npm link normalmente risolve qualsiasi problema che possa sorgere.