更新至最新语法

Author: Alumopper

docs/zh/quickstart/01project/01create-project.md

@@ -23,7 +23,7 @@ MCFPP目前提供了两种使用方法：直接使用命令行，或者借助Gra
 随后，我们创建一个简单的mcfpp文件，例如`example.mcfpp`：
 
 ```mcfpp
-func hello(){
+func hello {
     print("Hello World");
 }
 ```

docs/zh/quickstart/02base/01variables.md

@@ -11,9 +11,14 @@ lastUpdated: true
 变量的声明一般如下：
 
 ```mcfpp
-#<变量的类型> <变量的标识符> [= 表达式或值]
-int i = 5;
-int b = i * 6;
+#var <变量的标识符> [as <变量的类型>] [= 表达式或值]
+var i as int = 5;
+var b as int = i * 6;
+
+#类型自动推断
+var j = 5; #j的类型会被推断为int
+var k = 5.0; #k的类型会被推断为float
+var i; # [!code error] #错误，缺少初始化表达式，无法推断
 ```
 
 变量的标识符可以为任意字母和数字的组合。在同一个作用域中，一个相同名称的变量只能被声明一次。
@@ -82,20 +87,6 @@ int b = i * 6;
 表示一个目标选择器。储存为一个字符串。
 :::
 
-## var关键字
-
-`var`关键字是MCFPP中的一个特殊关键字，它可以用来声明一个变量，而不需要指定变量的类型。编译器会根据变量的初始化表达式来推断变量的类型。
-
-然而，如果要使用`var`关键字声明一个变量，那么变量的初始化表达式是必须的。
-
-例如：
-
-```mcfpp
-var i = 5; #i的类型会被推断为int
-var j = 5.0; #j的类型会被推断为float
-var i; # [!code error] #错误，缺少初始化表达式
-```
-
 ## 变量修饰符
 
 变量修饰符可以用来表示变量的特性，包括`dynamic`，`const`
@@ -113,11 +104,11 @@ var i; # [!code error] #错误，缺少初始化表达式
 在编译的过程中，编译器会针对一些编译器已知的量进行优化处理。当一个变量被直接赋值为字面量的时候，编译器就会记住这个变量的名字，直到对这个变量失去跟踪。
 
 ```mcfpp
-int i = 5;  #编译器记住了这个变量的值为5
+var i = 5;  #编译器记住了这个变量的值为5
 i += 7;     #编译器直接将i的值记为12，不会输出记分板命令
-int j = i;  #编译器同样也知道了j的值
+var j = i;  #编译器同样也知道了j的值
 
-dynamic int x;
+dynamic var x as int;
 j = x;      #编译器丢失了对j具体值的跟踪
 j += 1;     #编译器会输出记分板命令
 ```

docs/zh/quickstart/02base/03logic-statements.md

@@ -69,7 +69,7 @@ do{
 `break`语句用来跳出整个循环，`continue`语句用来跳过本次循环。例如：
 
 ```mcfpp
-for (int i = 0; i < 10; i++){
+for (var i = 0; i < 10; i++){
     if (i == 5){
         break;
     }

docs/zh/quickstart/02base/05original-command.md

@@ -11,7 +11,7 @@ MCFPP支持Minecraft原生命令的使用。有两种方法可以使用原生命
 以`/`开头的语句将会被认为是一个原生命令。例如：
 
 ```mcfpp
-func test(){
+func test {
     /summon minecraft:armor_stand ~ ~ ~
 }
 ```
@@ -23,7 +23,7 @@ func test(){
 `insert`函数可以将一个字符串插入到当前位置。例如：
 
 ```mcfpp
-func test(){
+func test {
     insert("summon minecraft:armor_stand ~ ~ ~");
 }
 ```

docs/zh/quickstart/03namespace/01namespace.md

@@ -11,7 +11,7 @@ MCFPP中的命名空间和MC中的命名空间是同一种东西。这也意味
 ```mcfpp
 namespace test;
 
-func test(){    # test:test函数
+func test {    # test:test函数
     print(i);
 }
 ```

docs/zh/quickstart/04function/01define-and-call.md

@@ -17,13 +17,25 @@ func functionName(parameter1, parameter2, ...) -> returnType{
 `func`是函数的关键字，`functionName`是函数的标识符或者说名字，而紧随其后的`parameter1, parameter2, ...`则是函数的参数列表，`returnType`是可选的，即函数的返回类型。函数体则是由`{}`包裹的一系列语句。下面是一个实际的例子：
 
 ```mcfpp
-func add(int a, int b) -> int{
+func add(a as int, b as int) -> int{
     return a + b;
 }
 ```
 
 这个函数的名字是`add`，它有两个整数类型的参数`a`和`b`，返回值也是一个整数类型。这个函数的作用是把两个参数相加并返回结果。
 
+若函数没有参数，你可以省略参数列表
+
+```mcfpp
+func getRandom -> int{
+    return random(0, 100);
+}
+
+func sayHi {
+    print("hi");
+}
+```
+
 ## return
 
 `return`和Minecraft中的`return`命令作用相同，都是用于返回函数的返回值。它的语法即为`return expression;`，其中`expression`是一个表达式，它的值就是函数的返回值。
@@ -37,7 +49,7 @@ func add(int a, int b) -> int{
 MCFPP中，函数的调用语法和C/Java一样，即`functionName(parameter1, parameter2, ...);`。其中，`functionName`是函数的名字，`parameter1, parameter2, ...`是要传递给函数的参数。下面是一个实际的例子：
 
 ```mcfpp
-func test(){
+func test {
     print(add(1, 2));  #上面定义的add函数
 }
 ```
@@ -49,11 +61,11 @@ func test(){
 函数中，对参数的修改不会影响到函数外部的变量。例如：
 
 ```mcfpp
-func test(int a){
+func test(int a) {
     a = 5;
 }
 
-void main(){
+void main {
     int a = 0;
     test(a);
     print(a);   #输出0

docs/zh/quickstart/04function/02static-params.md

@@ -7,11 +7,11 @@ lastUpdate: true
 `static`关键字用于声明一个静态参数。静态参数表示，在参数传递的过程中，是传递的参数本身而不是参数的值，因此在函数中对参数的修改会影响外部的变量。例如：
 
 ```mcfpp
-func test(static int a){
+func test(static a as int){
     a = 5;
 }
 
-void main(){
+void main {
     int a = 0;
     test(a);
     print(a);  #输出5

docs/zh/quickstart/04function/03inline-function.md

@@ -21,22 +21,22 @@ inline func functionName(parameter1, parameter2, ...) -> returnType{
 在调用内联函数的地方，编译器会直接将内联函数的代码插入，而不是通过函数调用的方式来执行。例如下面的例子：
 
 ```mcfpp
-inline func add(int a, int b) -> int{
+inline func add(a as int, b as int) -> int{
     return a + b;
 }
 
-func main(){
+func main {
     print(add(1, 2));
 }
 ```
 
 编译的时候，上述代码会相当于：
 
 ```mcfpp
-func main(){
-    int a = 1;
-    int b = 2;
-    int ret = a + b;
+func main {
+    var a = 1;
+    var b = 2;
+    var ret = a + b;
     print(ret);
 }
 ```

docs/zh/quickstart/05class/01define-and-instantiate.md

@@ -12,11 +12,11 @@ class SuperCreeper{
 
     text name;
 
-    constructor(text name){
+    constructor(name as text){
         this.name = name;
     }
 
-    override func tick(){
+    override func tick {
         effect(@a[distance=..5], Effects.Poison);
         title(@a[distance=..5], this.name);
     }
@@ -60,8 +60,8 @@ SuperCreeper p = SuperCreeper("")[
 事实上，实体模板初始化器可以用在任何地方，而不只是在实体模板的初始化的时候。比如
 
 ```mcfpp
-func main(){
-    Test t = Test();
+func main {
+    var t = Test();
     t = t[a = 100];
     print(t.toText());
 }

docs/zh/quickstart/05class/02member.md

@@ -12,20 +12,24 @@ lastUpdate: true
 
 ```mcfpp
 class A{
-    int a;
-    int b = 5;
+    a as int;
+    b as int = 5;
 }
 ```
 
 上述代码定义了一个实体模板`A`，它有两个属性`a`和`b`。`a`是一个整数类型的属性，没有初始化；`b`是一个整数类型的属性，初始化为`5`。
 
+:::tip
+实体模板和数据模板的成员定义都不需要写`var`关键字，直接写成员的类型和名字即可。
+:::
+
 ## 方法
 
 方法是实体模板的函数成员，用来操作对象的数据。方法的定义语法如下：
 
 ```mcfpp
 class A{
-    void test(){
+    func test {
         print("Hello, World!");
     }
 }
@@ -35,8 +39,8 @@ class A{
 
 ```mcfpp
 class A{
-    int a;
-    void setA(int a){
+    a as int;
+    func setA(a as int){
         this.a = a;
     }
 }
@@ -52,21 +56,21 @@ MCFPP中，实体模板的成员可以使用`public`、`protected`、`private`
 
 ```mcfpp
 class A{
-    public int a;
-    protected int b;
-    private int c;
+    public a as int;
+    protected b as int;
+    private c as int;
 }
 
 class B: A{
-    void test(){
+    func test {
         a = 1;  #合法
         b = 2;  #合法
         c = 3;  #编译错误
     }
 }
 
-func test(){
-    A obj = A();
+func test {
+    var obj = A();
     obj.a = 1;  #合法
     obj.b = 2;  #编译错误
     obj.c = 3;  #编译错误

docs/zh/quickstart/05class/03object.md

@@ -11,11 +11,11 @@ lastUpdate: true
 ```mcfpp
 object class Singleton {
     # 成员
-    int value = 0;
+    value as int = 0;
 
     # 方法
-    func setValue(int v) {
-        value = v
+    func setValue(value as int) {
+        this.value = value
     }
 }
 
@@ -30,7 +30,7 @@ Singleton.setValue(10)
 ```mcfpp
 class Person {
 
-    int id = 0;
+    id as int = 0;
 
     constructor() {
         this.id = Person.nextId();
@@ -39,9 +39,9 @@ class Person {
 
 object class Person {
     
-    private int id = 0;
+    private id as int = 0;
     
-    int nextId() {
+    func nextId -> int {
         id = id + 1;
         return id;
     }

docs/zh/quickstart/05class/04inheritance-abstract.md

@@ -12,16 +12,16 @@ MCFPP中，类支持继承和抽象。
 
 ```mcfpp
 class Parent{
-    protect int a;
-    func test(){
+    protect a as int;
+    func test {
         print("Parent");
         print(a);
     }
 }
 
 class Child: Parent{
-    int b;
-    override func test(){
+    b as int;
+    override func test {
         print("Child");
         print(super.a);
     }
@@ -38,7 +38,7 @@ abstract class A{
 }
 
 class B: A{
-    override func test(){
+    override func test {
         print("Hello, World!");
     }
 }

docs/zh/quickstart/05class/05miscellaneous.md

@@ -24,7 +24,7 @@ lastUpdate: true
 
 ```mcfpp
 
-SuperCreeper p = SuperCreeper("Super Creeper");
+var p = SuperCreeper("Super Creeper");
 
 p.dispose();
 

docs/zh/quickstart/07generic/01concrete_var.md

@@ -7,8 +7,8 @@ lastUpdate: true
 在编译过程中，编译器会对一些编译器可以确定的变量进行优化，例如
 
 ```mcfpp
-int i = 5;
-int j = 5;
+var i = 5;
+var j = 5;
 
 print(i + j);
 ```
@@ -18,8 +18,8 @@ print(i + j);
 这种变量，在MCFPP中叫做编译确定量（`Concrete Var`）。编译确定量和普通变量是可以相互转换的，例如：
 
 ```mcfpp
-int i = 5;
-dynamic j;
+var i = 5;
+dynamic var j as int;
 i = j;
 ```