{
  "schemaVersion": "0.11.0",
  "canonical": "https://www.pystone.net/notes/javascript-for-csharp-developers/",
  "atlas": "https://www.pystone.net/?node=javascript-for-csharp-developers#knowledge-atlas",
  "markdown": "https://www.pystone.net/notes/javascript-for-csharp-developers.md",
  "context": "https://www.pystone.net/notes/javascript-for-csharp-developers.context.json",
  "knowledgeVersion": "224c990773de.5fa8af6e39fa",
  "build": {
    "siteCommit": "224c990773de166d23a886306577dd90379529ce",
    "notesCommit": "5fa8af6e39fa3891d1b9b4832bfa6c4e0ecaaf0a",
    "builtAt": "1970-01-01T00:00:00.000Z",
    "version": "224c990773de.5fa8af6e39fa"
  },
  "id": "note:javascript-for-csharp-developers",
  "slug": "javascript-for-csharp-developers",
  "title": "JavaScript（From CSharp）",
  "type": "note",
  "visibility": "public",
  "idStability": "rename-stable",
  "author": {
    "name": "Perrin Yong",
    "profile": "https://www.pystone.net/profile/"
  },
  "publisher": {
    "name": "Perrin Yong",
    "profile": "https://www.pystone.net/profile/"
  },
  "aliases": [],
  "summary": "JavaScript（From CSharp）",
  "contentRole": "unspecified",
  "isMoc": false,
  "mocRecognition": "none",
  "generated": false,
  "attribution": "unspecified",
  "domain": "10-计算机、信息技术与工程",
  "tags": [],
  "mocs": [],
  "contentHash": "698dda3338118f3769a89c13bc8ae8962f2b804acf583c8dc5fd3524a4d6d997",
  "assets": [],
  "headings": [
    {
      "depth": 1,
      "text": "JavaScript（From CSharp）",
      "anchor": "javascriptfrom-csharp",
      "citation": "https://www.pystone.net/notes/javascript-for-csharp-developers/#javascriptfrom-csharp"
    },
    {
      "depth": 3,
      "text": "为什么选 C# 来对比",
      "anchor": "为什么选-c-来对比",
      "citation": "https://www.pystone.net/notes/javascript-for-csharp-developers/#%E4%B8%BA%E4%BB%80%E4%B9%88%E9%80%89-c-%E6%9D%A5%E5%AF%B9%E6%AF%94"
    },
    {
      "depth": 2,
      "text": "1 变量与类型",
      "anchor": "1-变量与类型",
      "citation": "https://www.pystone.net/notes/javascript-for-csharp-developers/#1-%E5%8F%98%E9%87%8F%E4%B8%8E%E7%B1%BB%E5%9E%8B"
    },
    {
      "depth": 2,
      "text": "2 对象与原型 / 类",
      "anchor": "2-对象与原型-类",
      "citation": "https://www.pystone.net/notes/javascript-for-csharp-developers/#2-%E5%AF%B9%E8%B1%A1%E4%B8%8E%E5%8E%9F%E5%9E%8B-%E7%B1%BB"
    },
    {
      "depth": 3,
      "text": "C# class ↔ JS class（语法相似）",
      "anchor": "c-class-js-class语法相似",
      "citation": "https://www.pystone.net/notes/javascript-for-csharp-developers/#c-class-js-class%E8%AF%AD%E6%B3%95%E7%9B%B8%E4%BC%BC"
    },
    {
      "depth": 3,
      "text": "C# 动态对象 ↔ JS 字面量",
      "anchor": "c-动态对象-js-字面量",
      "citation": "https://www.pystone.net/notes/javascript-for-csharp-developers/#c-%E5%8A%A8%E6%80%81%E5%AF%B9%E8%B1%A1-js-%E5%AD%97%E9%9D%A2%E9%87%8F"
    },
    {
      "depth": 2,
      "text": "3 函数、Lambda、闭包",
      "anchor": "3-函数lambda闭包",
      "citation": "https://www.pystone.net/notes/javascript-for-csharp-developers/#3-%E5%87%BD%E6%95%B0lambda%E9%97%AD%E5%8C%85"
    },
    {
      "depth": 2,
      "text": "4 模块与命名空间",
      "anchor": "4-模块与命名空间",
      "citation": "https://www.pystone.net/notes/javascript-for-csharp-developers/#4-%E6%A8%A1%E5%9D%97%E4%B8%8E%E5%91%BD%E5%90%8D%E7%A9%BA%E9%97%B4"
    },
    {
      "depth": 2,
      "text": "5 异步编程：async / await",
      "anchor": "5-异步编程async-await",
      "citation": "https://www.pystone.net/notes/javascript-for-csharp-developers/#5-%E5%BC%82%E6%AD%A5%E7%BC%96%E7%A8%8Basync-await"
    },
    {
      "depth": 2,
      "text": "6 集合操作：LINQ ↔ JS 数组高阶函数",
      "anchor": "6-集合操作linq-js-数组高阶函数",
      "citation": "https://www.pystone.net/notes/javascript-for-csharp-developers/#6-%E9%9B%86%E5%90%88%E6%93%8D%E4%BD%9Clinq-js-%E6%95%B0%E7%BB%84%E9%AB%98%E9%98%B6%E5%87%BD%E6%95%B0"
    },
    {
      "depth": 2,
      "text": "7 内存管理与垃圾回收",
      "anchor": "7-内存管理与垃圾回收",
      "citation": "https://www.pystone.net/notes/javascript-for-csharp-developers/#7-%E5%86%85%E5%AD%98%E7%AE%A1%E7%90%86%E4%B8%8E%E5%9E%83%E5%9C%BE%E5%9B%9E%E6%94%B6"
    },
    {
      "depth": 2,
      "text": "8 错误处理",
      "anchor": "8-错误处理",
      "citation": "https://www.pystone.net/notes/javascript-for-csharp-developers/#8-%E9%94%99%E8%AF%AF%E5%A4%84%E7%90%86"
    },
    {
      "depth": 2,
      "text": "9 运行时反射 / 元编程",
      "anchor": "9-运行时反射-元编程",
      "citation": "https://www.pystone.net/notes/javascript-for-csharp-developers/#9-%E8%BF%90%E8%A1%8C%E6%97%B6%E5%8F%8D%E5%B0%84-%E5%85%83%E7%BC%96%E7%A8%8B"
    },
    {
      "depth": 2,
      "text": "10 严格模式与类型安全",
      "anchor": "10-严格模式与类型安全",
      "citation": "https://www.pystone.net/notes/javascript-for-csharp-developers/#10-%E4%B8%A5%E6%A0%BC%E6%A8%A1%E5%BC%8F%E4%B8%8E%E7%B1%BB%E5%9E%8B%E5%AE%89%E5%85%A8"
    },
    {
      "depth": 3,
      "text": "小结 · 迁移学习技巧",
      "anchor": "小结-迁移学习技巧",
      "citation": "https://www.pystone.net/notes/javascript-for-csharp-developers/#%E5%B0%8F%E7%BB%93-%E8%BF%81%E7%A7%BB%E5%AD%A6%E4%B9%A0%E6%8A%80%E5%B7%A7"
    }
  ],
  "claims": [],
  "outgoing": [],
  "incoming": [
    {
      "id": "note:game-graphics-and-runtime",
      "title": "游戏图形与运行时",
      "url": "https://www.pystone.net/notes/game-graphics-and-runtime/",
      "atlas": "https://www.pystone.net/?node=game-graphics-and-runtime#knowledge-atlas",
      "label": "游戏图形与运行时",
      "origin": "explicit",
      "humanReviewed": true,
      "context": "WebGL中的“JavaScript（From CSharp）”导航项",
      "citation": "https://www.pystone.net/notes/game-graphics-and-runtime/#webgl"
    }
  ],
  "contentMarkdown": "# JavaScript（From CSharp）\n\n# JavaScript（From CSharp）\n\n\n### 为什么选 **C#** 来对比\n\n* 语法符号同属 C 家族：花括号作用域、`;` 语句结束、`++ --` 运算符等几乎一致。\n* 都支持 **类→对象**、**接口**、**lambda 表达式**、**async / await**。\n* C# 6 起引入的 **动态类型（`dynamic`）**、**匿名对象**、**LINQ** 风格，与 JavaScript 的动态、函数式特性可一一映射。\n  （C++ / Java 在异步与动态方面更远，Python 则语法风格完全不同。）\n\n---\n\n## 1 变量与类型\n\n| 主题    | C#                                      | JavaScript                        |\n| ----- | --------------------------------------- | --------------------------------- |\n| 声明    | `int x = 5;``var y = \"hi\";` (编译期推断) | `let x = 5;``const y = \"hi\";` |\n| 动态    | `dynamic obj = 7; obj = \"txt\";`         | 所有变量天然动态                          |\n| 作用域   | 块级 `{}`（自 C# 8 起）                       | `let / const` 块级，`var` 函数级        |\n| 字符串插值 | `$\"Name:{name}\"`                        | `` `Name:${name}` ``              |\n\n---\n\n## 2 对象与原型 / 类\n\n### C# class ↔ JS class（语法相似）\n\n```csharp\nclass Player {\n    public string Name { get; }\n    public Player(string n) { Name = n; }\n    public virtual void Say() => Console.WriteLine($\"Hi I’m {Name}\");\n}\n```\n\n```js\nclass Player {\n    constructor(name){ this.name = name; }\n    say(){ console.log(`Hi I’m ${this.name}`); }\n}\n```\n\n**差异**\n\n* **继承**：`class Mage : Player` (C#) vs `class Mage extends Player` (JS)。\n* **字段可见性**：C# 有 `public/private/protected/internal`；JS #私有字段仅 ES2022+。\n* **原型链**：JS 每个对象指向其 **prototype**；C# 无此概念，运行期通过元数据 (reflection)。\n\n### C# 动态对象 ↔ JS 字面量\n\n```csharp\nvar o = new { x = 1, y = \"hi\" };  // 匿名类型，编译期只读\ndynamic d = new ExpandoObject();\nd.z = 10;                         // 运行期可增删\n```\n\n```js\nconst o = { x:1, y:\"hi\" };        // 可随时增删\no.z = 10;\n```\n\n---\n\n## 3 函数、Lambda、闭包\n\n| 概念         | C#                                                       | JavaScript                                   |\n| ---------- | -------------------------------------------------------- | -------------------------------------------- |\n| 普通函数       | `int Add(int a,int b){return a+b;}`                      | `function add(a,b){return a+b}`              |\n| Lambda     | `(int a,int b)=>a+b`                                     | `(a,b)=>a+b`                                 |\n| 闭包         | 捕获外部变量`Func<int> counter(){int c=0;return ()=>++c;}` | `function counter(){let c=0;return ()=>++c}` |\n| 默认参数 / 可变参 | `void Foo(int a=1, params int[] r)`                      | `function foo(a=1,...r)`                     |\n\n---\n\n## 4 模块与命名空间\n\n```csharp\n// File: Game.Core.cs\nnamespace Game.Core { public class Util { } }\n```\n\n```js\n// ES Module\n// File: util.js\nexport function util(){}\n```\n\n* C# 编译期基于 **命名空间**；JS 运行期基于 **文件级模块**（`import / export`）。\n* Node.js 早期用 `require()` CommonJS；现代浏览器/Node 支持 ES Module。\n\n---\n\n## 5 异步编程：async / await\n\n```csharp\nasync Task<string> FetchAsync(string url){\n    using var cli=new HttpClient();\n    return await cli.GetStringAsync(url);\n}\n```\n\n```js\nasync function fetchText(url){\n    const res = await fetch(url);\n    return await res.text();\n}\n```\n\n共性\n\n* 关键字、语义几乎一致：`await` 暂停直到 Promise / Task 完成。\n* 错误以 **异常**（`catch` / `try { } catch { }`）处理。\n\n---\n\n## 6 集合操作：LINQ ↔ JS 数组高阶函数\n\n| 操作 | C# LINQ                 | JavaScript                                   |\n| -- | ----------------------- | -------------------------------------------- |\n| 过滤 | `numbers.Where(n=>n>5)` | `numbers.filter(n=>n>5)`                     |\n| 映射 | `.Select(n=>n*2)`       | `.map(n=>n*2)`                               |\n| 聚合 | `.Sum()` `.Average()`   | `.reduce((s,n)=>s+n,0)`                      |\n| 惰性 | `IEnumerable<>` 延迟执行    | 所有数组方法立即执行 (ES2024 `iterator.toArray()` 将类似) |\n\n---\n\n## 7 内存管理与垃圾回收\n\n* **两者都有 GC**；C# 倾向代数分代 + 基于引用计数的 `IDisposable` 模式；JS Omni GC（浏览器 V8、SpiderMonkey）。\n* C# 用 `using` / `await using` 调用 `Dispose`，JS 暂无语言级析构；需要手动取消事件监听或使用 `WeakRef`。\n\n---\n\n## 8 错误处理\n\n```csharp\ntry {\n    Do();\n} catch(Exception ex) {\n    Console.WriteLine(ex.Message);\n} finally { }\n```\n\n```js\ntry {\n    doSomething();\n} catch(ex){\n    console.log(ex.message);\n} finally {}\n```\n\n* 异常对象相似：`ex.Message` vs `ex.message`，JS 还自带 `stack` 字符串。\n\n---\n\n## 9 运行时反射 / 元编程\n\n| 场景     | C#                                 | JavaScript                                           |\n| ------ | ---------------------------------- | ---------------------------------------------------- |\n| 读取类型信息 | `typeof(Player)` / `obj.GetType()` | `typeof obj` 返回 `\"object\"`；原型：`obj.constructor.name` |\n| 动态调用   | `MethodInfo.Invoke`                | `obj[methodName]()`                                  |\n| 生成代码   | `Expression<T>` / Roslyn           | `eval()` / 动态 `Function()`                           |\n\nJS 天然动态，反射成本更低但易失控；C# 需 `System.Reflection` 且编译期安全性更高。\n\n---\n\n## 10 严格模式与类型安全\n\n* **C#**：编译期强类型，可用 `dynamic` 放宽，但失去 IntelliSense 与大部分静态检查。\n* **JavaScript**：本体弱类型，可借 **TypeScript** 提供编译期类型系统；TypeScript 语法酷似 C#（接口、枚举、可空类型）。\n\n---\n\n### 小结 · 迁移学习技巧\n\n1. **先抓相同符号**：花括号作用域、`;`、`for(;;)`、`if( )` 条件写法 100% 通用。\n2. **把 C# Lambda→JS Arrow**：语法仅是去掉参数类型、换 `=>` 体为表达式或块。\n3. **async/await 迁移**：连关键字与错误模型都一致；记得 JS 的 `fetch` 返回 Promise。\n4. **面向对象差异**：别把 C# 的访问修饰符与接口多重继承惯性带入 JS；JS 支持混入、动态扩展原型，设计更灵活也更易出错。\n5. **动态特性对照**：用 C# 的 `dynamic` + `ExpandoObject` 练习，可快速体会 JS 对象可随时增删属性的模式。\n\n掌握以上“一一映射”后，你就能**借熟悉的 C# 思维快速摸通 JavaScript**，再深入异步事件循环、原型链与模块打包器（Webpack/Vite）时，会更游刃有余。\n"
}