Attention: Here be dragons

This is the latest (unstable) version of this documentation, which may document features not available in or compatible with released stable versions of Godot.

Checking the stable version of the documentation...

Callable

Un tipo integrato che rappresenta un metodo o una funzione autonoma.

Descrizione

Callable is a built-in Variant type that represents a function. It can either be a method within an Object instance, or a custom callable used for different purposes (see is_custom()). Like all Variant types, it can be stored in variables and passed to other functions. It is most commonly used for signal callbacks.

func print_args(arg1, arg2, arg3 = ""):
    prints(arg1, arg2, arg3)

func test():
    var callable = Callable(self, "print_args")
    callable.call("hello", "world")  # Prints "hello world ".
    callable.call(Vector2.UP, 42, callable)  # Prints "(0.0, -1.0) 42 Node(node.gd)::print_args"
    callable.call("invalid")  # Invalid call, should have at least 2 arguments.

// Default parameter values are not supported.
public void PrintArgs(Variant arg1, Variant arg2, Variant arg3 = default)
{
    GD.PrintS(arg1, arg2, arg3);
}

public void Test()
{
    // Invalid calls fail silently.
    Callable callable = new Callable(this, MethodName.PrintArgs);
    callable.Call("hello", "world"); // Default parameter values are not supported, should have 3 arguments.
    callable.Call(Vector2.Up, 42, callable); // Prints "(0, -1) 42 Node(Node.cs)::PrintArgs"
    callable.Call("invalid"); // Invalid call, should have 3 arguments.
}

In GDScript, it's possible to create lambda functions within a method. Lambda functions are custom callables that are not associated with an Object instance. Optionally, lambda functions can also be named. The name will be displayed in the debugger, or when calling get_method().

func _init():
    var my_lambda = func (message):
        print(message)

    # Prints "Hello everyone!"
    my_lambda.call("Hello everyone!")

    # Prints "Attack!", when the button_pressed signal is emitted.
    button_pressed.connect(func(): print("Attack!"))

In GDScript, you can access methods and global functions as Callables:

tween.tween_callback(node.queue_free)  # Object methods.
tween.tween_callback(array.clear)  # Methods of built-in types.
tween.tween_callback(print.bind("Test"))  # Global functions.

Note: Dictionary does not support the above due to ambiguity with keys.

var dictionary = { "hello": "world" }

# This will not work, `clear` is treated as a key.
tween.tween_callback(dictionary.clear)

# This will work.
tween.tween_callback(Callable.create(dictionary, "clear"))

Note: In a boolean context, a callable will evaluate to false if it's null (see is_null()). Otherwise, a callable will always evaluate to true.

Nota

Ci sono differenze sostanziali quando si usa questa API con C#. Vedi Differenze dell'API C# rispetto a GDScript per maggiori informazioni.

Costruttori

Callable	Callable()
Callable	Callable(from: Callable)
Callable	Callable(object: Object, method: StringName)

Metodi

Callable	bind(...) vararg const
Callable	bindv(arguments: Array)
Variant	call(...) vararg const
void	call_deferred(...) vararg const
Variant	callv(arguments: Array) const
Callable	create(variant: Variant, method: StringName) static
int	get_argument_count() const
Array	get_bound_arguments() const
int	get_bound_arguments_count() const
StringName	get_method() const
Object	get_object() const
int	get_object_id() const
int	get_unbound_arguments_count() const
int	hash() const
bool	is_custom() const
bool	is_null() const
bool	is_standard() const
bool	is_valid() const
void	rpc(...) vararg const
void	rpc_id(peer_id: int, ...) vararg const
Callable	unbind(argcount: int) const

Operatori

bool	operator !=(right: Callable)
bool	operator ==(right: Callable)

Descrizioni dei costruttori

Callable Callable() 🔗

Costruisce un Callable vuoto, senza oggetto né metodo associato.

Callable Callable(from: Callable)

Costruisce un Callable come copia del Callable specificato.

Callable Callable(object: Object, method: StringName)

Crea un nuovo Callable per il metodo con nome method nell'oggetto object specificato.

Nota: Per i metodi di tipi Variant incorporati, utilizza create() invece.

Descrizioni dei metodi

Callable bind(...) vararg const 🔗

Restituisce una copia di questo Callable con uno o più argomenti associati. Quando è chiamato, gli argomenti associati sono passati dopo gli argomenti forniti da call(). Vedi anche unbind().

Nota: Quando questo metodo è concatenato con altri metodi simili, l'ordine in cui la lista degli argomenti è modificata è letto da destra a sinistra.

Callable bindv(arguments: Array) 🔗

Restituisce una copia di questo Callable con uno o più argomenti associati, leggendoli da un array. Quando è chiamato, gli argomenti associati sono passati dopo gli argomenti forniti da call(). Vedi anche unbind().

Nota: Quando questo metodo è concatenato con altri metodi simili, l'ordine in cui la lista degli argomenti è modificata è letto da destra a sinistra.

Variant call(...) vararg const 🔗

Chiama il metodo rappresentato da questo Callable. Argomenti aggiuntivi possono essere passati e devono corrispondere alla firma del metodo.

void call_deferred(...) vararg const 🔗

Chiama il metodo rappresentato da questo Callable in modalità differita, cioè alla fine del frame corrente. Argomenti aggiuntivi possono essere passati e devono corrispondere alla firma del metodo.

func _ready():
    grab_focus.call_deferred()

public override void _Ready()
{
    Callable.From(GrabFocus).CallDeferred();
}

Nota: Le chiamate differite sono elaborate nei periodi di inattività. Il tempo di inattività avviene principalmente alla fine dei frame di processo e di fisica. Durante esso, le chiamate differite saranno eseguite finché non ne resterà più nessuna, il che significa che puoi rinviare le chiamate da altre chiamate differite e saranno comunque eseguite nel ciclo di inattività attuale. Ciò significa che non dovresti chiamare un metodo differito da se stesso (o da un metodo chiamato da esso), poiché ciò porta a una ricorsione infinita come se avessi chiamato il metodo direttamente.

Vedi anche Object.call_deferred().

Variant callv(arguments: Array) const 🔗

Chiama il metodo rappresentato da questo Callable. A differenza di call(), questo metodo prevede che tutti gli argomenti siano contenuti all'interno di dell'Array arguments.

Callable create(variant: Variant, method: StringName) static 🔗

Crea un nuovo Callable per il metodo con nome method nel variant specificato. Per rappresentare un metodo di tipo Variant integrato, è utilizzato un chiamabile personalizzato (vedi is_custom()). Se variant è Object, sarà invece creato un chiamabile standard.

Nota: Questo metodo è sempre necessario per il tipo Dictionary, poiché la sintassi della proprietà è utilizzata per accedere alle sue voci. Puoi anche utilizzare questo metodo quando il tipo di variant non è conosciuto in anticipo (per il polimorfismo).

int get_argument_count() const 🔗

Restituisce il numero totale di argomenti che questo Callable dovrebbe accettare, inclusi gli argomenti facoltativi. Ciò significa che qualsiasi argomento associato con bind() è sottratto dal risultato, e qualsiasi argomento disassociato con unbind() è aggiunto al risultato.

Array get_bound_arguments() const 🔗

Restituisce l'array di argomenti associati tramite successive chiamate a bind() o unbind(). Questi argomenti saranno aggiunti dopo gli argomenti passati alla chiamata, da cui il numero restituito di argomenti da get_unbound_arguments_count() sulla destra sono stati precedentemente esclusi.

func get_effective_arguments(callable, call_args):
    assert(call_args.size() - callable.get_unbound_arguments_count() >= 0)
    var result = call_args.slice(0, call_args.size() - callable.get_unbound_arguments_count())
    result.append_array(callable.get_bound_arguments())
    return result

int get_bound_arguments_count() const 🔗

Restituisce la quantità totale di argomenti associati tramite successive chiamate a bind() o unbind(). È la stessa dimensione dell'array restituito da get_bound_arguments(). Vedi get_bound_arguments() per i dettagli.

Nota: I metodi get_bound_arguments_count() e get_unbound_arguments_count() possono entrambi restituire valori positivi.

StringName get_method() const 🔗

Restituisce il nome del metodo rappresentato da questo Callable. Se il chiamabile è una funzione lambda di GDScript, restituisce il nome della funzione o "<anonymous lambda>".

Object get_object() const 🔗

Restituisce l'oggetto su cui si chiama questo Callable.

int get_object_id() const 🔗

Restituisce l'ID dell'oggetto di questo Callable (vedi Object.get_instance_id()).

int get_unbound_arguments_count() const 🔗

Restituisce la quantità totale di argomenti disassociati tramite chiamate successive a bind() o unbind(). Vedi get_bound_arguments() per i dettagli.

Note: I metodi get_bound_arguments_count() e get_unbound_arguments_count() possono entrambi restituire valori positivi.

int hash() const 🔗

Restituisce il valore hash a 32 bit dell'oggetto di questo Callable.

Nota: I Callable con lo stesso contenuto produrranno sempre valori hash identici. Tuttavia, non è vero il contrario. Restituire valori hash identici non implica che i chiamabili siano uguali, perché chiamabili diversi possono avere valori hash identici a causa di collisioni di hash. Il motore utilizza un algoritmo hash a 32 bit per hash().

bool is_custom() const 🔗

Restituisce true se questo Callable è un chiamabile personalizzato. I chiamabili personalizzati sono utilizzati:

per associare o disassociare argomenti (vedi bind() e unbind());
per rappresentare metodi di tipi Variant incorporati (vedi create());
per rappresentare funzioni globali, lambda, e RPC in GDScript;
per altri scopi nel core, GDExtension, e C#.

bool is_null() const 🔗

Restituisce true se questo Callable non ha una destinazione su cui chiamare il metodo. Equivale a callable == Callable().

Nota: Questo non è lo stesso di not is_valid() e usare not is_null() non garantirà che questo chiamabile possa essere chiamato. Usa invece is_valid().

bool is_standard() const 🔗

Restituisce true se questo Callable è un chiamabile standard. Questo metodo è l'opposto di is_custom(). Restituisce false se questa chiamabile è una funzione lambda.

bool is_valid() const 🔗

Restituisce true se l'oggetto del chiamabile esiste e ha un nome di metodo valido assegnato, o è un chiamabile personalizzato.

void rpc(...) vararg const 🔗

Eseguisce una RPC (Chiamata di procedura remota) su tutti i peer connessi. Questo è utilizzato per il multiplayer e normalmente non è disponibile, a meno che la funzione richiamata non sia stata contrassegnata come RPC (usando @GDScript.@rpc o Node.rpc_config()). Chiamare questo metodo su funzioni non supportate genererà un errore. Vedi Node.rpc().

void rpc_id(peer_id: int, ...) vararg const 🔗

Eseguisce una RPC (Chiamata di procedura remota) su un ID peer specifico (vedi la documentazione sul multiplayer per riferimento). Questo è utilizzato per il multiplayer e normalmente non è disponibile, a meno che la funzione richiamata non sia stata contrassegnata come RPC (usando @GDScript.@rpc o Node.rpc_config()). Chiamare questo metodo su funzioni non supportate genererà un errore. Vedi Node.rpc().

Callable unbind(argcount: int) const 🔗

Restituisce una copia di questo Callable con un numero di argomenti disassociati. In altre parole, quando viene chiamato il nuovo chiamabile, gli ultimi argomenti forniti dall'utente saranno ignorati, secondo argcount. Gli argomenti rimanenti sono passati al chiamabile. Ciò consente di utilizzare il chiamabile originale in un contesto che tenta di passare più argomenti di quelli che questo chiamabile può gestire, ad esempio per un segnale con un numero fisso di argomenti. Vedi anche bind().

Nota: Quando questo metodo è concatenato con altri metodi simili, l'ordine in cui la lista degli argomenti è modificata è letto da destra a sinistra.

func _ready():
    foo.unbind(1).call(1, 2) # Calls foo(1).
    foo.bind(3, 4).unbind(1).call(1, 2) # Chiama foo(1, 3, 4), tieni conto che non cambia gli argomenti dalla funzione bind.

Descrizioni degli operatori

bool operator !=(right: Callable) 🔗

Restituisce true se entrambi i Callable invocano obiettivi diversi.

bool operator ==(right: Callable) 🔗

Restituisce true se entrambi i Callable invocano lo stesso obiettivo personalizzato.