Jak korzystać z lokalnej wersji modułu w node.js. Na przykład w mojej aplikacji zainstalowałem skrypt do kawy:

npm install coffee-script

Spowoduje to zainstalowanie ./node_modulesi uruchomienie polecenia kawy ./node_modules/.bin/coffee. Czy istnieje sposób na uruchomienie tego polecenia, gdy jestem w głównym folderze mojego projektu? Chyba szukam czegoś podobnego do bundle execw pakiecie. Zasadniczo chciałbym określić wersję skryptu kawowego, z której powinien korzystać każdy zaangażowany w projekt.

Wiem, że mogę dodać -gflagę, aby zainstalować ją globalnie, aby kawa działała dobrze w dowolnym miejscu, ale co, jeśli chciałbym mieć różne wersje kawy na projekt?

AKTUALIZACJA : Jak wskazuje Seyeong Jeong w swojej odpowiedzi poniżej, ponieważ npm 5.2.0 możesz użyć npx [command], co jest wygodniejsze.

STARA ODPOWIEDŹ dla wersji wcześniejszych niż 5.2.0 :

Problem ze stawianiem

./node_modules/.bin

w twojej ŚCIEŻCE jest to, że działa ona tylko wtedy, gdy bieżący katalog roboczy jest katalogiem głównym struktury katalogu projektu (tj. lokalizacja node_modules)

Niezależnie od katalogu roboczego możesz uzyskać ścieżkę do lokalnie zainstalowanych plików binarnych

npm bin

Aby wykonać lokalnie zainstalowany coffeeplik binarny niezależnie od tego, gdzie jesteś w hierarchii katalogu projektu, możesz użyć tej konstrukcji bash

PATH=$(npm bin):$PATH coffee

Skalowałem to do npm-exec

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

Więc teraz mogę

npm-exec coffee

uruchomić prawidłową kopię kawy bez względu na to, gdzie jestem

$ 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

Nie musisz $PATHjuż manipulować !

Od npm@5.2.0 , npm jest dostarczany z npxpakietem, który pozwala na uruchamianie poleceń z lokalnego node_modules/.binlub centralnego bufora.

Po prostu uruchom:

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

Domyślnie npxsprawdzi, czy <command>istnieje w $PATHlokalnych plikach binarnych projektu, czy też go uruchomi.

Wywołanie, npx <command>gdy <command>nie ma go w twoim $PATHkatalogu, automatycznie zainstaluje dla ciebie pakiet o tej nazwie z rejestru NPM i uruchom go. Gdy to zrobisz, zainstalowany pakiet nie będzie nigdzie w twoich globalsach, więc nie będziesz musiał martwić się o zanieczyszczenie w perspektywie długoterminowej. Możesz temu zapobiec, udostępniając --no-installopcję.

Dla npm < 5.2.0, można zainstalować npxpakiet ręcznie, uruchamiając następującą komendę:

$ npm install -g npx

Użyj npm binpolecenia, aby uzyskać katalog modułów / bin węzła swojego projektu

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

na przykład

$ $(npm bin)/bower install

Posługiwać się npm run[-script] <script name>

Po użyciu npm do zainstalowania pakietu bin w ./node_moduleskatalogu lokalnym , zmodyfikuj, package.jsonaby dodać w <script name>następujący sposób:

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

Byłoby miło, gdyby instalacja npm miała opcję --add-script lub coś, lub gdyby uruchomienie npm działało bez dodawania do bloku skryptów.

Zastosowanie npm-run.

Z pliku Readme:

npm-run

Znajdź i uruchom lokalne pliki wykonywalne z node_modules

Każdy plik wykonywalny dostępny dla skryptu cyklu życia npm jest dostępny dla npm-run.

Stosowanie

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

Instalacja

$ npm install -g npm-run

Aktualizacja: Nie polecam już tej metody, zarówno ze względu na wspomniane względy bezpieczeństwa, jak i nowsze npm binpolecenie. Oryginalna odpowiedź poniżej:

Jak się dowiedziałeś, wszystkie lokalnie zainstalowane pliki binarne znajdują się w ./node_modules/.bin. Aby zawsze uruchamiać pliki binarne w tym katalogu zamiast globalnie dostępnych plików binarnych, jeśli są obecne, sugeruję, abyś postawił na ./node_modules/.binpierwszym miejscu swoją ścieżkę:

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

Jeśli umieścisz to w swoim ~/.profile, coffeezawsze będzie ./node_modules/.bin/coffeedostępne, w przeciwnym razie /usr/local/bin/coffee(lub jakikolwiek prefiks, pod którym instalujesz moduły węzłów).

Rozwiązanie PATH ma problem polegający na tym, że jeśli $ (npm bin) jest umieszczony w twoim .profile / .bashrc / etc, jest on oceniany raz i na zawsze jest ustawiany w jakimkolwiek katalogu, w którym najpierw oceniono ścieżkę. Jeśli zamiast tego zmodyfikujesz bieżącą ścieżkę, to za każdym razem, gdy uruchomisz skrypt, ścieżka się powiększy.

Aby obejść te problemy, utworzyłem funkcję i wykorzystałem ją. Nie modyfikuje środowiska i jest prosty w użyciu:

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

Można to następnie wykorzystać w następujący sposób bez wprowadzania zmian w środowisku:

npm-exec r.js <args>

Jeśli chcesz zachować npm, npx powinien zrobić to, czego potrzebujesz.

Jeśli przejście na przędzę (zastąpienie npm przez facebook) jest dla Ciebie opcją, możesz zadzwonić:

 yarn yourCmd

skrypty w pakiecie.json będą miały pierwszeństwo, jeśli żaden nie zostanie znaleziony, zajrzy do ./node_modules/.bin/folderu.

Wyświetla również to, co uruchomił:

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

Więc nie musisz konfigurować skryptów dla każdego polecenia w swoim package.json.

Jeśli masz skrypt zdefiniowany w .scriptsswoim package.json:

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

yarn tscbyłoby równoważne yarn run tsclub npm run tsc:

 yarn tsc
 yarn tsc v0.27.5
 $ tsc

aktualizacja: jeśli korzystasz z najnowszej wersji npm (wersja> 5.2)

Możesz użyć:

npx <command>

npxszuka polecenia w .binkatalogu twojegonode_modules

stara odpowiedź:

Dla Windowsa

Zapisz następujące elementy w pliku o nazwie npm-exec.bati dodaj go do swojego%PATH%

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

Stosowanie

Następnie możesz go użyć jak npm-exec <command> <arg0> <arg1> ...

Na przykład

Aby wykonać wdioinstalację zainstalowaną w lokalnym katalogu modułów_węzła, wykonaj:

npm-exec wdio wdio.conf.js

tj. będzie działać .\node_modules\.bin\wdio wdio.conf.js

Wolę nie polegać na aliasach powłoki lub innym pakiecie.

Dodając prosty wiersz do scriptssekcji package.json, możesz uruchamiać lokalne polecenia npm

npm run webpack

pakiet.json

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

Jeśli chcesz, aby zmienna PATH poprawnie aktualizowała się w oparciu o bieżący katalog roboczy, dodaj to na końcu swojego .bashrcekwiwalentu (lub po cokolwiek, co definiuje 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

Może to dodawać krótkie opóźnienie za każdym razem, gdy zostanie wyświetlony monit bash (w zależności od rozmiaru projektu, najprawdopodobniej), więc domyślnie jest wyłączony.

Można włączyć i wyłączyć go w terminalu, uruchamiając node-modei node-mode-offodpowiednio.

Zawsze korzystałem z tego samego podejścia co @ guneysus, aby rozwiązać ten problem, czyli tworzenie skryptu w pliku package.json i używanie go z uruchomioną nazwą skryptową npm.

Jednak w ostatnich miesiącach używam npx i uwielbiam to.

Na przykład pobrałem projekt Angular i nie chciałem instalować Angular CLI na całym świecie. Tak więc, z zainstalowanym npx, zamiast używać globalnego polecenia kątowego cli (jeśli go zainstalowałem) w następujący sposób:

ng serve

Mogę to zrobić z konsoli:

npx ng serve

Oto artykuł, który napisałem o NPX i który zagłębia się w to.

zxc jest jak „bundle exec” dla nodejs. Jest podobny do używania PATH=$(npm bin):$PATH:

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

Akceptowane to samo @regular, ale smak rybiej skorupy

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

Możesz także użyć direnv i zmienić zmienną $ PATH tylko w folderze roboczym.

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

Dodaj ten skrypt do swojego .bashrc. Następnie możesz zadzwonić coffeelub zadzwonić lokalnie. Jest to przydatne dla laptopa, ale nie używaj go na serwerze.

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;

Uwaga : ten skrypt tworzy alias cdpolecenia, a po każdym jego wywołaniu cdsprawdza node_modules/.bini dodaje go do twojego $PATH.

uwaga 2 : możesz zmienić trzecią linię na NODE_MODULES=$(npm bin);. Ale to spowodowałoby, że cddowodzenie byłoby zbyt wolne.

W systemie Windows użyj tego:

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

Napotkałem ten sam problem i szczególnie nie lubię używać aliasów (jak sugerują regularni ), a jeśli ich też nie lubisz, oto inne obejście, którego używam, najpierw musisz utworzyć mały skrypt wykonywalny bash, powiedz 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 "$@"

a następnie możesz użyć dowolnego pliku wykonywalnego w lokalnym /binza pomocą tego polecenia:

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

Jeśli używasz scriptsw package.json:

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

Chciałbym wiedzieć, czy to niepewny / zły pomysł, ale po odrobinie zastanowienia nie widzę tutaj problemu:

Modyfikując niepewne rozwiązanie Linusa, aby dodać go na końcu, używając npm bindo znalezienia katalogu, i uruchamiając skrypt tylko npm binwtedy, gdy a package.jsonjest obecny w rodzicu (dla szybkości), oto co wymyśliłem 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
}

Ponieważ bashzamiast używać precmdhaka, możesz użyć $PROMPT_COMMANDzmiennej (nie testowałem tego, ale masz pomysł):

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

Jestem Windowsużytkownikiem i właśnie to działało dla mnie:

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

Powodzenia.

Jeśli używasz fish shelli nie chcesz dodawać do $pathze względów bezpieczeństwa. Możemy dodać poniższą funkcję do uruchamiania plików wykonywalnych węzła lokalnego.

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

Teraz możesz uruchomić takie rzeczy jak:

n coffee

lub więcej argumentów takich jak:

n browser-sync --version

Uwaga: jeśli jesteś bashużytkownikiem, to odpowiedzi @ Bob9630 są dobrym sposobem na skorzystanie z bash $@, który nie jest dostępny w fishshell.

Dołącz skrypt kawy w pakiecie.json z określoną wersją wymaganą w każdym projekcie, zwykle tak:

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

Następnie uruchom npm install, aby zainstalować zależności w każdym projekcie. Spowoduje to zainstalowanie określonej wersji skryptu do kawy, która będzie dostępna lokalnie dla każdego projektu.