Understanding Lua tables in Corona SDK

Posted by Jonathan Beebe

In Corona, you use the Lua programming language to do everything. Thus, it’s equally as important to understand Lua as it is to understand the individual Corona-specific concepts and API’s, such as the Event Model we went over last week.

One common source of confusion comes with one of Lua’s most powerful features: Tables.

What Are Tables?

If you’re familiar with other programming languages, then most likely, you’re already familiar with arrays and dictionaries. In Lua, a table is a mixture of both (which is why they are so flexible and powerful).

If the Corona SDK is your first foray into the programming world, however, the description above probably means nothing to you. In that case, you can think of a table as a dresser.

The drawers of the dresser would be known as “keys”, and the stuff (data) you’d put into the drawers is what’s known as the “value”. Where Lua tables differ from real drawers, however, is that you can place complete dressers (tables) within the individual drawers!

Before we go any further, let’s break down what you’ve learned so far:

• Tables hold data (aka “stuff”). Data can be of any type, to include functions.
• Tables can also hold other tables.
• A “key” is the location where data is stored (like a drawer).
• A “value” is the data that’s stored in a specific key.

And that’s probably the most basic explanation of Lua tables as you can get. In the following sections, I’ll show you how to define tables, how to store/retrieve the data within tables, and also how to use tables in conjunction with a “for” loop.

Defining Tables

And by defining, of course, I mean creating a table so you can use it whenever you want. For now, I’ll focus on creating a blank table, with no data in it. This is going to be our brand new dresser:

    local myTable = {}

A table is just another variable in Lua, so it’s defined the same way: just a variable name separated by an equals sign and the data you want to store in the variable.

The way Lua can tell it’s a table is, you guessed it, because of the brackets. Anywhere you see an opening bracket ( “{” ) in Lua, you know it’s a start of a table. The end of a table is always denoted by a closing bracket ( “}” ). You’ll see these all along, many times as arguments within functions, so it’s important for you to be able to identify them as tables whenever you see them.

Now that you have a blank table (myTable), it’s time to start storing stuff in it! Next I’ll go over the different ways to store data into a table, and also how to retrieve that data.

Tables as Arrays

Below are three different ways you can use a table as a numerical array. Each “method” shown below is completely identical. They are simply three ways to do the same exact thing.

The fourth method is exactly the same as the third, but it shows how line breaks aren’t necessary–you’ll see this one a lot when passing tables as arguments to functions.

METHOD 1:

    local colorTable = {}



    colorTable[1] = "blue"

    colorTable[2] = "red"

    colorTable[3] = "yellow"

    colorTable[4] = "green"

    colorTable[5] = "purple"



    print( colorTable[3] )  -- output: "yellow"

METHOD 2:

    local colorTable = {

        [1] = "blue",

        [2] = "red",

        [3] = "yellow",

        [4] = "green",

        [5] = "purple"

    }



    print( colorTable[3] )  -- output: "yellow"

METHOD 3:

    local colorTable = {

        "blue",

        "red",

        "yellow",

        "green",

        "purple"

    }



    print( colorTable[3] )  -- output: "yellow"

METHOD 4:

    local colorTable = { "blue", "red", "yellow", "green", "purple" }



    print( colorTable[3] )  -- output: "yellow"

Once again, the examples shown above all produce the same thing. A table with five different keys, all with the same value. As a Corona developer, you’ll see every single one because they all depend on personal preference.

When a table is used as a numerical array, the keys are all numerical values that go in order (starting from 1, not 0 as with most other programming languages). The print statement in each example (above) shows you how to access data in a table by placing their index number between square brackets ( “[]” ).

Also remember, whenever you define a table, keys are always separated by commas, with the final key not requiring one.

To get the total count of a table with numerical keys, you can do so by using the ‘#’ sign in front of the table name, like so:

print( #colorTable )    -- output: 5

Tables as Dictionaries

Lua tables can also behave like dictionaries from other programming languages (aka, “associative arrays”). Below is an example of a table behaving like a dictionary:

    local colorTable = {

        sky = "blue",

        grass = "green",

        water = "blue",

        lava = "red"

    }



    colorTable.dirt = "brown"



    -- Accessing the data:



    print( colorTable.grass )   -- output: green



    print( colorTable["dirt"] ) -- output: brown

In the above example, you can see the keys are NOT defined numerically, and that’s the main difference here. Sometimes, data is easier to identify using this method because of the way you’re able to access the data.

Instead of accessing data using numbers, you can “associate” the keys with words instead. In the example above, you see two different methods of accessing the data:

    colorTable["sky"]



    -- and...



    colorTable.sky

The two methods shown above are exactly the same–just two different ways to access the same data. And just as with numerical keys, you can add keys later on, as you can see with the dirt key being added after the table was already defined.

And speaking of flexibility, although Lua tables can behave like arrays and dictionaries, they can also behave like both at the same time. If you want, you could mix numerical keys with string-based keys, though this would make for a very confusing table structure. Normally, it’s best to go with either or.

Data Types

As mentioned before, tables can hold any kind of data within it’s individual keys. That means you can store additional tables, functions, and function references with the keys of a table, as well as the more common numbers and strings.

Here’s an example of how to store a table within a table (and how to access the data):

    local people = {

        { name="Bob", age=32, gender="male" },

        { name="Jane", age=29, gender="female" }

    }



    print( people[1].name )     -- output: Bob



    print( people[2]["gender"] )    -- output: female

There is no limit to how many tables you can store within other tables.

Another complex form of data you’ll see stored within the keys of a table are functions and references to other functions. Here’s an example of a reference to a function stored in the key of a table:

    local function helloWorld()

        print( "Hello World!" )

    end



    local myTable = {

        name = "Bob",

        func = helloWorld

    }



    myTable.func()  -- output: Hello World!





    ----------





    local function helloWorld()

        print( "Hello World!" )

    end



    local myTable = { 100, 100, helloWorld, true }



    myTable[3]()    -- output: Hello World!

And here’s how you would store an actual function (not a reference) in a table’s key:

    local myTable = { 100, 100, function() print( "Hello World!" ); end, true }



    myTable[3]()    -- output: Hello World!

As you’ve probably already figured out by now, each key within a table is no different than any other variable in Lua. You can store anything you want within it. That’s the best way to look at it.

When tables start getting big and confusing, the best advice I can give is to just look at what’s between the commas separately, as if it is on a line of code by itself. From there, your confusion should start clearing up.

Tables and Loops

One of the most common purposes of using tables over regular variables is the ability to “iterate” over the keys of a table with a loop.

Below is an example of how to iterate through a table with numerical keys:

    local myTable = { "blue", "red", "yellow", "green", "white", "purple" }



    for i=1,#myTable do

        print( myTable[i] )

    end



    -- OUTPUT:

    blue

    red

    yellow

    green

    white

    purple

With everything that I’ve went over so far, the above code should be pretty clear. Iterating over the contents of a table with numerical keys is pretty straight-forward.

However, what if your table has key names instead of numbers?

For that, we’ll use the pairs() function (which returns two variables):

local colorTable = {

    sky = "blue",

    grass = "green",

    water = "blue",

    lava = "red",

    dirt = "brown"

}



for key,value in pairs(colorTable) do

    print( key, value )

end



-- OUTPUT:

sky     blue

grass   green

water   blue

lava    red

dirt    brown

If a table uses names to identify the keys, then you can’t simply get the count and iterate over the keys numerically. Instead, you use the pairs() function with tables that don’t have numerical keys (just as you see in the example above).

Further Reading

To get a more complete, well-rounded understanding of tables in Lua, please visit the following two web pages (both of which were extremely useful to me when I was learning):

• http://www.lua.org/pil/2.5.html
• http://lua.gts-stolberg.de/en/Tables.php

The more you see them and use them “out in the wild”, the more clear tables will become. When you finally have a real need for tables is when their power and flexibility will really shine through.

Feel free to post your questions in the comments section, I’ll try my best to respond to them as they come (be sure to do a quick skim of the comments to make sure your question wasn’t already asked!).