有没有办法从“package.json”获取版本？ Node.js 代码中的文件？

Question

有没有办法获取 package.json 中设置的版本。 Node.js 应用程序中的 json 文件？我想要这样的东西

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

Answer 1

或者在普通的旧外壳中：

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

这可以缩短为

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

Answer 2

检索版本的方法有两种：

1. 需要 package.json 和获取版本：

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

2. 使用环境变量：

const version = process.env.npm_package_version;

请不要使用 JSON.parse、fs .readFile、fs.readFileSync 并且不要使用其他 npm 模块，这个问题没有必要。

Answer 3

对于那些寻找也适用于服务器端的安全客户端解决方案的人来说，有genversion。它是一个命令行工具，可以从最近的 package.json 读取版本并生成导出该版本的可导入 CommonJS 模块文件。免责声明：我是维护者。

$ genversion lib/version.js

我承认客户端安全不是 OP 的主要意图，但正如 Mark Wallace 和 aug，它是高度相关的，也是我找到这个问答的原因。

Answer 4

以下是如何从 package.json 中读取版本：

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

在其他答案中，可能最干净的是：

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

这是 ES6 版本：

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

Answer 5

NPM oneliner：

来自npm v7.20.0：

npm pkg get version

在 npm v7.20.0 之前：

npm -s run env echo '$npm_package_version'

请注意，这两种方法的输出略有不同：前者输出用引号括起来的版本号（即 "1.0.0"），后者不带引号（即 1.0.0）。

在 Unix 中删除引号的一种解决方案是使用 xargs

npm pkg get version | xargs

Answer 6

还有另一种方法可以从 package.json 文件中获取某些信息，即使用 pkginfo 模块。

该模块的使用非常简单。您可以使用以下方式获取所有包变量：

require('pkginfo')(module);

或者仅获取某些详细信息（在本例中为 version）：

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

并且您的包变量将设置为 module.exports （因此版本号将可以通过 module.exports.version 访问）。

您可以使用以下代码片段：

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

---

该模块具有非常好的功能。它可以在项目中的任何文件中使用（例如，在子文件夹中），并且它将自动从您的 package.json 文件中获取信息。因此，您不必担心 package.json 文件在哪里。

Answer 7

选项 1

最佳实践是使用 npm 环境变量从 package.json 进行版本控制。

process.env.npm_package_version

更多信息： https://docs.npmjs.com/using-npm/config.html

仅当您使用 NPM 命令启动服务时，这才有效。

快速信息：您可以使用 process.env.npm_package_[keyname] 读取 pacakge.json 中的任何值

选项 2

使用 https://www.npmjs.com/package/dotenv 作为 .env 文件并将其读取为 process.env。版本

Answer 8

我们可以通过两种方式从 package.json 读取版本或其他密钥

1-使用 require 并导入所需的密钥，例如：

const version = require('./package.json')

2-使用 package_vars 如文档中所述

process.env.npm_package_version

Answer 9

只是添加一个答案，因为我来到这个问题是为了了解将 package.json 中的版本包含在我的 Web 应用程序中的最佳方法。

我知道这个问题是针对 Node.js 的，但是，如果您使用 Webpack 捆绑您的应用程序，只是提醒一下，推荐的方法是使用 DefinePlugin 在配置中声明全局版本并引用它。因此，您可以在 webpack.config.json 中执行操作

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

...

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

，然后 AppVersion 现在是可供您使用的全局变量。另请确保在您的 .eslintrc 中通过全局属性

Answer 10

一个安全的选择是添加一个 npm 脚本来生成单独的版本文件：

"scripts": {
    "build": "yarn version:output && blitz build",
    "version:output": "echo 'export const Version = { version: \"'$npm_package_version.$(date +%s)'\" }' > version.js"
  }

这会输出 version.js 内容：

export const Version = { version: "1.0.1.1622225484" }

Answer 11

您可以使用ES6导入package.json来检索版本号并在控制台输出版本。

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

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

Answer 12

如果您正在寻找 module (package.json: "type": "module") (ES6 import) 支持，例如来自重构 commonJS，您应该（在撰写本文时）执行以下任一操作：

import { readFile } from 'fs/promises';

const pkg = JSON.parse(await readFile(new URL('./package.json', import.meta.url)));

console.log(pkg.version)

或者，使用 node --experimental-json-modules index.js 运行节点进程来执行以下操作：

import pkg from './package.json'
console.log(pkg.version)

但是，您会收到警告，直到 json 模块变得普遍可用。

如果您收到语法或（顶级）异步错误，则您可能使用的是较旧的节点版本。至少更新到node@14。

Answer 13

要确定节点代码中的包版本，可以使用以下命令：

1. const version = require('./package.json').version; for

   const version = require('./package.json').version; ES6 版本

2. import {version} from './package.json'; 对于 ES6 版本

3. const version = process.env.npm_package_version;
   如果应用程序已使用 npm start 启动，则所有 npm_* 环境变量都可用。

4. 您也可以使用以下 npm 包 - root-require、pkginfo、project-version。

Answer 14

为什么不使用 require resolve...

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

这种方法适用于所有子路径:)

Answer 15

我正在使用 create-react-app ，但在执行 React-app 时没有可用的 process.env.npm_package_version 。

我不想在我的客户端代码中引用 package.json （因为向客户端暴露危险信息，例如包版本），我也不想安装另一个依赖项（genversion）。

我发现我可以通过在 package.json 中使用 $npm_package_version 来引用 package.json 中的 version：

"scripts": {
    "my_build_script": "REACT_APP_VERSION=$npm_package_version react-scripts start"
}

现在版本始终遵循package.json 中的那个。

Answer 16

您可以使用 project-version 包。

$ npm install --save project-version

然后

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

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

它使用 process.env.npm_package_version ，但会回退到 package.json 中编写的版本，以防环境变量由于某种原因丢失。

Answer 17

我知道这不是OP的意图，但我不得不这样做，所以希望它能帮助下一个人。

如果您使用 Docker Compose 进行 CI/CD流程，可以这样搞定！

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

对于图像，您可以使用任何 Node.js 图像。我使用 Alpine Linux，因为它是最小的。

Answer 18

我发现的最精简的方法：

const { version } = JSON.parse(fs.readFileSync('./package.json'))

Answer 19

如果您想获取目标包的版本。

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

示例：

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

Answer 20

实际上，我已经尝试过这里的大多数解决方案，它们要么在 Windows 和 Linux/OSX 上都不起作用，要么根本不起作用，要么依赖于 grep/awk/sed 等 Unix shell 工具。

接受的答案在技术上可行，但它会将整个 package.json 吸进您的构建中，这是一件坏事，只有绝望的人才应该使用，暂​​时解锁，并且通常应该避免，至少用于生产代码。一种替代方法是使用该方法仅将版本写入可用作构建源文件的单个常量，而不是整个文件。

因此，对于任何其他正在寻找跨平台解决方案（不依赖于 Unix shell 命令）和本地解决方案（没有外部依赖项）的人来说：

由于可以假设已安装 Node.js，并且它已经是跨平台的，所以我只是使用以下命令创建了一个 make_version.js 文件（或在较新的环境中为 make_version.cjs）：

const PACKAGE_VERSION = require("./package.json").version;
console.log(`export const PACKAGE_VERSION = "${PACKAGE_VERSION}";`);
console.error("package.json version:", PACKAGE_VERSION);

并向 package 添加了一个 version 命令。 json：

scripts: {
    "version": "node make_version.js > src/version.js",

或

scripts: {
    "version": "node make_version.cjs > src/version.js",

（对于CommonJS 文件），然后添加：

    "prebuild": "npm run version",
    "prestart": "npm run version",

它会在每次 start 或 build 上创建一个新的 src/versions.js。当然，这可以在 version 脚本中轻松调整为不同的位置，或者在 make_version.js 文件中输出不同的语法和常量名称等。

另请注意pnpm 包管理器不会自动运行“pre”脚本，因此如果使用该 PM，您可能需要调整两个命令。

Answer 21

我正在使用 gitlab ci 并希望自动使用不同的版本来标记我的 docker 镜像并推送它们。现在，他们的默认 docker 映像不包含节点，因此我仅在 shell 中执行此操作的版本是

script/getCurrentVersion.sh

BASEDIR=$(dirname $0)
cat $BASEDIR/../package.json | grep '"version"' | head -n 1 | awk '{print $2}' | sed 's/"//g; s/,//g'

现在，它的作用是

1. 打印您的包 json
2. 搜索带有“version”的行
3. 仅获取第一个结果
4. 替换“和，

请注意，我的脚本位于存储库中具有相应名称的子文件夹中，因此，如果您不将 $BASEDIR/../package.json 更改为 $BASEDIR/package.json

或者如果您希望能够获得专业，次要版本和补丁版本 如果您的版本是 1.2.3，我会这样使用

script/getCurrentVersion.sh

VERSION_TYPE=$1
BASEDIR=$(dirname $0)
VERSION=$(cat $BASEDIR/../package.json | grep '"version"' | head -n 1 | awk '{print $2}' | sed 's/"//g; s/,//g')

if [ $VERSION_TYPE = "major" ]; then
  echo $(echo $VERSION | awk -F "." '{print $1}' )
elif [ $VERSION_TYPE = "minor" ]; then
  echo $(echo $VERSION | awk -F "." '{print $1"."$2}' )
else
  echo $VERSION
fi

您的输出将如下所示

$ > sh ./getCurrentVersion.sh major
1

gt; sh ./getCurrentVersion.sh minor
1.2

gt; sh ./getCurrentVersion.sh
1.2.3

现在您唯一需要确保的是您的软件包版本将是软件包中的第一次。 .json 使用该密钥，否则您将得到错误的版本

Answer 22

我使用 findup-sync 执行此操作：

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

Answer 23

我编写了一个有用的代码来获取父模块的 package.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
}

Answer 24

如果使用 rollup，则可以使用 rollup-plugin-replace 插件添加版本，而无需向客户端公开 package.json。

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

然后，在源代码中，任何想要使用 package.json 版本的地方，都可以使用字符串“MY_PACKAGE_JSON_VERSION”。

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

Answer 25

const { version } = require("./package.json");
console.log(version);

const v = require("./package.json").version;
console.log(v);

Answer 26

将 package.json 文件导入到 server.js 或 app.js 中，然后将 package.json 属性访问到服务器文件中。

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

package 变量包含 package.json 中的所有数据。

Answer 27

const packageJson = require('./package.json'); // Adjust the path if needed

const appVersion = packageJson.version;

console.log(`The version specified in package.json is: ${appVersion}`);

此代码假设您的 package.json 文件位于 Node.js 应用程序的根目录中。如果它位于不同的目录中，请相应地调整所需路径。

这会将 package.json 中指定的版本记录到控制台。您可以根据需要在应用程序中使用 appVersion 变量。

Answer 28

我发现以下代码片段最适合我。由于它使用 require 加载 package.json，因此无论当前工作目录如何，它都可以正常工作。

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

警告，由 @Pathogen 提供：

使用 Browserify 执行此操作会产生安全隐患。
请小心，不要将您的 package.json 暴露给客户端，因为这意味着您的所有依赖项版本号、构建和测试命令等都会发送到客户端。
如果您在同一个项目中构建服务器和客户端，那么您也会公开服务器端版本号。
攻击者可以使用此类特定数据来更好地适应对您服务器的攻击。<​​/p>

Answer 29

如果您的应用程序是使用 npm start 启动的，您只需使用：

process.env.npm_package_version

请参阅 package.json vars 了解更多详细信息。

Answer 30

使用 ES6 模块，您可以执行以下操作：

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