跳到主要内容 Node.js 环境变量配置与管理 | 极客日志
JavaScript Node.js
Node.js 环境变量配置与管理 Node.js 环境变量管理是开发中的关键环节，涉及避免硬编码、多环境配置及安全性。 process.env 基础、多种设置方法（命令行、.env 文件、系统变量）、企业级配置架构（验证与结构化）、生产部署策略（Docker/K8s）以及安全实践与调试技巧。通过规范化管理，可提升应用的可维护性与安全性。
芝士奶盖 发布于 2026/3/29 更新于 2026/4/17 Node.js 环境变量配置与管理
引言：为什么环境变量是现代开发的基石？
在软件开发领域，有一个被无数开发者用血泪教训换来的黄金法则：永远不要将配置信息硬编码在代码中 。想象一下这样的场景：凌晨三点，生产环境数据库突然崩溃，急需切换到备份数据库，却发现数据库连接字符串深深嵌入在数千行代码中；新同事加入团队，花了三天时间搭建开发环境，只因不知道需要配置哪些参数；不小心将包含 API 密钥的代码提交到公开仓库，导致数千美元的意外费用。
这些看似戏剧性的场景，在实际开发中却屡见不鲜。而环境变量，正是解决这些问题的银弹。
环境变量方案 vs 硬编码方案
graph TD subgraph A [环境变量方案] A1[开发环境] --> A11[数据库地址=process.env.DB_URL] A2[测试环境] --> A21[数据库地址=process.env.DB_URL] A3[生产环境] --> A31[数据库地址=process.env.DB_URL] A11 & A21 & A31 --> A4[一处配置，多环境复用] end subgraph B [硬编码方案] B1[开发环境] --> B11[数据库地址=localhost:3306] B2[测试环境] --> B21[数据库地址=test-db:3306] B3[生产环境] --> B31[数据库地址=prod-db:3306] B11 & B21 & B31 --> B4[代码修改频繁<br>配置分散难维护] end A4 --> C[✅ 配置统一管理] B4 --> D[❌ 维护成本高]
环境变量基础：深入理解 process.env
什么是进程环境？ 在 Node.js 中，process 是一个全局对象，提供了当前 Node.js 进程的信息和控制能力。process.env 则是这个对象的一个重要属性，它返回一个包含用户环境键值对的对象。
console .log (typeof process.env );
console .log (process.env instanceof Object );
for (const [key, value] of Object .entries (process.env )){
console .log (`${key} : ${value} ` );
}
环境变量的本质特征
字符串类型 ：所有环境变量的值都是字符串进程级作用域 ：每个进程都有自己独立的环境变量集合继承机制 ：子进程会继承父进程的环境变量大小写敏感 ：在不同操作系统中表现不一致（Windows 不敏感，Linux/macOS 敏感）
console .log (typeof process.env .NODE_ENV );
process.env .MY_VARIABLE = 'some value' ;
console .log (process.env .MY_VARIABLE );
环境变量设置方法大全
环境变量设置方法对比 对比维度 系统环境变量 .env 文件 命令行设置 操作步骤 1. Windows: 高级系统设置 1. 创建 .env 文件 终端执行: 优点 • 所有进程可用 • 项目级配置管理 • 无需修改文件 缺点 • 步骤复杂 • 需安装 dotenv 依赖 • 重启终端失效 适用场景 跨项目通用配置 本地开发、项目级配置 临时测试、单次脚本执行
1. 命令行临时设置
NODE_ENV=production node app.js
DB_HOST=localhost DB_PORT=5432 API_KEY=secret123 node app.js
export API_BASE="https://api.example.com"
NODE_ENV=development API_URL="${API_BASE} /v1" node app.js
:: Command Prompt
set NODE_ENV=production && set DB_HOST=localhost && node app.js
:: PowerShell
$env:NODE_ENV="production"; $env:DB_HOST="localhost"; node app.js
2. 使用 package.json 脚本 {
"scripts" : {
"dev" : "NODE_ENV=development nodemon server.js" ,
"start" : "NODE_ENV=production node server.js" ,
"test" : "NODE_ENV=test jest" ,
"debug" : "NODE_ENV=development DEBUG=app:* node --inspect server.js" ,
"build:dev" : "NODE_ENV=development webpack --config webpack.config.js" ,
"build:prod" : "NODE_ENV=production webpack --config webpack.config.js"
}
}
3. 跨平台解决方案 为了解决不同操作系统环境变量设置的差异，可以使用 cross-env 包：
npm install --save-dev cross-env
{
"scripts" : {
"dev" : "cross-env NODE_ENV=development DB_HOST=localhost node server.js" ,
"build" : "cross-env NODE_ENV=production npm run build:client && npm run build:server"
}
}
dotenv 深度解析：开发环境的利器
基础安装与配置
多种加载方式
require ('dotenv' ).config ();
console .log (process.env .DB_HOST );
require ('dotenv' ).config ({ path : '/path/to/custom/.env' });
const envFile = process.env .NODE_ENV === 'test' ? '.env.test' : '.env' ;
require ('dotenv' ).config ({ path : envFile });
方式三：预加载（避免其他模块先使用 process.env）
node -r dotenv/config server.js
node -r dotenv/config server.js dotenv_config_path=/custom/path/.env
高级配置选项 require ('dotenv' ).config ({
path : '.env.development' ,
encoding : 'utf8' ,
debug : process.env .NODE_ENV === 'development' ,
override : false
});
实际项目中的 .env 文件结构
NODE_ENV =development
APP_NAME =My Awesome App
PORT =3000
HOST =0.0 .0.0
API_VERSION =v1
DB_HOST =localhost
DB_PORT =5432
DB_NAME =myapp_development
DB_USER =dev_user
DB_PASSWORD =dev_password123
DB_SSL =false
DB_POOL_MAX =20
DB_POOL_MIN =5
DB_POOL_ACQUIRE =30000
DB_POOL_IDLE =10000
JWT_SECRET =your_super_secret_jwt_key_here
JWT_EXPIRES_IN =7 d
JWT_REFRESH_SECRET =your_refresh_secret_key
JWT_REFRESH_EXPIRES_IN =30 d
STRIPE_PUBLISHABLE_KEY =pk_test_xxxxxxxx
STRIPE_SECRET_KEY =sk_test_xxxxxxxx
AWS_ACCESS_KEY_ID =your_aws_access_key
AWS_SECRET_ACCESS_KEY =your_aws_secret_key
AWS_REGION =us-east-1
S3_BUCKET_NAME =my-app-uploads
SENDGRID_API_KEY =SG.xxxxxxxx
REDIS_URL =redis://localhost:6379
REDIS_PASSWORD =your_redis_password
FEATURE_NEW_UI =true
FEATURE_PAYMENT =false
ENABLE_ANALYTICS =true
MAINTENANCE_MODE =false
RATE_LIMIT_WINDOW_MS =900000
RATE_LIMIT_MAX_REQUESTS =100
UPLOAD_LIMIT =10 mb
SESSION_TIMEOUT =3600000
企业级配置管理实战
配置管理架构 graph TD
A[基础层：环境变量源] --> B[验证层：变量校验]
B --> C[结构化层：配置整合]
C --> D[适配层：多环境切换]
D --> E[应用层：配置使用]
A1[.env 文件] --> A
A2[系统环境变量] --> A
A3[配置中心] --> A
B1[类型校验] --> B
B2[必填项检查] --> B
C1[整合为 JSON 结构] --> C
D1[根据 NODE_ENV 自动加载<br>对应配置] --> D
E1[业务模块调用] --> E
1. 配置验证与默认值
const Joi = require ('joi' );
const envVarsSchema = Joi .object ({
NODE_ENV : Joi .string ().valid ('development' , 'production' , 'test' , 'staging' ).default ('development' ),
PORT : Joi .number ().default (3000 ),
DB_HOST : Joi .string ().required ().description ('Database host name' ),
DB_PORT : Joi .number ().default (5432 ),
DB_NAME : Joi .string ().required ().description ('Database name' ),
DB_USER : Joi .string ().required ().description ('Database user' ),
DB_PASSWORD : Joi .string ().required ().description ('Database password' ),
JWT_SECRET : Joi .string ().required ().description ('JWT secret key' ),
API_RATE_LIMIT : Joi .number ().default (100 ).description ('API rate limit per window' ),
}).unknown ();
const { value : envVars, error } = envVarsSchema.validate (process.env );
if (error){
throw new Error (`环境变量配置验证失败：${error.message} ` );
}
module .exports = envVars;
2. 结构化配置管理
const env = require ('./validateEnv' );
module .exports = {
env : env.NODE_ENV ,
port : env.PORT ,
database : {
host : env.DB_HOST ,
port : env.DB_PORT ,
name : env.DB_NAME ,
user : env.DB_USER ,
password : env.DB_PASSWORD ,
ssl : env.DB_SSL === 'true' ,
pool : {
max : parseInt (env.DB_POOL_MAX , 10 ),
min : parseInt (env.DB_POOL_MIN , 10 ),
acquire : parseInt (env.DB_POOL_ACQUIRE , 10 ),
idle : parseInt (env.DB_POOL_IDLE , 10 )
}
},
jwt : {
secret : env.JWT_SECRET ,
expiresIn : env.JWT_EXPIRES_IN ,
refreshSecret : env.JWT_REFRESH_SECRET ,
refreshExpiresIn : env.JWT_REFRESH_EXPIRES_IN
},
api : {
prefix : `/api/${env.API_VERSION} ` ,
rateLimit : {
windowMs : parseInt (env.RATE_LIMIT_WINDOW_MS , 10 ),
max : parseInt (env.RATE_LIMIT_MAX_REQUESTS , 10 )
}
},
services : {
stripe : {
publishableKey : env.STRIPE_PUBLISHABLE_KEY ,
secretKey : env.STRIPE_SECRET_KEY
},
aws : {
accessKeyId : env.AWS_ACCESS_KEY_ID ,
secretAccessKey : env.AWS_SECRET_ACCESS_KEY ,
region : env.AWS_REGION ,
s3Bucket : env.S3_BUCKET_NAME
}
},
features : {
newUI : env.FEATURE_NEW_UI === 'true' ,
payment : env.FEATURE_PAYMENT === 'true' ,
analytics : env.ENABLE_ANALYTICS === 'true' ,
maintenance : env.MAINTENANCE_MODE === 'true'
}
};
3. 在 Express 应用中使用配置
const express = require ('express' );
const helmet = require ('helmet' );
const rateLimit = require ('express-rate-limit' );
const config = require ('./config' );
const app = express ();
app.use (helmet ());
const limiter = rateLimit ({
windowMs : config.api .rateLimit .windowMs ,
max : config.api .rateLimit .max ,
message : '请求过于频繁，请稍后再试'
});
app.use (limiter);
const { Pool } = require ('pg' );
const dbPool = new Pool (config.database );
app.use (config.api .prefix , require ('./routes' ));
app.get ('/health' , (req, res ) => {
res.json ({
status : 'OK' ,
environment : config.env ,
timestamp : new Date ().toISOString (),
uptime : process.uptime ()
});
});
app.use ((err, req, res, next ) => {
console .error (err.stack );
res.status (500 ).json ({
error : config.env === 'development' ? err.message : '内部服务器错误' ,
...(config.env === 'development' && { stack : err.stack })
});
});
app.listen (config.port , () => {
console .log (` 🚀 服务器启动成功! 📍 环境：${config.env} 🔗 地址：http://localhost:${config.port} 📅 时间：${new Date ().toISOString()} ` );
});
module .exports = app;
生产环境部署策略
CI/CD 环境变量管理流程 代码提交 -> C1 构建加载构建环境变量 -> 自动化测试加载测试环境变量 -> 镜像打包注入基础变量 -> 镜像推送 -> 生产部署从配置中心拉取 -> 生产环境变量 -> 服务启动
1. Docker 环境变量管理 # Dockerfile
FROM node:18-alpine
WORKDIR /app
# 安装依赖
COPY package*.json ./
RUN npm ci --only=production
# 复制源码
COPY . .
# 创建非 root 用户
RUN addgroup -g 1001 -S nodejs
RUN adduser -S nextjs -u 1001
# 使用非 root 用户
USER nextjs
# 健康检查
HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
CMD node health-check.js
# 通过环境变量传递配置
ENV NODE_ENV=production \
PORT=3000
EXPOSE 3000
CMD ["node", "server.js"]
version: '3.8'
services:
app:
build: .
ports:
- "3000:3000"
environment:
- NODE_ENV=production
- DB_HOST=postgres
- DB_PORT=5432
- DB_NAME=myapp_production
- REDIS_URL=redis://redis:6379
env_file:
- .env.production
depends_on:
- postgres
- redis
restart: unless-stopped
postgres:
image: postgres:14
environment:
- POSTGRES_DB=myapp_production
- POSTGRES_USER=prod_user
- POSTGRES_PASSWORD_FILE=/run/secrets/db_password
secrets:
- db_password
volumes:
- postgres_data:/var/lib/postgresql/data
restart: unless-stopped
redis:
image: redis:6-alpine
command: redis-server --requirepass ${REDIS_PASSWORD}
volumes:
- redis_data:/data
restart: unless-stopped
volumes:
postgres_data:
redis_data:
secrets:
db_password:
file: ./secrets/db_password.txt
2. 云平台环境配置 {
"containerDefinitions" : [
{
"name" : "app" ,
"image" : "my-app:latest" ,
"essential" : true ,
"environment" : [
{ "name" : "NODE_ENV" , "value" : "production" } ,
{ "name" : "DB_HOST" , "value" : "production-db.cluster-xxx.us-east-1.rds.amazonaws.com" }
] ,
"secrets" : [
{ "name" : "DB_PASSWORD" , "valueFrom" : "arn:aws:secretsmanager:us-east-1:123456789012:secret:db/password-abc123" } ,
{ "name" : "JWT_SECRET" , "valueFrom" : "arn:aws:secretsmanager:us-east-1:123456789012:secret:jwt/secret-def456" }
]
}
]
}
3. Kubernetes 配置
apiVersion: apps/v1
kind: Deployment
metadata:
name: nodejs-app
spec:
replicas: 3
selector:
matchLabels:
app: nodejs-app
template:
metadata:
labels:
app: nodejs-app
spec:
containers:
- name: app
image: my-app:latest
ports:
- containerPort: 3000
env:
- name: NODE_ENV
value: "production"
- name: DB_HOST
valueFrom:
configMapKeyRef:
name: app-config
key: db.host
- name: DB_NAME
valueFrom:
configMapKeyRef:
name: app-config
key: db.name
envFrom:
- secretRef:
name: app-secrets
resources:
requests:
memory: "256Mi"
cpu: "250m"
limits:
memory: "512Mi"
cpu: "500m"
livenessProbe:
httpGet:
path: /health
port: 3000
initialDelaySeconds: 30
periodSeconds: 10
readinessProbe:
httpGet:
path: /health
port: 3000
initialDelaySeconds: 5
periodSeconds: 5
---
apiVersion: v1
kind: ConfigMap
metadata:
name: app-config
data:
db.host: "postgres-service"
db.name: "myapp_production"
redis.url: "redis-service:6379"
---
apiVersion: v1
kind: Secret
metadata:
name: app-secrets
type: Opaque
data:
db.password: <base64-encoded-password>
jwt.secret: <base64-encoded-secret>
stripe.secretKey: <base64-encoded-key>
高级技巧与最佳实践
1. 环境特定的配置
module .exports = {
database : {
logging : true ,
sync : { force : false }
},
logging : {
level : 'debug' ,
prettyPrint : true
},
cors : {
origin : ['http://localhost:3000' , 'http://127.0.0.1:3000' ],
credentials : true
}
};
module .exports = {
database : {
logging : false ,
sync : { force : false }
},
logging : {
level : 'info' ,
prettyPrint : false
},
cors : {
origin : ['https://myapp.com' , 'https://www.myapp.com' ],
credentials : true
}
};
const development = require ('./development' );
const production = require ('./production' );
const test = require ('./test' );
const environments = { development, production, test };
module .exports = environments[process.env .NODE_ENV ] || {};
2. 配置加密与安全 服务启动获取解密密钥 -> 密钥管理服务 -> 敏感变量加密工具 -> 加密后的值存储到.env 文件或配置中心 -> process.env -> 供服务使用
const crypto = require ('crypto' );
class ConfigEncryption {
constructor (encryptionKey ) {
this .algorithm = 'aes-256-gcm' ;
this .key = crypto.scryptSync (encryptionKey, 'salt' , 32 );
}
encrypt (text ) {
const iv = crypto.randomBytes (16 );
const cipher = crypto.createCipher (this .algorithm , this .key );
cipher.setAAD (Buffer .from ('additionalData' ));
let encrypted = cipher.update (text, 'utf8' , 'hex' );
encrypted += cipher.final ('hex' );
const authTag = cipher.getAuthTag ();
return {
iv : iv.toString ('hex' ),
data : encrypted,
authTag : authTag.toString ('hex' )
};
}
decrypt (encryptedData ) {
const decipher = crypto.createDecipher (this .algorithm , this .key );
decipher.setAAD (Buffer .from ('additionalData' ));
decipher.setAuthTag (Buffer .from (encryptedData.authTag , 'hex' ));
let decrypted = decipher.update (encryptedData.data , 'hex' , 'utf8' );
decrypted += decipher.final ('utf8' );
return decrypted;
}
}
module .exports = ConfigEncryption ;
3. 配置热重载（开发环境）
const fs = require ('fs' );
const path = require ('path' );
const chokidar = require ('chokidar' );
class ConfigHotReload {
constructor (configPath ) {
this .configPath = configPath;
this .watcher = null ;
this .callbacks = [];
}
watch (if (process.env .NODE_ENV !== 'development' ) return ;
this .watcher = chokidar.watch (this .configPath , {
ignoreInitial : true ,
persistent : true
});
this .watcher .on ('change' , (filePath ) => {
console .log (`配置文件变更：${filePath} ` );
this .notifyCallbacks ();
});
console .log (`正在监听配置文件变更：${this .configPath} ` );
}
onReload (callback ) {
this .callbacks .push (callback);
}
notifyCallbacks (Object .keys (require .cache ).forEach (key =>if (key.includes (this .configPath )){
delete require .cache [key];
}
});
this .callbacks .forEach (callback =>try {
callback ();
}catch (error){
console .error ('配置重载回调执行失败:' , error);
}
});
}
stop (if (this .watcher ){
this .watcher .close ();
}
}
}
module .exports = ConfigHotReload ;
故障排查与调试
环境变量故障排查流程图 flowchart TD
%% 起始节点
A[环境变量异常<br>（如读取为 undefined）] --> B[检查变量是否定义]
%% 分支 1：变量未定义
B -->|否（未定义）| C[补充定义变量]
C --> C1[选项 1：修改.env 文件添加变量]
C --> C2[选项 2：终端临时设置（export 变量=值）]
C --> C3[选项 3：配置系统环境变量]
C1 & C2 & C3 --> H[重新启动服务验证]
%% 分支 2：变量已定义，检查加载方式
B -->|是（已定义）| D[检查 dotenv 加载方式]
D -->|否（未加载/加载顺序错误）| E[调整加载配置]
E --> E1[1. 确认已安装 dotenv（npm list dotenv）]
E --> E2[2. 在入口文件首行添加 require('dotenv').config()]
E1 & E2 --> H
%% 分支 3：加载正常，检查环境是否正确
D -->|是（加载正常）| F[检查 NODE_ENV 是否正确]
F -->|否（环境不匹配）| G[修改 NODE_ENV]
G --> G1[开发环境：export NODE_ENV=development]
G --> G2[生产环境：export NODE_ENV=production]
G1 & G2 --> H
%% 分支 4：环境正确，检查代码逻辑
F -->|是（环境正确）| I[排查业务代码]
I --> I1[1. 检查变量名拼写（如 DB_URL vs DbUrl）]
I --> I2[2. 确认变量使用在加载之后（避免提前调用）]
I1 & I2 --> H
%% 结束节点
H --> J[验证成功<br>（变量正常读取）]
%% 样式设置
classDef start fill:#fff2e8,stroke:#fa8c16,stroke-width:2px;
classDef branch fill:#e6f7ff,stroke:#1890ff,stroke-width:2px;
classDef end fill:#f0fff4,stroke:#52c41a,stroke-width:2px;
class A start;
class B,D,F,I branch;
class J end;
1. 环境变量调试工具
function debugEnvironmentVariables (const sensitiveKeys = ['PASSWORD' ,'SECRET' ,'KEY' ,'TOKEN' ];
console .log ('🔍 环境变量调试信息:' );
console .log ('=' .repeat (50 ));
Object .keys (process.env ).filter (key =>includes ('NODE' ) || key.includes ('DB' ) || key.includes ('API' ) || key.includes ('JWT' )
).sort ().forEach (key =>const value = process.env [key];
const isSensitive = sensitiveKeys.some (sensitive =>toUpperCase ().includes (sensitive));
const displayValue = isSensitive ? '***' + value.slice (-4 ) : value;
console .log (`📌 ${key} : ${displayValue} ` );
});
console .log ('=' .repeat (50 ));
const requiredVars = ['NODE_ENV' ,'DB_HOST' ,'DB_NAME' ];
const missingVars = requiredVars.filter (varName =>env [varName]);
if (missingVars.length > 0 ){
console .error ('❌ 缺失必需的环境变量:' , missingVars);
process.exit (1 );
}
}
module .exports = { debugEnvironmentVariables };
2. 配置验证报告
function generateValidationReport (config ){
const report = {
timestamp : new Date ().toISOString (),
environment : process.env .NODE_ENV ,
status : 'VALID' ,
issues : [],
warnings : [],
recommendations : []
};
if (config.database .host .includes ('localhost' ) && process.env .NODE_ENV === 'production' ){
report.warnings .push ('生产环境使用 localhost 作为数据库主机' );
}
if (config.database .password && config.database .password .length < 8 ){
report.issues .push ('数据库密码强度不足' );
}
if (config.jwt .secret === 'default-secret' || config.jwt .secret .length < 32 ){
report.issues .push ('JWT 密钥强度不足或使用默认值' );
report.status = 'INVALID' ;
}
if (config.database .pool .max > 50 ){
report.recommendations .push ('考虑降低数据库连接池最大值以优化性能' );
}
return report;
}
总结
环境变量管理知识图谱 graph LR
%% 中心节点
A[环境变量管理<br>（Node.js 场景）] --> B[基础载体：process.env]
A --> C[配置来源]
A --> D[工具库]
A --> E[安全机制]
A --> F[实践场景]
A --> G[问题排查]
%% 基础载体分支
B --> B1[特性：全局可访问]
B --> B2[来源：继承父进程环境变量]
B --> B3[用法：process.env.变量名]
%% 配置来源分支
C --> C1[命令行临时设置<br>（export 变量=值）]
C --> C2[.env 文件持久化<br>（项目级配置）]
C --> C3[系统环境变量<br>（全局级配置）]
C --> C4[配置中心<br>（企业级：如 Nacos/Apollo）]
%% 工具库分支
D --> D1[dotenv<br>（加载.env 文件到 process.env）]
D --> D2[cross-env<br>（跨平台设置 NODE_ENV）]
D1 --> D11[核心 API：dotenv.config()]
%% 安全机制分支
E --> E1[敏感变量加密<br>（如 openssl 加密 DB_PASSWORD）]
E --> E2[密钥管理服务<br>（如 KMS 存储解密密钥）]
E --> E3[.env 文件.gitignore<br>（避免敏感信息提交）]
%% 实践场景分支
F --> F1[多环境配置<br>（开发/测试/生产隔离）]
F --> F2[企业级架构<br>（变量验证→结构化整合→应用调用）]
F --> F3[Docker 部署<br>（ENV 指令注入变量）]
%% 问题排查分支
G --> G1[变量未定义<br>（检查定义/加载顺序）]
G --> G2[环境不匹配<br>（核对 NODE_ENV）]
G --> G3[拼写错误<br>（检查变量名大小写）]
%% 样式设置
classDef center fill:#fff2cc,stroke:#ffc107,stroke-width:3px;
classDef branch fill:#e6f7ff,stroke:#1890ff,stroke-width:2px;
class A center;
class B,C,D,E,F,G branch;
环境变量管理是 Node.js 应用开发中至关重要的一环。通过本文的深入学习，你应该掌握：
环境变量的核心概念 和 process.env 的工作原理多种设置方法 ，从命令行到 .env 文件再到云平台企业级配置架构 ，包括验证、结构化管理和类型安全生产环境部署策略 ，涵盖 Docker、Kubernetes 和各大云平台高级安全实践 ，如配置加密、密钥轮换和访问控制调试与监控技巧 ，确保配置的正确性和可靠性 记住，良好的配置管理是构建可维护、可扩展、安全可靠的 Node.js 应用的基石。投资时间在建立健壮的配置系统上，将在项目的整个生命周期中带来丰厚的回报。
微信扫一扫，关注极客日志 微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
相关免费在线工具 Keycode 信息 查找任何按下的键的javascript键代码、代码、位置和修饰符。 在线工具，Keycode 信息在线工具，online
Escape 与 Native 编解码 JavaScript 字符串转义/反转义；Java 风格 \uXXXX（Native2Ascii）编码与解码。 在线工具，Escape 与 Native 编解码在线工具，online
JavaScript / HTML 格式化 使用 Prettier 在浏览器内格式化 JavaScript 或 HTML 片段。 在线工具，JavaScript / HTML 格式化在线工具，online
JavaScript 压缩与混淆 Terser 压缩、变量名混淆，或 javascript-obfuscator 高强度混淆（体积会增大）。 在线工具，JavaScript 压缩与混淆在线工具，online
Base64 字符串编码/解码 将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
Base64 文件转换器 将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online
