what is everything i can put in a variable?
i have been seeing people put alot of things in varibles but what are all the things i can put in them?
0
1
0
0
0
3 answers
While you might think they are putting a large amount of "things" into a variable, you must understand that not only variables can be defined with local. The local definition is there to define scope. An example of scope would be:
1 | local a = 1 |
2 | function findOutScope() |
3 | local b = 2 |
4 | end |
5 | print(a, b) |
6 | -- output --> 1 nil |
Why is this? The reason b is nil is because we defined it locally inside of the function. This means that it is not visible outside of the function. Things defined locally are only visible in the block they were created in. Here is an example of local being used with a table and not a variable:
1 | function scopeTrial() |
2 | local a = {"a", "b", "c"} -- this is a table not a variable |
3 | end |
4 | print(a[1], a[2], a[3]) |
5 | -- output --> nil nil nil |
6 | local a = {"a", "b", "c"} -- defining it outside of the block |
7 | print(a[1], a[2], a[3]) |
8 | -- output --> a b c |
local can also be used with functions and it is even an encouraged practice. The reason I did not use it in the explanations above was so that I could tackle each local individually and not make a really complex explanation involving both functions and tables (or something like that). Example of locally defined function:
1 | local function hello() |
2 | print("hi") |
3 | end |
The only time that a function would be hidden by defining it locally would be if you had it inside of another block. Example:
01 | local function hello() -- I will just use local all the time when defining now because it is good practice |
02 | local function hi() -- nested function is what this is called |
03 | print("hi") |
04 | end |
05 | hi() |
06 | end |
07 | hello() -- calling the function |
08 | -- output --> hi |
09 | hi() -- calling the inner function |
10 | -- output --> error because of calling a non-existent global function |
In this final example using scope I will show you how not using local makes you able to use the inner function because it is not local to the block:
01 | local function hello() |
02 | function hi() -- not defining it locally this time |
03 | print("hi") |
04 | end |
05 | hi() |
06 | end |
07 | hello() -- have to call the function so that hi() is defined |
08 | -- the hello function works the same way it did before so we won't test that |
09 | hi() -- calling the no longer local function on the inside of the block |
10 | -- output --> hi hi |
Another way to create a block would be using do end:
01 | do |
02 | local function hi() |
03 | print("hi") |
04 | end |
05 | function hello() |
06 | print("hello") |
07 | end |
08 | end |
09 | hi() -- would error |
10 | hello() -- would print hello |
Ok, so that was a quick explanation of what local is for and why not everything defined by it is a variable. Now it is time to cover all the things you can put into a variable. There are three main things that variables are used for: strings, booleans, and numbers. Some examples:
1 | local hello = "hi" |
2 | local five = 5 |
3 | local notTrue = false |
4 | print(hello, five, notTrue) |
5 | -- output --> hi 5 false |
I am pretty sure that you already know that stuff so I will move on to the more complex variable definitions. One thing that people do is define multiple variables at once. Here is an example of that:
1 | local a, b = 1, 2 -- defining them both at once |
2 | print(a, b) |
3 | -- output --> 1 2 |
More info on that here.
You can also define a variable by calling a function that returns a value for that variable to hold. This can be done by the use of return. Example:
1 | local function add(a, b) |
2 | return a + b -- returning a value |
3 | end |
4 | local x = add(2, 3) |
5 | print(x) |
6 | -- output --> 5 |
Make sure that your function is really returning some value each time or your code will error.
Here is an example using pcall:
1 | local success, message = pcall(function() -- defining to variables with what the function returns |
2 | local x = 1 + nil |
3 | end |
4 | -- success is defined as a boolean determined to be true or false based on the whether or not the code in the pcall errored. message is defined as a string that is the error message if there was an error. If there was no error success would be true and message would be nil. |
5 | print(success, message) |
6 | -- output --> false (error message) |
Sometimes people use ternary operators to define their variables. I will use an example from my own experience:
01 | -- I wanted to load a player's data, but it was a table. The issue was that I needed to make sure the table existed before getting the value at that index or it would error. So, I used ternary operators: |
02 | local mainDataTable |
03 | local success, message = pcall(function() |
04 |
05 | mainDataTable = mainDataStore:GetAsync(specialKey) |
06 |
07 | end) |
08 |
09 | if success then |
10 |
11 | print("Player Data Loaded Successfully") |
12 |
13 | plrInfo.Money.Value = type(mainDataTable) == "table" and mainDataTable[1] or 0 |
14 | plrInfo.BuildLevel.Value = type(mainDataTable) == "table" and mainDataTable[2] or 1 |
15 |
16 | end -- this may not be the most efficient way out there (I wrote this a while ago), but it is a perfect example |
Take for example, the players money. If the mainDataTable is a table and there is a value stored at the index of one, then the player's money gets set to that value found at the index of one. If the mainDataTable is not a table the second part, mainDataTable[1] would not error because it would not be evaluated. If the first part of an and is false, it does not evaluate the second part. If either the table or a value at that index don't exist, the value of the player's money is set to 0.
Variables can also be set to mathematical expressions:
1 | local x = 5*4+3-10/2 |
2 | print(x) |
3 | -- output --> 18 |
I hope this answers all your questions. Have a great day scripting!
Links for reference:
0
0
Hello Eze, Variables are holders for a value and mostly used for Strings and Numbers.
You can assign variable by using the operator "=". So it's gonna be like that VARIABLE = VALUE
Here are examples of different Variables:
1 | x = 13 -- Assign the variable to the value |
2 | print(x) -- Printing the variable value |
Output: 13
1 | text = "Hello World" |
2 | print(text) |
Output: Hello World
That's not all you can change the value any time buy using events, functions or timers
1 | z = 5 |
2 | print(z) |
3 |
4 | wait(1) |
5 |
6 | z = 8 |
7 | print(z) |
Output: 5 [After1Second] 8
As well as assigning a variable to another variable
1 | b = 9 |
2 | k = b |
3 | print(k) |
Output: 9
Assign it to part
1 | ballName = script.parent.Name -- Let's suppose the part's name is Ball |
2 | print(ballName) |
Output: Ball
Assign it to Booleans
1 | t = true |
2 | if t then |
3 | print("True") |
4 | else |
5 | print("False") |
6 | end |
Output: True
I think that's all the values you can assign a variable to, If i forgot won i may edit this.
Here is a code for all the codes explained above and how would it function:
01 | -- Defining Variables -- |
02 | x = 13 |
03 | text = "Hello World" |
04 | z = 5 |
05 | b = 9 |
06 | k = b |
07 | ballName = script.parent.Name -- Let's suppose the part's name is Ball |
08 | t = true |
09 |
10 |
11 | if t then |
12 | print(x) |
13 | print(text) |
14 | print(z) |
15 | z = 8 |
16 | print(z) |
17 | print(k) |
18 | print(ballName) |
19 | end |
Output: 13 Hello World 5 8 9 Ball
Thanks.
1
liike definers u can put practically everything in existence into them, thanks mostly to stringvalue