Find the version of an installed npm package

问题:

How to find the version of an installed node.js/npm package?

This prints the version of npm itself:

npm -v <package-name>

This prints a cryptic error:

npm version <package-name>

This prints the package version on the registry (i.e. the latest version available):

npm view <package-name> version

How do I get the installed version?

回答1:

npm list for local packages or npm list -g for globally installed packages.

You can find the version of a specific package by passing its name as an argument. For example, npm list grunt will result in:

projectName@projectVersion /path/to/project/folder
└── grunt@0.4.1

Alternatively, you can just run npm list without passing a package name as an argument to see the versions of all your packages:

├─┬ cli-color@0.1.6 
│ └── es5-ext@0.7.1 
├── coffee-script@1.3.3 
├── less@1.3.0 
├─┬ sentry@0.1.2 
│ ├── file@0.2.1 
│ └── underscore@1.3.3 
└── uglify-js@1.2.6 

回答2:

Another quick way of finding out what packages are installed locally and without their dependencies is to use:

npm list --depth=0

Which gives you something like

├── bower@0.8.6
├── grunt@0.4.1
├── grunt-bower-requirejs@0.4.3
├── grunt-contrib-clean@0.4.1
├── grunt-contrib-coffee@0.7.0
├── grunt-contrib-copy@0.4.1
├── grunt-contrib-imagemin@0.1.4
├── grunt-contrib-jshint@0.1.1
├── grunt-contrib-livereload@0.1.2
├── grunt-contrib-requirejs@0.4.1
├── grunt-regarde@0.1.1
└── grunt-svgmin@0.1.0

Obviously, the same can be done globally with npm list -g --depth=0.

This method is clearer in case you have installed a lot of packages.

To find out which packages need to be updated, you can use npm outdated -g --depth=0.

回答3:

npm view <package> version - returns the latest available version on the package.

npm list --depth=0 - returns versions of all installed modules without dependencies.

npm list - returns versions of all modules and dependencies.

And lastly to get node version: node -v

回答4:

npm info YOUR_PACKAGE version

e.g.

npm info grunt version
0.4.5

回答5:

I just used npm list | grep <package name> and it worked great

On windows run:

npm list | find <package name>

In PowerShell run:

npm list | sls <package name>

回答6:

From the root of the package do:

node -p "require('./package.json').version"

EDIT: (so you need to cd into the module's home directory if you are not already there. If you have installed the module with npm install, then it will be under node_modules/<module_name>)

EDIT 2: updated as per answer from @jeff-dickey

回答7:

You can also check the version by this command.

npm info <package name > version

回答8:

If you agree to install jq, you can use the JSON output of npm list.

npm -j ls <package-name> | jq -r .version

or, if you want to be verbose

npm --json list <package-name> | jq --raw-output '.version'

For instance:

$ npm -j ls ghost | jq -r .version
0.4.2

Also, the JSON format is slightly different for global packages, so you'll need to change the query.

For instance:

$ npm -j -g ls | jq -r .dependencies.ghost.version
0.4.2

回答9:

If you are brave enough (and have node installed), you can always do something like:

echo "console.log(require('./package.json').version);" | node

This will print the version of the current package. You can also modify it to go insane, like this:

echo "eval('var result='+require('child_process').execSync('npm version',{encoding:'utf8'})); console.log(result.WHATEVER_PACKAGE_NAME);" | node

That will print the version of WHATEVER_PACKAGE_NAME package, that is seen by npm version.

回答10:

You can use npm view [module] version, npm info [module] version, npm show [module] version or npm v [module] version to check the version on an installed npm module.

Let's suppose my grunt module version is the 0.4.5:

npm view grunt version => 0.4.5
npm info grunt version => 0.4.5
npm show grunt version => 0.4.5
npm v grunt version    => 0.4.5

回答11:

For local packages

npm list --depth=0

For Global packages

npm list  -g --depth=0

回答12:

To see all the installed packages locally or globally, use these commands:

1. npm list for local packages or npm list -g for globally installed packages.
2. npm list --depth=0
3. npm list | sls <package name>
4. node -v

回答13:

Combining some of the above answers and produces a super simple and super quick lookup.
Run from project root. No need to cd into any folder, just 1 line:

node -p "require('SOMEPACKAGE/package.json').version"

回答14:

Try with:

npm list --depth 1 --global packagename

回答15:

Here's a portable Unix (using grep and sed) one-liner that returns the version string of a globally-installed npm package (remove the g from -pg to query local packages instead):

$ npm ll -pg --depth=0 grunt | grep -o "@.*:" | sed 's/.$//; s/^.//'
0.4.5

• the npm ll outputs a parseable string formatted like: /usr/lib/node_modules/npm:npm@2.14.8:;
• the grep command extracts the value between @ and :, inclusive;
• the sed command removes the surrounding characters.

回答16:

You may try this: npm show {package} version shows the latest package version. And if your package is outdated, npm outdated will show it with version info.

回答17:

I've built a tool that does exactly that - qnm

qnm - A simple CLI utility for querying the node_modules directory.

Install it using:

npm i --global qnm

and run:

qnm [module]

for example:

> qnm lodash

lodash
├── 4.17.5
├─┬ cli-table2
│ └── 3.10.1
└─┬ karma
  └── 3.10.1

Which means we have lodash installed in the root of the node_modules and two other copies in the node_modules of cli-table2 and karma.

It's really fast, and has some nice features like tab completion and match search.

回答18:

I added this to my .bashrc

function npmv {
    case $# in # number of arguments passed
    0) v="$(npm -v)" ; #store output from npm -v in variable
        echo "NPM version is: $v"; #can't use single quotes 
                                   #${v} would also work
    ;;   
    1) s="$(npm list --depth=0 $1 | grep $1 | cut -d @ -f 2)";
       echo "$s";
    ;;
    2) case "$2" in # second argument
        g) #global|#Syntax to compare bash string to literal
             s="$(npm list --depth=0 -g $1 | grep $1 | cut -d @ -f 2)";
        echo "$s";
        ;;
        l) #latest
             npm view $1 version; #npm info $1 version does same thing
       ;;
       *) echo 'Invalid arguments';
       ;;
       esac;
    ;;
    *) echo 'Invalid arguments';
    ;;
    esac;
}
export -f npmv

Now all I have to do is type:

• npmv for the version of npm eg: NPM version is: 4.2.0
• npmv <package-name> for the local version eg: 0.8.08
• npmv <package-name> g for global version eg: 0.8.09
• npmv <package-name> l for latest version eg: 0.8.10

Note -d on cut command means delimit by, followed by @, then f means field the 2 means second field since there will be one either side of the @ symbol.

回答19:

Access the package.json

You can access the package.json or bower.json of the package with:

notepad ./node_modules/:packageName/package.json

This will open the package.json in notepad which has the version number of the :packageName you included in the command.

For example :

notepad ./node_modules/vue-template-compiler/package.json

Good Luck.

回答20:

We can use npm view any-promise(your module name) -v