Merge branch 'master' into elixir-casing

11 files changed, 1363 insertions, 593 deletions

diff --git a/zh-cn/asciidoc-cn.html.markdown b/zh-cn/asciidoc-cn.html.markdown
index 74eed445..0709e8c1 100644
--- a/zh-cn/asciidoc-cn.html.markdown
+++ b/zh-cn/asciidoc-cn.html.markdown
@@ -1,6 +1,6 @@
 ---
 language: asciidoc
-filename: asciidoc-cn.md
+filename: asciidoc-cn.adoc
 contributors:
     - ["Ryan Mavilia", "http://unoriginality.rocks/"]
     - ["Abel Salgado Romero", "https://twitter.com/abelsromero"]
diff --git a/zh-cn/awk-cn.html.markdown b/zh-cn/awk-cn.html.markdown
index bac833a6..02f1f7d5 100644
--- a/zh-cn/awk-cn.html.markdown
+++ b/zh-cn/awk-cn.html.markdown
@@ -179,7 +179,7 @@ function string_functions(    localvar, arr) {
     # 都是返回替换的个数
     localvar = "fooooobar"
     sub("fo+", "Meet me at the ", localvar) # localvar => "Meet me at the bar"
-    gsub("e", ".", localvar) # localvar => "m..t m. at th. bar"
+    gsub("e", ".", localvar) # localvar => "M..t m. at th. bar"
 
     # 搜索匹配正则的字符串
     # index() 也是搜索, 不支持正则
diff --git a/zh-cn/c-cn.html.markdown b/zh-cn/c-cn.html.markdown
index dd4445f7..851f2981 100644
--- a/zh-cn/c-cn.html.markdown
+++ b/zh-cn/c-cn.html.markdown
@@ -474,7 +474,7 @@ void testFunc() {
 // 用户自定义类型和结构
 ///////////////////////////////////////
 
-// Typedefs可以创建类型别名
+// typedef 可以创建类型别名
 typedef int my_type;
 my_type my_type_var = 0;
 
diff --git a/zh-cn/cobol-cn.html.markdown b/zh-cn/cobol-cn.html.markdown
new file mode 100644
index 00000000..08eb36fb
--- /dev/null
+++ b/zh-cn/cobol-cn.html.markdown
@@ -0,0 +1,192 @@
+---
+language: COBOL
+filename: learn-cn.COB
+contributors:
+    - ["Hyphz", "http://github.com/hyphz/"]
+translators:
+    - ["GOLGO11", "https://github.com/GOLGO11/"]
+lang: zh-cn
+---
+COBOL是一门面向商业的语言，它从1960年最初设计以来被修订过数次。它被宣称仍然有超过80%的机构在使用它。
+
+```cobol
+      *COBOL. 最好是按照它1985年的标准来编程。 
+      *用附带GnuCOBOL编译器的OpenCobolIDE 4.7.6来编译。
+       
+      *COBOL在老版（COBOL-85）和新版（COBOL-2002以及COBOL-2014）之间有明显的差别。
+      *老版COBOL要求编码的前一到六列是空着的（它们被用来存储穿孔卡片的序列号...
+      *第七列的一个“*”符号表示注释的开始。
+      *在老版COBOL中，一条以*开头的注释最长只能占一行，
+      *新版COBOL不需要额外的列来补序列号，并且用“*>" 来注释，允许在行中开始注释
+      *老版COBOL也强加了对最大行长度的限制
+      *关键字在老版COBOL中必须大写，
+      *但在新版COBOL中不区分大小写
+      *虽然新版COBOL允许你编写大小写混合的代码
+      *但是在大多数情况下编写COBOL代码时全用大写字符
+      *大多数专业的COBOL开发者都是这么做的。
+      *COBOL语句以句点结尾。
+      
+      *COBOL代码被拆成了四个部。
+      *各部按顺序，它们是:
+      *IDENTIFICATION DIVSION.（标识部）
+      *ENVIRONMENT DIVISION.（环境部）
+      *DATA DIVISION.（数据部）
+      *PROCEDURE DIVISION.（过程部）
+
+      *第一步，我们必须给我们的程序一个ID。
+      *Identification division 也能包含其他的值，
+      *但它们都只是程序的元数据。Program-id是唯一一个必须给出的值。
+       IDENTIFICATION DIVISION.
+           PROGRAM-ID.    LEARN.
+           AUTHOR.        JOHN DOE.
+           DATE-WRITTEN.  05/02/2020.
+
+      *让我们来声明一些变量。
+      *我们要在DATA DIVISION的WORKING-STORAGE节来完成这个事情。
+      *每个数据项（又名变量）从一个级别编号开始。
+      *然后是数据项的名字，后边再跟着一个picture关键字，
+      *来描述这个变量将要包含的数据的类型。
+      *几乎所有的COBOL开发者都会把PICTURE简写为PIC。
+      *A代表字母，X代表字母和数字，9代表数字。
+       
+      *举例：
+      01  MYNAME PIC xxxxxxxxxx.    *> 十个字符的字符串。
+       
+      *但是逐个数那些x会导致错误，
+      *所以以上代码可以，并且应该
+      *这样重写：
+      01 MYNAME PIC X(10).
+       
+      *这是几个更多的例子：
+      01  AGE             PIC      9(3).   *> 数字最多三位
+      01  LAST_NAME       PIC      X(10).  *> 字符串最多十个字符
+       
+      *在COBOL里，一行中多个空格和一个空格的效果是一样的， 所以通常
+      *情况下都用多个空格排列代码来便于
+      *其他的开发者阅读。
+      01  inyear picture s9(7). *> S 使数字为正数.
+                                 *> 括号里意思是重复7次9，
+                                 *> 即六位数字（不是数组）
+
+      *现在让我们来写一点儿代码。这是一个简单的Hello World程序。
+      IDENTIFICATION DIVISION.
+      PROGRAM-ID. HELLO.
+      DATA DIVISION.
+      WORKING-STORAGE SECTION.
+      01 THE-MESSAGE      PIC X(20).
+      PROCEDURE DIVSION.
+          DISPLAY "STARTING PROGRAM".
+          MOVE "HELLO WORLD" TO THE-MESSAGE.
+          DISPLAY THE-MESSAGE.
+          STOP RUN.
+      
+      *以上的代码会输出：
+      *STARTING PROGRAM
+      *HELLO WORLD
+      
+
+      
+      ********用COBOL可以做数学运算***************
+      ADD 1 TO AGE GIVING NEW-AGE.
+      SUBTRACT 1 FROM COUNT.
+      DIVIDE VAR-1 INTO VAR-2 GIVING VAR-3.
+      COMPUTE TOTAL-COUNT = COUNT1 PLUS COUNT2.
+      
+      
+      *********PERFORM********************
+      *PERFORM关键字允许你跳到代码中其他特殊的代码段，
+      *当这段特殊的代码被执行完后继续回来执行下面的可执行语句。 
+      *你必须把PERFORM这个词写完整，不可以缩写它。
+
+      IDENTIFICATION DIVISION.
+      PROGRAM-ID. HELLOCOBOL.
+
+      PROCEDURE DIVISION.
+         FIRST-PARA.
+             DISPLAY 'THIS IS IN FIRST-PARA'.
+         PERFORM THIRD-PARA THRU FOURTH-PARA. *>跳过second-para，执行3rd&4th
+         *> 之后当third和fourth执行完，
+         *> 回到这里继续往下执行直到遇到STOP RUN.
+   
+         SECOND-PARA.
+             DISPLAY 'THIS IS IN SECOND-PARA'.
+         STOP RUN.
+   
+         THIRD-PARA.
+             DISPLAY 'THIS IS IN THIRD-PARA'.
+   
+         FOURTH-PARA.
+             DISPLAY 'THIS IS IN FOURTH-PARA'.
+   
+   
+      *当你编译执行以上程序时，它会生成以下结果：
+          THIS IS IN FIRST-PARA
+          THIS IS IN THIRD-PARA
+          THIS IS IN FOURTH-PARA
+          THIS IS IN SECOND-PARA
+          
+          
+      **********用STRING关键字把变量组合到一起************
+      
+      *现在是时候学习两个类似的COBOL动词了：string和unstring。.
+
+      *string动词经常被用来连接两个或多个字符串（把它们拼在一起）。
+      *没什么特别的，Unstring被用来把一个字符串拆分成两个或多个更小的字符串。       
+      *当你在程序中使用string或unstring时不要忘记使用”delimited by“，这个很重要。
+      
+      IDENTIFICATION DIVISION.
+      PROGRAM-ID. LEARNING.
+      ENVIRONMENT DIVISION.
+      DATA DIVISION.
+      WORKING-STORAGE SECTION.
+      01 FULL-NAME PIC X(20).
+      01 FIRST-NAME PIC X(13) VALUE "BOB GIBBERISH".
+      01 LAST-NAME PIC X(5) VALUE "COBB".
+      PROCEDURE DIVISION.
+          STRING FIRST-NAME DELIMITED BY SPACE
+            " "
+            LAST-NAME DELIMITED BY SIZE
+            INTO FULL-NAME
+          END-STRING.
+          DISPLAY "THE FULL NAME IS: "FULL-NAME.
+      STOP RUN.
+
+
+      *以上代码将会输出：
+      THE FULL NAME IS: BOB COBB
+
+
+      *让我们来看看为什么是这样。
+
+      *首先，我们在DATA DIVISION声明了所有的变量，
+      *包括我们想存储string命令生成的新字符串用到的的变量。
+
+      *这个操作过程在PROCEDURE DIVISION完成。
+      *我们从STRING 关键字开始，到END-STRING结束。         
+      *在它们之间我们列出我们想要组合变量形成更大的主变量的过程。
+      *这里，我们组合了FIRST-NAME, 一个空格和LAST-NAME。
+
+      *跟在FIRST-NAME和LAST-NAME后面的DELIMITED BY短语告诉程序我们想要在各自变量上截取字符的规则。
+      *DELIMITED BY SPACE告诉程序从最开始截取字符直到遇到一个空格。
+      *DELIMITED BY SIZE告诉程序截取字符的完整长度。
+      *我们在FIRST-NAME后面使用DELIMITED BY SPACE，字符串中的GIBBERISH部分就被忽略了。
+
+      *为了更清楚，改变代码中的第10行如下:
+
+      STRING FIRST-NAME DELIMITED BY SIZE
+
+      *然后重新执行程序. 这次的输出变成:
+
+      THE FULL NAME IS: BOB GIBBERISH COBB
+
+
+
+
+
+
+```
+
+## 想了解更多吗?
+
+* [GnuCOBOL](https://sourceforge.net/projects/open-cobol/)
+
diff --git a/zh-cn/csharp-cn.html.markdown b/zh-cn/csharp-cn.html.markdown
index 0bad34ce..b6cc70c0 100644
--- a/zh-cn/csharp-cn.html.markdown
+++ b/zh-cn/csharp-cn.html.markdown
@@ -5,45 +5,64 @@ contributors:
     - ["Max Yankov", "https://github.com/golergka"]
     - ["Melvyn Laïly", "http://x2a.yt"]
     - ["Shaun McCarthy", "http://www.shaunmccarthy.com"]
+    - ["Wouter Van Schandevijl", "http://github.com/laoujin"]
+    - ["Jo Pearce", "http://github.com/jdpearce"]
+    - ["Chris Zimmerman", "https://github.com/chriszimmerman"]
+    - ["Shawn McGuire", "https://github.com/bigbash"]
 translators:
     - ["Jakukyo Friel", "http://weakish.github.io"]
+    - ["CatfishWen", "http://catfishwen.github.io"]
 filename: LearnCSharp-cn.cs
 lang: zh-cn
 ---
 
+C#是一种优雅且类型安全的面向对象的语言，使开发人员能够构建运行在跨平台的.NET框架上，安全且健壮的应用程序。
 
-C#是一个优雅的、类型安全的面向对象语言。使用C#，开发者可以在.NET框架下构建安全、健壮的应用程序。
-
-[更多关于C#的介绍](http://msdn.microsoft.com/en-us/library/vstudio/z1zx9t92.aspx)
+[更多关于C#的介绍](https://learn.microsoft.com/zh-cn/dotnet/csharp/tour-of-csharp/)
 
 ```c#
 // 单行注释以 // 开始
 /*
 多行注释是这样的
 */
+
 /// <summary>
-/// XML文档注释
+/// 这是 XML文档注释
+/// 可用于生成外部文档或在 IDE 中提供上下文帮助
 /// </summary>
+/// <param name="firstParam">这是 firstParam 参数的文档</param>
+/// <returns>这是函数返回值的信息</returns>
+public void MethodOrClassOrOtherWithParsableHelp(string firstParam) { }
 
-// 声明应用用到的命名空间
+// 声明这段源码使用到的命名空间
+// 下面的命名空间都是标准 .NET Framework 类库的一部分
 using System;
 using System.Collections.Generic;
-using System.Data.Entity;
 using System.Dynamic;
 using System.Linq;
-using System.Linq.Expressions;
 using System.Net;
 using System.Threading.Tasks;
 using System.IO;
 
-// 定义作用域，将代码组织成包
+// 但是这个并不是标准类库:
+using System.Data.Entity;
+// 为了在下方使用它，你需要添加一个 dll 引用
+// 你可以使用 NuGet 包管理器进行安装
+// `Install-Package EntityFramework`
+
+// 命名空间 Namespaces 可用于将一定的代码组织为 “包” 或者 “模块”
+// 你可以在其他文件中这样引用：using Learning.CSharp;
+
+// 在 C# 10 以后，你也可以这样定义命名空间。这被称为 file-scoped namespaces（文件范围的命名空间）.
+// namespace Learning.CSharp;
+
 namespace Learning
 {
     // 每个 .cs 文件至少需要包含一个和文件名相同的类
-    // 你可以不这么干，但是这样不好。
+    // 你可以不这么干，但是这样并不推荐。
     public class LearnCSharp
     {
-        // 基本语法 -  如果你以前用过 Java 或 C++ 的话，可以直接跳到后文「有趣的特性」
+        // 基本语法 - 如果你以前用过 Java 或 C++ 的话，可以直接跳到后文「有趣的特性」
         public static void Syntax() 
         {
             // 使用 Console.WriteLine 打印信息
@@ -53,7 +72,7 @@ namespace Learning
                 " Double: " + 3.14 +
                 " Boolean: " + true);
 
-            // 使用 Console.Write 打印，不带换行符号
+            // 使用 Console.Write 打印将不会换行
             Console.Write("Hello ");
             Console.Write("World");
 
@@ -113,7 +132,7 @@ namespace Learning
             char charFromString = fooString[1]; // => 'e'
             // 字符串不可修改:  fooString[1] = 'X' 是行不通的;
 
-            // 根据当前的locale设定比较字符串，大小写不敏感
+            // 根据当前的区域格式设置比较字符串，大小写不敏感
             string.Compare(fooString, "x", StringComparison.CurrentCultureIgnoreCase);
 
             // 基于sprintf的字符串格式化
@@ -123,12 +142,13 @@ namespace Learning
             DateTime fooDate = DateTime.Now;
             Console.WriteLine(fooDate.ToString("hh:mm, dd MMM yyyy"));
 
-            // 使用 @  符号可以创建跨行的字符串。使用 "" 来表示 "
+            // 逐字字符串
+            // 使用 @ 符号可以创建跨行的字符串。使用 "" 来表示 "
             string bazString = @"Here's some stuff
 on a new line! ""Wow!"", the masses cried";
 
-            // 使用const或read-only定义常量
-            // 常量在编译期演算
+            // 使用 const 或 read-only 定义常量
+            // 常量在编译阶段演算
             const int HOURS_I_WORK_PER_WEEK = 9001;
 
             ///////////////////////////////////////////////////
@@ -136,7 +156,7 @@ on a new line! ""Wow!"", the masses cried";
             ///////////////////////////////////////////////////
 
             // 数组 - 从0开始计数
-            // 声明数组时需要确定数组长度
+            // 声明数组时需要指定数组长度
             // 声明数组的格式如下：
             // <datatype>[] <var name> = new <datatype>[<array size>];
             int[] intArray = new int[10];
@@ -155,8 +175,8 @@ on a new line! ""Wow!"", the masses cried";
             // List<datatype> <var name> = new List<datatype>();
             List<int> intList = new List<int>();
             List<string> stringList = new List<string>();
-            List<int> z = new List<int> { 9000, 1000, 1337 }; // i
-            // <>用于泛型 - 参考下文
+            List<int> z = new List<int> { 9000, 1000, 1337 }; // 初始化
+            // <> 用于泛型 - 参考下文
 
             // 列表无默认值
             // 访问列表元素时必须首先添加元素
@@ -164,18 +184,18 @@ on a new line! ""Wow!"", the masses cried";
             Console.WriteLine("intList @ 0: " + intList[0]);
 
             // 其他数据结构：
-            // 堆栈/队列
-            // 字典 (哈希表的实现)
-            // 哈希集合
-            // 只读集合
-            // 元组 (.Net 4+)
+            // Stack 堆栈 / Queue 队列
+            // Dictionary 字典 (哈希表的实现)
+            // HashSet 哈希集合
+            // Read-only Collections 只读集合
+            // Tuple 元组 (.Net 4+)
 
             ///////////////////////////////////////
             // 操作符
             ///////////////////////////////////////
             Console.WriteLine("\n->Operators");
 
-            int i1 = 1, i2 = 2; // 多重声明的简写形式
+            int i1 = 1, i2 = 2; // 声明多个变量的简写形式
 
             // 算术直截了当
             Console.WriteLine(i1 + i2 - i1 * 3 / 7); // => 3
@@ -214,7 +234,7 @@ on a new line! ""Wow!"", the masses cried";
             ///////////////////////////////////////
             Console.WriteLine("\n->Control Structures");
 
-            // 类似C的if语句
+            // 类似 C 的 if 语句
             int j = 10;
             if (j == 10)
             {
@@ -239,7 +259,7 @@ on a new line! ""Wow!"", the masses cried";
             int fooWhile = 0;
             while (fooWhile < 100)
             {
-                //迭代 100 次, fooWhile 0->99
+                // 迭代 100 次, fooWhile 0->99
                 fooWhile++;
             }
 
@@ -247,14 +267,21 @@ on a new line! ""Wow!"", the masses cried";
             int fooDoWhile = 0;
             do
             {
-                //迭代 100 次, fooDoWhile 0->99
+                // 迭代 100 次, fooDoWhile 0->99
+                if (false)
+                    continue; // 跳过本次迭代
+
                 fooDoWhile++;
+
+                if (fooDoWhile == 50)
+                    break; // 结束整个循环
+
             } while (fooDoWhile < 100);
 
-            //for 循环结构 => for(<初始条件>; <条件>; <步>)
+            // for 循环结构 => for(<初始条件>; <条件>; <步>)
             for (int fooFor = 0; fooFor < 10; fooFor++)
             {
-                //迭代10次, fooFor 0->9
+                // 迭代10次, fooFor 0->9
             }
 
             // foreach循环
@@ -269,7 +296,7 @@ on a new line! ""Wow!"", the masses cried";
             }
 
             // Switch 语句
-            // switch 适用于 byte、short、char和int 数据类型。
+            // switch 适用于 byte、short、char 和 int 数据类型。
             // 同样适用于可枚举的类型
             // 包括字符串类, 以及一些封装了原始值的类：
             // Character、Byte、Short和Integer。
@@ -307,46 +334,63 @@ on a new line! ""Wow!"", the masses cried";
 
             // 转换字符串为整数
             // 转换失败会抛出异常
-            int.Parse("123");//返回整数类型的"123"
+            int.Parse("123"); // 返回整数类型的"123"
 
-            // TryParse会尝试转换类型，失败时会返回缺省类型
+            // TryParse 会尝试转换类型，失败时会返回缺省类型
             // 例如 0
             int tryInt;
             if (int.TryParse("123", out tryInt)) // Funciton is boolean
                 Console.WriteLine(tryInt);       // 123
 
             // 转换整数为字符串
-            // Convert类提供了一系列便利转换的方法
+            // Convert 类提供了一系列方便转换类型的方法
+
+            // 比如 字符串 与 int 之间
+
+            // 最佳方法
+            bool result = int.TryParse(string, out var integer)
+            int.Parse(string);
+
+            // 不推荐
             Convert.ToString(123);
-            // or
+
+            // Int 到字符串
             tryInt.ToString();
+
+            // 转换
+            // 显式转换 decimal 类型的 15 为 int 类型
+            // 然后隐式转换为 long 类型
+            long x = (int) 15M;
         }
 
         ///////////////////////////////////////
-        // 类
+        // 类 - 请参阅文件末尾的定义
         ///////////////////////////////////////
         public static void Classes()
         {
             // 参看文件尾部的对象声明
 
-            // 使用new初始化对象
+            // 使用 new 初始化对象
             Bicycle trek = new Bicycle();
 
             // 调用对象的方法
-            trek.SpeedUp(3); // 你应该一直使用setter和getter方法
+            trek.SpeedUp(3); // 你应该一直使用 setter 和 getter 方法
             trek.Cadence = 100;
 
             // 查看对象的信息.
             Console.WriteLine("trek info: " + trek.Info());
 
-            // 实例化一个新的Penny Farthing
+            // 实例化一个新的 Penny Farthing 对象
             PennyFarthing funbike = new PennyFarthing(1, 10);
             Console.WriteLine("funbike info: " + funbike.Info());
 
             Console.Read();
         } // 结束main方法
 
-        // 终端程序 终端程序必须有一个main方法作为入口
+        // record 在 C# 9 及以后可用, 这基本上是类的语法糖. record 对象是不可变的 immutable*.
+        public record ARecord(string Csharp);
+
+        // 终端程序入口 终端程序必须有一个 main 方法作为入口
         public static void Main(string[] args)
         {
             OtherInterestingFeatures();
@@ -359,11 +403,11 @@ on a new line! ""Wow!"", the masses cried";
         // 默认方法签名
 
         public // 可见性
-        static // 允许直接调用类，无需先创建实例
-        int, //返回值
+        static // 允许从类直接调用，无需先创建实例
+        int // 返回值类型
         MethodSignatures(
-            int maxCount, // 第一个变量，类型为整型
-            int count = 0, // 如果没有传入值，则缺省值为0
+            int maxCount, // 第一个参数，类型为整型
+            int count = 0, // 如果没有传入值，则缺省值为 0
             int another = 3,
             params string[] otherParams // 捕获其他参数
         )
@@ -371,17 +415,22 @@ on a new line! ""Wow!"", the masses cried";
             return -1;
         }
 
-        // 方法可以重名，只要签名不一样
-        public static void MethodSignature(string maxCount)
+        // 方法可以重名，只要方法签名不一样
+        // 一个只有返回值类型不同的方法
+        public static void MethodSignatures(
+            ref int maxCount, // 通过引用传递
+            out int count)
         {
+            // 通过 'count' 参数传入的值将在该方法外保留值 15
+            count = 15; // 必须在离开方法之前为 out 参数赋值
         }
 
-        //泛型
-        // TKey和TValue类由用用户调用函数时指定。
-        // 以下函数模拟了Python的SetDefault
+        // 泛型
+        // TKey 和 TValue 由用户调用方法时指定
+        // 以下函数模拟了 Python 的 SetDefault
         public static TValue SetDefault<TKey, TValue>(
-            IDictionary<TKey, TValue> dictionary, 
-            TKey key, 
+            IDictionary<TKey, TValue> dictionary,
+            TKey key,
             TValue defaultItem)
         {
             TValue result;
@@ -393,55 +442,125 @@ on a new line! ""Wow!"", the masses cried";
         // 你可以限定传入值的范围
         public static void IterateAndPrint<T>(T toPrint) where T: IEnumerable<int>
         {
-            // 我们可以进行迭代，因为T是可枚举的
+            // 我们可以进行迭代，因为 T 是可枚举的
             foreach (var item in toPrint)
-                // ittm为整数
+                // item 为整数
                 Console.WriteLine(item.ToString());
         }
 
+        // YIELD
+        // 使用 "yield" 关键字表明它出现的方法是一个迭代器 Iterator
+        // (这意味着你可以在 foreach 循环中使用它)
+        public static IEnumerable<int> YieldCounter(int limit = 10)
+        {
+            for (var i = 0; i < limit; i++)
+                yield return i;
+        }
+
+        // 你可以这样调用它
+        public static void PrintYieldCounterToConsole()
+        {
+            foreach (var counter in YieldCounter())
+                Console.WriteLine(counter);
+        }
+
+        // 你可以在一个方法中使用多个 "yield return"
+        public static IEnumerable<int> ManyYieldCounter()
+        {
+            yield return 0;
+            yield return 1;
+            yield return 2;
+            yield return 3;
+        }
+
+        // 你也可以使用 "yield break" 停止该迭代器
+        // 此方法只会返回从 0 到 limit 的一半值。
+        public static IEnumerable<int> YieldCounterWithBreak(int limit = 10)
+        {
+            for (var i = 0; i < limit; i++)
+            {
+                if (i > limit / 2) yield break;
+                yield return i;
+            }
+        }
+
         public static void OtherInterestingFeatures()
         {
-            // 可选参数  
+            // 可选参数
             MethodSignatures(3, 1, 3, "Some", "Extra", "Strings");
             MethodSignatures(3, another: 3); // 显式指定参数，忽略可选参数
 
+            // 使用 ref 和 out 参数
+            int maxCount = 0, count; // ref 参数必须有值
+            MethodSignatures(ref maxCount, out count);
+
             // 扩展方法
             int i = 3;
-            i.Print(); // 参见下面的定义 
+            i.Print(); // 参见下面的定义
 
-            // 可为null的类型 对数据库交互、返回值很有用
+            // 可为 null 的类型 对数据库交互、返回值很有用
             // 任何值类型 (i.e. 不为类) 添加后缀 ? 后会变为可为null的值
             // <类型>? <变量名> = <值>
             int? nullable = null; // Nullable<int> 的简写形式
             Console.WriteLine("Nullable variable: " + nullable);
             bool hasValue = nullable.HasValue; // 不为null时返回真
+
             // ?? 是用于指定默认值的语法糖
             // 以防变量为null的情况
             int notNullable = nullable ?? 0; // 0
 
+            // ?. 是另一个可空类型的操作符 - 简写 null 检查
+            nullable?.Print(); // 当可空类型值不为 null 的时候调用 Print() 拓展方法
+
             // 变量类型推断 - 你可以让编译器推断变量类型:
             var magic = "编译器确定magic是一个字符串，所以仍然是类型安全的";
-            // magic = 9; // 不工作，因为magic是字符串，而不是整数。 
+            // magic = 9; // 不工作，因为magic是字符串，而不是整数。
 
             // 泛型
             //
-            var phonebook = new Dictionary<string, string>() { 
+            var phonebook = new Dictionary<string, string>() {
                 {"Sarah", "212 555 5555"} // 在电话簿中加入新条目
             };
 
-            // 调用上面定义为泛型的SETDEFAULT
-            Console.WriteLine(SetDefault<string,string>(phonebook, "Shaun", "No Phone")); // 没有电话
-            // 你不用指定TKey、TValue，因为它们会被隐式地推导出来
+            // 调用上面定义为泛型的 SETDEFAULT
+            Console.WriteLine(SetDefault<string, string>(phonebook, "Shaun", "No Phone")); // No Phone
+            // 你不用指定 TKey、TValue 的类型
+            // 因为它们会被隐式地推导出来
             Console.WriteLine(SetDefault(phonebook, "Sarah", "No Phone")); // 212 555 5555
 
             // lambda表达式 - 允许你用一行代码搞定函数
             Func<int, int> square = (x) => x * x; // 最后一项为返回值
             Console.WriteLine(square(3)); // 9
 
-            // 可抛弃的资源管理 - 让你很容易地处理未管理的资源
-            // 大多数访问未管理资源 (文件操作符、设备上下文, etc.)的对象
-            // 都实现了IDisposable接口。 
-            // using语句会为你清理IDisposable对象。
+            // 错误处理 - 应对不确定的世界
+            try
+            {
+                var funBike = PennyFarthing.CreateWithGears(6);
+
+                // 将不再执行，因为 CreateWithGears 抛出异常
+                string some = "";
+                if (true) some = null;
+                some.ToLower(); // 抛出 NullReferenceException
+            }
+            catch (NotSupportedException)
+            {
+                Console.WriteLine("Not so much fun now!");
+            }
+            catch (Exception ex) // 捕获所有其他异常
+            {
+                throw new ApplicationException("It hit the fan", ex);
+                // throw; // 重新抛出异常并保留调用堆栈
+            }
+            // catch { } // 捕获所有没有捕获的异常
+            finally
+            {
+                // 在 try 或 catch 之后执行
+            }
+
+            // 可抛弃的资源管理 - 让你很容易地处理未托管的资源
+            // 大多数访问未托管资源 (文件句柄、设备上下文, etc.) 的对象
+            // 都实现了 IDisposable 接口。
+            // using语句会为你清理 IDisposable 对象
             using (StreamWriter writer = new StreamWriter("log.txt"))
             {
                 writer.WriteLine("这里没有什么可疑的东西");
@@ -450,29 +569,23 @@ on a new line! ""Wow!"", the masses cried";
             } 
 
             // 并行框架
-            // http://blogs.msdn.com/b/csharpfaq/archive/2010/06/01/parallel-programming-in-net-framework-4-getting-started.aspx
-            var websites = new string[] { 
-                "http://www.google.com", "http://www.reddit.com", 
-                "http://www.shaunmccarthy.com"
-            };
-            var responses = new Dictionary<string, string>();
-            
-            // 为每个请求新开一个线程
-            // 在运行下一步前合并结果
-            Parallel.ForEach(websites, 
-                new ParallelOptions() {MaxDegreeOfParallelism = 3}, // max of 3 threads
-                website =>
-            {
-                // Do something that takes a long time on the file
-                using (var r = WebRequest.Create(new Uri(website)).GetResponse())
+            // https://learn.microsoft.com/zh-cn/dotnet/standard/parallel-programming/data-parallelism-task-parallel-library
+
+            var words = new List<string> {"dog", "cat", "horse", "pony"};
+
+            Parallel.ForEach(words,
+                new ParallelOptions() { MaxDegreeOfParallelism = 4 },
+                word =>
                 {
-                    responses[website] = r.ContentType;
+                    Console.WriteLine(word);
                 }
-            });
+            );
 
-            // 直到所有的请求完成后才会运行下面的代码
-            foreach (var key in responses.Keys)
-                Console.WriteLine("{0}:{1}", key, responses[key]);
+            // 运行它会产生不同的输出
+            // 因为每个线程在不同的时间完成
+            // 一些可能的输出是：
+            // cat dog horse pony
+            // dog horse pony cat
 
             // 动态对象（配合其他语言使用很方便）
             dynamic student = new ExpandoObject();
@@ -486,10 +599,10 @@ on a new line! ""Wow!"", the masses cried";
             // IQUERYABLE<T> - 几乎所有的集合都实现了它，
             // 带给你 Map / Filter / Reduce 风格的方法
             var bikes = new List<Bicycle>();
-            bikes.Sort(); // Sorts the array
+            bikes.Sort(); // 排序 array
             bikes.Sort((b1, b2) => b1.Wheels.CompareTo(b2.Wheels)); // 根据车轮数排序
             var result = bikes
-                .Where(b => b.Wheels > 3) // 筛选 - 可以连锁使用 （返回IQueryable)
+                .Where(b => b.Wheels > 3) // 筛选 - 可以连锁使用 （返回 IQueryable)
                 .Where(b => b.IsBroken && b.HasTassles)
                 .Select(b => b.ToString()); // Map - 这里我们使用了select，所以结果是IQueryable<string>
 
@@ -502,19 +615,19 @@ on a new line! ""Wow!"", the masses cried";
                 Console.WriteLine(bikeSummary.Name);
 
             // ASPARALLEL
-            // 邪恶的特性 —— 组合了linq和并行操作
+            // 这就是事情开始棘手的地方 —— 组合了 linq 和并行操作
             var threeWheelers = bikes.AsParallel().Where(b => b.Wheels == 3).Select(b => b.Name);
             // 以上代码会并发地运行。会自动新开线程，分别计算结果。
             // 适用于多核、大数据量的场景。
 
-            // LINQ - 将IQueryable<T>映射到存储，延缓执行
+            // LINQ - 映射一组 IQueryable<T> 对象，并延迟执行
             // 例如 LinqToSql 映射数据库, LinqToXml 映射XML文档
             var db = new BikeRespository();
 
-            // 执行被延迟了，这对于查询数据库来说很好
+            // 执行被延迟了，这对于查询数据库来说非常好
             var filter = db.Bikes.Where(b => b.HasTassles); // 不运行查询
             if (42 > 6) // 你可以不断地增加筛选，包括有条件的筛选，例如用于“高级搜索”功能
-                filter = filter.Where(b => b.IsBroken); // 不运行查询 
+                filter = filter.Where(b => b.IsBroken); // 不运行查询
 
             var query = filter
                 .OrderBy(b => b.Wheels)
@@ -541,15 +654,64 @@ on a new line! ""Wow!"", the masses cried";
             Console.WriteLine(obj.ToString());
         }
     }
+
+
+    // 委托 和 事件
+    public class DelegateTest
+    {
+        public static int count = 0;
+        public static int Increment()
+        {
+            // 增加 count 然后返回它
+            return ++count;
+        }
+
+        // 委托是一个方法的引用.
+        // 要引用 Increment 方法,
+        // 首先声明一个具有相同签名的委托,
+        // i.e. 不带参数并返回 int
+        public delegate int IncrementDelegate();
+
+        // 事件也可用于触发委托
+        // 使用委托类型创建事件
+        public static event IncrementDelegate MyEvent;
+
+        static void Main(string[] args)
+        {
+            // 通过实例化委托来引用 Increment 方法
+            // 并将方法本身作为参数传递
+            IncrementDelegate inc = new IncrementDelegate(Increment);
+            Console.WriteLine(inc());  // => 1
+
+            // 委托可以用 + 运算符组合
+            IncrementDelegate composedInc = inc;
+            composedInc += inc;
+            composedInc += inc;
+
+            // composedInc 将执行 Increment 3 次
+            Console.WriteLine(composedInc());  // => 4
+
+
+            // 为事件订阅与委托
+            MyEvent += new IncrementDelegate(Increment);
+            MyEvent += new IncrementDelegate(Increment);
+
+            // 触发事件
+            // ie. 运行这个事件所有的委托订阅
+            Console.WriteLine(MyEvent());  // => 6
+        }
+    }
+
+
     // 声明类的语法：
     // <public/private/protected/internal> class <类名>{
-    //    //数据字段, 构造器, 内部函数.
-    /     // 在Java中函数被称为方法。
+    //    // 数据字段, 构造器, 内部函数
+    //    // 在Java中函数被称为方法
     // }
 
     public class Bicycle
     {
-        // 自行车的字段、变量
+        // 自行车的字段/变量
         public int Cadence // Public: 任何地方都可以访问
         {
             get // get - 定义获取属性的方法
@@ -558,30 +720,35 @@ on a new line! ""Wow!"", the masses cried";
             }
             set // set - 定义设置属性的方法
             {
-                _cadence = value; // value是被传递给setter的值
+                _cadence = value; // value 是被传递给 setter 的值
             }
         }
         private int _cadence;
 
-        protected virtual int Gear // 类和子类可以访问
+        protected virtual int Gear // Protected: 类和子类可以访问
         {
             get; // 创建一个自动属性，无需成员字段
             set;
         }
 
-        internal int Wheels // Internal:在同一程序集内可以访问
+        internal int Wheels // Internal: 在同一程序集内可以访问
         {
             get;
-            private set; // 可以给get/set方法添加修饰符
+            private set; // 可以给 get/set 方法添加修饰符
         }
 
-        int _speed; // 默认为private: 只可以在这个类内访问，你也可以使用`private`关键词
+        int _speed; // 类中的任何内容默认为 private: 只可以在这个类内访问
+                    // 你也可以使用 `private` 关键词显式指定
         public string Name { get; set; }
 
-        // enum类型包含一组常量
+        // 当您想要一个仅返回表达式结果的只读属性时，
+        // 属性还具有特殊的语法
+        public string LongName => Name + " " + _speed + " speed";
+
+        // enum 枚举是一种值类型，由一组命名常量组成
         // 它将名称映射到值（除非特别说明，是一个整型）
-        // enmu元素的类型可以是byte、sbyte、short、ushort、int、uint、long、ulong。
-        // enum不能包含相同的值。
+        // enmu 元素的类型可以是 byte、sbyte、short、ushort、int、uint、long、ulong
+        // enum 不能包含相同的值
         public enum BikeBrand
         {
             AIST,
@@ -589,13 +756,32 @@ on a new line! ""Wow!"", the masses cried";
             Electra = 42, //你可以显式地赋值
             Gitane // 43
         }
-        // 我们在Bicycle类中定义的这个类型，所以它是一个内嵌类型。
-        // 这个类以外的代码应当使用`Bicycle.Brand`来引用。
+        // 我们在 Bicycle 类中定义的这个类型，所以它是一个内嵌类型
+        // 这个类以外的代码应当使用 `Bicycle.Brand` 来引用
+
+        public BikeBrand Brand; // 声明一个 enum 类型之后，我们可以声明这个类型的字段
+
+        // 使用 FlagsAttribute 定义枚举，表示有多个值可以被匹配
+        // 任何从 Attribute 派生的类都可以用来修饰类型、方法、参数等
+        // 位运算符 & 和 | 可用于 和/或 操作
+
+        [Flags]
+        public enum BikeAccessories
+        {
+            None = 0,
+            Bell = 1,
+            MudGuards = 2, // 需要手动设定值!
+            Racks = 4,
+            Lights = 8,
+            FullPackage = Bell | MudGuards | Racks | Lights
+        }
 
-        public BikeBrand Brand; // 声明一个enum类型之后，我们可以声明这个类型的字段
+        // 用法: aBike.Accessories.HasFlag(Bicycle.BikeAccessories.Bell)
+        // 在 .NET 4 之前: (aBike.Accessories & Bicycle.BikeAccessories.Bell) == Bicycle.BikeAccessories.Bell
+        public BikeAccessories Accessories { get; set; }
 
-        // 静态方法的类型为自身，不属于特定的对象。
-        // 你无需引用对象就可以访问他们。
+        // 静态方法属于类型自身，不属于特定的对象
+        // 你无需通过对象就可以访问他们
         // Console.WriteLine("Bicycles created: " + Bicycle.bicyclesCreated);
         static public int BicyclesCreated = 0;
         
@@ -607,7 +793,7 @@ on a new line! ""Wow!"", the masses cried";
         // 下面是一个默认的构造器
         public Bicycle() 
         {
-            this.Gear = 1; // 你可以使用关键词this访问对象的成员
+            this.Gear = 1; // 你可以使用关键词 this 访问对象的成员
             Cadence = 50;  // 不过你并不总是需要它
             _speed = 5;
             Name = "Bontrager";
@@ -618,7 +804,7 @@ on a new line! ""Wow!"", the masses cried";
         // 另一个构造器的例子（包含参数）
         public Bicycle(int startCadence, int startSpeed, int startGear,
                        string name, bool hasCardsInSpokes, BikeBrand brand) 
-            : base() // 首先调用base
+            : base() // 显式调用基类的无参构造方法
         {
             Gear = startGear; 
             Cadence = startCadence;
@@ -637,8 +823,9 @@ on a new line! ""Wow!"", the masses cried";
         // 函数语法
         // <public/private/protected> <返回值> <函数名称>(<参数>)
 
-        // 类可以为字段实现 getters 和 setters 方法 for their fields
-        // 或者可以实现属性（C#推荐使用这个）
+        // 类可以为其字段实现 getters 和 setters 方法
+        // 或者可以使用属性封装字段（C#推荐使用这个）
+
         // 方法的参数可以有默认值
         // 在有默认值的情况下，调用方法的时候可以省略相应的参数
         public void SpeedUp(int increment = 1)
@@ -652,8 +839,8 @@ on a new line! ""Wow!"", the masses cried";
         }
 
         // 属性可以访问和设置值
-        // 当只需要访问数据的时候，考虑使用属性。
-        // 属性可以定义get和set，或者是同时定义两者
+        // 当只需要外部访问数据的时候，考虑使用属性。
+        // 属性可以定义 get 和 set，或者是同时定义两者
         private bool _hasTassles; // private variable
         public bool HasTassles // public accessor
         {
@@ -663,7 +850,7 @@ on a new line! ""Wow!"", the masses cried";
         
         // 你可以在一行之内定义自动属性
         // 这个语法会自动创建后备字段
-        // 你可以给getter或setter设置访问修饰符
+        // 你可以给 getter 或 setter 设置访问修饰符
         // 以便限制它们的访问
         public bool IsBroken { get; private set; }
 
@@ -671,12 +858,29 @@ on a new line! ""Wow!"", the masses cried";
         public int FrameSize
         {
             get;
-            // 你可以给get或set指定访问修饰符
-            // 以下代码意味着只有Bicycle类可以调用Framesize的set
+            // 你可以给 get 或 set 指定访问修饰符
+            // 以下代码意味着只有 Bicycle 类可以调用 Framesize 的 set
             private set;
         }
 
-        //显示对象属性的方法
+        // 还可以在对象上定义自定义索引器
+        // 尽管这在本例中并不完全有用, you
+        // 你可以使用 bicycle[0] 返回 "chris" 来获得第一项
+        // 或者 bicycle[1] = "lisa" 来设定值
+        private string[] passengers = { "chris", "phil", "darren", "regina" };
+
+        public string this[int i]
+        {
+            get {
+                return passengers[i];
+            }
+
+            set {
+                passengers[i] = value;
+            }
+        }
+
+        // 显示对象属性的方法
         public virtual string Info()
         {
             return "Gear: " + Gear +
@@ -698,7 +902,7 @@ on a new line! ""Wow!"", the masses cried";
 
     } //  Bicycle类结束
 
-    // PennyFarthing是Bicycle的一个子类
+    // PennyFarthing 是 Bicycle 的一个子类
     class PennyFarthing : Bicycle
     {
         // (Penny Farthings是一种前轮很大的自行车。没有齿轮。）
@@ -717,10 +921,17 @@ on a new line! ""Wow!"", the masses cried";
             }
             set
             {
-                throw new ArgumentException("你不可能在PennyFarthing上切换齿轮");
+                throw new ArgumentException("你不可能在 PennyFarthing 上切换齿轮");
             }
         }
 
+        public static PennyFarthing CreateWithGears(int gears)
+        {
+            var penny = new PennyFarthing(1, 1);
+            penny.Gear = gears; // 你不能这样做!
+            return penny;
+        }
+
         public override string Info()
         {
             string result = "PennyFarthing bicycle ";
@@ -732,7 +943,7 @@ on a new line! ""Wow!"", the masses cried";
     // 接口只包含成员的签名，而没有实现。
     interface IJumpable
     {
-        void Jump(int meters); // 所有接口成员是隐式地公开的
+        void Jump(int meters); // 所有接口成员是隐式地公开的 public
     }
 
     interface IBreakable
@@ -741,6 +952,8 @@ on a new line! ""Wow!"", the masses cried";
     }
 
     // 类只能继承一个类，但是可以实现任意数量的接口
+    // 但是基类名称必须是列表中的第一个，所有接口都在后面
+    class MountainBike : Bicycle, IJumpable, IBreakable
     {
         int damage = 0;
 
@@ -759,41 +972,374 @@ on a new line! ""Wow!"", the masses cried";
     }
 
     /// <summary>
-    /// 连接数据库，一个 LinqToSql的示例。
+    /// 连接数据库，一个 LinqToSql 的示例。
     /// EntityFramework Code First 很棒 (类似 Ruby的 ActiveRecord, 不过是双向的)
-    /// http://msdn.microsoft.com/en-us/data/jj193542.aspx
+    /// https://learn.microsoft.com/zh-cn/ef/ef6/modeling/code-first/workflows/new-database
     /// </summary>
-    public class BikeRespository : DbSet
+    public class BikeRepository : DbContext
     {
-        public BikeRespository()
+        public BikeRepository()
             : base()
         {
         }
 
         public DbSet<Bicycle> Bikes { get; set; }
     }
+
+    // 一个类可以通过 partial 关键字分别写在多个 .cs 文件中
+    // A1.cs
+    public partial class A
+    {
+        public static void A1()
+        {
+            Console.WriteLine("Method A1 in class A");
+        }
+    }
+
+    // A2.cs
+    public partial class A
+    {
+        public static void A2()
+        {
+            Console.WriteLine("Method A2 in class A");
+        }
+    }
+
+    // 使用 partial 类 "A"
+    public class Program
+    {
+        static void Main()
+        {
+            A.A1();
+            A.A2();
+        }
+    }
+
+    // 通过在字符串前加上 $ 前缀来进行字符串插值
+    // 并用 { 大括号 } 包裹要插值的表达式
+    // 您还可以将插值字符串和逐字字符串与 $@ 组合起来
+    public class Rectangle
+    {
+        public int Length { get; set; }
+        public int Width { get; set; }
+    }
+
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            Rectangle rect = new Rectangle { Length = 5, Width = 3 };
+            Console.WriteLine($"The length is {rect.Length} and the width is {rect.Width}");
+
+            string username = "User";
+            Console.WriteLine($@"C:\Users\{username}\Desktop");
+        }
+    }
+
+    // C# 6 新特性
+    class GlassBall : IJumpable, IBreakable
+    {
+        // 自动属性设置初始值
+        public int Damage { get; private set; } = 0;
+
+        // 为仅有 getter 的自动属性设定初始值
+        public string Name { get; } = "Glass ball";
+
+        // 在构造函数中初始化的仅有 getter 的自动属性
+        public string GenieName { get; }
+
+        public GlassBall(string genieName = null)
+        {
+            GenieName = genieName;
+        }
+
+        public void Jump(int meters)
+        {
+            if (meters < 0)
+                // 新的 nameof() 表达式; 编译器将检查标识符是否存在
+                // nameof(x) == "x"
+                // 预防 例如 参数名称已更改但错误消息中未更新
+                throw new ArgumentException("Cannot jump negative amount!", nameof(meters));
+
+            Damage += meters;
+        }
+
+        // 表达式主体 expression-bodied 属性 ...
+        public bool Broken
+            => Damage > 100;
+
+        // ... 刚发
+        public override string ToString()
+            // 插值字符串
+            => $"{Name}. Damage taken: {Damage}";
+
+        public string SummonGenie()
+            // Null 条件运算符
+            // x?.y 如果 x 为 null 将立即返回 null; y 将不会求值
+            => GenieName?.ToUpper();
+    }
+
+    static class MagicService
+    {
+        private static bool LogException(Exception ex)
+        {
+            // 记录某处的异常
+            return false;
+        }
+
+        public static bool CastSpell(string spell)
+        {
+            try
+            {
+                // 假设我们在这里调用 API
+                throw new MagicServiceException("Spell failed", 42);
+
+                // Spell succeeded
+                return true;
+            }
+            // 仅当 Code 为 42（Spell failed）时才捕获
+            catch(MagicServiceException ex) when (ex.Code == 42)
+            {
+                // Spell failed
+                return false;
+            }
+            // 其他异常，或 MagicServiceException 的 Code 不是 42
+            catch(Exception ex) when (LogException(ex))
+            {
+                // 永远不会执行到这块代码
+                // 堆栈未展开
+            }
+            return false;
+            // 请注意，捕获 MagicServiceException
+            // 并在 Code 不是 42 或 117 时重新抛出是不同的
+            // 因为最终的 catch-all 块将不会捕获重新抛出的异常
+        }
+    }
+
+    public class MagicServiceException : Exception
+    {
+        public int Code { get; }
+
+        public MagicServiceException(string message, int code) : base(message)
+        {
+            Code = code;
+        }
+    }
+
+    public static class PragmaWarning {
+        // 过时的属性
+        [Obsolete("Use NewMethod instead", false)]
+        public static void ObsoleteMethod()
+        {
+            // obsolete code
+        }
+
+        public static void NewMethod()
+        {
+            // new code
+        }
+
+        public static void Main()
+        {
+            ObsoleteMethod(); // CS0618: 'ObsoleteMethod 已过时：使用 NewMethod 代替'
+#pragma warning disable CS0618
+            ObsoleteMethod(); // no warning
+#pragma warning restore CS0618
+            ObsoleteMethod(); // CS0618: 'ObsoleteMethod 已过时：使用 NewMethod 代替'
+        }
+    }
 } // 结束 Namespace
+
+using System;
+// C# 6, 静态引用
+using static System.Math;
+
+namespace Learning.More.CSharp
+{
+    class StaticUsing
+    {
+        static void Main()
+        {
+            // 不使用静态引用时..
+            Console.WriteLine("The square root of 4 is {}.", Math.Sqrt(4));
+            // 使用时
+            Console.WriteLine("The square root of 4 is {}.", Sqrt(4));
+        }
+    }
+}
+
+// C# 7 新特性
+// 使用 Nuget 安装 Microsoft.Net.Compilers 最新版
+// 使用 Nuget 安装 System.ValueTuple 最新版
+using System;
+namespace Csharp7
+{
+    // 元组 TUPLES, 析构 DECONSTRUCTION 和 弃元 DISCARDS
+    class TuplesTest
+    {
+        public (string, string) GetName()
+        {
+            // 元组中的字段默认命名为 Item1、Item2...
+            var names1 = ("Peter", "Parker");
+            Console.WriteLine(names1.Item2);  // => Parker
+
+            // 字段可以显式命名
+            // 第 1 种声明
+            (string FirstName, string LastName) names2 = ("Peter", "Parker");
+
+            // 第 2 种声明
+            var names3 = (First:"Peter", Last:"Parker");
+
+            Console.WriteLine(names2.FirstName);  // => Peter
+            Console.WriteLine(names3.Last);  // => Parker
+
+            return names3;
+        }
+
+        public string GetLastName() {
+            var fullName = GetName();
+
+            // 元组可以被析构
+            (string firstName, string lastName) = fullName;
+
+            // 析构获得的字段可以使用 弃元 _ 丢弃
+            var (_, last) = fullName;
+            return last;
+        }
+
+        // 通过指定析构方法，
+        // 可以以相同的方式解构任何类型
+        public int randomNumber = 4;
+        public int anotherRandomNumber = 10;
+
+        public void Deconstruct(out int randomNumber, out int anotherRandomNumber)
+        {
+            randomNumber = this.randomNumber;
+            anotherRandomNumber = this.anotherRandomNumber;
+        }
+
+        static void Main(string[] args)
+        {
+            var tt = new TuplesTest();
+            (int num1, int num2) = tt;
+            Console.WriteLine($"num1: {num1}, num2: {num2}");  // => num1: 4, num2: 10
+
+            Console.WriteLine(tt.GetLastName());
+        }
+    }
+
+    // 模式匹配
+    class PatternMatchingTest
+    {
+        public static (string, int)? CreateLogMessage(object data)
+        {
+            switch(data)
+            {
+                // 使用 when 进行附加过滤
+                case System.Net.Http.HttpRequestException h when h.Message.Contains("404"):
+                    return (h.Message, 404);
+                case System.Net.Http.HttpRequestException h when h.Message.Contains("400"):
+                    return (h.Message, 400);
+                case Exception e:
+                    return (e.Message, 500);
+                case string s:
+                    return (s, s.Contains("Error") ? 500 : 200);
+                case null:
+                    return null;
+                default:
+                    return (data.ToString(), 500);
+            }
+        }
+    }
+
+    // Reference 变量 / ref 局部变量
+    // 允许返回对象的引用而不仅仅是其值
+    class RefLocalsTest
+    {
+        // 返回值前标明 ref
+        public static ref string FindItem(string[] arr, string el)
+        {
+            for(int i=0; i<arr.Length; i++)
+            {
+                if(arr[i] == el) {
+                    // 返回引用
+                    return ref arr[i];
+                }
+            }
+            throw new Exception("Item not found");
+        }
+
+        public static void SomeMethod()
+        {
+            string[] arr = {"this", "is", "an", "array"};
+
+            // 要在所有地方使用 ref
+            ref string item = ref FindItem(arr, "array");
+            item = "apple";
+            Console.WriteLine(arr[3]);  // => apple
+        }
+    }
+
+    // 本地函数 LOCAL FUNCTIONS
+    class LocalFunctionTest
+    {
+        private static int _id = 0;
+        public int id;
+        public LocalFunctionTest()
+        {
+            id = generateId();
+
+            // 这个本地函数只能在此作用域中被访问
+            int generateId()
+            {
+                return _id++;
+            }
+        }
+
+        public static void AnotherMethod()
+        {
+            var lf1 = new LocalFunctionTest();
+            var lf2 = new LocalFunctionTest();
+            Console.WriteLine($"{lf1.id}, {lf2.id}");  // => 0, 1
+
+            int id = generateId();
+            // error CS0103: 当前上下文中不存在名称“generateId”
+        }
+    }
+}
+
 ```
 
 ## 没有涉及到的主题
+✨ 新的, 👍 旧的, 🎈 长期支持的, 🔥 跨平台的, 🎁 只支持Windows的
+
+ * 特性 Attributes
+
+ * 异步编程
+
+ * Web 开发
+    * ASP.NET Core ✨
+
+ * 桌面应用开发 Development
+    * Windows Presentation Foundation (WPF) 👍 🎈 🎁
+    * Universal Windows Platform (UWP) ✨ 🎁
+    * Uno Platform 🔥 ✨
+    * WinForms 👍 🎈 🎁
+    * Avalonia 🔥 ✨
+    * WinUI ✨ 🎁
 
- * Flags
- * Attributes
- * 静态属性
- * Exceptions, Abstraction
- * ASP.NET (Web Forms/MVC/WebMatrix)
- * Winforms
- * Windows Presentation Foundation (WPF)
+ * 跨平台开发
+    * Xamarin.Forms 👍
+    * MAUI ✨
 
 ## 扩展阅读
 
+ * [C# language reference](https://docs.microsoft.com/dotnet/csharp/language-reference/)
+ * [Learn .NET](https://dotnet.microsoft.com/learn)
+ * [C# Coding Conventions](https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/inside-a-program/coding-conventions)
  * [DotNetPerls](http://www.dotnetperls.com)
  * [C# in Depth](http://manning.com/skeet2)
- * [Programming C#](http://shop.oreilly.com/product/0636920024064.do)
- * [LINQ](http://shop.oreilly.com/product/9780596519254.do)
- * [MSDN Library](http://msdn.microsoft.com/en-us/library/618ayhy6.aspx)
- * [ASP.NET MVC Tutorials](http://www.asp.net/mvc/tutorials)
- * [ASP.NET Web Matrix Tutorials](http://www.asp.net/web-pages/tutorials)
- * [ASP.NET Web Forms Tutorials](http://www.asp.net/web-forms/tutorials)
+ * [Programming C# 5.0](http://shop.oreilly.com/product/0636920024064.do)
+ * [LINQ Pocket Reference](http://shop.oreilly.com/product/9780596519254.do)
  * [Windows Forms Programming in C#](http://www.amazon.com/Windows-Forms-Programming-Chris-Sells/dp/0321116208)
- * [C# Coding Conventions](http://msdn.microsoft.com/en-us/library/vstudio/ff926074.aspx)
+ * [freeCodeCamp - C# Tutorial for Beginners](https://www.youtube.com/watch?v=GhQdlIFylQ8)
diff --git a/zh-cn/fortran-cn.html.markdown b/zh-cn/fortran-cn.html.markdown
new file mode 100644
index 00000000..ab521e0a
--- /dev/null
+++ b/zh-cn/fortran-cn.html.markdown
@@ -0,0 +1,444 @@
+---
+language: Fortran
+filename: learnfortran-cn.f90
+contributors:
+    - ["Robert Steed", "https://github.com/robochat"]
+translators:
+    - ["Corvusnest", "https://github.com/Corvusnest"]
+lang: zh-cn
+---
+
+Fortran 是最古老的计算机语言之一。它由 IBM 开发于 1950 年用于数值运算（Fortran 为 "Formula
+Translation" 的缩写）。虽然该语言已年代久远，但目前仍用于高性能计算，如天气预报。
+该语言仍在持续发展，并且基本保持向下兼容。知名的版本为 Fortran 77, Fortran 90,
+Fortran 95, Fortran 2008, Fortran 2015 和 Fortran 2023。
+
+这篇概要将讨论 Fortran 2008 的一些特征。因为它是目前所广泛采用的标准版本，并且与最新版本的内容
+也基本相同（而 Fortran 77 则是一个非常不同的版本）。
+
+```fortran
+! 这是一个注释
+
+program example         ! 声明一个名为 example 的程序
+
+    ! 代码只能存在于程序、函数、子程序或模块中
+    ! 使用缩进不是必需的，但推荐使用
+
+    ! 声明变量
+    ! =========
+
+    ! 所有的声明必须在语句和表达式之前
+
+    implicit none       ! 防止动态声明变量（推荐！）
+    ! implicit none 推荐在每个函数/程序/模块中重新声明...
+
+    ! 注意 - Fortran 中对大小写不敏感
+    real z
+    REAL Z2
+
+    real :: v, x        ! 警告：默认的初始值取决于编译器！
+    real :: a = 3, b = 2E12, c = 0.01
+    integer :: i, j, k = 1, m
+    real, parameter :: PI = 3.1415926535897931    ! 声明一个常数
+    logical :: y = .TRUE., n = .FALSE.            ! 布尔类型
+    complex :: w = (0, 1)                         ! 单位虚数
+    character(len=3) :: month                     ! 字符串，长度为 3 个字符
+
+    real :: array(6)                              ! 声明一个包含 6 个实数的数组
+    real, dimension(4) :: arrayb                  ! 另一种声明数组的方式
+    integer :: arrayc(-10:10)                     ! 具有自定义索引的数组
+    real :: array2d(3, 2)                         ! 多维数组
+
+    ! 这些分隔符 '::' 并不总是必需的，但推荐使用
+
+    ! 还有许多其他的变量属性：
+    real, pointer :: p                            ! 声明一个指针
+
+    integer, parameter :: LP = selected_real_kind(20)
+    real(kind=LP) :: d                            ! 长精度变量
+
+    ! 警告：在声明过程中初始化变量会在函数中造成问题，
+    ! 因为这会自动暗示 'save' 属性，
+    ! 在函数调用之间保存变量的值一般情况下，
+    ! 除了常量外，声明和初始化的代码应该分开！
+
+    ! 字符串
+    ! =======
+
+    character :: a_char = 'i'
+    character(len=6) :: a_str = "qwerty"
+    character(len=30) :: str_b
+    character(len=*), parameter :: a_long_str = "This is a long string."
+    ! 使用 (len=*) 可以自动计算长度，但只适用于常量
+
+    str_b = a_str//" keyboard"      ! 使用 // 运算符连接字符串
+
+    ! 赋值和算术
+    ! =============
+
+    Z = 1                           ! 对上面声明的变量 z 进行赋值（对大小写不敏感）
+    j = 10 + 2 - 3
+    a = 11.54/(2.3*3.1)
+    b = 2**3                        ! 幂运算
+
+    ! 流程控制语句和操作符
+    ! ===================
+
+    ! 单行 if 语句
+    if (z == a) b = 4               ! 条件始终需要在括号中
+
+    if (z /= a) then                ! z 不等于 a
+        ! 其他的比较操作符包括 < > <= >= == /=
+        b = 4
+    else if (z .GT. a) then         ! z 大于 a
+        ! 文本等价于符号操作符中的 .LT. .GT. .LE. .GE. .EQ. .NE.
+        b = 6
+    else if (z < a) then            ! 'then' 必须在本行上
+        b = 5                       ! 执行块必须在新的一行上
+    else
+        b = 10
+    end if                          ! end 语句后需要 'if'（或可以使用 'endif'）
+
+    if (.NOT. (x < c .AND. v >= a .OR. z == z)) then    ! 布尔运算符
+        inner: if (.TRUE.) then     ! 可以对 if 结构命名
+            b = 1
+        end if inner                ! then 必须命名对应的 endif 语句
+    end if
+
+    i = 20
+    select case (i)
+    case (0, 1)                     ! 当 i == 0 或 i == 1 时
+        j = 0
+    case (2:10)                     ! 当 i 在 2 到 10 之间（包括边界）时
+        j = 1
+    case (11:)                      ! 当 i >= 11 时
+        j = 2
+    case default
+        j = 3
+    end select
+
+    month = 'jan'
+    ! 条件可以是整数、逻辑、或字符类型
+    ! Select 结构也可以命名
+    monthly:select case(month)
+    case ("jan")
+        j = 0
+    case default
+        j = -1
+    end select monthly
+
+    do i = 2, 10, 2             ! 循环从 2 到 10（包括）以 2 为步长
+        innerloop: do j = 1, 3  ! 循环也可以命名
+            exit                ! 退出循环
+        end do innerloop
+        cycle                   ! 跳到下一个循环迭代
+    end do
+
+    ! 虽然存在 Goto 语句，但它被强烈不推荐
+    goto 10
+    stop 1                      ! 立即停止代码（并返回指定的条件代码）
+10  j = 201                     ! 这一行被标记为 10 行
+
+    ! 数组
+    ! =====
+    array = (/1, 2, 3, 4, 5, 6/)
+    array = [1, 2, 3, 4, 5, 6]  ! 使用 Fortran 2003 的表示法
+    arrayb = [10.2, 3e3, 0.41, 4e-5]
+    array2d = reshape([1.0, 2.0, 3.0, 4.0, 5.0, 6.0], [3, 2])
+
+    ! Fortran 数组索引从 1 开始
+    ! （默认情况下，但对于特定数组可以定义不同的索引）
+    v = array(1)                ! 取数组的第一个元素
+    v = array2d(2, 2)
+
+    print *, array(3:5)         ! 打印从第三个到第五个元素（包括）
+    print *, array2d(1, :)      ! 打印二维数组的第一列
+
+    array = array*3 + 2         ! 可以对数组应用数学表达式
+    array = array*array         ! 数组操作是逐元素进行的
+    ! array = array*array2d     ! 这两个数组是不兼容的
+
+    ! 有许多内置函数可用于数组
+    c = dot_product(array, array)   ! 这是点积
+    ! 使用 matmul() 进行矩阵运算
+    c = sum(array)
+    c = maxval(array)
+    print *, minloc(array)
+    c = size(array)
+    print *, shape(array)
+    m = count(array > 0)
+
+    ! 循环数组（通常使用 product() 函数）
+    v = 1
+    do i = 1, size(array)
+        v = v*array(i)
+    end do
+
+    ! 条件性地执行逐元素赋值
+    array = [1, 2, 3, 4, 5, 6]
+    where (array > 3)
+        array = array + 1
+    elsewhere(array == 2)
+        array = 1
+    elsewhere
+        array = 0
+    end where
+
+    ! 隐含 do 循环是创建数组的紧凑方式
+    array = [(i, i=1, 6)]       ! 创建一个数组 [1,2,3,4,5,6]
+    array = [(i, i=1, 12, 2)]   ! 创建一个数组 [1,3,5,7,9,11]
+    array = [(i**2, i=1, 6)]    ! 创建一个数组 [1,4,9,16,25,36]
+    array = [(4, 5, i=1, 3)]    ! 创建一个数组 [4,5,4,5,4,5]
+
+    ! 输入/输出
+    ! =========
+
+    print *, b                  ! 将变量 'b' 打印到命令行
+
+    ! 可以对打印的输出进行格式化
+    print "(I6)", 320           ! 打印 '   320'
+    print "(I6.4)", 3           ! 打印 '  0003'
+    print "(F6.3)", 4.32        ! 打印 ' 4.320'
+
+    ! 字母表示预期的类型，后面的数字表示用于打印值的字符数
+    ! 字母可以是 I（整数），F（实数），E（工程表示法），
+    ! L（逻辑），A（字符串）...
+    print "(I3)", 3200          ! 打印 '***'，因为该数字不适合
+
+    ! 可以有多个格式规范
+    print "(I5,F6.2,E6.2)", 120, 43.41, 43.41
+    print "(3I5)", 10, 20, 30                       ! 整数的三次重复（字段宽度为 5）
+    print "(2(I5,F6.2))", 120, 43.42, 340, 65.3     ! 格式重复组合
+
+    ! 我们还可以从终端读取输入
+    read (*, *) v
+    read (*, "(2F6.2)") v, x                        ! 读取两个数字
+
+    ! 写入文件
+    open (unit=12, file="records.txt", status="replace")
+    ! 文件通过 'unit number' 引用，这个数字可以在 9:99 范围内选择
+    ! Status 可以是 {'old','replace','new'} 中的一个
+    write (12, "(F10.2,F10.2,F10.2)") c, b, a
+    close (12)
+
+    ! 读取文件
+    open (newunit=m, file="records.txt", status="old")
+    ! 文件通过 'new unit number' 引用，编译器为您选择一个整数
+    read (unit=m, fmt="(3F10.2)") a, b, c
+    close (m)
+
+    ! 还有更多功能可用，超出了本文所讨论的范围，
+    ! 还有由于与旧版本的 Fortran 的向后兼容性而存在的替代方案
+
+    ! 内置函数
+    ! ===========
+
+    ! Fortran 大约有 200 个语言内部的函数/子程序
+    ! 例如 -
+    call cpu_time(v)        ! 将 'v' 设置为以秒为单位的时间
+    k = ior(i, j)           ! 两个整数的位 OR 运算
+    v = log10(x)            ! 以 10 为底的对数
+    i = floor(b)            ! 返回小于或等于 x 的最接近的整数
+    v = aimag(w)            ! 复数的虚部
+
+    ! 函数和子程序
+    ! ==============
+
+    ! 子程序运行一些代码，并可以对输入值产生副作用或修改输入值
+
+    call routine(a, c, v)   ! 子程序调用
+
+    ! 函数采用一系列输入参数，并返回一个单个值
+    ! 不过，输入参数可能仍会被修改，并且会执行副作用
+
+    m = func(3, 2, k)       ! 函数调用
+
+    ! 函数调用还可以在表达式中使用
+    print *, func2(3, 2, k)
+
+    ! 一个纯函数是一个不修改其输入参数，
+    ! 也不会引起任何副作用的函数
+    m = func3(3, 2, k)
+
+contains                    ! 包含程序内部定义的子程序的区域
+
+    ! Fortran 有几种稍微不同的方式来定义函数
+
+    integer function func(a, b, c)      ! 函数返回一个整数值
+        ! implicit none                 ! 子变量域可以不再声明 implicit none
+        integer, intent(in) :: a, b, c  ! 在函数内部定义输入参数的类型
+
+        if (a >= 2) then
+            func = a + b + c            ! 返回变量默认为函数名
+            return                      ! 随时可以从函数返回当前值
+        end if
+        func = a + c
+
+        ! 在函数的末尾不需要 return 语句
+    end function func
+
+    function func2(a, b, c) result(f)   ! 返回变量声明为 'f'
+        integer, intent(in) :: a, b     ! 可以声明和强制约定变量
+        ! 不会被函数修改
+        integer, intent(inout) :: c
+        integer :: f                    ! 函数返回类型在函数内部声明
+        integer :: cnt = 0              ! 注意：初始化暗示变量在函数调用之间保存
+        !
+
+        f = a + b - c
+        c = 4                           ! 修改输入变量的值
+        cnt = cnt + 1                   ! 计算函数调用的次数
+
+    end function func2
+
+    pure function func3(a, b, c)        ! 纯函数不能有副作用
+        integer, intent(in) :: a, b, c
+        integer :: func3
+
+        func3 = a*b*c
+
+    end function func3
+
+    subroutine routine(d, e, f)
+        real, intent(inout) :: f
+        real, intent(in) :: d, e
+
+        f = 2*d + 3*e + f
+
+    end subroutine routine
+
+end program example                     ! 程序定义结束--------------------------
+
+! 函数和子程序在程序列表之外声明，在程序之间以及模块中声明时，需要使用 interface 声明（即使它们在同一源文件中）（见下面）将它们定义在模块或程序的 'contains' 部分更容易
+
+elemental real function func4(a) result(res)
+! elemental 函数是一个纯函数，它采用标量输入变量，
+! 但也可以在数组上独立应用，并返回一个新的数组
+    real, intent(in) :: a
+
+    res = a**2 + 1.0
+
+end function func4
+
+! 模块
+! =======
+
+! 模块是在可重用性中将相关的声明、函数和子程序结合在一起的有用方式
+
+module fruit
+
+    real :: apple
+    real :: pear
+    real :: orange
+
+end module fruit
+
+module fruity
+    ! 声明的顺序必须是：模块、接口、变量
+    !（也可以在程序中声明模块和接口）
+
+    use fruit, only: apple, pear    ! 使用 fruit 模块中的 apple 和 pear
+    implicit none                   ! 导入模块之后
+
+    private                         ! 将一些内容私有化（默认为公共）
+    ! 显式将一些变量/函数声明为公共
+    public :: apple, mycar, create_mycar
+    ! 将一些变量/函数声明为模块私有（本例中是多余的）
+    private :: func4
+
+    ! 接口
+    ! ========
+    ! 在模块内部（最好放在 'contains' 部分）显式声明外部函数/过程
+    interface
+        elemental real function func4(a) result(res)
+            real, intent(in) :: a
+        end function func4
+    end interface
+
+    ! 可以使用命名接口定义重载函数
+    interface myabs
+        ! 可以使用 'module procedure' 关键字包括模块内已经定义的函数
+        module procedure real_abs, complex_abs
+    end interface
+
+    ! 派生数据类型
+    ! ==================
+    ! 可以创建自定义的结构化数据集合
+    type car
+        character(len=100) :: model
+        real :: weight              !（千克）
+        real :: dimensions(3)       ! 即，长度-宽度-高度（米）
+        character :: colour
+    contains
+        procedure :: info           ! 将过程绑定到类型
+    end type car
+
+    type(car) :: mycar              ! 声明自定义类型的变量
+    ! 请查看 create_mycar() 程序的用法
+
+    ! 注意：模块中没有可以执行的语句
+
+contains
+
+    subroutine create_mycar(mycar)
+        ! 演示派生数据类型的用法
+        type(car), intent(out) :: mycar
+
+        ! 使用 '%' 运算符访问类型元素
+        mycar%model = "Ford Prefect"
+        mycar%colour = 'r'
+        mycar%weight = 1400
+        mycar%dimensions(1) = 5.0   ! 默认索引从 1 开始！
+        mycar%dimensions(2) = 3.0
+        mycar%dimensions(3) = 1.5
+
+    end subroutine create_mycar
+
+    subroutine info(self)
+        class(car), intent(in) :: self
+        ! 使用 'class' 关键字将过程绑定到类型
+
+        print *, "Model     : ", self%model
+        print *, "Colour    : ", self%colour
+        print *, "Weight    : ", self%weight
+        print *, "Dimensions: ", self%dimensions
+
+    end subroutine info
+
+    real pure function real_abs(x)
+        real, intent(in) :: x
+
+        if (x < 0) then
+            real_abs = -x
+        else
+            real_abs = x
+        end if
+
+    end function real_abs
+
+    real pure function complex_abs(z)
+        complex, intent(in) :: z
+        ! 长行可以使用继续字符 '&' 进行延续
+
+        complex_abs = sqrt(real(z)**2 + &
+                           aimag(z)**2)
+
+    end function complex_abs
+
+end module fruity
+
+```
+
+### 更多资源
+
+了解更多的 Fortran 信息:
+
++ [wikipedia](https://en.wikipedia.org/wiki/Fortran)
++ [Fortran-lang Organization](https://fortran-lang.org/)
++ [Fortran_95_language_features](https://en.wikipedia.org/wiki/Fortran_95_language_features)
++ [fortranwiki.org](http://fortranwiki.org)
++ [www.fortran90.org/](http://www.fortran90.org)
++ [list of Fortran 95 tutorials](http://www.dmoz.org/Computers/Programming/Languages/Fortran/FAQs%2C_Help%2C_and_Tutorials/Fortran_90_and_95/)
++ [Fortran wikibook](https://en.wikibooks.org/wiki/Fortran)
++ [Fortran resources](http://www.fortranplus.co.uk/resources/fortran_resources.pdf)
++ [Mistakes in Fortran 90 Programs That Might Surprise You](http://www.cs.rpi.edu/~szymansk/OOF90/bugs.html)
diff --git a/zh-cn/fortran95-cn.html.markdown b/zh-cn/fortran95-cn.html.markdown
deleted file mode 100644
index e28d309f..00000000
--- a/zh-cn/fortran95-cn.html.markdown
+++ /dev/null
@@ -1,435 +0,0 @@
----
-language: Fortran
-filename: learnfortran-cn.f95
-contributors:
-    - ["Robert Steed", "https://github.com/robochat"]
-translators:
-    - ["Corvusnest", "https://github.com/Corvusnest"]
-lang: zh-cn
----
-
-Fortran 是最古老的计算机语言之一。它由IBM开发于1950年用于数值运算（Fortran 为 "Formula
-Translation" 的缩写）。虽然该语言已年代久远，但目前仍用于高性能计算，如天气预报。
-该语言仍在持续发展，并且基本保持向下兼容。知名的版本为 Fortran 77, Fortran 90,
-Fortran 95, Fortran 2003, Fortran 2008 与 Fortran 2015。
-
-这篇概要将讨论 Fortran 95 的一些特征。因为它是目前所广泛采用的标准版本，并且与最新版本的内容
-也基本相同（而 Fortran 77 则是一个非常不同的版本）。
-
-```fortran
-
-! 这是一行注释
-
-
-program example   !声明一个叫做 example 的程序
-
-    ! 代码只能放在程序、函数、子程序或者模块内部
-    ! 推荐使用缩进，但不是必须的。
-
-    ! 声明变量
-    ! ===================
-
-    ! 所有的声明必须放在语句与表达式之前
-
-    implicit none    !阻止变量的隐式声明 (推荐!)
-    ! Implicit none 必须在每一个 函数/程序/模块 中进行声明
-
-    ! 重要  - Fortran 对大小写不敏感
-    real z
-    REAL Z2
-
-    real :: v,x    ! 警告: 默认值取决于编译器!    
-    real :: a = 3, b=2E12, c = 0.01
-    integer :: i, j, k=1, m
-    real, parameter :: PI = 3.1415926535897931    !声明一个常量
-    logical :: y = .TRUE. , n = .FALSE.    !布尔值
-    complex :: w = (0,1)    !sqrt(-1) (译注: 定义复数，此为-1的平方根)
-    character (len=3) :: month    !长度为3的字符串
-
-    real :: array(6)     !声明长度为6的浮点数数组
-    real, dimension(4) :: arrayb    !声明数组的另一种方法
-    integer :: arrayc(-10:10)   !有着自定义索引的数组
-    real :: array2d(3,2)    !多维数组
-
-    ! 分隔符 '::' 并不总是必要的，但推荐使用
-
-    ! 还存在很多其他的变量特征:
-    real, pointer :: p    !声明一个指针
-
-    integer, parameter :: LP = selected_real_kind(20)
-    real (kind = LP) :: d    !长精度变量
-
-    ! 警告：在声明期间初始化变量将导致在函数内发生问题，因为这将自动具备了 “save” 属性，
-    ! 因此变量的值在函数的多次调用期间将被存储。一般来说，除了常量，应分开声明与初始化！
-
-    ! 字符串
-    ! =======
-
-    character :: a_char = 'i'
-    character (len = 6) :: a_str = "qwerty"
-    character (len = 30) :: str_b
-    character (len = *), parameter :: a_long_str = "This is a long string."
-    !可以通过使用 (len=*) 来自动判断长度，但只对常量有效
-
-    str_b = a_str // " keyboard"    !通过 // 操作符来连接字符串
-
-
-    ! 任务与计算
-    ! =======================
-
-    Z = 1    !向之前声明的变量 z 赋值 (大小写不敏感).
-    j = 10 + 2 - 3
-    a = 11.54  /  (2.3 * 3.1)
-    b = 2**3    !幂
-
-
-    ! 控制流程语句 与 操作符
-    ! ===================================
-
-    !单行 if 语句
-    if (z == a) b = 4  !判别句永远需要放在圆括号内
-
-    if (z /= a) then !z 不等于 a
-    ! 其他的比较运算符： < > <= >= == /=
-      b = 4
-    else if (z .GT. a) then !z 大于(Greater) a
-    ! 文本形式的比较运算符: .LT. .GT. .LE. .GE. .EQ. .NE.  
-      b = 6
-    else if (z < a) then !'then' 必须放在该行
-      b = 5 !执行部分必须放在新的一行里
-    else
-      b = 10
-    end if !结束语句需要 'if' (也可以用 'endif').
-
-
-    if (.NOT. (x < c .AND. v >= a .OR. z == z)) then   !布尔操作符
-      inner: if (.TRUE.) then    !可以为 if 结构命名
-        b = 1
-      endif inner    !接下来必须命名 endif 语句.
-    endif
-
-
-    i = 20
-    select case (i)
-      case (0)    !当 i == 0
-        j=0
-      case (1:10)    !当 i 为 1 到 10 之内 ( 1 <= i <= 10 )
-        j=1
-      case (11:)    !当 i>=11
-        j=2
-      case default
-        j=3
-    end select
-
-
-    month = 'jan'
-    ! 状态值可以为整数、布尔值或者字符类型
-    ! Select 结构同样可以被命名
-    monthly: select case (month)
-      case ("jan")
-         j = 0
-      case default
-         j = -1
-    end select monthly
-
-    do i=2,10,2    !从2到10(包含2和10)以2为步进值循环
-      innerloop: do j=1,3    !循环同样可以被命名
-        exit    !跳出循环
-      end do innerloop
-    cycle    !重复跳入下一次循环
-    enddo
-
-
-    ! Goto 语句是存在的，但强烈不建议使用
-    goto 10    
-    stop 1    !立即停止程序 (返回一个设定的状态码).
-10  j = 201    !这一行被标注为 10 行 （line 10）
-
-
-    ! 数组
-    ! ======
-    array = (/1,2,3,4,5,6/)
-    array = [1,2,3,4,5,6]    !当使用 Fortran 2003 版本.
-    arrayb = [10.2,3e3,0.41,4e-5]
-    array2d =  reshape([1.0,2.0,3.0,4.0,5.0,6.0], [3,2])
-
-    ! Fortran 数组索引起始于 1
-    ! (默认下如此，也可以为数组定义不同的索引起始)
-    v = array(1)    !获取数组的第一个元素
-    v = array2d(2,2)
-
-    print *, array(3:5)    !打印从第3到第五5之内的所有元素
-    print *, array2d(1,:)    !打印2维数组的第一列
-
-    array = array*3 + 2    !可为数组设置数学表达式
-    array = array*array    !数组操作支持元素级(操作) (element-wise)
-    !array = array*array2d    !这两类数组并不是同一个维度的
-
-    ! 有很多内置的数组操作函数
-    c = dot_product(array,array)    !点乘 (点积)
-    ! 用 matmul() 来进行矩阵运算.
-    c = sum(array)
-    c = maxval(array)
-    print *, minloc(array)
-    c = size(array)
-    print *, shape(array)
-    m = count(array > 0)
-
-    ! 遍历一个数组 (一般使用 Product() 函数).
-    v = 1
-    do i = 1, size(array)
-        v = v*array(i)
-    end do
-
-    ! 有条件地执行元素级操作
-    array = [1,2,3,4,5,6]
-    where (array > 3)
-        array = array + 1
-    elsewhere (array == 2)
-        array = 1
-    elsewhere
-        array = 0
-    end where
-
-    ! 隐式DO循环可以很方便地创建数组
-    array = [ (i, i = 1,6) ]    !创建数组 [1,2,3,4,5,6]
-    array = [ (i, i = 1,12,2) ]    !创建数组 [1,3,5,7,9,11]
-    array = [ (i**2, i = 1,6) ]    !创建数组  [1,4,9,16,25,36]
-    array = [ (4,5, i = 1,3) ]    !创建数组 [4,5,4,5,4,5]
-
-
-    ! 输入/输出
-    ! ============
-
-    print *, b    !向命令行打印变量 'b'
-
-    ! 我们可以格式化输出
-    print "(I6)", 320    !打印 '   320'
-    print "(I6.4)", 3    !打印 '  0003'
-    print "(F6.3)", 4.32    !打印 ' 4.320'
-
-
-    ! 该字母与数值规定了给定的数值与字符所用于打印输出的类型与格式
-    ! 字母可为 I (整数), F (浮点数), E (工程格式),
-    ! L (逻辑/布尔值), A (字符) ...
-    print "(I3)", 3200    !如果数值无法符合格式将打印 '***'
-
-    ! 可以同时设定多种格式
-    print "(I5,F6.2,E6.2)", 120, 43.41, 43.41
-    print "(3I5)", 10, 20, 30    !连续打印3个整数 (字段宽度 = 5).
-    print "(2(I5,F6.2))", 120, 43.42, 340, 65.3   !连续分组格式
-
-    ! 我们也可以从终端读取输入
-    read *, v
-    read "(2F6.2)", v, x    !读取2个数值
-
-    ! 读取文件
-    open(unit=11, file="records.txt", status="old")
-    ! 文件被引用带有一个单位数 'unit', 为一个取值范围在9-99的整数
-    ! 'status' 可以为 {'old','replace','new'} 其中之一
-    read(unit=11, fmt="(3F10.2)") a, b, c
-    close(11)
-
-    ! 写入一个文件
-    open(unit=12, file="records.txt", status="replace")
-    write(12, "(F10.2,F10.2,F10.2)") c, b, a
-    close(12)
-    ! 在讨论范围之外的还有更多的细节与可用功能，并于老版本的 Fortran 保持兼容
-
-
-    ! 内置函数
-    ! ==================
-
-    ! Fortran 拥有大约 200 个内置函数/子程序
-    ! 例子
-    call cpu_time(v)    !以秒为单位设置时间
-    k = ior(i,j)    !2个整数的位或运算
-    v = log10(x)    !以10为底的log运算
-    i = floor(b)    !返回一个最接近的整数小于或等于x (地板数)
-    v = aimag(w)    !复数的虚数部分
-
-
-    ! 函数与子程序
-    ! =======================
-
-    ! 一个子程序会根据输入值运行一些代码并会导致副作用 (side-effects) 或修改输入值
-    ! (译者注: 副作用是指对子程序/函数外的环境产生影响，如修改变量)
-
-    call routine(a,c,v)    !调用子程序
-
-    ! 一个函数会根据输入的一系列数值来返回一个单独的值
-    ! 但输入值仍然可能被修改以及产生副作用
-
-    m = func(3,2,k)  !调用函数
-
-    ! 函数可以在表达式内被调用
-    Print *, func2(3,2,k)
-
-    ! 一个纯函数不会去修改输入值或产生副作用
-    m = func3(3,2,k)
-
-
-contains ! 用于定义程序内部的副程序(sub-programs)的区域
-
-    ! Fortran 拥有一些不同的方法去定义函数
-
-    integer function func(a,b,c)    !一个返回一个整数的函数
-        implicit none   !最好也在函数内将含蓄模式关闭 (implicit none)
-        integer :: a,b,c !输入值类型定义在函数内部
-        if (a >= 2) then
-            func = a + b + c !返回值默认为函数名
-            return !可以在函数内任意时间返回当前值
-        endif
-        func = a + c
-        ! 在函数的结尾不需要返回语句
-    end function func
-
-
-    function func2(a,b,c) result(f)    !将返回值声明为 'f'
-        implicit none
-        integer, intent(in) :: a,b    !可以声明让变量无法被函数修改
-        integer, intent(inout) :: c
-        integer :: f     !函数的返回值类型在函数内声明
-        integer :: cnt = 0    !注意 - 隐式的初始化变量将在函数的多次调用间被存储
-        f = a + b - c
-        c = 4    !变动一个输入变量的值
-        cnt  = cnt + 1    !记录函数的被调用次数
-    end function func2
-
-
-    pure function func3(a,b,c)  !一个没有副作用的纯函数
-        implicit none
-        integer, intent(in) :: a,b,c
-        integer :: func3
-        func3 = a*b*c
-    end function func3
-
-
-    subroutine routine(d,e,f)
-        implicit none
-        real, intent(inout) :: f
-        real, intent(in) :: d,e
-        f = 2*d + 3*e + f
-    end subroutine routine
-
-
-end program example   ! 函数定义完毕 -----------------------
-
-! 函数与子程序的外部声明对于生成程序清单来说，需要一个接口声明（即使它们在同一个源文件内）(见下)
-! 使用 'contains' 可以很容易地在模块或程序内定义它们
-
-elemental real function func4(a) result(res)
-! 一个元函数(elemental function) 为一个纯函数使用一个标量输入值
-! 但同时也可以用在一个数组并对其中的元素分别处理，之后返回一个新的数组
-    real, intent(in) :: a
-    res = a**2 + 1.0
-end function func4
-
-
-! 模块
-! =======
-
-! 模块十分适合于存放与复用相关联的一组声明、函数与子程序
-
-module fruit
-    real :: apple
-    real :: pear
-    real :: orange
-end module fruit
-
-
-module fruity
-
-    ! 声明必须按照顺序: 模块、接口、变量
-    ! (同样可在程序内声明模块和接口)
-
-    use fruit, only: apple, pear    ! 使用来自于 fruit 模块的 apple 和 pear
-    implicit none    !在模块导入后声明
-
-    private    !使得模块内容为私有(private)(默认为公共 public)
-    ! 显式声明一些变量/函数为公共
-    public :: apple,mycar,create_mycar
-    ! 声明一些变量/函数为私有(在当前情况下没必要)(译注: 因为前面声明了模块全局 private)
-    private :: func4
-
-    ! 接口
-    ! ==========
-    ! 在模块内显式声明一个外部函数/程序
-    ! 一般最好将函数/程序放进 'contains' 部分内
-    interface
-        elemental real function func4(a) result(res)
-            real, intent(in) :: a
-        end function func4
-    end interface
-
-    ! 重载函数可以通过已命名的接口来定义
-    interface myabs
-        ! 可以通过使用 'module procedure' 关键词来包含一个已在模块内定义的函数
-        module procedure real_abs, complex_abs
-    end interface
-
-    ! 派生数据类型
-    ! ==================
-    ! 可创建自定义数据结构
-    type car
-        character (len=100) :: model
-        real :: weight    !(公斤 kg)
-        real :: dimensions(3)    !例: 长宽高(米)
-        character :: colour
-    end type car
-
-    type(car) :: mycar    !声明一个自定义类型的变量
-    ! 用法具体查看 create_mycar()
-
-    ! 注: 模块内没有可执行的语句
-
-contains
-
-    subroutine create_mycar(mycar)
-        ! 展示派生数据类型的使用
-        implicit none
-        type(car),intent(out) :: mycar
-
-        ! 通过 '%' 操作符来访问(派生数据)类型的元素
-        mycar%model = "Ford Prefect"
-        mycar%colour = 'r'
-        mycar%weight = 1400
-        mycar%dimensions(1) = 5.0    !索引默认起始值为 1 !
-        mycar%dimensions(2) = 3.0
-        mycar%dimensions(3) = 1.5
-
-    end subroutine
-
-    real function real_abs(x)
-        real :: x
-        if (x<0) then
-            real_abs = -x
-        else
-            real_abs = x
-        end if
-    end function real_abs
-
-    real function complex_abs(z)
-        complex :: z
-        ! 过长的一行代码可通过延续符 '&' 来换行
-        complex_abs = sqrt(real(z)**2 + &
-                                         aimag(z)**2)
-    end function complex_abs
-
-
-end module fruity
-
-```
-
-### 更多资源
-
-了解更多的 Fortran 信息:
-
-+ [wikipedia](https://en.wikipedia.org/wiki/Fortran)
-+ [Fortran_95_language_features](https://en.wikipedia.org/wiki/Fortran_95_language_features)
-+ [fortranwiki.org](http://fortranwiki.org)
-+ [www.fortran90.org/](http://www.fortran90.org)
-+ [list of Fortran 95 tutorials](http://www.dmoz.org/Computers/Programming/Languages/Fortran/FAQs%2C_Help%2C_and_Tutorials/Fortran_90_and_95/)
-+ [Fortran wikibook](https://en.wikibooks.org/wiki/Fortran)
-+ [Fortran resources](http://www.fortranplus.co.uk/resources/fortran_resources.pdf)
-+ [Mistakes in Fortran 90 Programs That Might Surprise You](http://www.cs.rpi.edu/~szymansk/OOF90/bugs.html)
diff --git a/zh-cn/go-cn.html.markdown b/zh-cn/go-cn.html.markdown
index 0123c0a6..a2b71761 100644
--- a/zh-cn/go-cn.html.markdown
+++ b/zh-cn/go-cn.html.markdown
@@ -78,7 +78,7 @@ func learnTypes() {
     // 非ascii字符。Go使用UTF-8编码。
     g := 'Σ' // rune类型，int32的别名，使用UTF-8编码
 
-    f := 3.14195 // float64类型，IEEE-754 64位浮点数
+    f := 3.14159 // float64类型，IEEE-754 64位浮点数
     c := 3 + 4i  // complex128类型，内部使用两个float64表示
 
     // var变量可以直接初始化。
@@ -392,15 +392,15 @@ func requestServer() {
 
 ## 更进一步
 
-关于Go的一切你都可以在[Go官方网站](http://golang.org/)找到。
+关于Go的一切你都可以在[Go官方网站](https://go.dev/)找到。
 在那里你可以获得教程参考，在线试用，和更多的资料。
-在简单的尝试过后，在[官方文档](https://golang.org/doc/)那里你会得到你所需要的所有资料、关于编写代码的规范、库和命令行工具的文档与Go的版本历史。
+在简单的尝试过后，在[官方文档](https://go.dev/doc/)那里你会得到你所需要的所有资料、关于编写代码的规范、库和命令行工具的文档与Go的版本历史。
 
 强烈推荐阅读语言定义部分，很简单而且很简洁！（赶时髦！）
 
-你还可以前往[Go在线体验中心](https://play.golang.org/p/tnWMjr16Mm)进，在浏览器里修改并运行这些代码，一定要试一试哦！你可以将[https://play.golang.org](https://play.golang.org)当作一个[REPL](https://en.wikipedia.org/wiki/Read-eval-print_loop)，在那里体验语言特性或运行自己的代码，连环境都不用配！
+你还可以前往[Go在线体验中心](https://go.dev/play/p/tnWMjr16Mm)进，在浏览器里修改并运行这些代码，一定要试一试哦！你可以将[https://go.dev/play/](https://go.dev/play/)当作一个[REPL](https://en.wikipedia.org/wiki/Read-eval-print_loop)，在那里体验语言特性或运行自己的代码，连环境都不用配！
 
-学习Go还要阅读Go[标准库的源代码](http://golang.org/src/)，全部文档化了，可读性非常好，可以学到go，go style和go idioms。在[文档](http://golang.org/pkg/)中点击函数名，源代码就出来了！
+学习Go还要阅读Go[标准库的源代码](https://go.dev/src/)，全部文档化了，可读性非常好，可以学到go，go style和go idioms。在[文档](https://go.dev/pkg/)中点击函数名，源代码就出来了！
 
 [Go by example](https://gobyexample.com/)也是一个学习的好地方。
 
diff --git a/zh-cn/json-cn.html.markdown b/zh-cn/json-cn.html.markdown
index 73d3eb57..f5842c07 100644
--- a/zh-cn/json-cn.html.markdown
+++ b/zh-cn/json-cn.html.markdown
@@ -8,24 +8,30 @@ filename: learnjson-cn.json
 lang: zh-cn
 ---
 
-因为JSON是一个极其简单的数据交换格式，本教程最有可能成为有史以来最简单的
-Learn X in Y Minutes。
+JSON是一个极其简单的数据交换格式。按[json.org](https://json.org)说的，它对人类易读易写，对机器易解析易生成。
 
-纯正的JSON实际上没有注释，但是大多数解析器都
-接受C-风格(//, /\* \*/)的注释。为了兼容性，最好不要在其中写这样形式的注释。
+一段JSON可以是下文列出的类型的任意值，但实际一般按以下两种方式之一呈现：
+
+* 一个键值对的集合(`{ }`)。按不同语言，这可能被理解为对象/记录/结构体/字典/哈希表/有键列表/关联数组
+* 一个有序的值列表(`[ ]`)。按不同语言，这可能被理解为数组/向量/列表/序列
+
+纯正的JSON实际上没有注释，但是大多数解析器都接受C-风格(//, /\* \*/)的注释。一些解析器还容许trailing comma，即最后一个数组元素或最后一个对象属性之后的逗号。不过为了兼容性最好避免。
 
 因此，本教程的一切都会是100%有效的JSON。幸亏，它的表达能力很丰富。
 
 支持的数据类型：
 
-- 字符串: "hello", "\"A quote.\"", "\u0abe", "Newline.\n"
-- 数字: 23, 0.11, 12e10, 3.141e-10, 1.23e+4
-- 对象: { "key": "value" }
-- 数组: ["Values"]
-- 其他: true, false, null
+* 字符串：`"hello"`、`"\"A quote.\""`、`"\u0abe"`、`"Newline.\n"`
+* 数字：`23`、`0.11`、`12e10`、`3.141e-10`、`1.23e+4`
+* 对象：`{ "key": "value" }`
+* 数组：`["Values"]`
+* 其它：`true`、`false`、`null`
 
 ```json
 {
+  "key": "value",
+
+  "keys": "must always be enclosed in double quotes",
   "numbers": 0,
   "strings": "Hellø, wørld. All unicode is allowed, along with \"escaping\".",
   "has bools?": true,
@@ -55,6 +61,23 @@ Learn X in Y Minutes。
     ]
   ],
 
-  "that was short": "And, you're done. You now know everything JSON has to offer."
+  "alternative style": {
+    "comment": "check this out!"
+  , "comma position": "doesn't matter, if it's before the next key, it's valid"
+  , "another comment": "how nice"
+  },
+
+
+
+  "whitespace": "Does not matter.",
+
+
+
+  "that was short": "And done. You now know everything JSON has to offer."
 }
 ```
+
+## 进一步阅读
+
+* [JSON.org](https://www.json.org/json-zh.html) 完美图解JSON的一切
+* [JSON Tutorial](https://www.youtube.com/watch?v=wI1CWzNtE-M) 简要介绍
diff --git a/zh-cn/nim-cn.html.markdown b/zh-cn/nim-cn.html.markdown
index dc662b1e..fa7d8259 100644
--- a/zh-cn/nim-cn.html.markdown
+++ b/zh-cn/nim-cn.html.markdown
@@ -3,7 +3,7 @@ language: Nim
 filename: learnNim-cn.nim
 contributors:
     - ["Jason J. Ayala P.", "http://JasonAyala.com"]
-    - ["Dennis Felsing", "http://felsin9.de/nnis/"]
+    - ["Dennis Felsing", "https://dennis.felsing.org"]
 translators:
     - ["lzw-723", "https://github.com/lzw-723"]
 lang: zh-cn
diff --git a/zh-cn/ruby-cn.html.markdown b/zh-cn/ruby-cn.html.markdown
index 63adab64..b0b8b58c 100644
--- a/zh-cn/ruby-cn.html.markdown
+++ b/zh-cn/ruby-cn.html.markdown
@@ -430,7 +430,7 @@ def guests(*array)
   array.each { |guest| puts guest }
 end
 
-# 结构
+# 解构
 
 # 如果函数返回一个数组，在赋值时可以进行拆分：
 def foods
@@ -449,7 +449,7 @@ end
 
 best *ranked_competitors.first(3) #=> Winners are John, Sally, and Dingus.
 
-# 结构操作符也可放在参数里面
+# 解构操作符也可放在参数里面
 def best(first, second, third, *others)
   puts "Winners are #{first}, #{second}, and #{third}."
   puts "There were #{others.count} other participants."