Scripting Helpers is winding down operations and is now read-only. More info→

Since roblox new wiki has lack of lua doc i ask this:?

Asked by

WindowMall 54

5 years ago

What is: Variant, Tuple, Table, Arguments, Parameters, array

its been long time scripting but i have decided to return scripting but since the old wiki doesn't exists anymore

https://scriptinghelpers.org/glossary User#5423 17 — 5y

1 answer

Answered by

Fifkee 2017

5 years ago

Edited 5 years ago

Arrays / Tables

In Lua, an Array is literally just a Table.

Arguments are the values provided within a function call, for example:

`1`	`local` `MyFunction` `=` `function(ArgumentONE, ArgumentTWO, ArgumentTHREE)`

`2`	`return` `(ArgumentONE^2` `+ ArgumentTWO^2` `==` `ArgumentTHREE^2)`

A table is an object that can contain key-value pairs:

1local Table = {}; --Tables are initialized using curly brackets.
2 
3--We can then add stuff using the table using keys or dot notation:
4 
5Table.Fat = true;
6print(Table.Fat) -->> true;
7 
8Table['Egg'] = 'green';
9print(Table['Egg']) -->> 'green'

With tables, we can also hardcode definitions in by defining the key and value in the table before hand:

1local Table = {
2    Green = true;
3    Eggs = false;
4    And = true;
5    Ham = false;
6};

Make sure to have a semicolon (;) or a comma (,) to seperate keys! Whitespace will not do it!

Parameters are the variables that are to be defined when the function is called:

function newFunction(a, b, c): in this case, a, b, and c are all parameters. newFunction(a,b,c): in this case, a, b, and c are all arguments.

Tuples

Tuples are an ordered set of values that can be assigned to various other variables.

For example, let's say I have a function.

1function myNewFunction(adjacent,opposite,hypotenuse)
2    return adjacent^2 + opposite^2, adjacent^2 + opposite^2 == hypotenuse --return two values: the result of the pythagorean theorem, and if it's a valid triangle. 
3end

In the return value, I return two values (seperated by commas, NOT semicolons.)

I then call the function and assign the tuple to one value.

`1`	`local` `VariableONE` `=` `myNewFunction(2,2,8);`

VariableONE is only set to the result of the pythagorean theorem, and not both. The amount of values captured is equal to the amount of variables set "equal" to the tuple.

So, if I wanted to capture all two values of the tuple, I'd use two arguments in this case:

1local VariableONE, variableTWO = myNewFunction(2,2,8);
2--Now, if I print variableONE, variableTWO:
3print(VariableONE, variableTWO) --hey, look! we also provide a tuple in this print by seperating by commas!

This example will print "8" and "true" to console.

Variants

A variable is called a "variant" when the return value is not defined and set in stone. For example, a function that returns a random type (instance, bool, or number) is a variant.

For example:

--variant function MyFunction, function type is determined by the return value

01function MyFunction()
02    local MyRandomValue = math.random(100);
03    if (MyRandomValue < 100/3) then
04        return true;
05    elseif (MyRandomValue > 100/3 and MyRandomValue < 100/2) then
06        return 6.9; --nice
07    else
08        return Instance.new('Part', workspace)
09    end
10end;

Since the return value of the function is random (meaning we can't accurately measure the value by convenient measures), the return value is a variant.

That's why when you see a function, sometimes it says variant MyFunction(), because it returns a Variant value.

Pretty neat, huh?