Constants | Godot GDScript Tutorial | Ep 03

Summary

The video script explains the concept of constants in computer science, specifically within the context of GDScript used in game development. It details how to declare constants with the 'Const' keyword, emphasizing their immutability post-declaration. The script advocates for the use of constants over literals for better code readability, easier debugging, and efficient code maintenance. It illustrates the benefits with examples, such as changing game item speeds by modifying a single constant instead of numerous hardcoded values, and discusses the importance of naming conventions to visually distinguish constants from variables.

Takeaways

• 📝 Constants in computer science are values that do not change.
• 🔑 In GDScript, constants are declared with the keyword 'Const' followed by a unique name, an equal sign, and a value.
• 🈲️ Assigning an empty constant or a constant without a value is not allowed.
• 🔄 The difference between a variable and a constant is the keyword used; everything else is the same.
• 📊 Data types can be explicitly added to constants with a colon and data type name, but it's optional as the type is inferred.
• 🚫 Constants are read-only and cannot be modified after declaration and assignment.
• 👍 Using constants is beneficial for debugging, editing, and reading code.
• 💡 Beginners often use literals instead of constants, but constants improve code readability and maintainability.
• 🔍 Constants should be visually distinct from variables, often using uppercase letters for easy identification.
• 🔄 Changing a constant's value automatically propagates the change throughout the code where the constant is used.
• 🎮 Constants are ideal for values that will not change during the lifecycle of a game, such as player dimensions.

Q & A

What is a constant in computer science?

In computer science, a constant is a value that does not change throughout the execution of a program.

How do you declare a constant in GDScript?

In GDScript, constants are declared using the keyword 'const' followed by a unique name, an equal sign, and a value.

Is it possible to assign an empty value to a constant in GDScript?

No, you cannot assign an empty constant; it must have an assigned value upon declaration.

What is the difference between a variable and a constant in GDScript?

The only difference between a variable and a constant in GDScript is the keyword used for declaration; 'var' for variables and 'const' for constants.

Can you modify the value of a constant after it has been declared in GDScript?

No, constants in GDScript are read-only after declaration, and modifications are not permitted.

Is it necessary to specify a data type when declaring a constant in GDScript?

Specifying a data type when declaring a constant is not necessary as the data type is inferred from the assigned value, but you can explicitly add a data type for clarity.

Why should beginners avoid using literal values and instead use constants?

Using constants instead of literals makes code more readable, easier to debug, and simplifies the process of editing code, especially when the same value is used in multiple places.

What is the advantage of using constants over literals in a large codebase?

Using constants in a large codebase allows for easier maintenance and updating of values. Changing the value of a constant will propagate the change throughout the code where the constant is used, instead of having to find and replace every instance of the literal value.

What is the recommended naming convention for constants in GDScript to differentiate them from variables?

A recommended naming convention for constants is to start their names with an uppercase letter, while variables start with a lowercase letter, making it visually clear which is which when reading the code.

Can you provide an example of how using constants can simplify changing a value in a large codebase?

If a game's speed value is initially set as a literal 5 in multiple variables, changing it to 10 later would require finding and editing each instance of the literal 5. However, if the speed is declared as a constant, changing it to 10 would automatically update all instances where the constant is used, reducing the potential for errors and saving time.

Outlines

00:00

📝 Understanding Constants in GDScript

This paragraph explains the concept of constants in computer science, specifically within the context of GDScript used in Godot game engine development. Constants are fixed values that do not change throughout the program's execution. The declaration of a constant involves using the 'const' keyword, followed by a unique name, an equal sign, and a value. Assigning a value to a constant is mandatory, and attempting to change a constant's value post-declaration results in an error. The paragraph also touches on the importance of using constants over literals for better code readability, easier debugging, and maintenance. An example is provided where changing a game item's speed from 5 to 10 requires altering multiple lines of code when using literals, versus changing just one line when using a constant.

05:00

🔑 The Power of Constants in Code Efficiency

This paragraph emphasizes the benefits of using constants over hardcoded literal values in programming, particularly in game development. It illustrates how constants can significantly reduce the time and effort required for code changes. By using a constant for values that are unlikely to change, such as a player's height or width, any necessary adjustments can be made by simply altering one line of code, which then propagates throughout the entire codebase. The paragraph also discusses the importance of naming conventions for constants, suggesting that they should be visually distinct from variables to aid in code recognition and maintenance. Examples of such conventions include starting constants with uppercase letters, while variables begin with lowercase, although personal preference is acknowledged in choosing a convention.

Keywords

💡Constants

In computer science, 'constants' refer to values that are set once and do not change throughout the program's execution. In the context of the video, constants in GDScript are declared with the 'Const' keyword, followed by a unique name and an assigned value. The video emphasizes the importance of using constants for values that remain unchanged, such as game settings or parameters, to improve code readability and maintainability.

💡Declaration

The term 'declaration' in programming is the act of introducing a new variable or constant to the code. In the video, it explains how to declare a constant in GDScript using the 'Const' keyword, an equal sign, and a value. Proper declaration is crucial for defining what the constant represents and ensuring it is used correctly throughout the code.

💡Unique Name

A 'unique name' in programming ensures that each constant or variable has a distinct identifier. The video script highlights the necessity of using unique names for constants to avoid conflicts and errors in the code. This is essential for organizing code and ensuring that each constant can be easily referenced without ambiguity.

💡Datatype

A 'datatype' defines the kind of value a variable or constant can hold, such as integer, float, or string. The video mentions that while it's not mandatory to explicitly declare a datatype for a constant in GDScript, as the type is inferred from the assigned value, doing so can enhance code clarity. For example, declaring a constant with an integer datatype makes it clear that the constant holds a numerical value.

💡Literal

A 'literal' in programming is a representation of a fixed value in code, such as the number 1 or the string 'hello'. The video contrasts the use of literals with constants, suggesting that while literals can be used, constants are preferable for values that should not change, as they provide a centralized point of reference in the code.

💡Read-Only

'Read-Only' refers to the property of a value that cannot be modified after its initial assignment. In the video, it is mentioned that constants are read-only in GDScript, meaning that once a constant is declared and assigned a value, it cannot be changed, which helps prevent accidental modifications and ensures the stability of the program.

💡Debugging

Debugging is the process of finding and fixing errors in code. The video script suggests that using constants can make debugging easier because if a constant value needs to be changed for testing or adjustment, only the constant declaration needs to be modified, and the change will propagate throughout the code where the constant is used.

💡Maintainability

Maintainability refers to how easy it is to update, modify, or debug a piece of software. The video emphasizes the role of constants in improving maintainability by centralizing the definition of values that are used throughout the code, making it easier to make global changes without manually editing each instance.

💡Naming Convention

A 'naming convention' is a set of rules for how identifiers in code should be named to make the code more readable and understandable. The video recommends using a naming convention that visually distinguishes constants from variables, such as starting constants with an uppercase letter, to help programmers quickly identify the nature of the identifier at a glance.

💡Hard-Coding

Hard-coding is the practice of embedding values directly into the source code. The video discourages hard-coding values like game settings, instead advocating for the use of constants. This approach allows for easier adjustments and reduces the risk of errors when values need to be changed, as demonstrated by the example of changing game item speeds.

Highlights

A constant in computer science is a value that never changes.

In GD script, constants are declared with the keyword 'Const' followed by a unique name, an equal sign, and a value.

Assigning an empty constant is not allowed; a constant must have an assigned value.

The distinction between a variable and a constant is the keyword used; otherwise, the declaration is the same.

Data type can be explicitly added to a constant declaration for clarity.

The data type of a constant is inferred from the assigned value if not explicitly stated.

The format for declaring a constant includes the keyword 'Const', a unique name, optional data type, and an equal sign followed by a literal or data object.

Constants are read-only and cannot be modified after declaration and assignment.

Using constants can simplify debugging and code editing.

Constants should be used instead of literals for better code readability and easier debugging.

Hard-coding literal values can lead to more work when changes are needed across multiple lines of code.

Using constants can reduce the effort needed to propagate changes across a codebase.

Constants are recommended for values that will not change throughout the lifecycle of a game.

Naming conventions for constants should visually distinguish them from variables.

Using uppercase for constants and lowercase for variables can help in quickly identifying them in the code.

The choice of naming convention should be comfortable for the programmer and visually distinct.

Transcripts

so what exactly are constants in

computer science a constant is a value

that never changes so how exactly do you

declare a constant in GD script

constants are declared with the keyword

Const spelled Co n st followed by a

unique name an equal sign symbol and a

value all of these are required you

cannot assign an empty constant you

cannot have a constant without an

assigned value the only thing separating

a variable from a constant is the

keyword everything else is exactly the

same just like variables keep in mind

that each and every variable in constant

you declare must have a unique name or

an error will be thrown

now just like variables you may also add

a datatype explicitly by adding a colon

science symbol followed by the data type

in this case we have declared a constant

called value never changes and assigned

it the datatype integer which is

assigned a literal integer 1 assigning a

datatype to a constant is not necessary

as the datatype is inferred to the

constant with the assigned value

basically a constant declaration format

looks like the following you have the

keyword Const followed by a unique name

for the constant with the option to a

data type but this must be followed by

an equal sign symbol followed by a

literal or data object everything in

yellow is required while everything in

white and the parentheses is optional

one thing to note is that constants are

read only after declaration therefore

modifications are not permitted after

Declaration and assignment let's take a

look at a quick example we declared a

constant value never changes and

assigned it the literal integer 1

somewhere in the code after the

declaration if we try to assign a new

value to our constant value never

changes in this case we're trying to

assign it the value 100 this will throw

an error in GDD script there are pros

when using constants

one thing I noticed with beginners is

the use of literal values beginners tend

to use literal values instead of

assigning literal values to constants I

recommend using constants because you'll

have an easier time debugging you'll

save time when editing code and of

course easier time reading code one

thing I noticed with beginners is this

question aren't constants the same as

literals and yes you can use literals

instead of constants to the compiler it

doesn't make a difference how values are

given however for the sake of readable

code and easier debugging you should use

constants let's take a look at some

examples so to a beginner let's say that

they have a speed for their game items

and in this case they need to use an

integer value of 5 what a beginner

typically does is they just hard inject

literal values in this case you can see

we have three variables a player speed a

laser speed and a boomerang speed all

being assigned the literal integer 5 now

let's say we need to change our main

speed for the game to be 10 instead of 5

now we've gone ahead and changed the

speed to 10 in our case to change our

main speed for game items we needed to

manually find and edit three lines of

code now this doesn't seem to be a lot

of work for three lines of code however

if we had more code this would take more

time in this case we have 20 variables

that rely on the speed value 10 as you

can see we have 20 lines of code now

imagine if we had to change 20 lines of

code when we decided that the speed is

too fast you're in trouble now because

you need to change 20 lines of code that

means you need to take the time to

manually find in your script any code

that uses your speed and you have to

find them all and if you fail to find

them all if you even forget about one

line of code that uses the old value

speed 10

your game may perform as it's not

intended to perform because you forgot

one line of code let's go ahead and fix

this instead of hard-coding the speed

for the game as a literal value instead

we will assign that value to a constant

and

case we have a constant speed which is

equal to five five being the value for

our speed in our game now that we have

our constant called speed which holds

our speed for the game in this case five

we can go ahead and work on our game as

time passes by maybe we have a thousand

line of code that rely on our constant

speed as you can see here we have

changed one line of code we have changed

the speed from five to ten and now this

change in our value to our constant

speed will propagate to the rest of our

code as you can see here we have

essentially edited a thousand line of

code by just changing one line of code

as you can see here this is the power of

using constants instead of injecting

literal values I recommend using

constants when you want to declare a

value that you know will never change in

the life cycle of your game for example

you may have a player and that player

may have a height and a width instead of

injecting the raw literal value all over

your code assign that value to a

constant and then assign that constant

to your code in this case this is good

practice because the player height and

player width will most likely never

change throughout the game lifecycle and

if you do happen to want to change the

value all you have to do is change one

line of code and it propagates to the

rest of your code one thing to keep in

mind is the naming convention when using

constants make sure that naming

conventions for constants are visually

different than variables this is

recommended to help you as a programmer

recognize what is a constant versus what

is a variable when looking through your

code let's take a look notice how all my

constants start with an uppercase just

so that I can visually know that when I

read anything with an uppercase in its

name that it is a constant and that I

intend to never change its value now

this is different than how I declare my

variables as you notice I declare my

variables starting in lowercase this is

so when I see anything starting with

lowercase I know that the value can

change another example

of a constant being visually different

than a variable as some people tend to

use uppercase to name their constants

while using whatever they want with

their variables again you don't have to

use this

they are visually different use whatever

you are comfortable with again just make

sure the to help you as a programmer

that the constant is visually different

than the variable