Question on returning

Local function hi()
	print("hi there")
	return "something"

local returning = hi()

I don’t get how returning is useful. If someone can tell me, thanks in advance.

The return statement is extremely useful as it serves several purposes, like making module scripts work or getting a value from a function.

What the return statement does is in the name, it returns something i.e. a value. Let’s say for example you have a function which gets all the players in the game, and you want to put them all into a table. It would look something like this:

local function getPlayers() -- Declaring the function
   local players = {} -- Making the table to store all the players names
   for _, v in pairs(game.Players:GetPlayers()) -- Looping through all the players in the game  
     table.insert(players, v.Name) -- Puts the players name into the end of the table

It should look something like this. But, there’s no way of us getting the players from this function, all its done is worked it out and ended. We can change that by adding the return to the end of it, which should look something like this:

return players

Now, if it’s called and stored, it will be stored as all the players names, not a nil value.

In short, return is what you give back to whatever is requesting it. If I were a baker, and a customer wanted a baguette, they would request for it and I’d return it to them.

Thank you so much. I didn’t really know much about it. This helps me understand the concept better.

Using return is useful for OOP (Object Orientated Programming), for example:

local mt = {
	__index = {
		changeType = function(t, s)
			t.Species = s

local function createObject(name, species)
	local t = {
		Name = name,
		Species = species
	setmetatable(t, mt)
	return t

local kermit = createObject("Kermit", "Frog")
local missPiggy = createObject("Miss Piggy", "Piggy")

print(missPiggy.Species) --> Oh no, piggy is a popular Roblox game!

missPiggy:changeType("Pig") --> Change the Type for missPiggy


Using return, ‘Objects’ (or tables) that use similar functions (methods) can be quickly constructed without requiring an excessive repeat of code - adhering to the DRY principle.

Here’s another example of how it could be useful
Let’s say you have a table, and you want to duplicate it. You could do this:

local function DeepCopy(tabl)
    local copytabl = {}
    for i,v in pairs (tabl) do
        If type(v) == "table" then
            v = DeepCopy(v)
        copytabl[i] = v
    return copytabl

local initialtable = {1,2,3,4}
local copy = DeepCopy(initialtable)

You use return to assign any value you want to the place you called the function from. Every time you make a variable, you can think of it as this:

local number = 5--what your familiar with

local function getfive()
    return 5
local number = getfive() --same thing