Gibt es eine Möglichkeit, die Version von package.json in nodejs Code abzurufen?

Gibt es eine Möglichkeit, die package.jsonin einer NodeJS-App festgelegte Version zu erhalten ? Ich würde so etwas wollen

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

Ich fand, dass das folgende Codefragment für mich am besten funktioniert. Da es requirezum Laden von verwendet wird package.json, funktioniert es unabhängig vom aktuellen Arbeitsverzeichnis.

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

Eine Warnung mit freundlicher Genehmigung von @Pathogen:

Dies mit Browserify zu tun, hat Auswirkungen auf die Sicherheit.
Achten Sie darauf, dass Sie nicht package.jsondem Client ausgesetzt werden, da alle Versionsnummern, Build- und Testbefehle und mehr für Abhängigkeiten an den Client gesendet werden.
Wenn Sie Server und Client im selben Projekt erstellen, legen Sie auch Ihre serverseitigen Versionsnummern offen. Solche spezifischen Daten können von einem Angreifer verwendet werden, um den Angriff auf Ihren Server besser anzupassen.

Wenn Ihre Anwendung mit 'npm start' gestartet wird, können Sie einfach Folgendes verwenden:

process.env.npm_package_version

Weitere Informationen finden Sie unter package.json vars .

Mit ES6-Modulen können Sie Folgendes tun:

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

Oder in einfacher alter Schale:

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

Dies kann auf verkürzt werden

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

Auch wenn dies nicht genau das ist, was die Frage gestellt hat, ist es nützlich, wenn Sie die Version in sich package.jsonselbst verwenden möchten , z. B. um sich bei einer versionierten Datei in einem Protokoll anzumelden 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",
  ...
}

Es gibt zwei Möglichkeiten, die Version abzurufen:

1. package.jsonVersion anfordern und abrufen :

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

2. Verwenden der Umgebungsvariablen:

const version = process.env.npm_package_version;

Bitte verwenden Sie nicht JSON.parse, fs.readFile, fs.readFileSyncund das andere tun nicht verwenden npm moduleses für diese Frage nicht notwendig ist.

So lesen Sie die Version aus package.json:

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

Es gibt eine andere Möglichkeit, bestimmte Informationen von Ihrem abzurufen package.json Datei abzurufen, nämlich das pkginfo- Modul.

Die Verwendung dieses Moduls ist sehr einfach. Sie können alle Paketvariablen abrufen mit:

require('pkginfo')(module);

Oder nur bestimmte Details (version in diesem Fall)

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

Und Ihre Paketvariablen werden auf gesetzt module.exports (so dass die Versionsnummer über zugänglich istmodule.exports.version ).

Sie können das folgende Codefragment verwenden:

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

Dieses Modul hat eine sehr schöne Funktion - es kann in jeder Datei in Ihrem Projekt verwendet werden (z. B. in Unterordnern) und ruft automatisch Informationen von Ihrem ab package.json . Sie müssen sich also keine Sorgen machen, wo Sie package.jsonsind.

Ich hoffe das wird helfen.

Für diejenigen, die nach einer sicheren clientseitigen Lösung suchen , die auch serverseitig funktioniert, gibt es eine Genversion . Es ist ein Befehlszeilentool, das die Version aus der nächsten package.json liest und eine importierbare CommonJS-Moduldatei generiert, die die Version exportiert. Haftungsausschluss: Ich bin ein Betreuer.

$ genversion lib/version.js

Ich erkenne an, dass die clientseitige Sicherheit nicht die primäre Absicht von OP war, aber wie in den Antworten von Mark Wallace und aug erörtert , ist sie von hoher Relevanz und auch der Grund, warum ich diese Fragen und Antworten gefunden habe.

Ich habe nur eine Antwort hinzugefügt, weil ich auf diese Frage gekommen bin, um herauszufinden, wie ich die Version von package.json am besten in meine Webanwendung aufnehmen kann.

Ich weiß, dass diese Frage für Node.js bestimmt ist. Wenn Sie jedoch Webpack verwenden, um Ihre App zu bündeln, wird nur empfohlen, das DefinePlugin zu verwenden, um eine globale Version in der Konfiguration zu deklarieren und darauf zu verweisen. So könnten Sie in Ihrem tunwebpack.config.json

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

...

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

Und dann AppVersionsteht Ihnen jetzt ein Global zur Verfügung. Stellen Sie außerdem sicher, dass .eslintrcSie dies über die globale Requisite ignorieren

Option 1

Die beste Vorgehensweise ist die Versionierung von package.json unter Verwendung von npm-Umgebungsvariablen.

process.env.npm_package_version

Weitere Informationen unter: https://docs.npmjs.com/using-npm/config.html

Dies funktioniert nur, wenn Sie Ihren Dienst mit dem NPM-Befehl starten.

Kurzinfo: Sie können alle Werte in pacakge.json mit process.env.npm_package_ [keyname] lesen.

Option 2

Festlegen der Version in der Umgebungsvariablen mithilfe von https://www.npmjs.com/package/dotenv als .envDatei und in Bezug auf inprocess.env.version

Mit ES6 können Sie package.json importieren, um die Versionsnummer abzurufen und die Version auf der Konsole auszugeben.

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

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

Um die Paketversion im Knotencode zu bestimmen, können Sie Folgendes verwenden:

1. const version = require('./package.json').version; für <ES6-Versionen

2. import {version} from './package.json'; für ES6-Version

3. const version = process.env.npm_package_version; Wenn die Anwendung mit gestartet wurde npm start, werden alle Umgebungsvariablen npm_ * verfügbar.

4. Sie können auch die folgenden npm-Pakete verwenden - root-require, pkginfo, project-version.

Sie können das Projektversionspaket verwenden .

$ npm install --save project-version

Dann

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

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

Es verwendet process.env.npm_package_versionaber einen Fallback auf die Version, die in dem package.jsonFall geschrieben wurde, falls die env var aus irgendeinem Grund fehlt.

Ich mache das mit findup-sync:

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

Ich weiß, dass dies nicht die Absicht des OP ist, aber ich musste dies nur tun, also hoffe, es hilft der nächsten Person.

Wenn Sie Docker-Compose für Ihren CI / CD-Prozess verwenden, können Sie dies auf diese Weise erreichen!

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', '')\""

Für das Bild können Sie ein beliebiges Knotenbild verwenden. Ich benutze alpine, weil es das kleinste ist.

Warum nicht die erforderliche Auflösung verwenden ...

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

Mit diesem Ansatz arbeiten für alle Unterpfade :)

Importieren Sie Ihre package.jsonDatei in Ihre server.jsoder app.jsund greifen Sie dann auf die Eigenschaften package.json in die Serverdatei zu.

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

Die Paketvariable enthält alle Daten in package.json.

Ich habe einen nützlichen Code erstellt, um die package.json des übergeordneten Moduls abzurufen

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
}

Wenn Sie Rollup verwenden, kann das rollup-plugin-replacePlugin verwendet werden, um die Version hinzuzufügen, ohne package.json für den Client verfügbar zu machen.

// 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
    }),
  ]
};

Dann würden Sie im Quellcode überall dort, wo Sie die package.json-Version haben möchten, die Zeichenfolge 'MY_PACKAGE_JSON_VERSION' verwenden.

// src/index.js
export const packageVersion = 'MY_PACKAGE_JSON_VERSION' // replaced with actual version number in rollup.config.js