Come posso utilizzare una versione locale di un modulo in node.js. Ad esempio, nella mia app ho installato coffee-script:

npm install coffee-script

Questo lo installa ./node_modulese il comando caffè è attivo ./node_modules/.bin/coffee. C'è un modo per eseguire questo comando quando mi trovo nella cartella principale del mio progetto? Immagino che sto cercando qualcosa di simile a bundle execin bundler. Fondamentalmente, vorrei specificare una versione della sceneggiatura del caffè che tutti gli attori coinvolti nel progetto dovrebbero usare.

So di poter aggiungere il -gflag per installarlo a livello globale in modo che il caffè funzioni bene ovunque, ma se volessi avere versioni diverse di caffè per progetto?

AGGIORNAMENTO : Come sottolinea Seyeong Jeong nella loro risposta di seguito, da npm 5.2.0 è possibile utilizzare npx [command], il che è più conveniente.

RISPOSTA VECCHIA per versioni precedenti alla 5.2.0 :

Il problema con il mettere

./node_modules/.bin

nel tuo PERCORSO è che funziona solo quando la tua directory di lavoro corrente è la radice della struttura della directory del tuo progetto (ovvero la posizione di node_modules)

Indipendentemente dalla directory di lavoro, è possibile ottenere il percorso dei file binari installati localmente

npm bin

Per eseguire un coffeebinario installato localmente indipendente da dove ti trovi nella gerarchia della directory di progetto puoi usare questo costrutto bash

PATH=$(npm bin):$PATH coffee

Ho modificato questo al npm-exec

alias npm-exec='PATH=$(npm bin):$PATH'

Quindi ora posso

npm-exec coffee

per eseguire la copia corretta del caffè, indipendentemente da dove mi trovo

$ pwd
/Users/regular/project1

$ npm-exec which coffee
/Users/regular/project1/node_modules/.bin/coffee

$ cd lib/
$ npm-exec which coffee
/Users/regular/project1/node_modules/.bin/coffee

$ cd ~/project2
$ npm-exec which coffee
/Users/regular/project2/node_modules/.bin/coffee

Non devi $PATHpiù manipolare !

Da npm@5.2.0 , npm viene fornito con un npxpacchetto che consente di eseguire comandi da una node_modules/.bincache locale o centrale.

Esegui semplicemente:

$ npx [options] <command>[@version] [command-arg]...

Per impostazione predefinita, npxverificherà se <command>esiste $PATHo nei file binari del progetto locale ed eseguirà ciò.

La chiamata npx <command>quando <command>non è già $PATHpresente installerà automaticamente un pacchetto con quel nome dal registro NPM e lo invocherà. Al termine, il pacchetto installato non sarà in nessuna parte dei tuoi globi, quindi non dovrai preoccuparti dell'inquinamento a lungo termine. È possibile impedire questo comportamento fornendo l' --no-installopzione.

Per npm < 5.2.0, è possibile installare il npxpacchetto manualmente eseguendo il comando seguente:

$ npm install -g npx

Utilizzare il npm bincomando per ottenere la directory dei moduli / bin del nodo del progetto

$ $(npm bin)/<binary-name> [args]

per esempio

$ $(npm bin)/bower install

Uso npm run[-script] <script name>

Dopo aver usato npm per installare il pacchetto bin nella tua ./node_modulesdirectory locale , modifica package.jsonper aggiungere in <script name>questo modo:

$ npm install --save learnyounode
$ edit packages.json
>>> in packages.json
...
"scripts": {
    "test": "echo \"Error: no test specified\" && exit 1",
    "learnyounode": "learnyounode"
},
...
$ npm run learnyounode

Sarebbe bello se npm install avesse un'opzione --add-script o qualcosa del genere o se npm run funzionasse senza aggiungere al blocco degli script.

Usa npm-run.

Dal readme:

NPM-run

Trova ed esegui eseguibili locali da node_modules

Qualsiasi eseguibile disponibile per uno script del ciclo di vita di npm è disponibile per npm-run.

uso

$ npm install mocha # mocha installed in ./node_modules
$ npm-run mocha test/* # uses locally installed mocha executable 

Installazione

$ npm install -g npm-run

Aggiornamento: non consiglio più questo metodo, sia per i motivi di sicurezza menzionati, sia per il npm bincomando più recente . Risposta originale di seguito:

Come hai scoperto, sono presenti tutti i file binari installati localmente ./node_modules/.bin. Per eseguire sempre i binari in questa directory piuttosto che i binari disponibili a livello globale, se presente, ti suggerisco di inserire ./node_modules/.binprima il percorso:

export PATH="./node_modules/.bin:$PATH"

Se lo metti nel tuo ~/.profile, coffeesarà sempre ./node_modules/.bin/coffeese disponibile, altrimenti /usr/local/bin/coffee(o qualunque prefisso stai installando i moduli del nodo).

La soluzione PATH ha il problema che se $ (npm bin) viene inserito nel tuo .profile / .bashrc / etc, viene valutato una volta ed è sempre impostato su qualsiasi directory in cui è stato valutato il percorso per la prima volta. Se invece modifichi il percorso corrente, allora ogni volta che esegui lo script il tuo percorso aumenterà.

Per aggirare questi problemi, ho creato una funzione e l'ho usata. Non modifica il tuo ambiente ed è semplice da usare:

function npm-exec {
   $(npm bin)/$@  
}

Questo può quindi essere utilizzato in questo modo senza apportare modifiche al proprio ambiente:

npm-exec r.js <args>

Se vuoi mantenere npm, allora npx dovrebbe fare quello che ti serve.

Se passare al filato (una sostituzione npm di Facebook) è un'opzione per te, puoi chiamare:

 yarn yourCmd

gli script all'interno di package.json avranno la precedenza, se non viene trovato nessuno, apparirà all'interno della ./node_modules/.bin/cartella.

Produce anche ciò che ha funzionato:

$ yarn tsc
yarn tsc v0.27.5
$ "/home/philipp/rate-pipeline/node_modules/.bin/tsc"

Quindi non devi impostare gli script per ciascun comando nel tuo package.json.

Se .scriptsall'interno del tuo script fosse definito uno script package.json:

"tsc": "tsc" // each command defined in the scripts will be executed from `./node_modules/.bin/` first

yarn tscsarebbe equivalente a yarn run tsco npm run tsc:

 yarn tsc
 yarn tsc v0.27.5
 $ tsc

aggiornamento: se sei nel npm recente (versione> 5.2)

Puoi usare:

npx <command>

npxcerca il comando nella .bindirectory del tuonode_modules

vecchia risposta:

Per Windows

Memorizza quanto segue in un file chiamato npm-exec.bate aggiungilo al tuo%PATH%

@echo off
set cmd="npm bin"
FOR /F "tokens=*" %%i IN (' %cmd% ') DO SET modules=%%i
"%modules%"\%*

uso

Quindi puoi usarlo come npm-exec <command> <arg0> <arg1> ...

Per esempio

Per eseguire wdioinstallato nella directory node_modules locale, eseguire:

npm-exec wdio wdio.conf.js

cioè funzionerà .\node_modules\.bin\wdio wdio.conf.js

Preferisco non fare affidamento sugli alias di shell o su un altro pacchetto.

Aggiungendo una semplice riga alla scriptssezione del tuo package.json, puoi eseguire comandi npm locali come

npm run webpack

package.json

{
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1",
    "webpack": "webpack"
  },
  "devDependencies": {
    "webpack": "^4.1.1",
    "webpack-cli": "^2.0.11"
  }
}

Se vuoi che la tua variabile PATH si aggiorni correttamente in base alla tua attuale directory di lavoro, aggiungi questo alla fine del tuo .bashrcequivalente (o dopo tutto ciò che definisce PATH):

__OLD_PATH=$PATH
function updatePATHForNPM() {
  export PATH=$(npm bin):$__OLD_PATH
}

function node-mode() {
  PROMPT_COMMAND=updatePATHForNPM
}

function node-mode-off() {
  unset PROMPT_COMMAND
  PATH=$__OLD_PATH
}

# Uncomment to enable node-mode by default:
# node-mode

Questo può aggiungere un breve ritardo ogni volta che viene visualizzato il prompt di bash (a seconda delle dimensioni del progetto, molto probabilmente), quindi è disabilitato per impostazione predefinita.

È possibile abilitarlo e disabilitarlo all'interno del proprio terminale eseguendo node-modee node-mode-off, rispettivamente.

Ho sempre usato lo stesso approccio di @guneysus per risolvere questo problema, che sta creando uno script nel file package.json e lo uso con npm run script-name.

Tuttavia, negli ultimi mesi ho usato npx e lo adoro.

Ad esempio, ho scaricato un progetto Angular e non volevo installare la CLI Angular a livello globale. Quindi, con npx installato, invece di utilizzare il comando cli angolare globale (se lo avessi installato) in questo modo:

ng serve

Posso farlo dalla console:

npx ng serve

Ecco un articolo che ho scritto su NPX e che approfondisce.

zxc è come "bundle exec" per nodejs. È simile all'utilizzo di PATH=$(npm bin):$PATH:

$ npm install -g zxc
$ npm install gulp
$ zxc which gulp
/home/nathan/code/project1/node_modules/.bin/gulp

Stessa soluzione accettata da @regular, ma sapore di conchiglia di pesce

if not contains (npm bin) $PATH
    set PATH (npm bin) $PATH
end

Puoi anche usare direnv e cambiare la variabile $ PATH solo nella tua cartella di lavoro.

$ cat .envrc
> export PATH=$(npm bin):$PATH

Aggiungi questo script al tuo .bashrc. Quindi puoi chiamare coffeeo fare qualsiasi cosa localmente. Questo è utile per il tuo laptop, ma non usarlo sul tuo server.

DEFAULT_PATH=$PATH;

add_local_node_modules_to_path(){
  NODE_MODULES='./node_modules/.bin';
  if [ -d $NODE_MODULES ]; then
    PATH=$DEFAULT_PATH:$NODE_MODULES;
  else
    PATH=$DEFAULT_PATH;
  fi
}

cd () {
  builtin cd "$@";
  add_local_node_modules_to_path;
}

add_local_node_modules_to_path;

nota : questo script esegue un cdcomando, e dopo ogni chiamata cdlo controlla node_modules/.bine lo aggiunge al proprio $PATH.

note2 : è possibile modificare la terza riga in NODE_MODULES=$(npm bin);. Ma ciò renderebbe il cdcomando troppo lento.

Per Windows usa questo:

/* cmd into "node_modules" folder */
"%CD%\.bin\grunt" --version

Ho riscontrato lo stesso problema e non mi piace particolarmente usare gli alias (come suggerito da Regular ), e se non ti piacciono anche loro, ecco un'altra soluzione alternativa che uso, devi prima creare un piccolo script eseguibile bash, dì setenv.sh :

#!/bin/sh

# Add your local node_modules bin to the path
export PATH="$(npm bin):$PATH"

# execute the rest of the command
exec "$@"

e quindi puoi usare qualsiasi eseguibile nel tuo locale /binusando questo comando:

./setenv.sh <command>
./setenv.sh 6to5-node server.js
./setenv.sh grunt

Se stai usando scriptsin package.json, allora:

...,
scripts: {
    'start': './setenv.sh <command>'
}

Mi piacerebbe sapere se questa è un'idea insicura / cattiva, ma dopo averci pensato un po 'non vedo un problema qui:

Modificando la soluzione insicura di Linus per aggiungerla alla fine, usando npm binper trovare la directory e facendo chiamare lo script solo npm binquando a package.jsonè presente in un genitore (per velocità), questo è ciò che mi è venuto in mente per zsh:

find-up () {
  path=$(pwd)
  while [[ "$path" != "" && ! -e "$path/$1" ]]; do
    path=${path%/*}
  done
  echo "$path"
}

precmd() {
  if [ "$(find-up package.json)" != "" ]; then
    new_bin=$(npm bin)
    if [ "$NODE_MODULES_PATH" != "$new_bin" ]; then
      export PATH=${PATH%:$NODE_MODULES_PATH}:$new_bin
      export NODE_MODULES_PATH=$new_bin
    fi
  else
    if [ "$NODE_MODULES_PATH" != "" ]; then
      export PATH=${PATH%:$NODE_MODULES_PATH}
      export NODE_MODULES_PATH=""
    fi
  fi
}

Per bash, invece di usare l' precmdhook, puoi usare la $PROMPT_COMMANDvariabile (non l'ho testata ma hai avuto l'idea):

__add-node-to-path() {
  if [ "$(find-up package.json)" != "" ]; then
    new_bin=$(npm bin)
    if [ "$NODE_MODULES_PATH" != "$new_bin" ]; then
      export PATH=${PATH%:$NODE_MODULES_PATH}:$new_bin
      export NODE_MODULES_PATH=$new_bin
    fi
  else
    if [ "$NODE_MODULES_PATH" != "" ]; then
      export PATH=${PATH%:$NODE_MODULES_PATH}
      export NODE_MODULES_PATH=""
    fi
  fi   
}

export PROMPT_COMMAND="__add-node-to-path"

Sono un Windowsutente e questo è ciò che ha funzionato per me:

// First set some variable - i.e. replace is with "xo"
D:\project\root> set xo="./node_modules/.bin/"

// Next, work with it
D:\project\root> %xo%/bower install

In bocca al lupo.

Nel caso in cui si stia utilizzando fish shelle non si desideri aggiungerlo $pathper motivi di sicurezza. È possibile aggiungere la seguente funzione per eseguire gli eseguibili del nodo locale.

### run executables in node_module/.bin directory
function n 
  set -l npmbin (npm bin)   
  set -l argvCount (count $argv)
  switch $argvCount
    case 0
      echo please specify the local node executable as 1st argument
    case 1
      # for one argument, we can eval directly 
      eval $npmbin/$argv
    case '*'
      set --local executable $argv[1]
      # for 2 or more arguments we cannot append directly after the $npmbin/ since the fish will apply each array element after the the start string: $npmbin/arg1 $npmbin/arg2... 
      # This is just how fish interoperate array. 
      set --erase argv[1]
      eval $npmbin/$executable $argv 
  end
end

Ora puoi eseguire cose come:

n coffee

o più argomenti come:

n browser-sync --version

Nota, se sei bashutente, allora @ Bob9630 risponde è la strada da percorrere sfruttando bash's $@, che non è disponibile in fishshell.

Includi coffee-script in package.json con la versione specifica richiesta in ciascun progetto, in genere in questo modo:

"dependencies":{
  "coffee-script": ">= 1.2.0"

Quindi eseguire npm install per installare dipendenze in ciascun progetto. Ciò installerà la versione specificata di coffee-script che sarà accessibile localmente per ogni progetto.