In all programming languages, variables are used to store values and references. Examples are: the current score value or a reference to an item of inventory.

It is good practice to give variables descriptive names in lower-case text, and join words with underscores. Here are some examples of variable declarations:

var score = 0
var remaining_fuel = 99.9
var paused = false
var player_name = ""
var selected_weapon
var starting_grid_position

Notice how some variables don't have their value set yet, and we can assign different types of values to the variables.

Some basic types are as follows:

Type Details Examples
int A 64bit signed number -12 54 0xAF
float Floating point number 1.23 1e6
bool True or false true false
String For words and character sequences "Hello World"


In our first example, the variables can take any type of value, and the value may be changed later to another type of value. This kind of variable is called a Variant.

So it is easy and quick to code our variable declarations in this way.

Typed Variables

There is a way to declare what type of value a variable will accept. This has advantages to reduce bugs, and get help and warnings from the editor as you enter code.

There are two ways to declare typed variables as follows:

# Method 1
var score: int = 0
var remaining_fuel: float = 99.9
var paused: bool = false
var player_name: String = ""

# Method 2 (inferring the type)
var my_int := 8
var size := 32.6
var running := true
var name := ""

We call this static typing, and when using variants as before, we call that dynamic typing. Both can be used as you like within your program.

Variable Scope

Scope is the area of the program code where the variable is accessible. Text indentation levels are used to define scope in the editor, and the various regions may be expanded and collapsed.

Global scope is where the variable is available everywhere such as when it is declared in an Autoload file. And local scope is the area within a function containing the variable after it's declaration.

It is good practice to keep the scope of a variable as small as possible to reduce bugs and make self-contained chunks of functionality that don't depend on external variables.

Here is an example of global and local scope:

extends Node2D

# score has global scope in this code module
var score = 5

# A function that may be called to add points to score
func add_to_score(points):
	# points is a variable passed from outside
	# it has local scope in this indented code block
	score = score + points

# This function runs when we view the scene
func _ready():
	# score is accessible inside this code block
	print(score) # prints 6

Bugs can creep in if you rely on global scope and mistakenly re-declare a variable with the same name in local scope. As in this example:

extends Node2D

var score = 5
var new_score

func add_to_score(points):
	# new_score is accidentally re-declared
	# with local scope in this indented code block
	var new_score = score + points

func _ready():
	# new_score has not been set
	print(new_score) # prints null

For an exercise, practice declaring both static and dynamic types of variables. Print out the values, and experiment with scope to solidify your understanding of the concepts.

The next topic is: Operators