Comment utiliser le package installé localement dans node_modules?

StackOverflow https://stackoverflow.com//questions/9679932

Question

Comment puis-je utiliser une version locale d'un module dans node.js.Par exemple, dans mon application, j'ai installé le café-script:

npm install coffee-script

Cette installe dans ./node_modules et le café de commande est en ./node_modules/.bin/coffee.Est-il un moyen pour exécuter cette commande quand je suis dans mon projet principal du dossier?Je suppose que je suis à la recherche de quelque chose de similaire à bundle exec dans le bundler.En gros, j'aimerais préciser une version de café-script que tous les acteurs du projet doivent utiliser.

Je sais que je peux ajouter de la -g drapeau de l'installer de manière globale de façon à café fonctionne bien partout, mais que si je voulais avoir des versions différentes de café par projet?

Était-ce utile?

La solution

Mise à JOUR:Comme Seyeong Jeong points dans leur réponse ci-dessous, depuis mnp 5.2.0 vous pouvez utiliser npx [command], ce qui est plus pratique.

VIEILLE RÉPONSE pour les versions avant 5.2.0:

Le problème avec la mise en

./node_modules/.bin

dans votre CHEMIN, c'est qu'il ne fonctionne que lorsque votre répertoire de travail actuel est à la racine de votre répertoire de projet de la structure (c'est à direl'emplacement de node_modules)

Indépendant de ce qui est votre répertoire de travail, vous pouvez obtenir le chemin d'installé localement des binaires avec

npm bin

Pour exécuter installé localement coffee binaire indépendant de l'endroit où vous êtes dans le répertoire du projet hiérarchie vous pouvez utiliser cette bash construire

PATH=$(npm bin):$PATH coffee

J'ai un alias de ce npm-exec

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

Alors, maintenant, je peux

npm-exec coffee

pour exécuter la copie correcte de café, peu importe d'où je suis

$ 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

Autres conseils

Nice example

Vous n'avez pas à manipuler $PATH plus!

À partir de npm@5.2.0, npm livré avec npx package qui permet d'exécuter des commandes à partir d'un local node_modules/.bin ou à partir d'un centre de cache.

Exécutez simplement:

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

Par défaut, npx va vérifier si <command> existe en $PATH, ou , dans le projet local de fichiers binaires et de l'exécuter.

L'appel npx <command> lorsque <command> n'est-ce pas déjà dans votre $PATH va automatiquement installer un paquet avec le nom du mécanisme national de prévention de registre pour vous, et à l'appeler.Quand c'est fait, le paquet ne sera pas n'importe où dans votre globals, de sorte que vous n'aurez pas à vous soucier de la pollution dans le long terme.Vous pouvez éviter ce type de comportements en fournissant --no-install option.

Pour npm < 5.2.0, vous pouvez installer npx package manuellement en exécutant la commande suivante:

$ npm install -g npx

L'utilisation de la npm bin commande pour obtenir le nœud modules répertoire /bin de votre projet

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

par exemple

$ $(npm bin)/bower install

Utilisation npm run[-script] <script name>

Après l'utilisation de la ngp pour installer le bac de package pour votre local ./node_modules répertoire, modifier package.json pour ajouter <script name> comme ceci:

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

Ce serait bien si npm install avait un --ajouter des options de script ou quelque chose ou si mnp fonctionner de travail sans augmenter les scripts bloc.

Utilisation npm-run.

Depuis le readme:

npm-exécuter

Trouver et exécuter des fichiers exécutables locaux de node_modules

Tout fichier exécutable à la disposition d'un mécanisme de prévention du cycle de vie script est disponible pour npm-run.

L'utilisation de la

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

Installation

$ npm install -g npm-run

Mise à jour: Je n'ai plus recommander cette méthode, à la fois pour le mentionné des raisons de sécurité et non des moindres, la nouvelle npm bin commande.Réponse originale à cette question ci-dessous:

Comme vous l'avez constaté, tout installé localement, les binaires sont dans ./node_modules/.bin.Afin de toujours exécuter des binaires dans ce répertoire plutôt que globalement disponible binaires, si présent, je vous suggère de mettre ./node_modules/.bin d'abord dans votre chemin:

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

Si vous le mettez dans votre ~/.profile, coffee sera toujours ./node_modules/.bin/coffee si disponible, sinon /usr/local/bin/coffee (ou le préfixe de votre installation nœud de modules).

Le CHEMIN de la solution a la question que si $(mnp bin) est placé dans votre .profil/.bashrc/etc c'est évaluée une fois et pour toujours quel que soit le répertoire, le chemin a été évalué en premier dans.En revanche, si vous modifiez le chemin d'accès actuel, puis chaque fois que vous exécutez le script de votre chemin, vous allez grandir.

Pour contourner ces problèmes, j'ai créer une fonction et utilisé.Il ne modifie pas votre environnement et est simple à utiliser:

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

Cela peut ensuite être utilisé comme ce, sans aucune modification de votre environnement:

npm-exec r.js <args>

Si vous voulez garder la ngp, puis npx faire ce que vous avez besoin.

Si le passage à fil (mnp remplacement par facebook) est une option pour vous, alors vous pouvez appeler:

 yarn yourCmd

les scripts à l'intérieur du paquet.json aura préséance, si aucun n'est trouvé, il va chercher à l'intérieur de la ./node_modules/.bin/ dossier.

Il génère également ce qu'il a couru:

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

Si vous n'avez pas à configurer des scripts pour chaque commande dans votre package.json.

Si vous aviez un script défini à .scripts à l'intérieur de votre package.json:

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

yarn tsc serait équivalent à yarn run tsc ou npm run tsc:

 yarn tsc
 yarn tsc v0.27.5
 $ tsc

mise à jour:Si vous êtes sur la récente mnp (version >5.2)

Vous pouvez utiliser:

npx <command>

npx recherche de commande en .bin si votre répertoire node_modules

vieille réponse:

Pour Windows

Stocker les éléments suivants dans un fichier appelé npm-exec.bat et l'ajouter à votre %PATH%

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

L'utilisation de la

Ensuite, vous pouvez l'utiliser comme npm-exec <command> <arg0> <arg1> ...

Par exemple

Pour exécuter wdio installé dans les locaux répertoire node_modules, faire:

npm-exec wdio wdio.conf.js

c'est à direil sera exécuté .\node_modules\.bin\wdio wdio.conf.js

Je préfère ne pas compter sur la coquille d'alias ou d'un autre paquet.

L'ajout d'une simple ligne de scripts la section de votre package.json, vous pouvez exécuter local mnp des commandes comme

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 vous voulez que votre variable d'environnement PATH pour mettre correctement à jour basé sur, votre répertoire de travail, ajoutez ceci à la fin de votre .bashrc-équivalent (ou après tout ce qui définit 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

Cela peut ajouter un délai court et à chaque fois que l'invite bash est rendu (selon la taille de votre projet, le plus probable), il est donc désactivée par défaut.

Vous pouvez l'activer et le désactiver à l'intérieur de votre terminal en cours d'exécution node-mode et node-mode-off, respectivement.

J'ai toujours utilisé la même approche que @guneysus pour résoudre ce problème, qui est la création d'un script dans le package.fichier json et de l'utiliser à l'exécution de mnp exécuter le script de nom.

Cependant, dans les derniers mois, j'ai été en utilisant npx et je l'aime.

Par exemple, j'ai téléchargé Angulaire du projet et je ne voulais pas installer l'angle de la CLI à l'échelle mondiale.Ainsi, avec npx installé, au lieu d'utiliser le mondial angulaire de la cli de commande (si je l'avais installé il) comme ceci:

ng serve

Je peux le faire à partir de la console:

npx ng serve

Voici un article J'ai écrit à propos de NPX et qui va au plus profond en elle.

zxc c'est comme "bundle exec" pour nodejs.Il est similaire à l'utilisation d' PATH=$(npm bin):$PATH:

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

Même @régulièrement " s accepté solution, mais les Poissons shell saveur

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

Vous pouvez également utiliser direnv et modifier la variable $PATH seulement dans votre dossier de travail.

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

Ajouter ce script à votre .bashrc.Ensuite, vous pouvez appeler coffee ou anyhting localement.Ce qui est pratique pour votre ordinateur portable, mais ne l'utilisez pas sur votre serveur.

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;

note:ce script permet de aliase cd de commande, et après chaque appel de cd il vérifie node_modules/.bin et l'ajouter à votre $PATH.

note2:vous pouvez modifier la troisième ligne NODE_MODULES=$(npm bin);.Mais ce serait faire cd commande trop lent.

Pour Windows, utilisez ceci:

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

J'ai rencontré le même problème et je n'aime pas particulièrement l'utilisation d'alias (comme régulier's a suggéré), et si vous ne les aimez pas trop alors voici une autre solution que j'utilise, vous devez d'abord créer un petit fichier exécutable script bash, dire 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 "$@"

et puis vous pouvez ensuite utiliser tous les exécutables dans votre local /bin à l'aide de cette commande:

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

Si vous êtes en utilisant scripts dans le paquet.json puis:

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

J'aimerais savoir si c'est dangereux ou mauvaise idée, mais après y avoir réfléchi un peu, je ne vois pas un problème ici:

La modification de Linus de l'insécurité solution pour l'ajouter à la fin, à l'aide de npm bin afin de trouver le répertoire, et de faire le script uniquement appel npm bin lorsqu'un package.json est présent dans l'un des parents (pour la vitesse), c'est ce que j'ai trouvé pour 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
}

Pour bash, au lieu d'utiliser la precmd crochet, vous pouvez utiliser le $PROMPT_COMMAND variable (je ne l'ai pas testé, mais vous voyez l'idée):

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

Je suis un Windows l'utilisateur et c'est ce qui a fonctionné pour moi:

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

Bonne Chance.

Dans le cas où vous utilisez fish shell et ne voulez pas ajouter à $path pour des raisons de sécurité.Nous pouvons ajouter ci-dessous la fonction à exécuter nœud local exécutables. 

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

Maintenant, vous pouvez exécuter la chose comme:

n coffee

ou plusieurs arguments comme:

n browser-sync --version

Notez que si vous êtes bash l'utilisateur, puis @Bob9630 réponses est le chemin à parcourir en tirant parti de bash du $@, qui n'est pas disponible dans fishshell.

Notamment le café-script dans le paquet.json avec la version spécifique requise dans chaque projet, généralement comme ceci:

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

Ensuite, exécutez npm install pour installer les dépendances de chaque projet.Cela permettra d'installer la version spécifiée du café-script qui sera accessible localement à chaque projet.

Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top