¿Cómo uso una versión local de un módulo en node.js ? Por ejemplo, en mi aplicación, instalé coffee-script:

npm install coffee-script

Esto lo instala ./node_modulesy el comando coffee está en./node_modules/.bin/coffee . ¿Hay alguna manera de ejecutar este comando cuando estoy en la carpeta principal de mi proyecto? Supongo que estoy buscando algo similar a bundle execen bundler. Básicamente, me gustaría especificar una versión de coffee-script que todos los involucrados en el proyecto deberían usar.

Sé que puedo agregar la -gbandera para instalarlo globalmente para que el café funcione bien en cualquier lugar, pero ¿y si quisiera tener diferentes versiones de café por proyecto?

ACTUALIZACIÓN : Como Seyeong Jeong señala en su respuesta a continuación, desde npm 5.2.0 puede usar npx [command], lo cual es más conveniente.

ANTIGUA RESPUESTA para versiones anteriores a 5.2.0 :

El problema con poner

./node_modules/.bin

en su RUTA es que solo funciona cuando su directorio de trabajo actual es la raíz de la estructura de directorios de su proyecto (es decir, la ubicación de node_modules )

Independientemente de cuál sea su directorio de trabajo, puede obtener la ruta de los binarios instalados localmente con

npm bin

Para ejecutar un coffeebinario instalado localmente, independientemente de dónde se encuentre en la jerarquía del directorio del proyecto, puede usar esta construcción bash

PATH=$(npm bin):$PATH coffee

Alias ​​esto a npm-exec

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

Entonces ahora puedo

npm-exec coffee

para ejecutar la copia correcta de café sin importar dónde esté

$ 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

¡Ya no tienes que manipular $PATH!

Desde [email protected] , npm se envía con un npxpaquete que le permite ejecutar comandos desde un localnode_modules/.bin caché o central.

Simplemente ejecute:

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

Por defecto, npxverificará si <command>existe $PATHo en los binarios locales del proyecto y lo ejecutará.

Si llama npx <command>cuando aún <command>no está en su $PATH, se instalará automáticamente un paquete con ese nombre desde el registro de NPM y lo invocará. Cuando termine, el paquete instalado no estará en ninguna parte de sus globales, por lo que no tendrá que preocuparse por la contaminación a largo plazo. Puede evitar este comportamiento al proporcionar la --no-installopción.

Para npm < 5.2.0, puede instalar el npxpaquete manualmente ejecutando el siguiente comando:

$ npm install -g npx

Use el npm bincomando para obtener el directorio de módulos de nodo / bin de su proyecto

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

p.ej

$ $(npm bin)/bower install

Utilizar npm run[-script] <script name>

Después de usar npm para instalar el paquete bin en su ./node_modulesdirectorio local , modifíquelo package.jsonpara agregarlo <script name>así:

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

Sería bueno si npm install tuviera una opción --add-script o algo así o si npm run funcionaría sin agregar al bloque de scripts.

Utilizar npm-run .

Del léame:

npm-run

Encuentra y ejecuta ejecutables locales desde node_modules

Cualquier ejecutable disponible para un script de ciclo de vida npm está disponible para npm-run .

Uso

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

Instalación

$ npm install -g npm-run

Actualización: ya no recomiendo este método, tanto por las razones de seguridad mencionadas como por las más recientes.npm bin comando . Respuesta original a continuación:

Como descubrió, cualquier binario instalado localmente está en ./node_modules/.bin. Para ejecutar siempre los archivos binarios en este directorio en lugar de los archivos binarios disponibles a nivel mundial, si está presente, le sugiero que ponga ./node_modules/.binprimero en su ruta:

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

Si pone esto en su ~/.profile, coffeesiempre estará ./node_modules/.bin/coffeedisponible, de lo contrario /usr/local/bin/coffee(o cualquier prefijo en el que esté instalando los módulos de nodo).

La solución PATH tiene el problema de que si $ (npm bin) se coloca en su .profile / .bashrc / etc, se evalúa una vez y se establece para siempre en el directorio en el que se evaluó la ruta por primera vez. Si en cambio modifica la ruta actual, entonces Cada vez que ejecute el script, su camino crecerá.

Para solucionar estos problemas, creo una función y la utilicé. No modifica su entorno y es fácil de usar:

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

Esto se puede usar así sin hacer ningún cambio en su entorno:

npm-exec r.js <args>

Si desea mantener npm, entonces npx debe hacer lo que necesita.

Si cambiar a hilo (un reemplazo de npm por facebook) es una opción para usted, puede llamar a:

 yarn yourCmd

las secuencias de comandos dentro del paquete.json tendrán prioridad, si no se encuentra ninguna, se verá dentro de ./node_modules/.bin/ carpeta.

También genera lo que ejecutó:

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

Por lo tanto, no tiene que configurar scripts para cada comando en su package.json.

Si tenía un script definido .scriptsdentro de su package.json:

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

yarn tscsería equivalente a yarn run tsco npm run tsc:

 yarn tsc
 yarn tsc v0.27.5
 $ tsc

actualización: si está en el npm reciente (versión> 5.2)

Puedes usar:

npx <command>

npxbusca el comando en el .bindirectorio de sunode_modules

vieja respuesta:

Para ventanas

Almacene lo siguiente en un archivo llamado npm-exec.baty agréguelo a su%PATH%

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

Uso

Entonces puedes usarlo como npm-exec <command> <arg0> <arg1> ...

Por ejemplo

Para ejecutar wdioinstalado en el directorio local node_modules, haga:

npm-exec wdio wdio.conf.js

es decir, se ejecutará .\node_modules\.bin\wdio wdio.conf.js

Prefiero no confiar en alias de shell u otro paquete.

Al agregar una línea simple a la scriptssección de su package.json, puede ejecutar comandos locales npm como

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"
  }
}

Si desea que su variable PATH se actualice correctamente en función de su directorio de trabajo actual, agregue esto al final de su .bashrcequivalente (o después de cualquier cosa que defina 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

Esto puede agregar un pequeño retraso cada vez que se procesa el indicador bash (según el tamaño de su proyecto, lo más probable), por lo que está deshabilitado de forma predeterminada.

Puede habilitarlo y deshabilitarlo dentro de su terminal ejecutando node-modey node-mode-off, respectivamente.

Siempre he usado el mismo enfoque que @guneysus para resolver este problema, que es crear un script en el archivo package.json y usarlo ejecutando npm run script-name.

Sin embargo, en los últimos meses he estado usando npx y me encanta.

Por ejemplo, descargué un proyecto Angular y no quería instalar Angular CLI a nivel mundial. Entonces, con npx instalado, en lugar de usar el comando global angular cli (si lo hubiera instalado) así:

ng serve

Puedo hacer esto desde la consola:

npx ng serve

Aquí hay un artículo que escribí sobre NPX y que profundiza en él.

zxc es como "bundle exec" para nodejs. Es similar a usar PATH=$(npm bin):$PATH:

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

La misma solución aceptada de @regular, pero sabor a concha de pescado

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

También puede usar direnv y cambiar la variable $ PATH solo en su carpeta de trabajo.

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

Agregue este script a su .bashrc. Entonces puedes llamar coffeeo hacer cualquier cosa localmente. Esto es útil para su computadora portátil, pero no lo use en su servidor.

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 : este script hace un alias de cdcomando, y después de cada llamada cdlo verifica node_modules/.biny lo agrega a su $PATH.

nota2 : puede cambiar la tercera línea a NODE_MODULES=$(npm bin);. Pero eso haría que el cdcomando fuera demasiado lento.

Para Windows use esto:

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

Encontré el mismo problema y no me gusta especialmente el uso de alias (como se sugiere con regularidad ), y si no te gustan también, aquí hay otra solución alternativa que uso, primero tienes que crear un pequeño script ejecutable bash, diga 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 "$@"

y luego puedes usar cualquier ejecutable en tu local /binusando este comando:

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

Si está utilizando scriptspackage.json, entonces:

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

Me encantaría saber si esta es una idea insegura / mala, pero después de pensarlo un poco, no veo un problema aquí:

Modificando la solución insegura de Linus para agregarlo al final, usando npm binpara encontrar el directorio y haciendo que el script solo llame npm bincuando hay un package.jsonpresente en un padre (por velocidad), esto es lo que se me ocurrió 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
}

Para bash, en lugar de usar el precmdgancho, puede usar la $PROMPT_COMMANDvariable (no lo he probado pero se entiende):

__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"

Soy un Windowsusuario y esto es lo que funcionó para mí:

// 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

Buena suerte.

En caso de que esté usando fish shelly no quiera agregar $pathpor razones de seguridad. Podemos agregar la siguiente función para ejecutar ejecutables de nodo local.

### 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

Ahora puedes ejecutar cosas como:

n coffee

o más argumentos como:

n browser-sync --version

Tenga en cuenta que si es bashusuario, entonces las respuestas de @ Bob9630 son el camino a seguir aprovechando bash $@, que no está disponible en fishshell.

Incluya coffee-script en package.json con la versión específica requerida en cada proyecto, típicamente así:

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

Luego ejecute npm install para instalar dependencias en cada proyecto. Esto instalará la versión especificada de coffee-script que será accesible localmente para cada proyecto.