WSL快速在Ubuntu或者Debian安装golang、python、deno、nodejs、java前后端全栈一体化开发环境配置

安装golang

# 移除旧版本（如有）
sudo apt remove --autoremove -y golang

# 下载最新版（替换为官网最新版本号）
wget https://go.dev/dl/go1.24.4.linux-amd64.tar.gz

# 解压到 /usr/local
sudo rm -rf /usr/local/go
sudo tar -C /usr/local -xzf go1.24.4.linux-amd64.tar.gz
rm go1.24.4.linux-amd64.tar.gz

# 设置环境变量 $HOME/.profile or /etc/profile
echo 'export PATH=$PATH:/usr/local/go/bin' >> ~/.bashrc
echo 'export GOPATH=$HOME/soft/mygopath' >> ~/.bashrc
source ~/.bashrc

# 验证安装
go version
# 查看配置
go env

配置加速

echo "export GO111MODULE=on" >> ~/.profile
echo "export GOPROXY=https://goproxy.cn" >> ~/.profile
source ~/.profile

# 查看配置
go env

安装 Python、pip 和 venv

Ubuntu 附带已安装 Python 3.6，但它不包含你可能期望与其他 Python 安装一起使用的一些模块。 我们仍需要安装 pip、Python 的标准包管理器和 venv（用于创建和管理轻型虚拟环境的标准模块）。 请记住，你可能需要使用 sudo apt update && sudo apt upgrade 更新你的 Linux 发行版，使其具有最新版本。

1. 打开 Ubuntu 终端并输入 python3 --version，以便确认已安装了 Python3。 这应该返回 Python 版本号。 如果需要更新 Python 版本，请先通过输入以下内容来更新 Ubuntu 版本：sudo apt update && sudo apt upgrade，然后使用 sudo apt upgrade python3 更新 Python。
2. 通过输入以下内容来安装 pip：sudo apt install python3-pip。 通过 pip 可以安装和管理不属于 Python 标准库的其他包。
3. 通过输入以下内容来安装 venv：sudo apt install python3-venv。

$ python3 --version

Python 3.12.3

创建虚拟环境

# 创建项目目录
mkdir -p project/python2025/helloworld
cd project/python2025/helloworld
python3 -m venv .venv
# 安装
sudo apt install python3.12-venv
source .venv/bin/activate

# 编写测试文件
echo 'print("Hello, WSL!")' > helloworld.py
# 运行代码
python3 helloworld.py

安装uv

curl -LsSf https://astral.sh/uv/install.sh | sh

或者

# 安装pipx
sudo apt install pipx
# 安装uv
pipx install uv

安装后，新开一个终端窗口，此时，uv命令生效。

创建项目

cd python2025/
uv init test-uv
cd test-uv/
cat pyproject.toml
cat main.py

文件pyproject.toml

[project]
name = "test-uv"
version = "0.1.0"
description = "Add your description here"
readme = "README.md"
requires-python = ">=3.12"
dependencies = []

文件main.py

def main():
    print("Hello from test-uv!")


if __name__ == "__main__":
    main()

安装deno

curl -fsSL https://deno.land/install.sh | sh

安装nodejs

官网提供多种方法，测试下来，发现用volta安装nodejs简单快捷。

# On most Unix systems including macOS, you can install with a single command:
curl https://get.volta.sh | bash

# Download and install Node.js:
volta install node@22

# Verify the Node.js version:
node -v # Should print "v22.16.0".

# Verify npm version:
npm -v # Should print "10.9.2".

# Download and install pnpm:
volta install pnpm

# Verify pnpm version:
pnpm -v # Should print "10.12.1".

太全面了，测试下来发现volta网络正常。

安装java

Oracle JDK

在线文档
下载地址
JDK 8u202

cd ~/soft
wget https://download.oracle.com/java/24/latest/jdk-24_linux-x64_bin.tar.gz
sudo mkdir -p /opt/java
cd /opt/java/
sudo mv ~/soft/jdk-24_linux-x64_bin.tar.gz /opt/java/
sudo tar -xvzf /opt/java/jdk-24_linux-x64_bin.tar.gz
sudo rm /opt/java/jdk-24_linux-x64_bin.tar.gz
ls /opt/java/

一般显示jdk-24或者jdk-24.0.1

配置环境变量

# Java Environment Variables
export JAVA_HOME=/opt/java/jdk-24.0.1
export PATH=$PATH:$JAVA_HOME/bin

写入文件

echo "# Java Environment Variables" >> ~/.bashrc
echo "export JAVA_HOME=/opt/java/jdk-24.0.1" >> ~/.bashrc
echo "export PATH=\$PATH:\$JAVA_HOME/bin" >> ~/.bashrc
source ~/.bashrc

打开一个新的终端窗口

java -version 
# java version "24.0.1" 2025-04-15
# Java(TM) SE Runtime Environment (build 24.0.1+9-30)
# Java HotSpot(TM) 64-Bit Server VM (build 24.0.1+9-30, mixed mode, sharing)
javac -version
# javac 24.0.1
echo $JAVA_HOME
# /opt/java/jdk-24.0.1

OpenJDK

Alibaba Dragonwell 是一款免费的，多平台生产就绪型 OpenJDK 发行版，提供长期支持，包括稳定性，安全修复和性能增强。

https://dragonwell-jdk.io/#/index

Maven

安装教程 https://www.runoob.com/maven/maven-setup.html

cd ~/soft
wget https://dlcdn.apache.org/maven/maven-3/3.9.10/binaries/apache-maven-3.9.10-bin.tar.gz
sudo mkdir -p /opt/maven
sudo mv /opt/maven/apache-maven-3.9.10-bin.tar.gz /opt/maven/
cd /opt/maven/
sudo tar -xvzf /opt/maven/apache-maven-3.9.10-bin.tar.gz
sudo rm /opt/maven/apache-maven-3.9.10-bin.tar.gz

解压后，你会在 /opt/maven/ 目录下看到一个新的文件夹，例如 apache-maven-3.9.10。你可以通过 ls /opt/maven/ 确认。

配置环境变量 (关键步骤)
请确保将 apache-maven-3.9.10 替换为你实际解压后的文件夹名称。

# Maven Environment Variables
export M2_HOME=/opt/maven/apache-maven-3.9.10
export MAVEN_HOME=/opt/maven/apache-maven-3.9.10
export PATH=$PATH:$M2_HOME/bin

• M2_HOME 和 MAVEN_HOME：这两个变量都指向 Maven 的安装根目录。虽然 MAVEN_HOME 是旧的约定，但有些工具可能仍会查找它，所以同时设置两者是个好习惯。

• PATH=$PATH:$M2_HOME/bin：这会将 Maven 的 bin 目录（其中包含 mvn 可执行文件）添加到系统的 PATH 变量中。这样你就可以在任何位置运行 mvn 命令了。

执行生效source ~/.bashrc

配置集合

环境变量配置优化后如下：

# --- Deno Environment ---
# # Deno's installer usually adds this line. Ensure it's correct.
 . "$HOME/.deno/env"
#
# # --- Node.js / Volta Environment ---
 export VOLTA_HOME="$HOME/.volta"
# # Add Volta's bin directory to PATH. Place it before other common bins if
# # you want Volta-managed executables (like node, npm, yarn) to take precedence.
 export PATH="$VOLTA_HOME/bin:$PATH"
#
# # --- Java Environment ---
# # Define JAVA_HOME. Ensure the path is correct for your JDK installation.
 export JAVA_HOME="/opt/java/jdk-24.0.1"
# # Add Java's bin directory to PATH.
# # Consider placing it earlier in PATH if you want this specific Java version
# # to be prioritized over system-installed Javas.
 export PATH="$JAVA_HOME/bin:$PATH" # Placing it at the beginning of PATH for precedence
#
# # --- Maven Environment ---
# # Define MAVEN_HOME. Ensure the path is correct for your Maven installation.
 export MAVEN_HOME="/opt/maven/apache-maven-3.9.10"
# # M2_HOME is often set for backward compatibility with older tools,
# # though MAVEN_HOME is the official variable.
 export M2_HOME="$MAVEN_HOME" # Link M2_HOME to MAVEN_HOME for consistency
# # Add Maven's bin directory to PATH.
 export PATH="$MAVEN_HOME/bin:$PATH" # Placing it at the beginning of PATH for precedence
#
# # ================================================================= #
# #                 End Custom Environment Variables                #
# # ================================================================= #

环境变量检查

创建一个新文件，比如 check_env.sh：

#!/bin/bash

# --- 脚本说明 ---
# 这是一个用于验证重要开发工具环境变量是否正确设置的脚本。
# 它会检查常见的命令并显示它们解析到的路径和版本信息。

echo "--- 验证环境变量和命令 ---"
echo "请确保在运行此脚本前，你已经通过 'source ~/.bashrc' 或重启终端使环境变量生效。"
echo "--------------------------"

# 检查 JAVA_HOME 和 Java 命令
echo -e "\n=== 检查 Java 环境 ==="
if [ -n "$JAVA_HOME" ]; then
    echo "JAVA_HOME is set to: $JAVA_HOME"
    if [ -x "$JAVA_HOME/bin/java" ]; then
        echo "Found Java executable at: $JAVA_HOME/bin/java"
    else
        echo "WARNING: Java executable not found at $JAVA_HOME/bin/java"
    fi
else
    echo "JAVA_HOME is NOT set."
fi

# 检查 Java 版本
if command -v java &> /dev/null; then
    echo "Java command found in PATH."
    java -version 2>&1 | head -n 1 # 只显示第一行，避免过多信息
else
    echo "ERROR: Java command not found in PATH. Please check your PATH environment variable."
fi

# 检查 Maven 环境
echo -e "\n=== 检查 Maven 环境 ==="
if [ -n "$MAVEN_HOME" ]; then
    echo "MAVEN_HOME is set to: $MAVEN_HOME"
    if [ -x "$MAVEN_HOME/bin/mvn" ]; then
        echo "Found Maven executable at: $MAVEN_HOME/bin/mvn"
    else
        echo "WARNING: Maven executable not found at $MAVEN_HOME/bin/mvn"
    fi
else
    echo "MAVEN_HOME is NOT set."
fi
if [ -n "$M2_HOME" ]; then
    echo "M2_HOME is set to: $M2_HOME"
fi

# 检查 Maven 版本
if command -v mvn &> /dev/null; then
    echo "Maven command found in PATH."
    mvn -version 2>&1 | head -n 1
else
    echo "ERROR: Maven command not found in PATH. Please check your PATH environment variable."
fi

# 检查 Go 环境
echo -e "\n=== 检查 Go 环境 ==="
if [ -n "$GOPATH" ]; then
    echo "GOPATH is set to: $GOPATH"
else
    echo "GOPATH is NOT set."
fi

# 检查 Go 版本
if command -v go &> /dev/null; then
    echo "Go command found in PATH."
    go version
else
    echo "ERROR: Go command not found in PATH. Please check your PATH environment variable."
fi

# 检查 Volta 环境 (如果安装了 Node.js / Volta)
echo -e "\n=== 检查 Volta 环境 ==="
if [ -n "$VOLTA_HOME" ]; then
    echo "VOLTA_HOME is set to: $VOLTA_HOME"
    if [ -x "$VOLTA_HOME/bin/volta" ]; then
        echo "Found Volta executable at: $VOLTA_HOME/bin/volta"
    else
        echo "WARNING: Volta executable not found at $VOLTA_HOME/bin/volta"
    fi
else
    echo "VOLTA_HOME is NOT set."
fi

# 检查 Volta 版本 (如果存在)
if command -v volta &> /dev/null; then
    echo "Volta command found in PATH."
    volta --version
    if command -v node &> /dev/null; then
        echo "Node.js (managed by Volta) version:"
        node -v
    fi
else
    echo "WARNING: Volta command not found in PATH. If you use Volta, check your PATH."
fi

# 检查 Deno 环境 (如果安装了 Deno)
echo -e "\n=== 检查 Deno 环境 ==="
if command -v deno &> /dev/null; then
    echo "Deno command found in PATH."
    deno --version
else
    echo "WARNING: Deno command not found in PATH. If you use Deno, check its installation."
fi

echo -e "\n--- 验证完成 ---"

赋予执行权限chmod +x check_env.sh，运行脚本./check_env.sh

---

参考

Debian 12安装golang
开始在 Windows 上将 Python 用于 Web 开发
uv installation
uv Running scripts
deno installation
阿里巴巴Java开发手册（终极版）

pipx install uv 和 pip install uv区别

pipx install uv 和 pip install uv 有显著的区别，主要体现在它们管理 Python 包的方式和适用场景。

pip (Python Package Installer)

• 通用包安装器： pip 是 Python 的标准包安装器，用于安装 Python 包。
• 安装类型：
  • 库 (Libraries)： 主要用于安装作为其他 Python 项目依赖的库。当你 pip install some-library 时，这个库会被安装到当前激活的 Python 环境中，供你的 Python 代码导入和使用。
  • CLI 应用 (CLI Applications)： 也可以安装带有命令行入口点的应用，但通常会将它们直接安装到当前 Python 环境的 site-packages 目录中，并可能将可执行文件链接到 $PATH。
• 环境管理： pip 本身不提供环境隔离。如果你直接运行 pip install uv，uv 会被安装到你当前激活的 Python 环境中。这意味着如果你有多个项目依赖于不同版本的包，或者你希望全局安装一个工具而不污染你的项目环境，就可能遇到依赖冲突。为了隔离，你通常需要手动创建和激活虚拟环境（例如使用 venv 或 conda），然后在虚拟环境中运行 pip。
• 风险： 直接在系统 Python 环境中使用 pip 安装包可能会导致系统 Python 环境被污染，甚至与其他系统包管理器（如 apt、yum 等）管理的 Python 包发生冲突，这在一些 Linux 发行版中已经被明确阻止（PEP 668）。

pipx (Install and Run Python Applications in Isolated Environments)

• 专用应用安装器： pipx 专门设计用于安装和管理命令行工具（CLI applications），而不是 Python 库。它将 PyPI 视为一个 “应用商店”。
• 环境隔离： 这是 pipx 最核心的特点。当你 pipx install uv 时：
  1. pipx 会为 uv 创建一个独立的虚拟环境。
  2. uv 及其所有依赖都会被安装到这个独立的虚拟环境中。
  3. pipx 会自动将 uv 的可执行文件（其命令行入口点）链接到你的 $PATH 中（通常是 ~/.local/bin），这样你就可以像使用任何其他命令行工具一样，直接在任何地方运行 uv 命令，而无需手动激活虚拟环境。
• 无污染： 由于每个通过 pipx 安装的应用都有自己的隔离环境，因此它们之间的依赖不会冲突，也不会污染你的主 Python 环境或项目环境。
• 方便管理： pipx 提供了方便的命令来列出、升级、卸载和运行通过它安装的应用（例如 pipx list, pipx upgrade-all, pipx uninstall uv）。
• 依赖于 pip： pipx 实际上是建立在 pip 和 venv 之上的一个工具。它在底层仍然使用 pip 进行包安装，但它自动化了虚拟环境的创建和管理过程。

总结比较

特性	pip install uv	pipx install uv
用途	安装 Python 库或命令行工具到当前环境	专门用于安装独立的 Python 命令行工具
环境	安装到当前激活的 Python 环境（可能冲突）	为每个工具创建独立的虚拟环境（完全隔离）
可执行性	可能需要手动管理 PATH 或激活虚拟环境	自动将工具的可执行文件添加到 PATH
污染	可能污染当前环境，导致依赖冲突	不会污染当前环境，避免依赖冲突
管理	需要手动管理虚拟环境，升级等	提供方便的命令来管理安装的工具

为什么推荐 pipx install uv

对于 uv 这样的命令行工具（它是一个用于 Python 包管理的快速工具），强烈推荐使用 pipx 进行安装。原因如下：

1. 隔离性： uv 有自己的依赖项。使用 pipx 可以确保 uv 的依赖不会与你其他 Python 项目的依赖发生冲突。
2. 方便使用： pipx 会自动将 uv 命令添加到你的 $PATH，让你可以在任何终端会话中直接运行 uv，而无需考虑其底层虚拟环境。
3. 最佳实践： 对于所有独立的 Python 命令行工具，pipx 通常被认为是最佳的安装方法。

简而言之，如果你想将 uv 作为系统范围的命令行工具使用，并且希望它与其他 Python 项目或工具隔离，那么 pipx install uv 是更优的选择。如果你是在某个 Python 项目的虚拟环境中工作，并且想将 uv 作为该项目的一个开发依赖，那么 pip install uv 在该项目的虚拟环境中也是可行的。但对于像 uv 这种通用工具，pipx 的优势更加明显。

uv介绍

uv 是一个由 Astral（也开发了著名的 Rust 编写的 Python 代码 Linter Ruff）团队开发的极速 Python 包和项目管理器。它的目标是成为一个“Python 的 Cargo”，旨在取代并统一 Python 生态系统中多个常用的工具，包括：

• pip: Python 的标准包安装器。
• pip-tools: 用于管理 requirements.txt 和锁定依赖。
• pipx: 用于安装和管理独立的 Python 命令行应用。
• poetry: 另一个流行的 Python 包和依赖管理工具。
• pyenv: Python 版本管理工具。
• twine: 用于将 Python 包发布到 PyPI。
• virtualenv / venv: 用于创建和管理虚拟环境。

uv 的核心特点和优势：

1. 极速性能（Rust 编写）:

   • uv 使用 Rust 语言编写，这使其在性能上比许多传统的 Python 工具快得多。
   • 官方声称在安装包方面，uv 可以比 pip 快 10-100 倍，在创建虚拟环境方面比 python -m venv 快 80 倍。这种速度提升对于大型项目或CI/CD流程中依赖安装来说是革命性的。

2. 一体化解决方案（All-in-One）:

   • uv 旨在将上述多种工具的功能集成到一个统一的命令行接口中。这意味着你可以用一个工具来完成包安装、依赖解析、虚拟环境管理、Python 版本管理，甚至包的构建和发布。
   • 它大大简化了 Python 项目管理的复杂性，减少了学习和使用多个工具的开销。

3. 兼容性强（与现有工作流无缝衔接）:

   • uv 设计为 pip 和 pip-tools 的即插即用替代品。
   • 你可以直接在现有项目中，只需在 pip 命令前加上 uv 即可使用 uv 的功能（例如 uv pip install ...，uv pip compile ...）。这使得迁移到 uv 的过程非常平滑。
   • 它支持各种常见的 Python 打包特性，如可编辑安装、Git 依赖、URL 依赖、本地依赖、约束文件、源分发和自定义索引等。

4. 环境隔离和依赖解析:

   • uv 能够创建和管理独立的虚拟环境，确保不同项目之间的依赖不会冲突。
   • 它拥有先进的依赖解析器，能够快速准确地解决复杂的依赖关系。

5. Python 版本管理:

   • uv 甚至可以帮助你安装和管理不同版本的 Python。它能够自动下载缺失的 Python 版本，并在需要时使用它们。
   • 例如，uv python install 3.12 可以直接安装 Python 3.12。

6. 单一二进制文件:

   • uv 以一个单一的静态二进制文件发布，这意味着它易于安装和分发，通常不需要系统上预先安装 Python 即可运行。

uv 的典型使用场景：

• 快速安装项目依赖: 对于需要频繁安装大量依赖的项目，uv 可以显著缩短等待时间。
• 创建和管理虚拟环境: 替代 venv 或 virtualenv，提供更快的环境创建。
• 锁定和同步依赖: 类似于 pip-tools，用于生成和同步 requirements.txt 或 uv.lock 文件，确保环境的可复现性。
• 统一开发工具链: 对于希望减少工具数量，用一个工具管理所有 Python 相关任务的开发者。
• CI/CD 流水线: 在自动化构建和部署流程中，uv 的速度优势可以大大提高效率。

总而言之，uv 代表了 Python 包管理领域的一个重大进步，通过引入 Rust 的高性能和一体化的设计理念，它旨在为 Python 开发者提供一个更快、更可靠、更便捷的开发体验。

deno安装与使用

Deno 是一个安全、现代的 JavaScript、TypeScript 和 WebAssembly 运行时，由 Node.js 的创建者 Ryan Dahl 开发。它旨在解决 Node.js 的一些设计缺陷，提供更好的安全性、开发体验和对现代 Web 标准的支持。

Deno 的特点

• 默认安全： Deno 默认不允许文件系统、网络或环境访问，除非显式授予权限。这使得 Deno 应用程序更安全。
• 内置 TypeScript 支持： Deno 原生支持 TypeScript，无需额外配置或编译步骤。
• 单个可执行文件： Deno 是一个独立的二进制文件，包含了运行时、依赖管理、格式化、测试等所有功能。
• 去中心化的模块系统： Deno 直接通过 URL 导入模块，就像浏览器一样，不需要 node_modules 文件夹。
• 兼容 Web 标准： Deno 尽可能地遵循 Web 标准，例如使用 ES 模块、fetch API 等。
• 基于 Rust 和 V8： Deno 使用 Rust 编写核心部分，并使用 Google 的 V8 引擎执行 JavaScript/TypeScript 代码，性能优秀。

Deno 的安装

Deno 的安装非常简单，推荐使用官方提供的一键安装脚本。

macOS/Linux：

打开终端，运行以下命令：

curl -fsSL https://deno.land/x/install/install.sh | sh

Windows (PowerShell)：

打开 PowerShell (以管理员身份运行可能更好)，运行以下命令：

irm https://deno.land/x/install/install.ps1 | iex

其他安装方式：

• Homebrew (macOS)： brew install deno
• Chocolatey (Windows)： choco install deno
• Winget (Windows)： winget install DenoLand.Deno
• NPM (不推荐，影响启动速度)： npm install -g deno

验证安装：

安装完成后，在终端中运行以下命令，如果能看到 Deno 的版本信息，则表示安装成功：

deno --version

Deno 的使用

Deno 的使用方式与 Node.js 有些相似，但也有一些重要的区别。

1. 运行你的第一个 Deno 程序 (Hello World)

创建一个名为 main.ts (或者 main.js) 的文件，写入以下内容：

// main.ts
console.log("Hello, Deno!");

在终端中运行该文件：

deno run main.ts

你将看到输出：Hello, Deno!

2. 权限控制

Deno 默认是安全的，这意味着你的程序不能随意访问文件系统、网络或环境变量。如果你需要这些权限，必须显式地授予。

例如，如果你想读取一个文件 data.txt：

// read_file.ts
const text = await Deno.readTextFile("data.txt");
console.log(text);

直接运行 deno run read_file.ts 会报错，因为缺少文件读取权限。你需要这样运行：

deno run --allow-read read_file.ts

类似的权限标志有：

• --allow-net: 允许网络访问
• --allow-read: 允许文件读取
• --allow-write: 允许文件写入
• --allow-env: 允许访问环境变量
• --allow-run: 允许运行子进程
• --allow-hrtime: 允许高精度时间测量
• --unstable: 允许使用不稳定 (unstable) 的 Deno API

你也可以使用 --allow-all 来授予所有权限 (不推荐在生产环境使用)。

3. 模块导入

Deno 使用 URL 来导入模块，可以直接导入本地文件或远程模块。

导入本地模块：

// utils.ts
export function add(a: number, b: number): number {
  return a + b;
}

// main.ts
import { add } from "./utils.ts"; // 相对路径
console.log(add(1, 2)); // 输出 3

导入远程模块：

Deno 官方维护了一个标准库 (std)，你可以直接通过 URL 导入：

import { serve } from "https://deno.land/[email protected]/http/server.ts";

async function handler(req: Request): Promise<Response> {
  const url = new URL(req.url);
  if (url.pathname === "/") {
    return new Response("Hello, Deno!", { status: 200 });
  } else if (url.pathname === "/greet") {
    const name = url.searchParams.get("name") || "World";
    return new Response(`Hello, ${name}!`, { status: 200 });
  }
  return new Response("Not Found", { status: 404 });
}

console.log("HTTP webserver running. Access it at: http://localhost:8000/");
await serve(handler, { port: 8000 });

运行这个 Web 服务器：

deno run --allow-net server.ts

然后访问 http://localhost:8000/ 或 http://localhost:8000/greet?name=Alice。

Deno 会缓存下载的远程模块，所以第二次运行不需要再次下载。

4. Deno 工具链

Deno 作为一个一体化的运行时，内置了许多常用的开发工具：

• deno run: 运行 JavaScript/TypeScript 文件。
• deno fmt: 格式化代码。

  deno fmt main.ts
  

• deno lint: 检查代码风格和潜在问题。

  deno lint main.ts
  

• deno test: 运行测试文件。

  // test.ts
  import { assertEquals } from "https://deno.land/std/assert/mod.ts";
  
  Deno.test("add function", () => {
    function add(a: number, b: number) {
      return a + b;
    }
    assertEquals(add(1, 2), 3);
  });
  

  运行测试：

  deno test test.ts
  

• deno compile: 将 Deno 脚本编译成独立的可执行文件。

  deno compile --allow-net server.ts
  

  这会在当前目录生成一个名为 server (或 server.exe 在 Windows 上) 的可执行文件，你可以直接运行它而不需要 Deno 运行时。
• deno install: 将 Deno 脚本安装到你的 $DENO_INSTALL/bin 目录，使其可以在全局范围内作为命令使用。

  deno install --allow-net --name my-server server.ts
  

  现在你可以在任何地方运行 my-server 命令。
• deno doc: 生成代码文档。
• deno repl: 启动一个交互式 Deno shell。

5. deno.json (或 deno.jsonc) 配置文件

为了更好地管理 Deno 项目，你可以创建一个 deno.json 或 deno.jsonc 文件来配置各种选项，例如：

// deno.json
{
  "tasks": {
    "start": "deno run --allow-net server.ts",
    "dev": "deno run --allow-net --watch server.ts",
    "test": "deno test"
  },
  "fmt": {
    "files": {
      "include": ["."],
      "exclude": ["./vendor"]
    },
    "options": {
      "useTabs": false,
      "lineWidth": 80,
      "indentWidth": 2,
      "singleQuote": true,
      "proseWrap": "always"
    }
  },
  "lint": {
    "files": {
      "include": ["."],
      "exclude": ["./vendor"]
    },
    "rules": {
      "tags": ["recommended"],
      "exclude": ["no-explicit-any"]
    }
  },
  "imports": {
    "std/": "https://deno.land/[email protected]/",
    "oak/": "https://deno.land/x/[email protected]/"
  }
}

有了这个文件，你就可以通过 deno task start、deno task dev 等命令来运行预定义的任务，或者 deno fmt、deno lint 来格式化和检查代码。imports 字段可以让你为远程模块设置简短的别名，方便导入。

6. 与 VS Code 集成

Deno 官方提供了 VS Code 扩展，它能提供强大的 TypeScript/JavaScript 开发体验，包括自动补全、类型检查、代码格式化、调试等功能。

在 VS Code 中安装 “Deno” 扩展 (发布者是 denoland.deno) 即可。

总结

Deno 提供了一个现代、安全的 JavaScript/TypeScript 运行时，旨在改善开发体验并遵循 Web 标准。通过简单的安装、直观的权限模型和内置的工具链，Deno 为构建各种应用程序（从命令行工具到 Web 服务器）提供了一个强大的平台。随着其生态系统的不断发展，Deno 在未来有望成为 Web 开发的重要力量。