Pros/Cons of declaring values for variables at instantiation versus in _ready()

This is a READ-ONLY snapshot of the Godot Community Forums when TwistedTwigleg was the owner, which is hosted for archival reasons only. The current Godot Community Forums can be found here.

Some links may point to external websites, including the current Godot Community Forums. These websites are not associated with TwistedTwigleg.

Pros/Cons of declaring values for variables at instantiation versus in _ready()

v33to

Take the follow code for an example

extends Sprite

var v2_screensize
var v2_position
var extents
var v2_velocity
var rotate_speed

func _ready():
	randomize()
	v2_screensize = get_viewport_rect().size
	v2_position = v2_screensize / 2 # Center the sprite
	v2_velocity = Vector2(rand_range(-300,300),rand_range(-300,300))
	rotate_speed = rand_range(-720,720)
	extents = get_texture().get_size() / 2

I'm following a tutorial and this is more or less how the teacher wrote their code. I'm curious why we don't just assign the values when we create the variables versus assigning the values in _ready()

Is there any advantage to doing it one way or the other?

TwistedTwigleg

The reason behind it, in the case of the snippet shown above, is that you cannot calculate some of the values without calling functions like get_viewport_rect(). Because these functions have to be called when the node is in the scene, making them unable to be used when declaring the variables, using _ready (which is called once the node joins the scene and is fully initialized) is a good way to "initialize" those variables before any of the other code is called.

v33to

@TwistedTwigleg said: The reason behind it, in the case of the snippet shown above, is that you cannot calculate some of the values without calling functions like get_viewport_rect(). Because these functions have to be called when the node is in the scene, making them unable to be used when declaring the variables, using _ready (which is called once the node joins the scene and is fully initialized) is a good way to "initialize" those variables before any of the other code is called.

So why not just declare everything in _ready()?

Or just always use onready var somevar = somevalue?

Bimbam

I suspect the confusion comes down to variable scope. Something like:

func MyFunc():
	var MyVar = 0    #Only available within the scope of MyFunc, so this:
	MyVar+=1        # Works.... while this:

MyVar+=1                 # Doesn't

I would assume declaring a variable within _ready() does not expose it to any other functions by default, but tbh I've not actually tested it.

As for 'Onready...', this is just a shorthand to keep the _ready() function tidier I think. It does the same task as far as I know so this:

onready var MyVar  = 0

func MyFunc():
	MyVar+=1

is analogous to this:

var MyVar

func _ready():
	MyVar = 0

func MyFunc():
	MyVar+=1

Though they perhaps do different things if re-instancing the node, honestly not sure but for the majority of usecases, like for like.

TwistedTwigleg

@v33to said:

@TwistedTwigleg said: The reason behind it, in the case of the snippet shown above, is that you cannot calculate some of the values without calling functions like get_viewport_rect(). Because these functions have to be called when the node is in the scene, making them unable to be used when declaring the variables, using _ready (which is called once the node joins the scene and is fully initialized) is a good way to "initialize" those variables before any of the other code is called.

So why not just declare everything in _ready()?

Or just always use onready var somevar = somevalue?

I mean, you could if you wanted to. Ultimately, we could go back and forth with a discussion like this for a long time and never find the "right" answer, because while there are technical aspects, a lot of it also depends on personal preference and style. There is no right answer, you just need to go with whatever you prefer :smile:

Also, to add a bit to what @Bimbam wrote about onready: The following snippets of code show equivalent _ready and onready definitions:

##############
# Using _ready
var test
func _ready():
	test = 10
##############
# Using onready
onready var test = 10
##############
# Function call using _ready
var test
func _ready():
	test = test_function()
func test_function():
	return "Testing!"
###############
# Function call using onready
onready var test = test_function()
func test_function():
	return "Testing"
###############

Based on my understanding, onready initializes the variable with null and then calls the assignment declared in the initialization in the _ready function. Its just shorthand to make it a little easier to do stuff like onready var label = $label.