I am confused by part of the Godot Docs for the GDScript language. About midway down the page, in the "Referencing Functions" section, it says you can't store functions in variables, and then seems to immediately contradict itself.
Can Godot functions be stored in variables or not?
Referencing Functions
Contrary to Python, functions are not first class objects in GDScript. This means they cannot be stored in variables, passed as an argument to another function or be returned from other functions. This is for performance reasons.
To reference a function by name at runtime, (e.g. to store it in a variable, or pass it to another function as an argument) one must use the call or funcref helpers:
Can Godot functions be stored in variables or not? Contrary to Python, functions are not first class objects in GDScript. This means they cannot be stored in variables, passed as an argument to another function or be returned from other functions. This is for performance reasons.
These arguments show up in the editor's node dock, and Godot can use them to generate callback functions for you. However, you can still emit any number of arguments when you emit signals; it's up to you to emit the correct values. GDScript can bind an array of values to connections between a signal and a method.
GDScript Functions all belong to a class. Classes are a way to group together related functions and variables. Functions can also be refered to as methodsand variables can also ber refered to as properties. By default, GDScript functions return null. If you want a function to return a value, you will have to create a return statement.
Contrary to Python, functions are not first class objects in GDScript. This means they cannot be stored in variables, passed as an argument to another function or be returned from other functions. This is for performance reasons.
GDScript functions are not objects like they are in python. So, you cannot directly reference a function.
However, you can indirectly reference them by name using their associated instance.
For example with the following function:
func hello():
print('Hello')
You can call a function on an instance by name:
call('hello') # prints 'Hello'
You can store an instance and function name with funcref()
:
var ref = funcref(hello_object_instance, 'hello')
ref.call_func() # prints 'Hello'
takes_func_ref_to_call_later(ref) # later, prints 'Hello'
FuncRef.call_func()
does the same thing as Object.call()
it just wraps it in an object.
Consequently, a common pattern for callback functions, as shown by Object.connect()
and friends, is:
func deferred_finish(param1, param2, callback_obj, callback_func):
# ... do something
callback_ref = funcref(callback_obj, callback_func)
func _process(delta):
if _finished:
callback_ref.call_func()
func _enter_tree():
deferred_finish('hello', 'world', self, 'finished_callback')
I hope this helps. Let me know if you would like any clarifications.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With