Existe-t-il un moyen d'obtenir la version de package.json dans le code nodejs?


586

Existe-t-il un moyen d'obtenir la version définie package.jsondans une application nodejs? Je voudrais quelque chose comme ça

var port = process.env.PORT || 3000
app.listen port
console.log "Express server listening on port %d in %s mode %s", app.address().port, app.settings.env, app.VERSION

Est-il plus important d'obtenir la version de Node ou la version déclarée dans package.json? Si le formulaire, cela vous donnera la version en cours d'exécution:console.log(process.version)
Adrian Lynch

Réponses:


957

J'ai trouvé que le fragment de code suivant fonctionnait le mieux pour moi. Puisqu'il utilise requirepour charger le package.json, il fonctionne quel que soit le répertoire de travail actuel.

var pjson = require('./package.json');
console.log(pjson.version);

Un avertissement, gracieuseté de @Pathogen:

Faire cela avec Browserify a des implications de sécurité.
Veillez à ne pas exposer votre package.jsonau client, car cela signifie que tous vos numéros de version de dépendance, les commandes de génération et de test et plus sont envoyés au client.
Si vous créez un serveur et un client dans le même projet, vous exposez également vos numéros de version côté serveur. Ces données spécifiques peuvent être utilisées par un attaquant pour mieux adapter l'attaque sur votre serveur.


25
si vous continuez à vous brûler en essayant de l'attraper à différents endroits (comme moi), vous pouvez le fairerequire('root-require')('package.json').version
mikermcneil

5
Ne fonctionne pas pour mon script avec shebang installé dans le monde. Error: Cannot find module 'package.json'.
exebook

14
plus court - nécessite ('./ package'). version
Afanasii Kurakin

60
Attention! Faire cela avec browserify a des implications de sécurité: package.json dans votre bundle signifie que tous vos numéros de version de dépendance, les commandes de construction et de test et plus sont envoyés au client. Si vous créez un serveur et un client dans le même projet, vous exposez également vos numéros de version côté serveur.
Pathogène

4
@Pathogen genversion résout le problème côté client. C'est un outil qui lit la version de package.json et en génère un module importable. Avertissement: je suis un mainteneur.
Akseli Palén

349

Si votre application est lancée avec 'npm start', vous pouvez simplement utiliser:

process.env.npm_package_version

Voir package.json vars pour plus de détails.


6
c'est probablement la meilleure réponse puisque la plupart des informations dans package.json sont attachées à la variable d'exécution du processus
Alexander Mills

2
Ouais, je suis d'accord. Cela devrait être la bonne réponse, en utilisant la variable de processus, vous n'avez pas besoin d'ouvrir et de relire le fichier package.json.
Juanma

12
Et en dehors du nœud (par exemple, les scripts shell exécutés via npm run …) la version sera dans la variable d'environnement $npm_package_version.
Quinn Comendant

12
Lorsqu'il est appelé à partir de scripts d'un autre package, cela signale de manière incorrecte la version du package appelant et non le package appelé .
jjrv

6
Il fonctionne au sein d'une application électronique démarrée avec npm start, mais pas au sein d'une application électronique intégrée: pour cela, vous pouvez le trouver dans app.getVersion.
ChrisV

158

À l'aide des modules ES6, vous pouvez effectuer les opérations suivantes:

import {version} from './package.json';

2
Je pensais que ceux-ci n'étaient pas pris en charge dans le nœud: github.com/nodejs/help/issues/53
ripper234

1
Aucun module es6 n'est pas encore directement pris en charge mais couramment utilisé de toute façon, activé à l'aide de Babel
Patrick Lee Scott

4
@Sornii non, l'intégralité du package.json sera dans le client. J'ai utilisé definePlugin de webpack pour transmettre uniquement les informations sélectionnées de l'environnement de noeud au navigateur.
doeke

2
Toute implication de sécurité telle que spécifiée dans stackoverflow.com/a/10855054/540144 ?
itsazzad

1
Oui, mêmes problèmes de sécurité. L'ensemble package.json sera inclus dans le pack client.
Neromancer

95

Ou en plaine ancienne:

node -e "console.log(require('./package.json').version);"

Cela peut être raccourci

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

Même si ce n'est pas exactement la question posée, c'est utile si vous voulez utiliser la version en package.jsonelle-même, par exemple pour vous connecter à un fichier versionné dans un script:

{
  "name": "myapp",
  "version": "0.1.2",
  "scripts": {
    "run": "node index.js 2>&1 | tee -a myapp_v$(node -p \"require('./package.json').version\").log",
  ...
}

Ce n'est pas dans l'application nodeJS elle-même, comme demandé.
Steve Bennett

1
@SteveBennett Non, mais cela a aidé 90 personnes et moi.
K - La toxicité du SO augmente.

1
Probablement beaucoup plus que cela.
Steve Bennett

61

Il existe deux façons de récupérer la version:

  1. Exiger package.jsonet obtenir la version:
const { version } = require('./package.json');
  1. Utilisation des variables d'environnement:
const version = process.env.npm_package_version;

S'il vous plaît ne pas utiliser JSON.parse, fs.readFile, fs.readFileSyncet ne pas utiliser une autre , npm modulesil est pas nécessaire pour cette question.


2
Merci pour cet extrait de code, qui pourrait fournir une aide immédiate limitée. Une explication appropriée améliorerait considérablement sa valeur à long terme en montrant pourquoi c'est une bonne solution au problème, et la rendrait plus utile aux futurs lecteurs avec d'autres questions similaires. Veuillez modifier votre réponse pour ajouter des explications, y compris les hypothèses que vous avez faites.
milo526

8
Les npm_*valeurs d'environnement ne sont alors disponibles que si votre script a été démarré par NPM, par exemple npm start. Si vous le faites node app.jsou similaire, ils ne seront pas présents.
Nate

@Nate Il est donc préférable d'utiliser la version de package.json?
Filip Š

38

Voici comment lire la version de package.json:

fs = require('fs')
json = JSON.parse(fs.readFileSync('package.json', 'utf8'))
version = json.version

J'ai vu cela un tas, et j'aime ça - est-ce que vous / quelqu'un connaît les considérations qui require() introduces? (for instance, does exigent que () `ne supporte pas la lecture utf8? comme votre extrait peut le suggérer)
electblake

4
require()met en cache le fichier, ce qui dans ce cas ne devrait pas faire de différence.
jlee

@jlee y a-t-il une raison pour laquelle les gens font souvent JSON.parse(fs.readFileSync('package.json', 'utf8'))plutôt que de delete require.cache[require.resolve('package.json')]; require('package.json')vouloir recharger?
Mihail Malostanidis

const {version} = require ('./ package.json');
Alex Dykyі

23

Il existe une autre façon de récupérer certaines informations de votre package.jsonfichier, à savoir en utilisant le module pkginfo .

L'utilisation de ce module est très simple. Vous pouvez obtenir toutes les variables de package en utilisant:

require('pkginfo')(module);

Ou seulement certains détails ( versiondans ce cas)

require('pkginfo')(module, 'version');

Et vos variables de package seront définies sur module.exports(donc le numéro de version sera accessible via module.exports.version).

Vous pouvez utiliser l'extrait de code suivant:

require('pkginfo')(module, 'version');
console.log "Express server listening on port %d in %s mode %s", app.address().port, app.settings.env, module.exports.version

Ce module a une fonctionnalité très intéressante - il peut être utilisé dans n'importe quel fichier de votre projet (par exemple dans les sous-dossiers) et il récupérera automatiquement les informations de votre package.json. Vous n'avez donc pas à vous soucier où vous êtes package.json.

J'espère que cela aidera.


1
qu'y a- modulet-il ici?
chovy

@chovy, modulen'est pas cette variable d'exemple spécifique; c'est une variable représentant le module courant dans node.js. Vous pouvez en savoir plus sur les modules node.js ici: nodejs.org/api/modules.html#modules_the_module_object
Tom

2
J'essaie d'obtenir la version des autres modules requis par mon module ... et j'ai du mal à déterminer si pkginfo rend cela possible.
Michael

23

Pour ceux qui recherchent une solution côté client sûre qui fonctionne également côté serveur, il y a genversion . Il s'agit d'un outil en ligne de commande qui lit la version à partir du package.json le plus proche et génère un fichier de module CommonJS importable qui exporte la version. Avertissement: je suis un mainteneur.

$ genversion lib/version.js

Je reconnais que la sécurité côté client n'était pas l'intention principale d'OP, mais comme discuté dans les réponses de Mark Wallace et août , c'est très pertinent et c'est aussi la raison pour laquelle j'ai trouvé ce Q&R.


4
C'est LA réponse, et elle a besoin de plus de votes pour dépasser la réponse profondément problématique en haut en ce moment.
Jeff Allen

1
Certaines personnes pourraient être alarmées par le fait qu'il s'agit d'un outil en ligne de commande. Ne t'inquiète pas! Le fichier lisez-moi de l'outil décrit comment intégrer (facilement) l'appel à build dans package.json, de sorte que vous puissiez oublier l'existence de l'outil et avoir toujours le numéro de version le plus récent.
malamut

11

Je viens d'ajouter une réponse parce que je suis venu à cette question pour voir la meilleure façon d'inclure la version de package.json dans mon application Web.

Je sais que cette question est ciblée pour Node.js cependant, si vous utilisez Webpack pour regrouper votre application, juste un rappel, la méthode recommandée consiste à utiliser DefinePlugin pour déclarer une version globale dans la configuration et la référencer. Vous pourriez donc faire dans votrewebpack.config.json

const pkg = require('../../package.json');

...

plugins : [
    new webpack.DefinePlugin({
      AppVersion: JSON.stringify(pkg.version),
...

Et puis AppVersionest maintenant un global qui est disponible pour vous d'utiliser. Assurez- vous également que .eslintrcvous l'ignorez via l'accessoire global


8

Option 1

La meilleure pratique consiste à effectuer une version à partir de package.json à l'aide des variables d'environnement npm.

process.env.npm_package_version

plus d'informations sur: https://docs.npmjs.com/using-npm/config.html

Cela ne fonctionnera que lorsque vous démarrez votre service à l'aide de la commande NPM.

Info rapide: vous pouvez lire toutes les valeurs dans pacakge.json en utilisant process.env.npm_package_ [nom de clé]

Option 2

Définition de la version dans la variable d'environnement en utilisant https://www.npmjs.com/package/dotenv en tant que .envfichier et en la considérant dansprocess.env.version


7

Vous pouvez utiliser ES6 pour importer package.json pour récupérer le numéro de version et sortir la version sur la console.

import {name as app_name, version as app_version}  from './path/to/package.json';

console.log(`App ---- ${app_name}\nVersion ---- ${app_version}`);

3
Cela fonctionne tant que vous définissez «resolverJsonModule» sur «true» dans tsconfig.json.
Russell Phillips

6

Pour déterminer la version du package dans le code de nœud, vous pouvez utiliser les éléments suivants:

  1. const version = require('./package.json').version; pour <versions ES6

  2. import {version} from './package.json'; pour la version ES6

  3. const version = process.env.npm_package_version; si l'application a été démarrée à l'aide npm start, toutes les variables d'environnement npm_ * deviennent disponibles.

  4. Vous pouvez également utiliser les packages npm suivants - root-require, pkginfo, project-version.


4

Vous pouvez utiliser le package de version projet .

$ npm install --save project-version

alors

const version = require('project-version');

console.log(version);
//=>  '1.0.0'

Il utilise process.env.npm_package_versionmais se replie sur la version écrite dans le package.jsoncas où la var env serait manquante pour une raison quelconque.


Par exemple, si le fichier js a été démarré pas à partir de npm?
Mihail Malostanidis

2

Pourquoi ne pas utiliser la résolution requise ...

const packageJson = path.dirname(require.resolve('package-name')) + '/package.json';
const { version } = require(packageJson);
console.log('version', version)

Avec cette approche, travaillez pour tous les sous-chemins :)


1

Je fais ça avec findup-sync:

var findup = require('findup-sync');
var packagejson = require(findup('package.json'));
console.log(packagejson.version); // => '0.0.1' 

la recherche commence par cwd, donc dans la plupart des cas, elle obtiendrait simplement le niveau supérieur package.json, similaire au fait de process.env.npm_package_versionne pas exiger qu'elle soit démarrée via npm. Donc, essayer d'obtenir la version de votre bibliothèque obtiendrait en fait la version de l'appelant. Un simple besoin ('./ package.json') éviterait cela.
Mihail Malostanidis

1

Je sais que ce n'est pas l'intention du PO, mais je devais juste le faire, alors j'espère que cela aidera la prochaine personne.

Si vous utilisez docker-compose pour votre processus CI / CD, vous pouvez l'obtenir de cette façon!

version:
  image: node:7-alpine
  volumes:
    - .:/usr/src/service/
  working_dir: /usr/src/service/
  command: ash -c "node -p \"require('./package.json').version.replace('\n', '')\""

pour l'image, vous pouvez utiliser n'importe quelle image de nœud. J'utilise l'alpin car c'est le plus petit.


0

Importez votre package.jsonfichier dans votre server.jsou app.jspuis accédez aux propriétés package.json dans le fichier serveur.

var package = require('./package.json');

La variable de package contient toutes les données de package.json.


0

J'ai créé un code utile pour obtenir le package du module parent.json

function loadParentPackageJson() {
    if (!module.parent || !module.parent.filename) return null
    let dir = path.dirname(module.parent.filename)
    let maxDepth = 5
    let packageJson = null
    while (maxDepth > 0) {
        const packageJsonPath = `${dir}/package.json`
        const exists = existsSync(packageJsonPath)
        if (exists) {
            packageJson = require(packageJsonPath)
            break
        }
        dir = path.resolve(dir, '../')
        maxDepth--
    }
    return packageJson
}

0

Si vous utilisez le cumul, le rollup-plugin-replaceplug - in peut être utilisé pour ajouter la version sans exposer package.json au client.

// rollup.config.js

import pkg from './package.json';
import { terser } from "rollup-plugin-terser";
import resolve from 'rollup-plugin-node-resolve';
import commonJS from 'rollup-plugin-commonjs'
import replace from 'rollup-plugin-replace';

export default {
  plugins: [
    replace({
      exclude: 'node_modules/**',
      'MY_PACKAGE_JSON_VERSION': pkg.version, // will replace 'MY_PACKAGE_JSON_VERSION' with package.json version throughout source code
    }),
  ]
};

Ensuite, dans le code source, n'importe où où vous voulez avoir la version package.json, vous utiliseriez la chaîne 'MY_PACKAGE_JSON_VERSION'.

// src/index.js
export const packageVersion = 'MY_PACKAGE_JSON_VERSION' // replaced with actual version number in rollup.config.js
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.