GDScript：动态语言简介

大家好，欢迎来到IT知识分享网。

Gorgeous 3D with godot

关于

本教程旨在快速介绍如何更有效地使用GDScript。它只关注特定于该语言的常见情况，但是也涉及许多关于动态类型语言的信息。

对于没有或几乎没有动态类型语言经验的程序员来说，它特别有用。

动态性

动态类型的优缺点

GDScript是一种动态类型语言。因此，它的主要优点是：

• 这种语言简单易学。
• 大多数代码都可以快速地编写和更改，而且没有任何麻烦。
• 编写更少的代码意味着要修复的错误和失误更少。
• 更容易阅读代码（减少混乱）。
• 测试不需要编译。
• 运行时（Runtime）很小。
• 本质上是鸭子类型和多态性。

主要缺点是：

• 比静态类型语言的性能要低。
• 重构更加困难（无法追踪符号）
• 在静态类型语言中，一些通常在编译时检测到的错误只会在运行代码时出现（因为表达式解析更严格）。
• 代码完成的灵活性较低（一些变量类型只在运行时知道）。

这转化为现实，意味着Godot+GDScript是一个旨在快速高效创建游戏的组合。对于计算量很大并且无法从引擎内置工具（例如向量类型、物理引擎、数学库等）中受益的游戏，也存在使用C++的可能性。这允许您依旧使用GDScript创建游戏的绝大部分，并在需要性能的地方添加少量C++代码。

变量与赋值

动态类型语言中的所有变量都是类似 变体 的。这意味着它们的类型不是固定的，只能通过赋值修改。示例：

静态的：

int a; // Value uninitialized. a = 5; // This is valid. a = "Hi!"; // This is invalid.

动态的：

var a # 'null' by default. a = 5 # Valid, 'a' becomes an integer. a = "Hi!" # Valid, 'a' changed to a string.

作为函数参数：

函数也是动态的，这意味着它们可以用不同的参数调用，例如：

静态的：

void print_value(int value) { printf("value is %i\n", value); } [..] print_value(55); // Valid. print_value("Hello"); // Invalid.

动态的：

func print_value(value): print(value) [..] print_value(55) # Valid. print_value("Hello") # Valid.

指针和引用：

在静态语言，如C或C++（以及在一定程度上，Java和C#）中，变量和变量的指针/引用之间存在区别。后者通过传递对原始函数的引用，允许其他函数修改该对象。

在C# 或Java中，不是内置类型（int，float，有时的String）的任何东西都是指针或引用。引用也是自动垃圾回收的，这意味着它们在不再使用时被删除。动态类型的语言也倾向于使用这种内存模型。一些示例：

• C++：

void use_class(SomeClass *instance) { instance->use(); } void do_something() { SomeClass *instance = new SomeClass; // Created as pointer. use_class(instance); // Passed as pointer. delete instance; // Otherwise it will leak memory. }

• Java：

@Override public final void use_class(SomeClass instance) { instance.use(); } public final void do_something() { SomeClass instance = new SomeClass(); // Created as reference. use_class(instance); // Passed as reference. // Garbage collector will get rid of it when not in // use and freeze your game randomly for a second. }

• GDScript：

func use_class(instance): # Does not care about class type instance.use() # Will work with any class that has a ".use()" method. func do_something(): var instance = SomeClass.new() # Created as reference. use_class(instance) # Passed as reference. # Will be unreferenced and deleted.

在GDScript中，只有基本类型（int、float、string和vector类型）通过值传递给函数（值被复制）。其他所有（实例、数组、字典等）作为引用传递。继承 Reference （如果没有指定任何内容，则默认从这里继承）的类在不使用时将被释放，但对手动继承自 Object 的类也允许手动管理内存。

数组

动态类型语言的数组内部可以包含许多不同的混合数据类型，并且始终是动态的（可以随时调整大小）。比较在静态类型语言中的数组示例：

int *array = new int[4]; // Create array. array[0] = 10; // Initialize manually. array[1] = 20; // Can't mix types. array[2] = 40; array[3] = 60; // Can't resize. use_array(array); // Passed as pointer. delete[] array; // Must be freed. // or std::vector<int> array; array.resize(4); array[0] = 10; // Initialize manually. array[1] = 20; // Can't mix types. array[2] = 40; array[3] = 60; array.resize(3); // Can be resized. use_array(array); // Passed reference or value. // Freed when stack ends.

以及在GDScript中：

var array = [10, "hello", 40, 60] # Simple, and can mix types. array.resize(3) # Can be resized. use_array(array) # Passed as reference. # Freed when no longer in use.

在动态类型语言中，数组也可以作为其他数据类型有多种用法，例如列表：

var array = [] array.append(4) array.append(5) array.pop_front()

或无序集合：

var a = 20 if a in [10, 20, 30]: print("We have a winner!")

字典

字典是动态类型化语言中的一个强大工具。来自静态类型语言（例如C++或C#）的大多数程序员都忽略了它们的存在，并不必要地增加了他们的工作难度。这种数据类型通常不存在于此类语言中（或仅以受限的形式）。

字典可以完全忽略用作键或值的数据类型，将任何值映射到任何其他值。与流行的观点相反，它们是有效的，因为它们可以通过哈希表实现。事实上，它们非常高效，一些语言甚至可以像实现字典一样实现数组。

字典的示例：

var d = {"name": "John", "age": 22} # Simple syntax. print("Name: ", d["name"], " Age: ", d["age"])

字典也是动态的，键可以在任何一点添加或删除，花费很少：

d["mother"] = "Rebecca" # Addition. d["age"] = 11 # Modification. d.erase("name") # Removal.

在大多数情况下，使用字典可以更容易地实现二维数组。这里有一个简单的战舰游戏的示例：

# Battleship Game const SHIP = 0 const SHIP_HIT = 1 const WATER_HIT = 2 var board = {} func initialize(): board[Vector2(1, 1)] = SHIP board[Vector2(1, 2)] = SHIP board[Vector2(1, 3)] = SHIP func missile(pos): if pos in board: # Something at that position. if board[pos] == SHIP: # There was a ship! hit it. board[pos] = SHIP_HIT else: print("Already hit here!") # Hey dude you already hit here. else: # Nothing, mark as water. board[pos] = WATER_HIT func game(): initialize() missile(Vector2(1, 1)) missile(Vector2(5, 8)) missile(Vector2(2, 3))

字典还可以用作数据标记或快速结构。虽然GDScript字典类似于python字典，但它也支持Lua风格的语法和索引，这使得它对于编写初始状态和快速结构非常有用：

# Same example, lua-style support. # This syntax is a lot more readable and usable. # Like any GDScript identifier, keys written in this form cannot start # with a digit. var d = { name = "John", age = 22 } print("Name: ", d.name, " Age: ", d.age) # Used "." based indexing. # Indexing d["mother"] = "Rebecca" d.mother = "Caroline" # This would work too to create a new key.

For & while

在一些静态类型的语言中迭代可能非常复杂：

const char* strings = new const char*[50]; [..] for (int i = 0; i < 50; i++) { printf("Value: %s\n", i, strings[i]); } // Even in STL: for (std::list<std::string>::const_iterator it = strings.begin(); it != strings.end(); it++) { std::cout << *it << std::endl; }

这通常在动态类型语言中得到极大简化：

for s in strings: print(s)

容器数据类型（数组和字典）是可迭代的。字典允许迭代键：

for key in dict: print(key, " -> ", dict[key])

迭代索引也是可能的：

for i in range(strings.size()): print(strings[i])

range() 函数可以有3个参数：

range(n) # Will go from 0 to n-1. range(b, n) # Will go from b to n-1. range(b, n, s) # Will go from b to n-1, in steps of s.

一些静态类型的编程语言示例：

for (int i = 0; i < 10; i++) {} for (int i = 5; i < 10; i++) {} for (int i = 5; i < 10; i += 2) {}

转变成：

for i in range(10): pass for i in range(5, 10): pass for i in range(5, 10, 2): pass

反向循环是通过一个负计数器完成的：

for (int i = 10; i > 0; i--) {}

变成：

for i in range(10, 0, -1): pass

While

while() 循环在任何地方都是相同的：

var i = 0 while i < strings.size(): print(strings[i]) i += 1

自定义迭代器

在默认迭代器无法完全满足您的需求的情况下，您可以通过重写脚本中 Variant 类的 _iter_init、 _iter_next、和 _iter_get 函数来创建自定义迭代器。正向迭代器的一个示例实现如下：

class ForwardIterator: var start var current var end var increment func _init(start, stop, increment): self.start = start self.current = start self.end = stop self.increment = increment func should_continue(): return (current < end) func _iter_init(arg): current = start return should_continue() func _iter_next(arg): current += increment return should_continue() func _iter_get(arg): return current

它可以像任何其他迭代器一样使用：

var itr = ForwardIterator.new(0, 6, 2) for i in itr: print(i) # Will print 0, 2, and 4.

确保在 _iter_init 中重置迭代器的状态，否则使用自定义迭代器的嵌套for循环将无法正常工作。

鸭子类型

当从静态类型语言迁移到动态类型语言时，最难掌握的概念之一是鸭子类型。鸭子类型使整个代码设计更加简单和直接，但是它的工作方式并不明显。

举个示例，想象一个大石头从隧道里掉下来，在路上砸碎了一切。在静态类型语言中石头的代码有点像：

void BigRollingRock::on_object_hit(Smashable *entity) { entity->smash(); }

这样，任何能被岩石砸碎的东西都必须继承 Smashable。如果一个角色、敌人、家具、小石块都易碎，它们需要从 Smashable 类继承，可能需要多次继承。如果不希望进行多重继承，那么它们必须继承像 Entity 这样的公共类。然而，如果只是其中几个能被粉碎的话，在 Entity 中添加一个虚拟方法 smash() 并不十分优雅。

使用动态类型的语言，这将不是问题。鸭子类型确保您只需在需要的地方定义一个 smash() 函数，就行了。无需考虑继承、基类等。

func _on_object_hit(object): object.smash()

就是这样。如果击中大岩石的对象有一个 smash() 方法，它将被调用。不需要考虑继承或多态性。动态类型化语言只关心具有所需方法或成员的实例，而不关心它继承什么或其类型。鸭子类型的定义应该使这一点更清楚：

“当我看到一只鸟像鸭子一样走路，像鸭子一样游泳，像鸭子一样呱呱叫时，我就叫它鸭子”

在这种情况下，它可转变成：

“如果物体可以被砸碎，不要在意它是什么，只管砸碎它。”

是的，称它为 绿巨人（Hulk） 类型似乎更合适。

有可能被击中的对象没有 smash() 函数。一些动态类型语言在方法不存在时，简单地忽略方法调用（如Objective C），但是GDScript更严格，因此需要检查函数是否存在：

func _on_object_hit(object): if object.has_method("smash"): object.smash()

然后，简单地定义这个方法，岩石触碰的任何东西都可以被粉碎了。

https://docs.godotengine.org/zh_CN/stable/getting_started/scripting/gdscript/gdscript_advanced.html#doc-gdscript-more-efficiently