w wyl123ly 的博客
MD

编程语言对比

58 KB 2026.10.11 原文件

编程语言对比

这篇笔记讲什么

这是一篇选型参考,不是语法手册。语法细节请回到各语言自己的分节笔记(见文末「相关笔记」)。

这里只回答三个问题:Python、C#、JavaScript 在哪些维度上真正不同? 这些不同会导致什么后果?

面对一个具体目标,我该选哪一个?

所有对比都用表格呈现,涉及 TypeScript 的地方单独标注。

是什么

编程语言对比不是"哪个语言更好"的排行榜,而是在给定约束下比较取舍的分析框架。同一门语言在不同场景下既是优点也是缺点:

语言一句话定位规范与实现分离情况
Python(Python)以可读性和生态取胜的通用动态语言语言规范 + 参考实现 CPython(另有 PyPy、Jython 等实现)
C#(C#)由语言、运行时、SDK 三层组成的工程化静态语言语言由 ECMA 标准与 Roslyn 编译器定义;运行时是 .NET(CLR);工具链是 .NET SDK
JavaScript(JavaScript)唯一原生运行在浏览器里的语言,靠运行时补齐能力语言由 ECMA-262 标准定义;运行时是浏览器引擎或 Node.js,语言本身不含 I/O

一个必须先建立的认知

「Python / C# / JavaScript」这三个名字各自混合了语言与平台两个层次。

- Python 的执行速度取决于用的是 CPython 还是 PyPy;

- C# 的能力取决于目标框架(net10.0 还是 netstandard2.0);

- JavaScript 有没有文件系统取决于跑在 Node.js 还是浏览器。

所以任何"X 语言比 Y 语言快/强"的断言,不指明实现与版本,都是不完整的。

为什么需要对比

痛点一:选错语言的代价是几个月。 用 Python 写 Windows 桌面 GUI、用 C# 写浏览器前端、用 JavaScript 做大规模数值计算——都能做,但都要付出数倍的开发或性能代价。选型的目标不是找"最强语言",而是找与场景摩擦最小的那门。

痛点二:单语言技能会掩盖概念。 只会 Python 的人容易以为"变量就是标签,随便改类型"是常识;只会 C# 的人容易以为"必须有接口"是常识。对比能让你区分哪些是普遍概念、哪些只是某语言的实现选择。

痛点三:真实项目天然是多语言的。 一个典型产品可能是:Python 做数据与训练 → C# 做后端服务 → TypeScript 做前端。理解各自边界,才谈得上分工与联调(见本文末尾「多语言项目的协作方式」)。

怎么用这篇笔记

只想快速决策 → 直接跳到最后一节 [按目标选语言](#按目标选语言决策表)。

想理解差异根源 → 从「类型系统」读到「错误处理风格」。

核心内容

类型系统

维度PythonC#JavaScript
类型检查时机运行时(动态)编译期(静态)运行时(动态);TypeScript 提供编译期检查,运行时仍是动态
强弱类型强:"1" + 2 抛 TypeError强:类型不匹配编译不过弱:"1" + 2 === "12"、"1" - 2 === -1
类型推断无静态推断(运行时按值定类型)var / target-typed new 完整推断无(let 无类型信息);TypeScript 有双向推断
类型注解可选,x: int = 1,默认不检查,需 mypy/pyright 等外部工具强制(可 dynamic 绕过)无注解;TypeScript 用 .ts 后缀与 tsc 检查
泛型typing 类型提示层面(运行时擦除)运行时具体化(reified),可 new T()、typeof(T)无泛型;TypeScript 类型层面擦除
空安全无;None 是普通值可空引用类型:string? vs string,编译期警告无;null 与 undefined 是两个不同的空值
结构类型 / 名义类型鸭子类型(structural)名义类型(nominal)+ record 支持结构相等鸭子类型(structural);TypeScript 默认结构类型
数值模型int 任意精度;float 双精度定宽整数(int 32 位、long 64 位)+ decimal 十进制只有 number(IEEE 754 双精度)+ BigInt
# Python:类型注解是"文档",运行时不拦截
def add(a: int, b: int) -> int:
    return a + b

print(add("1", "2"))   # 输出 "12" —— 注解没有任何约束力!
// C#:可空性由编译器强制,这是 C# 相较另外两门语言最大的类型安全优势
#nullable enable
string? FindName(int id) => id > 0 ? "Ada" : null;

// 下面这行会产生编译警告 CS8602(可能取消引用空值)
// int len = FindName(1).Length;

// 正确写法:编译器逼你处理 null 分支
int len = FindName(1)?.Length ?? 0;
// JavaScript:弱类型的经典陷阱
console.log("1" + 2);        // "12"  字符串拼接
console.log("1" - 2);        // -1    数值减法
console.log([] + {});        // "[object Object]"
console.log(0.1 + 0.2);      // 0.30000000000000004

// 唯一可靠的相等比较是 ===(严格相等)
console.log(1 == "1");       // true  —— 避免使用
console.log(1 === "1");      // false —— 始终用这个

关键结论

"静态 vs 动态"与"强 vs 弱"是两个独立维度。 Python 是"动态 + 强",JavaScript 是"动态 + 弱",C# 是"静态 + 强"。

最容易出生产事故的组合是动态 + 弱(JavaScript 原生形态),因为它既不能在编译期发现错误,运行时还会静默做类型转换。

这也是 TypeScript 在前端几乎成为默认选择的原因——它把 JavaScript 拉到了"静态 + 较强"的象限。

编译与执行方式

维度Python(CPython)C#(.NET)JavaScript(V8)
第一步源码编译为字节码,缓存到 .pyc源码(Roslyn)编译为 IL 中间语言源码直接解析(无独立字节码文件)
中间产物字节码,运行在 CPython 虚拟机上IL,运行在 CLR 上无持久中间产物;V8 先产出内部字节码
执行方式解释执行字节码JIT 编译为本机代码(默认)JIT(多级:Ignition 解释 → Sparkplug → Maglev/TurboFan 优化)
提前编译(AOT)没有官方 AOT;可用 Nuitka、Cython 等第三方方案支持:ReadyToRun(部分预编译)、NativeAOT(完全原生)无标准 AOT;WASM 是另一条路
典型启动开销很小(但导入大型库如 numpy/pandas 可能到秒级)中等(JIT 需预热);NativeAOT 下极小引擎启动 + 解析开销;浏览器中引擎已常驻
长跑性能曲线平稳(无优化层级)逐步上升(分层编译 + 动态 PGO)逐步上升(热点函数被 TurboFan 优化)
首次执行延迟低较高(需 JIT)较高(需解析 + 基线编译)
部署形态需要 Python 解释器框架依赖 / 自包含 / 单文件 / NativeAOT需要浏览器或 Node.js(Node 也有 SEA 单可执行文件)
# 观察中间产物的差异
python -c "import dis; dis.dis('x = [i*i for i in range(3)]')"   # 看字节码

这三条路径各自的工程后果

- Python 的解释执行:开发-运行循环极短,改完即跑;代价是纯 Python 循环慢,重活必须下沉到 C 扩展(numpy、pandas)。

- C# 的两级编译:默认 JIT 让长驻服务越来越快,但对 Serverless 冷启动不友好;NativeAOT 用"构建慢 + 功能受限"换"启动极快"。

- JavaScript 的多级 JIT:同一段代码的运行速度会随执行次数变化。这意味着微基准测试极难做对——第一遍和第一万遍不是一回事。

内存管理与 GC 策略

维度Python(CPython)C#(.NET)JavaScript(V8)
主要回收机制引用计数为主 + 分代循环检测器追踪式分代 GC(标记-压缩)追踪式分代 GC(标记-清除/压缩)
纯引用计数能立刻回收吗能:引用归零立即释放否(等 GC)否(等 GC)
循环引用引用计数处理不了,靠 gc 模块的循环检测器GC 天然处理GC 天然处理
分代循环检测器分 3 代0/1/2 三代新生代(Scavenger)+ 老生代(Mark-Compact)
GC 触发导致的停顿有(循环检测),但通常很短有;服务器 GC 模式针对多核/大内存优化有(Orinoco 并发/增量标记以降低停顿)
可手动干预可以:gc.collect()、del、弱引用 weakref可以:GC.Collect()(生产环境通常不该调)、IDisposable 管非托管资源基本不可:无标准 API 强制 GC(Node 可 --expose-gc)
非托管资源处理with 语句 + 上下文管理器IDisposable + using;SafeHandle无析构概念;靠 FinalizationRegistry 与显式 close
内存布局对象头较大,小对象开销明显值类型(struct)可栈分配或内联,无堆分配无值类型(除 TypedArray 等特例),数字也可能装箱
# Python:引用计数让"离开作用域即释放"成为常态
import gc, weakref

class Resource:
    def __init__(self, name): self.name = name
    def __del__(self): print(f"释放 {self.name}")

r = Resource("A")
w = weakref.ref(r)          # 弱引用:不增加引用计数
print(w() is r)             # True
del r                       # 引用计数归零 —— __del__ 立即被调用
print(w())                  # None

# 循环引用需要循环检测器介入
gc.collect()
// C#:非托管资源必须显式释放,GC 不负责
public sealed class FileWriter : IDisposable
{
    private readonly StreamWriter _writer;
    public FileWriter(string path) => _writer = new StreamWriter(path);

    public void Dispose() => _writer.Dispose();
}

// using 声明:离开作用域自动 Dispose,即使抛异常
using var writer = new FileWriter("out.txt");
writer.ToString();
// JavaScript:没有显式释放,只能"断开引用"
let bigData = new Array(1_000_000).fill(0);
bigData = null;   // 移除引用,剩下的交给 GC(时机不可控)

// 非托管资源在 Node 中通过显式 close 处理
// const handle = await fs.open('out.txt', 'w');
// await handle.close();   // 必须显式关闭,否则文件描述符泄漏

三个与内存相关的真实坑

1. Python 的引用计数在循环引用下会延迟释放,__del__ 不保证及时调用。依赖析构器做清理是脆弱的——请用 with / try...finally。

2. C# 的 GC.Collect() 几乎总是帮倒忙。它会打断分代假设,让本该快速回收的新生代对象被提升。只有在测量证明必要时才用。

3. JavaScript 的闭包与事件监听器是头号内存泄漏源。移除 DOM 元素但忘了 removeEventListener,或者闭包捕获了巨大的外部变量,GC 都无从下手。

并发模型

这是三者差异最大、也最容易踩坑的维度。

维度PythonC#JavaScript
线程有 threading,但受 GIL 限制,同一时刻只有一个线程执行字节码真并行多线程(Thread、Task、线程池)主线程 + Worker Threads(Node);浏览器有 Web Workers
进程multiprocessing,可绕过 GIL 做 CPU 并行可与外部进程协作,语言内置支持较薄child_process、cluster
异步 I/Oasyncio + async/await(单线程事件循环)async/await + Task(基于线程池,真并行)原生事件循环,Promise + async/await
CPU 密集型并行需要多进程(或 GIL 被禁用的构建)线程/Task 直接可用Worker Threads / 子进程
I/O 密集型并行asyncio 或线程池都很有效(I/O 时释放 GIL)async/await 非常成熟async/await 是唯一自然写法
取消机制asyncio.Task.cancel()CancellationToken(贯穿整个 .NET API)AbortController / AbortSignal
并发原语Lock、Queue、asyncio.Locklock、SemaphoreSlim、Channel、Interlocked主线程无线程共享状态;Worker 靠 postMessage 传消息
# Python:GIL 决定了线程适合 I/O、进程适合 CPU
import threading, multiprocessing

# 适合:I/O 密集型(下载、读写文件),等待时会释放 GIL
def download(url: str) -> None: ...

threads = [threading.Thread(target=download, args=(u,)) for u in urls]

# 适合:CPU 密集型,用进程绕开 GIL
with multiprocessing.Pool() as pool:
    results = pool.map(heavy_compute, data)
// C#:async/await 背后是线程池,CPU 与 I/O 都能覆盖
public async Task<string[]> FetchAllAsync(string[] urls, CancellationToken ct)
{
    using var http = new HttpClient();

    // Task.WhenAll 并发发起所有请求,全部完成才返回
    var tasks = urls.Select(u => http.GetStringAsync(u, ct));
    return await Task.WhenAll(tasks);
}

// CPU 密集型可以直接并行,没有 GIL 的阻碍
var sum = data.AsParallel().Sum(HeavyCompute);
// JavaScript:事件循环是唯一模型,绝不要阻塞主线程
const results = await Promise.all(urls.map((u) => fetch(u).then((r) => r.text())));

// CPU 密集型必须搬到 Worker,否则整个进程卡住
// import { Worker } from 'node:worker_threads';
// const worker = new Worker(new URL('./heavy.js', import.meta.url));

GIL 的准确表述

GIL(Global Interpreter Lock,全局解释器锁)是 CPython 的实现细节,不是 Python 语言规范的要求。

它确保同一时刻只有一个线程执行 Python 字节码,因此多线程无法加速纯 Python 的 CPU 密集代码。

需要注意两点:

- I/O 操作和许多 C 扩展(如 numpy 的内层循环)会释放 GIL,所以多线程对 I/O 密集任务依然有效。

- CPython 3.13 起提供 --disable-gil 构建选项(PEP 703,自由线程 free-threading),但这不是默认行为,且生态兼容性仍在推进中。

因此写 Python 并发时的决策规则是:I/O 密集 → 线程或 asyncio;CPU 密集 → 多进程。

包管理与生态

维度PythonC#JavaScript
包管理器pipNuGet(dotnet CLI 内置)npm(另有 pnpm、yarn)
官方源PyPInuget.orgregistry.npmjs.org
虚拟环境必须手动创建:venv / conda不需要;包默认装到全局缓存,按项目解析不需要;包装到项目 node_modules
环境隔离方式每个项目一个虚拟环境目录全局包缓存 + obj/project.assets.json 决定用哪些每个项目一个 node_modules
依赖声明文件pyproject.toml(现代)/ requirements.txt(传统).csproj 内的 <PackageReference>;版本可集中于 Directory.Packages.propspackage.json
锁文件无官方标准;uv.lock、poetry.lock、pip freeze 输出packages.lock.json(需显式启用)package-lock.json / pnpm-lock.yaml(默认生成)
全局 CLI 工具pipx(推荐)或全局 pip 安装dotnet tool install -g / 本地工具清单npx(临时)/ npm i -g
版本范围语法>=1.0,<2.0(PEP 440)[1.0,2.0)、1.*、[1.0]^1.2.3、~1.2.3、1.x
生态规模特点数据科学 / AI / 科学计算绝对领先企业后端、Windows 桌面、游戏(Unity)强前端唯一选择,通用库数量最多
典型质量风险科学包对二进制轮子(wheel)依赖重,纯源码安装常失败生态相对收敛,微软系包质量稳定包数量大、更替快,供应链攻击与"依赖膨胀"问题突出
# Python:环境隔离是手动步骤,忘掉它是第一号新手错误
python -m venv .venv
# Windows: .venv\Scripts\activate ;macOS/Linux: source .venv/bin/activate
pip install requests
pip freeze > requirements.txt

# C#:无需虚拟环境;包版本可以集中在仓库根
dotnet add package Serilog
dotnet list package --vulnerable --include-transitive

# JavaScript:依赖默认装进项目本地
npm install express
npm ci          # CI 中按 lockfile 精确还原(比 npm install 更适合流水线)

三个生态特有的坑

1. Python:忘记激活虚拟环境,包被装进系统 Python,之后所有项目互相污染。养成"进目录先 activate"的习惯。

2. JavaScript:^ 与 ~ 的语义。^1.2.3 允许升到 <2.0.0,~1.2.3 只允许升到 <1.3.0。对于 0.x 版本,^0.2.3 只允许 <0.3.0——这与很多人的直觉相反。

3. C#:dotnet add package 不写 --version 会锁定到当时的"最新稳定版",导致同一命令在不同时间产出不同的 .csproj。

典型应用领域

领域PythonC#JavaScript
数据科学 / 机器学习★★★★★(numpy、pandas、PyTorch)★★(ML.NET,规模小)★(浏览器端推理有一定应用)
Web 后端★★★★(FastAPI、Django)★★★★(ASP.NET Core)★★★★(Node.js + Express/Nest)
前端 / 浏览器☆(不适用)☆(需 Blazor WASM 才能进浏览器)★★★★★ 唯一选择
Windows 桌面★★(打包分发麻烦)★★★★★(WinForms、WPF、WinUI)★★(Electron,体积大)
跨平台移动★(Kivy 等,生态弱)★★★★(.NET MAUI)★★★★(React Native、Capacitor)
游戏开发★★(Godot 脚本层)★★★★★(Unity 主语言)★★★(网页游戏、Cocos)
自动化 / 脚本 / DevOps★★★★★★★★(跨平台后改善明显)★★★(构建工具链里的胶水)
高性能服务 / 低延迟★★(需下沉到 C/C++/Rust)★★★★★(含 NativeAOT)★★★(Node 流式 I/O 强,CPU 密集弱)
CLI 工具★★★★★★★★(NativeAOT 后启动极快)★★★(Node 启动较慢)

学习曲线

维度PythonC#JavaScript
上手到能写脚本最快(小时级)中等(天级,需理解类型与项目结构)快(但容易先学到坏习惯)
语法噪音少(缩进即语法)中(修饰符、泛型、特性)中(历史包袱多:var/let/const、两种模块系统)
概念负担低(但"高级特性"如描述器、元类并不简单)高(值/引用类型、GC、LINQ、async 状态机、工具链)中高(原型链、this、事件循环、闭包陷阱)
最容易卡住的地方虚拟环境与包安装项目/解决方案/构建配置(即 [[CSharp-07-dotnet项目与工具链]] 的内容)this 绑定与异步执行顺序
长期上限高(可深入 C 扩展、CPython 内部)极高(从语法到 IL、JIT、AOT 全链路可控)高(可深入引擎优化、WASM)
不良习惯风险低(语言设计抑制了很多写法)低(编译器强制)高(弱类型 + 隐式转换 + 全局变量)

选第一门语言的真正判据

不是"哪门简单",而是"你能多快做出一个让自己有成就感的东西"。

想做网页 → JavaScript(配 前端-05-TypeScript);想做数据处理/爬虫/自动化 → Python;想做桌面软件或系统学习类型系统 → C#。

详见本文末尾的「如何选择第一门语言」。

性能量级对比

阅读这一节前请注意

下表的"相对量级"只用于建立数量级直觉,不是 benchmark 数字。

真实性能取决于实现与场景:CPython 还是 PyPy、是否 AOT、热点是否被 JIT 优化、任务是 CPU 密集还是 I/O 密集、

代码是纯语言实现还是调用 C 扩展。请务必用你的真实负载在Release/生产配置下实测。

场景Python(CPython)C#(.NET 10, JIT)C#(NativeAOT)JavaScript(V8)
纯语言紧密循环基准(1×)明显更快与 JIT 同量级或更好明显更快
数值数组运算最快(numpy 走 C/BLAS,即"取决于是否用对库")快快中(TypedArray 可用)
字符串处理 / 解析较慢快快中到快
I/O 密集型并发好(asyncio/线程)好好很好(事件循环是其主场)
冷启动快(导入大库除外)中(JIT 预热)最快中(Node 启动 + 解析)
内存占用高(对象开销大)中低中到高

这张表能得出的可靠结论只有两条:

  1. 对于纯语言实现的 CPU 密集任务,静态编译型语言(C#)通常比 CPython 快一个数量级以上。 但 Python 一旦把热点交给 C 扩展(numpy、pandas、regex),差距会缩小到很小甚至反超。
  2. I/O 密集型任务的瓶颈在等待,不在语言。 三种语言的异步模型差距通常远小于数据库或网络本身的延迟。选型时不要把 I/O 场景的性能当决策依据。

错误处理风格

维度PythonC#JavaScript
主要机制异常(try / except / finally)异常(try / catch / finally)异常(try / catch / finally)
哲学倾向EAFP("请求原谅比请求许可更容易")——先做,出错再捕获偏 LBYL,但异常也是正常流程的一部分混合;Node 回调风格时代遗留 (err, result) 约定
抛出语法raise ValueError("msg") from errthrow new ArgumentException(...)throw new Error("msg")
能否抛出任意类型能(但不要,会破坏调用方)不能,必须继承 Exception能(throw "字符串" 合法——绝对不要)
类型化异常无强制;异常类只是普通类内建大量特定异常类型,可精确捕获Error 及其子类(TypeError、RangeError…)
资源清理with 语句 / 上下文管理器using / IDisposable(确定性释放)try...finally;await using(显式资源管理提案)
异步错误await 会重新抛出,asyncio.gather 需注意部分失败await 重新抛出,AggregateException 在 Task.Wait 时出现未处理的 Promise rejection 可能静默失败(头号陷阱)
编译期检查无可空性 + 已检查的异常类型(部分)无;TypeScript 不追踪异常类型
自定义异常class MyError(Exception)class MyException : Exceptionclass MyError extends Error
# Python:EAFP 风格 + 异常链
try:
    value = int(user_input)
except ValueError as exc:
    # from 保留原始异常上下文,traceback 更可读
    raise ConfigError("输入不是合法整数") from exc
finally:
    cleanup()
// C#:只能抛 Exception 子类;用 when 做条件捕获
try
{
    var value = int.Parse(userInput);
}
catch (FormatException ex) when (userInput.Length > 0)
{
    throw new ConfigException("输入不是合法整数", ex);   // 内层异常作为 InnerException
}
finally
{
    Cleanup();
}
// JavaScript:只抛 Error 实例,并且一定处理 Promise rejection
try {
  const value = Number.parseInt(userInput, 10);
  if (Number.isNaN(value)) throw new TypeError('输入不是合法整数');
} catch (err) {
  // err 可能是任何类型,必须先判断
  if (err instanceof Error) throw new Error(`解析失败: ${err.message}`, { cause: err });
  throw new Error(`解析失败: ${String(err)}`);
} finally {
  cleanup();
}

// 关键:异步错误必须被处理,否则进程可能静默出问题
process.on('unhandledRejection', (reason) => {
  console.error('未处理的 Promise 拒绝:', reason);
  process.exitCode = 1;
});

空值语义差异

None / null / undefined 是三门语言里最容易写出 bug 的地方。

场景PythonC#JavaScript
唯一的"空"Nonenull两个:null 与 undefined
默认值差异无此问题引用类型默认 null;int 默认 0、bool 默认 falseundefined:未赋值、缺参数、缺属性;null:必须显式写
检查方式x is Nonex is null(推荐)或 x == nullx === null / x === undefined / x == null(同时匹配两者)
访问属性报什么AttributeErrorNullReferenceExceptionTypeError: Cannot read properties of undefined
编译期帮助无有(Nullable + string?)无;TypeScript 的 strictNullChecks 提供检查
安全访问语法x?.attr(Python 3.8+ 有 := 但无 ?.;dict.get() 是主要手段)x?.Attr、x ?? fallback、x!.Attrx?.attr、x ?? fallback
参数默认def f(x=None):void F(string? x = null)function f(x = null) —— 默认值只对 undefined 生效
常见坑if x: 把 0、""、[]、None 一视同仁地当假忘记开 <Nullable>enable</Nullable>,失去全部检查if (x) 把 0、""、NaN 当假;?? 与 `\\` 混用
# Python:falsy 值是最常见的误判来源
def process(items=None):
    # 错:空列表也会走 None 分支被替换
    # if not items: items = [1, 2, 3]

    # 对:只在真的是 None 时才给默认值
    if items is None:
        items = [1, 2, 3]
    return items

print(process([]))   # []  —— 空列表被尊重
// C#:?? 只处理 null,?. 短路整个链
string? name = null;
int length = name?.Length ?? 0;          // 0,安全

// 值类型的"空"完全不同:需要 Nullable<T> 或 int?
int? maybeAge = null;
int age = maybeAge ?? 18;

// 注意:! 只是压制警告,不做运行时检查,用多了等于关掉这个文件的检查
string forced = name!;
// JavaScript:null 与 undefined 的差异会真实影响业务
const config = { retries: undefined, timeout: null };

console.log(config.retries ?? 3);    // 3(undefined 走默认)
console.log(config.timeout ?? 3);    // 3(null 也走默认)
console.log(config.timeout || 3);    // 3(0 也会被替换!用 || 是 bug 源头)

// 默认参数只对 undefined 生效
function withDefault(x = 'default') { return x; }
console.log(withDefault(undefined)); // "default"
console.log(withDefault(null));      // null  —— 很多人误以为会得到 "default"

空值相关的四条实战规则

1. 优先用 is None / is null / === null 做精确判断,不要依赖真值判断(falsy/truthy)。

2. JavaScript 中默认值一律用 ?? 而不是 ||,否则 0、""、false 会被意外替换。

3. C# 项目第一件事就是开 <Nullable>enable</Nullable>,否则你放弃了这门语言相对另外两门最大的安全优势。

4. Python 的 dict.get(key) 返回 None 与"键存在但值是 None"无法区分,需要区分时用 key in d 先判断。

字符串不可变性

维度PythonC#JavaScript
字符串是否不可变是是是
不可变的后果拼接产生新对象,循环拼接是 同左,且这是 .NET 性能分析里的经典问题同左
官方可变替代io.StringIO、list 收集后 "".join(...)StringBuilder数组 push 后 join('')
字符串类型str(Unicode 码点序列)string(UTF-16 代码单元序列)string(原始值,非对象,UTF-16)
插值语法f-string(3.6+):f"{name!r:>10}"$"{name,-10}"` | 模板字符串:`` `${name} ``
是否有"字符"类型无,s[0] 返回长度 1 的 str有,char(UTF-16 单元)无,s[0] 返回长度 1 的 string
比较== 比较值== 比较值(string 重载了运算符);引用比较要 ReferenceEquals=== 比较值(原始值语义)
多行写法三引号 """..."""逐字字符串 @"..." 或原始字符串 """..."""反引号 ` ... `
代理对(emoji)陷阱长度按码点计,len("👍") == 1长度按 UTF-16 单元计,"👍".Length == 2同 C#,"👍".length === 2
# Python:循环拼接是 O(n^2),改成 join
parts = [str(i) for i in range(10000)]
result = "".join(parts)          # 推荐:先收集再一次性拼接

# 大量文本构建用 StringIO
import io
buf = io.StringIO()
for i in range(10):
    buf.write(f"{i},")
text = buf.getvalue()
// C#:StringBuilder 是字符串构建的标准答案
using System.Text;

var sb = new StringBuilder();
for (var i = 0; i < 10000; i++)
{
    sb.Append(i).Append(',');
}
var text = sb.ToString();

// 注意 UTF-16 长度语义与 Python 不同
Console.WriteLine("👍".Length);                     // 2(代理对)
Console.WriteLine(new StringInfo("👍").LengthInTextElements);  // 1(字素)
// JavaScript:收集到数组再 join
const parts = [];
for (let i = 0; i < 10000; i++) parts.push(String(i));
const text = parts.join(',');

// 代理对同样导致长度语义与 Python 不同
console.log('👍'.length);                    // 2
console.log([...'👍'].length);               // 1(按码点展开)
console.log('👍'.codePointAt(0).toString(16)); // 1f44d

为什么必须记住这一点

循环里用 += 拼字符串在三种语言里都是 :长度为 的最终结果会触发 次复制,总复制量为

数据量小时完全无感,一旦到几十万次就会从毫秒级退化到分钟级。

同一概念在三门语言中的名字

这张表是跨语言迁移时最实用的速查——概念相同,名字不同,很容易找个半天。

概念PythonC#JavaScript
有序可变序列listList<T>Array
定长不可变序列tupleValueTuple、record、ReadOnlyCollection<T>无原生;用 Object.freeze 或 as const(TS)
键值映射dictDictionary<TKey, TValue>Map(有序、任意键)或普通 Object
去重集合setHashSet<T>Set
接口 / 抽象契约abc.ABC、typing.Protocolinterface、abstract class无;靠鸭子类型,TypeScript 的 interface / type
命名空间 / 模块 / 包module(文件)、package(目录 + __init__.py)namespace、程序集(assembly)、NuGet 包ES Module(文件)、npm 包;历史上还有 CommonJS
泛型typing.Generic / TypeVar(仅类型提示)<T>(运行时具体化)无;TypeScript 的 <T>(编译期擦除)
可空 / 可选Optional[X] = `X \None`X?(Nullable<T> / 可空引用)`X \null`(TS;运行时无)
函数类型一等函数;Callable[[int], str]delegate、Func<T, TResult>、Action<T>一等函数;(x: number) => string(TS)
匿名函数lambda x: x + 1x => x + 1(Lambda 表达式)x => x + 1(箭头函数)
迭代协议__iter__ / __next__,for 循环IEnumerable<T> / IEnumerator<T>Symbol.iterator,for...of
惰性序列生成器 yield / 生成器表达式yield return,或 LINQ 的延迟执行生成器函数 function* / yield
数据查询列表推导式、itertoolsLINQ(Where/Select/GroupBy),查询语法map/filter/reduce
值语义 vs 引用语义全部是引用;不可变类型(int、str、tuple)行为类似值明确区分 struct(值)与 class(引用)原始值 vs 对象;对象总是引用
数据载体(DTO)@dataclass、NamedTuplerecord、record struct普通对象字面量;TS 的 interface
属性 / 访问器@property{ get; set; },支持 init 与表达式体get / set 访问器(Object.defineProperty)
运算符重载魔术方法 __add__operator 关键字无
继承多继承(MRO)单继承 + 多接口实现原型链单继承
模式匹配match / case(3.10+)switch 表达式与模式匹配(功能最完整)无原生;靠 if 链
单元测试框架pytest(事实标准)、unittestxUnit、NUnit、MSTestvitest、jest、Node 内置 node:test
包清单文件pyproject.toml.csprojpackage.json

迁移时最省时间的三个搜索

从 Python 迁到 C#:查 dict → Dictionary(注意 [] 赋值会自动新增键,Python 的 KeyError 在这里不存在)。

从 C# 迁到 JavaScript:查 List<T> → Array(但 Array 没有 容量概念,Length 对应 length)。

从 JavaScript 迁到 Python:查 Object → dict(obj.key 与 obj["key"] 的差异在这里变成 d.key 不存在,必须 d["key"])。

如何选择第一门语言

你的目标推荐理由
想做网页 / 前端JavaScript浏览器只认它;上手快,能立刻看到结果(→ [[前端-01-HTML基础]]、[[JavaScript-01-基础语法与类型]])
想做数据处理 / 爬虫 / 自动化Python生态绝对领先,脚本写法最短(→ [[Python-01-环境与基础语法]])
想系统学习类型系统与工程化C#编译器教你最多;从语法到 AOT 全链路可控(→ [[CSharp-01-环境与基础语法]])
想做 Windows 桌面软件C#WinForms/WPF/WinUI 是原生方案
想进游戏行业C#Unity 主语言
想快速验证一个想法Python代码量最少,依赖最省心
目标是打牢计算机基础(算法/数据结构)C# 或 Python两者都适合学算法;C# 能顺带理解静态类型,Python 能专注算法本身
完全零基础、容易受挫Python语法噪音最少,反馈循环最短

三条决策原则

1. 优先选"能最快做出成品"的语言。 正反馈是坚持学习的第一动力,语法优雅排在后面。

2. 第一门语言决定不了你的职业生涯。 概念(变量、循环、函数、数据结构、错误处理)是通用的,第二门语言的成本远低于第一门。

3. 不要为了"学得更扎实"而故意选最难的语言。 挫败感带来的放弃率远高于"从简单语言起步"的所谓基础不牢。

多语言项目的协作方式

真实项目很少只用一门语言。常见分工与衔接点:

分工模式各语言角色衔接方式注意事项
前后端分离C#/Node 后端 + TypeScript 前端HTTP + JSON(REST / GraphQL)契约先行;用 OpenAPI 生成前端类型,避免手写 DTO 漂移
数据 + 服务Python 训练/分析 + C# 或 Node 服务模型文件(ONNX)+ 推理接口;或消息队列Python 侧的输出格式要有版本号,否则模型更新会静默破坏服务
桌面 + 脚本C# WPF/WinForms + Python 脚本子进程调用 + 标准输入输出用退出码与 stdout 约定协议;不要依赖解析日志文本
全栈同语言TypeScript 前后端(Node)共享类型定义包唯一能真正做到"类型端到端"的组合
全栈同语言(备选)C# + Blazor共享程序集前端体积较大,交互复杂时不如 TS 生态丰富

跨语言协作的通用实践:

  1. 契约前置。 先定接口(OpenAPI / Protobuf / JSON Schema),再各自实现。不要让"前端对着后端代码猜字段"。
  2. 统一命名风格转换点明确。 Python 与 C# 用 snake_case / PascalCase,JavaScript 惯用 camelCase。序列化边界上统一转一次,不要在业务代码里到处转换。
  3. 时间与数字格式固定。 时间一律 ISO 8601 带时区(如 2026-10-11T08:30:00+08:00),不要传本地时间字符串;跨语言的浮点数精度不同,金额用字符串或整数最小单位(分)。
  4. 每种语言都用其惯用工具链。 不要用 Python 的 subprocess 去拼 C# 的构建命令——把构建交给各自的工具(见 工具-08-CICD入门)。
  5. 共享的逻辑放在一处。 一段校验规则如果在前后端各写一遍,迟早会不一致。要么后端为唯一真相源,要么用代码生成。

按目标选语言(决策表)

使用说明

下表是默认建议,不是硬性规定。若团队已有强技术栈积累,团队熟悉度通常优先于语言理论优势——

一个熟练团队用次优语言,产出通常好于生疏团队用最优语言。

目标首选次选关键理由
数据 / 脚本 / 自动化PythonJavaScript(Node)pandas/numpy 生态无对手;脚本写法最短;跨平台一致
企业后端服务C#(ASP.NET Core)Node.js(TypeScript)/ Python(FastAPI)静态类型 + 成熟 DI + 高性能;NativeAOT 适合 Serverless;长期可维护性最好
Web 前端TypeScript(JavaScript 的超集)—浏览器唯一原生语言;TS 补上类型安全;生态规模最大
Windows 桌面C#(WPF / WinForms / WinUI)Electron(TypeScript)原生性能与系统集成最佳;Electron 跨平台但体积大、内存高
跨平台移动TypeScript(React Native)/ C#(.NET MAUI)Dart(Flutter,不在本文范围)两者都能一套代码两平台;RN 生态更大,MAUI 与 C# 后端共享代码
机器学习 / AI 应用PythonC#(ML.NET,仅简单场景)训练与实验生态几乎被 Python 垄断
高并发 I/O 服务C# 或 Node.jsPython(asyncio)C# 真并行且性能强;Node 事件循环模型天然适合 I/O;Python 受 GIL 限制但 asyncio 可用
CLI 工具 / DevOpsPython 或 C#(NativeAOT)Node.js开发速度选 Python;启动速度与单文件分发选 C# NativeAOT
浏览器内运行复杂计算TypeScript + WASM(C#/Rust)JavaScript + Worker纯 JS 受单线程限制;重计算用 WASM 或 Worker
教学 / 算法练习PythonC#少写样板,聚焦算法本身;C# 能同时练类型思维

几个常见组合的推荐:

项目形态推荐组合
内部管理系统C# ASP.NET Core + TypeScript(React/Vue)
数据分析平台Python 后端(FastAPI)+ TypeScript 前端
桌面数据处理工具C# WPF(界面)+ Python(分析脚本,子进程调用)
个人博客 / 小工具TypeScript 全栈(Next.js)或 Python(FastAPI + 静态前端)
需要在无运行时环境分发的小工具C# + NativeAOT(单文件、秒启动)

怎么用

动手跑一遍:同一段逻辑的三种语言实现

选型最终要落到代码上。下面这段词频统计是同一个任务在三种语言中的完整实现,

三份都可直接运行(Python 3.12+ / .NET 6+ / Node.js 22+),并附了逐项对照表。

这是理解"同一概念、不同写法"最直观的方式。

同一段逻辑的三种语言实现

任务:读取一个文本文件,统计每个词出现的次数,输出出现最多的前 N 个词。

规则统一为:按非字母数字字符切分、统一转小写、按"次数降序 + 词字典序"排序,取前 N 个。

Python
#!/usr/bin/env python3
"""统计文本词频,输出前 N 个高频词。用法: python wordcount.py <文件> [topN]"""
from __future__ import annotations

import re
import sys
from collections import Counter

# 刻意不用 \w:Python 的 re 按"单个字符"匹配,中文会被拆成一个个单字。
# 下面这个字符类让连续的 CJK 字母聚成一个"词",与 C#/JS 的 \p{L}+ 语义对齐。
WORD_RE = re.compile(r"[^\W\d_]+|\d+", re.UNICODE)


def count_top(text: str, top_n: int = 10) -> list[tuple[str, int]]:
    """返回 [(词, 次数)],按次数降序、同次数按字典序。"""
    words = WORD_RE.findall(text.lower())
    counter = Counter(words)
    # 排序键设计:次数取负数以实现降序,避免额外的 reverse 分支
    return sorted(counter.items(), key=lambda item: (-item[1], item[0]))[:top_n]


def main(argv: list[str]) -> int:
    if len(argv) < 2:
        print("用法: python wordcount.py <文件> [topN]", file=sys.stderr)
        return 1

    path = argv[1]
    top_n = int(argv[2]) if len(argv) > 2 else 10

    try:
        # encoding 必须显式指定:默认值随平台变化,Windows 上不是 UTF-8
        with open(path, encoding="utf-8") as handle:
            text = handle.read()
    except FileNotFoundError:
        print(f"文件不存在: {path}", file=sys.stderr)
        return 1

    for word, count in count_top(text, top_n):
        print(f"{word:<20}{count}")

    return 0


if __name__ == "__main__":
    raise SystemExit(main(sys.argv))
C#
// Program.cs —— 需要 .NET 6+(用到顶级语句与 GeneratedRegex)
using System.Text.RegularExpressions;

if (args.Length == 0)
{
    Console.Error.WriteLine("用法: dotnet run -- <文件> [topN]");
    return 1;
}

var path = args[0];
var topN = args.Length > 1 && int.TryParse(args[1], out var n) ? n : 10;

if (!File.Exists(path))
{
    Console.Error.WriteLine($"文件不存在: {path}");
    return 1;
}

var text = await File.ReadAllTextAsync(path);   // 异步读取,不阻塞线程
var results = WordCounter.CountTop(text, topN);

foreach (var (word, count) in results)
{
    Console.WriteLine($"{word,-20}{count}");
}

return 0;

internal static partial class WordCounter
{
    // 源生成的正则:编译期生成实现,启动更快且对 NativeAOT 友好
    [GeneratedRegex(@"[\p{L}\p{N}']+")]
    private static partial Regex WordPattern();

    public static List<(string Word, int Count)> CountTop(string text, int topN = 10)
    {
        ArgumentNullException.ThrowIfNull(text);

        // StringComparer.OrdinalIgnoreCase:不随机器区域设置变化,结果可复现
        var counts = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);

        foreach (Match match in WordPattern().Matches(text))
        {
            var word = match.Value.ToLowerInvariant();
            counts[word] = counts.GetValueOrDefault(word) + 1;
        }

        // LINQ:先按次数降序,再按词序升序,最后取前 topN
        return counts
            .OrderByDescending(pair => pair.Value)
            .ThenBy(pair => pair.Key, StringComparer.Ordinal)
            .Take(topN)
            .Select(pair => (pair.Key, pair.Value))
            .ToList();
    }
}
JavaScript(Node.js,ESM)
#!/usr/bin/env node
// 用法: node wordcount.mjs <文件> [topN]
import { readFile } from 'node:fs/promises';
import process from 'node:process';

/**
 * 返回 [(词, 次数)],按次数降序、同次数按字典序。
 * @param {string} text
 * @param {number} topN
 * @returns {Array<[string, number]>}
 */
export function countTop(text, topN = 10) {
  const counts = new Map();

  // matchAll 需要带 g 标志;用 Unicode 属性类以正确处理中文等文字
  for (const match of text.matchAll(/[\p{L}\p{N}']+/gu)) {
    const word = match[0].toLowerCase();
    counts.set(word, (counts.get(word) ?? 0) + 1);
  }

  return [...counts.entries()]
    // 用码点比较(< / >)而不是 localeCompare:
    // localeCompare 受运行环境的区域设置影响,会让排序结果不可复现,也不利于写稳定的单元测试
    .sort((a, b) => b[1] - a[1] || (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0))
    .slice(0, topN);
}

async function main(argv) {
  if (argv.length < 3) {
    console.error('用法: node wordcount.mjs <文件> [topN]');
    return 1;
  }

  const path = argv[2];
  const topN = argv[3] ? Number.parseInt(argv[3], 10) : 10;

  let text;
  try {
    text = await readFile(path, 'utf8');   // 必须指定编码,否则得到 Buffer
  } catch (err) {
    if (err.code === 'ENOENT') {
      console.error(`文件不存在: ${path}`);
      return 1;
    }
    throw err;   // 其他错误不吞掉,交给上层
  }

  for (const [word, count] of countTop(text, topN)) {
    console.log(word.padEnd(20) + count);
  }

  return 0;
}

// 顶层 await 在 ESM 中可用
process.exitCode = await main(process.argv);

三门语言实现的对照要点:

关注点PythonC#JavaScript
文件读取open(...) + withFile.ReadAllTextAsyncreadFile(异步)
编码指定encoding="utf-8"(必写)默认 UTF-8,无需指定'utf8'(必写)
字符类写法[^\W\d_]+(不能直接用 \w)[\p{L}\p{N}']+[\p{L}\p{N}']+ 带 u 标志
计数容器Counter(标准库现成)Dictionary<string,int> + GetValueOrDefaultMap + ?? 0
排序sorted(key=...)LINQ OrderByDescending + ThenByArray.prototype.sort
同次数时的次序按码点(item[0])StringComparer.Ordinal(按码点)手写 < / > 比较(不要用 localeCompare)
稳定排序保证sorted 稳定LINQ 排序稳定sort 规范保证稳定(ES2019 起)
大小写归一.lower().ToLowerInvariant().toLowerCase()
错误处理try/except FileNotFoundErrorFile.Exists + 异常try/catch + err.code === 'ENOENT'
退出码raise SystemExit(n)顶级语句 return nprocess.exitCode = n

这段代码里最值得注意的三个差异

1. 正则的"字符"语义不同。 Python 的 re 按单个字符匹配,\w+ 会把"中文测试"拆成 4 个单字;

C# 与 JavaScript 的 \p{L}+ 会把连续的 CJK 字母聚成一个整体。所以 Python 侧必须换成 [^\W\d_]+,

三份实现才会对同一份输入给出完全一致的词表。这是跨语言做文本处理时最隐蔽的不一致来源。

2. 排序要用"码点"而不是"区域设置"。 C# 的 ToLowerInvariant() 与 StringComparer.Ordinal、

JavaScript 的手写 < / > 比较,都是文化无关的。若 JavaScript 改用 localeCompare,

排序结果会随运行环境的区域设置变化(实测中它会把 测试 排到 brown 之前),

导致单元测试在不同机器上随机失败。

3. C# 必须用 ToLowerInvariant() 而不是 ToLower()。 ToLower() 依赖当前区域设置——

在土耳其语环境下 "I".ToLower() 得到的是 ı 而不是 i,同一份输入会在不同机器上产出不同的词频结果。

Python 的 .lower() 与 JavaScript 的 .toLowerCase() 本身不做这种区域相关映射,因此不需要特殊处理。

常见坑

跨语言对比中最容易犯的十个错误

1. 把"Python 慢"当成语言属性。 慢的是 CPython 的纯 Python 循环;numpy/pandas 场景下 Python 常是最快选项。

2. 用 Debug 构建 / 未优化配置做性能对比。 结论完全无效(见 CSharp-07-dotnet项目与工具链 中 Debug 与 Release 的差异)。

3. 忽略 JavaScript 的弱类型隐式转换。 ==、+、|| 三处最容易出 bug;一律用 ===、显式 Number()、??。

4. 以为 Python 的类型注解会生效。 默认不检查,必须配 mypy 或 pyright。

5. 以为 TypeScript 能在运行时保护你。 类型在编译后被擦除,来自网络的数据仍需运行时校验。

6. 在 Python 里用多线程做 CPU 密集计算。 GIL 会让它比单线程还慢(线程切换有开销)。

7. 在 JavaScript 里用 sort() 排数字。 默认按字符串比较,[10, 9, 1].sort() 得到 [1, 10, 9];必须传 (a, b) => a - b。

8. 在 C# 里用 ToLower() 处理需要可复现的数据。 土耳其语 I 问题;数据处理一律 ToLowerInvariant()。

9. 混用 null 与 undefined 的判断。 JavaScript 中用 x == null 一次覆盖两者,或明确用 === null / === undefined,不要随手写 if (!x)。

10. 拿"某某语言性能是另一门 N 倍"的网文数字做决策。 那些数字通常来自微基准,与真实业务负载无关。取决于实现与场景。

练习题

1.(类型系统判断) 判断下面每个表达式的结果,并说明它体现了哪个维度的差异:

(a)Python:"1" + "2";(b)JavaScript:"1" + 2;(c)JavaScript:"1" - 2;

(d)C#:1 + "2";(e)Python:1 + "2"。

其中哪一个最能说明"弱类型"与"强类型"的区别?

2.(并发选型) 你需要写一个程序:下载 500 个网页,对每个页面做正则匹配统计,最后汇总。请回答:

(a)下载阶段在三种语言中分别该用什么模型?

(b)正则匹配阶段呢?请特别说明 Python 的选择理由。

(c)如果匹配阶段换成"把每个页面的纯文本传给一个 C 写的分词库",Python 的选型会变吗?为什么?

3.(空值陷阱) 下面 JavaScript 代码有一个 bug,请指出并修复:

function retry(times) {
  const n = times || 3;
  for (let i = 0; i < n; i++) { /* ... */ }
}
console.log(retry(0));   // 期望:一次都不重试

再把同样的逻辑用 Python 和 C# 各写一遍,说明三门语言处理"显式传入 0"的差异。

4.(概念迁移) 把下面的 Python 代码逐行翻译成 C# 和 JavaScript:

counts = {}
for word in words:
    counts[word] = counts.get(word, 0) + 1
top = sorted(counts.items(), key=lambda kv: (-kv[1], kv[0]))[:5]

翻译时请说明:C# 中 counts[word] 在键不存在时的行为与 Python dict 有何不同?JavaScript 中该用 Object 还是 Map,为什么?

5.(选型决策) 一个 5 人小团队要做一个"内部数据看板":从公司 PostgreSQL 读数据,做聚合统计,网页上展示图表,需要 Docker 部署,服务器是 2 核 4G 的 Linux。

请给出语言选型方案(可多语言),说明每部分为什么这么选,并指出这个方案中最可能出问题的一个环节。

FAQ

JavaScript 和 TypeScript 到底什么关系?我该学哪个?

TypeScript 是 JavaScript 的超集:所有合法的 JavaScript 都是合法的 TypeScript,TS 额外加了静态类型与编译期检查。

关键点:TS 的类型只在编译期存在,tsc 会把它擦除成普通 JavaScript。所以运行时你面对的仍然是动态弱类型。

实践建议:先学 JavaScript 的核心(类型、闭包、原型、事件循环、异步),再上 TypeScript。

直接学 TS 而不懂 JS,会在遇到 this 绑定或事件循环问题时无法定位——这两个恰恰是 TS 不检查的领域(→ 前端-05-TypeScript、JavaScript-02-函数与作用域、JavaScript-04-异步编程)。

既然 C# 更快、类型更安全,为什么不用 C# 做一切?

因为"更快"只在特定场景成立,而其他成本是全场景的:

- 启动与迭代成本:Python 写完即跑;C# 需要建项目、还原包、编译。写一次性脚本时这个差距是数量级的。

- 生态成本:数据科学、科学计算、AI 训练几乎只有 Python 生态;前端只有 JavaScript。这不是性能问题,是"有没有库"的问题。

- 分发成本:Python 脚本给同事时,对方装个 Python 就能跑(虽然虚拟环境仍要处理);C# 要么对方装对应运行时,要么你发布自包含版本。

- 人力成本:C# 的概念负担更高(值/引用类型、GC、异步状态机、构建体系),团队上手更慢。

简单结论:性能敏感、长期维护的后端和桌面选 C#;探索性、一次性、数据密集的任务选 Python;只要碰浏览器就只有 JavaScript。

Python 的 GIL 会不会被移除?现在还能不能学 Python 并发?

GIL 没有被移除,它是 CPython 的默认行为。PEP 703 提出了 --disable-gil 构建选项(CPython 3.13 起可用),

但官方明确采取"渐进推进、尽量不破坏兼容性"的策略,且这是可选构建而非默认。

因此现在学 Python 并发,正确的知识结构是:

1. I/O 密集型 → 用 asyncio(首选)或 threading(已有的阻塞库更适配时)。等待期间会释放 GIL,所以线程确实能提速。

2. CPU 密集型 → 用 multiprocessing 或 concurrent.futures.ProcessPoolExecutor,或者把热点下沉到 C 扩展(numpy 就是靠这个)。

3. 需要真并行又不想多进程 → 才去评估自由线程构建,并先验证依赖库的兼容性。

这套规则在可预见的未来都有效(→ Python-07-进阶特性、操作系统)。

团队里有人只会一门语言,该统一还是该按场景选?

分界线是团队规模与项目寿命:

- 2-3 人、短期项目 → 统一到团队最熟的语言。学习成本比语言优势更贵。

- 5 人以上、长期维护 → 按场景选,但每个场景只保留一个主力语言。比如"后端 C#、前端 TS、数据 Python",不要出现"两个后端语言"。

- 任何规模 → 都应有明确的边界与契约(API schema、消息格式),让语言选择不成为耦合点。

一个务实的信号:如果某个语言在项目里只被用来写不到 500 行的胶水代码,那它的引入成本(构建、CI、依赖管理、人员培训)几乎肯定超过收益。

相关笔记

  • Python-01-环境与基础语法——Python 基础:类型、流程控制、解释器
  • Python-07-进阶特性——类型注解、GIL 与并发的深入讨论
  • Python-08-虚拟环境与包管理——venv 与 pip 的完整用法
  • CSharp-01-环境与基础语法——C# 基础与 .NET SDK 入门
  • CSharp-03-集合与LINQ——本文对照代码中用到的 Dictionary 与 LINQ
  • CSharp-07-dotnet项目与工具链——项目、NuGet、发布模式与 CI 构建
  • JavaScript-01-基础语法与类型——七种原始类型、类型转换与相等性
  • JavaScript-04-异步编程——事件循环、Promise 与 async/await
  • JavaScript-06-模块化与工程化——ESM、npm 与打包概念
  • 前端-05-TypeScript——TypeScript 类型系统与工程配置
  • 工具-03-包管理器——pip / NuGet / npm 的横向对比
  • 算法-复杂度分析——理解本文中 字符串拼接等结论的基础

参考来源

  • Python 术语对照表(GIL、字节码、可哈希、鸭子类型、垃圾收集等定义):https://docs.python.org/zh-cn/3/glossary.html
  • PEP 703 – Making the Global Interpreter Lock Optional in CPython(--disable-gil、自由线程):https://peps.python.org/pep-0703/
  • C# 文档(语言参考总入口,类型系统与可空引用类型):https://learn.microsoft.com/zh-cn/dotnet/csharp/
  • SDK 样式项目中的目标框架(TFM 与 .NET Standard 实现关系):https://learn.microsoft.com/zh-cn/dotnet/standard/frameworks
  • Microsoft.NET.Sdk 的 MSBuild 属性参考(Nullable、TreatWarningsAsErrors 等):https://learn.microsoft.com/zh-cn/dotnet/core/project-sdk/msbuild-props
  • MDN:JavaScript 数据类型和数据结构(七种原始类型、原型、类型转换):https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Guide/Data_structures
  • MDN:JavaScript 指南(函数、类、控制流与错误处理):https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Guide
  • 现代 JavaScript 教程(中文,事件循环、原型、异步的深入讲解):https://zh.javascript.info/
  • Node.js:Child process 文档(进程模型与并发方式的官方说明):https://nodejs.org/docs/latest-v22.x/api/child_process.html
  • ECMAScript 语言规范(TC39,语言标准的最终依据):https://tc39.es/ecma262/
  • OI Wiki:复杂度 / 均摊分析(本文 拼接结论的背景):https://oi-wiki.org/

关于准确性与版本

本文的对比结论针对以下版本区间:Python 3.12+、.NET 10(C# 14)、ECMAScript 2023+(Node.js 22+ / 现代浏览器)。

语言特性演进较快,涉及具体版本行为时请以官方最新文档为准。

文中所有性能表述均为量级判断,实际性能取决于实现与场景,请以你自己负载下的实测结果为准。