What are the Differences between "Local Function" and "Function"? [closed]

adark missed the biggest practical different between local functions and not.

Global variables can be used lexically (in order in source) before they were declared. For instance,

local variables are only usable after them (lexically -- in source order):

The same applies to local functions -- they can only be used after they are declared, thus the following is invalid:

---

In addition, it lets you hide functions entirely:

---

According to Programming in Lua, the following two are equivalent:

There is no difference between 'local' functions and 'normal' functions, actually.

First, a bit of clarification: Functions do not fire events, they listen to them. The ROBLOX engine itself fires them, passing in relevant information as arguments. Also, Function is invalid, as Lua is case-sensitive.

What's going on is a shortcut of Lua:

Functions are first-class values in Lua, meaning that you can treat them as any other kind of variable. If you are familiar with C, Lua functions are more accurately function pointers.

This is why you'll see code like this:

The first set of parentheses calls loadstring, which returns a Lua function. The second set of parentheses calls that function.

---

As you probably know, the local keyword in Lua indicates the scope of a variable. If not, let me explain:

When you make a function local, the same rules apply. Using top-level local variables in place of globals gives a considerable performance increase after a while, so that's why it's common to see them.

---

One last word on functions, and Tables as well:

Unlike other variables types, functions and Tables are, effectively, pointers. This is why you get something like this when you try to print them. When you pass a Table or function around as an argument to some function call, you are actually passing a reference to the Table/function. Any other variable type is copied into a function's 'upvalues', which are the parameters:

tab and RunThis are pointers, to a Table and a function, respectively. RunThis() calls the function at the end of the pointer.

Notice, modifying the str upvalue passed into the RunThis call does not modify the external str variable. Modifying the Table's members, however, does modify the external Table. It is not possible (AFAIK) to modify the external function using just its upvalue.

A further note on upvalues: they act as local variables, following the rules above, so:

---

And, finally, reusing local variables:

In the above code, you'll notice that I did not write local X = {}. This is because X is already local. Since it was declared in the function definition as an upvalue (remember, parameters are upvalues), rewriting it in the 'global' scope simply reuses whatever scope the variable already had.

This is because variables in Lua do not have a specified Type. That is,

Is all valid Lua. In a language like C, that kind of code would produce a compile error, as x is either a Boolean or a String or an Integer, and definitely not all three at once.

All three of those x declarations are local, because the initial declaration is. When a higher-scoped variable is overridden, the most recent scope is used:

---

If you've been paying attention thus far, you'll realize that you can declare functions inside of code blocks:

And as members of Tables:

This second case is how you can make methods as opposed to functions: