How to learn Lua programming

how to learn lua programming language and how to lua in cheat engine and how lua fits into wireshark and how to install lua on windows
Dr.KiranArora Profile Pic
Published Date:27-10-2017
Your Website URL(Optional)
Introduction to Lua Apple has been issuing checks to developers, and the 2012 figures indicate that it has so far been to the tune of 5 billion. In the past, it used to be desktops with Microsoft-based products that were raking in money for developers, with Visual Basic, or earlier with database products such as dBase and FoxPro. While the major share of this revenue goes to larger companies such as EA, Chillingo, Gameloft, Rovio and even Disney, a lot of indie developers and smaller companies vie for a share of that big pie. Who knows what idea might just become the money-spinner for a developer. Robert Nay, a 14-year-old, made the game Bubble Ball while he was learning to code, and it went viral, with over 8 million downloads. And no one knows what the next top game will be. As a person that has an interest in development, you have made the first step in this journey. You could be a student that has never developed before, or you could be a guru developer who can whip up an enterprise app in minutes. The point is that whatever your background, you are for some reason drawn to this strange-sounding language, Lua (pronounced LOO-ah.). What Is Lua? Lua is a programming language that has a small footprint, works across several platforms, and is quite flexible and extensible. Further, Lua is a game changer for developers that want to write apps for the mobile devices. It has powered a lot of apps and games in the Apple App Store, and it has been spoken about by the late Steve Jobs. It has even been linked with one of the most advanced self-replicating and mutating viruses, the Flame. Despite all of that, Lua remains to be a language that seems more like plain English than a cryptic programmer’s language, making it a language with a smaller learning curve. The History of Lua While knowing the history of Lua will not change anything in terms of making anyone a better programmer, it important to get an idea of why you’d want to use Lua. Lua was created at the Pontifical Catholic University of Rio de Janeiro, Brazil, by Roberto Ierusalimschy, Luiz Henrique de Figueiredo, and Waldemar Celes, who were members of the 1 2 CHAPTER 1: Introduction to Lua Computer Graphics Technology Group (TeCGraf). Generally, funding for university research is provided by industry, which also expects solutions to some problems that they face. Petrobas, a Brazilian oil company, one of the clients this group was helping them resolve issues related to data entry. Operations of a petroleum company are large, and a large number of data transactions were to be processed on a daily basis. They approached the group to devise a graphical front end that would help eliminate errors in data entry, especially when working with legacy code from fixed-format files. TeCGraf looked at the whole series of screens that were provided to them and tried to find some form of uniformity to help find a solution. For this they came up with a simple and unified data entry language (DEL), which was used to describe the data in each data entry task. I think a good parallel would be that of XML, but without the multitude of tags that make it confusing to understand. That Sol also means sun in Portuguese.) than that of an IDE-type application. The API was implemented as a C library and linked to the main program. Each type could have a callback function that functioned as the constructor (i.e., the function is called when an object of a particular type is created). In 1993, the creators realized that DEL and SOL could both be combined into a single more powerful language. This led to a proper programming language that would have it all: assignment, control structures, subroutines, functions, and so on. However, it would also work with the basic requirement to be able to offer data-description facilities like those of DEL or SOL. They wanted it to be an easy–to-use language without cryptic syntax and semantics, as the end users weren’t expected to be professional programmers. Lastly, they wanted it to be portable to run on any and every platform (if required). Because it was a modified version of SOL, the creators called this new program Lua (which mean moon in Portuguese). Lua Timeline As of this writing, Lua is in version 5.2.1. It has undergone quite a few changes and has been used extensively in many projects for enterprise, entertainment, games, and apps. For many of us, it might come as a surprise that Lua is used in South American homes practically on a daily basis. It powers their interactive televisions. Universities use Lua in their research to allow for quick processing and results. In 1996, Lua got exposure internationally after an article in Dr. Dobbs. Following the article, there were e-mails from developers. In a paper, Roberto narrates about how Bret Mogilefsky, who was 1: Introduction to Lua 3 the lead programmer at LucasArts (of Grim Fandango fame), wanted to replace their scripting language SCUMM with Lua. This drew interest from other developers, and Lua started to appear on newsgroups. Starting with Lua One important point that I’ll make throughout the book is that, with Lua, it doesn’t matter what framework you use; what’s important is the glue that holds it all together: Lua. In the ’90s, Microsoft was pushing client-server and three-tier architecture (similar to what Apple has been pushing as MVC Model-View-Controller). The idea behind MVC is that it involves three distinct portions: a model, which takes care of the data; a view, which displays the data from the model and provides interaction with the user; and a controller, which communicates between the model and the view, as these two do not have any idea of each other’s existence. The controller is the broker that helps the two talk to each other. The most usual way to work with MVC is to use a framework, which takes care of a lot of the details for you. In this book, I shall cover a few frameworks: CoronaSDK, Gideros Studio, Moai, Codea, and LÖVE. All of these except LÖVE help develop and run apps on the iOS platform. The architecture of a Lua-based mobile app is simple, as the diagram in Figure 1-1 shows. Figure 1-1. The architecture of an app using Lua on a mobile device platform An application is made up of all the resources graphics, music, text, etc.), which are compiled into the application, with the Lua code along with the framework stub. When run, the framework or the engine creates an OpenGL surface on which all of the graphics are displayed. This is how all of the frameworks work, and this is how they can offer cross-platform compatibility. The limitations on the framework are imposed mainly due to either the limitations of OpenGL or the framework engine. 4 CHAPTER 1: Introduction to Lua The MVC pattern discussed earlier holds true in this architecture. If we write our code with this in mind, we can create not only cross-platform applications, but cross-framework ones. The controller code that we write in Lua will change to cater for the other framework, but the rest of the code will be the same. In the next section, we shall focus on Lua and how to use it. After that, we’ll look specifically at the frameworks and integrate some of the things that you’ve learned. Setting Up Lua If we need to work with Lua, we need to have Lua. Since most of the frameworks use Lua 5.1.4, we shall use that version for compatibility. Lua can be obtained as a precompiled binary or source code . You can as per your version of Windows. For the Mac, there are versions for Tiger, Leopard, Snow Leopard, and Lion. For nix, they are based on the kernel version; in this case, it’s easier to download Lua from the app catalog in each of the distributions. iOS There are two apps that I know of that allow for running Lua code interactively. Unlike the other Lua offerings mentioned, these are not free.  iLuaBox: This app uses the newer version of Lua 5.2 and costs about 2.99 in the App Store.  Lua Console: This app works with Lua 5.1.4 and costs 1.99 in the App Store. Of the two, iLuaBox has some advanced functionality in terms of managing files and directories. Features of Lua Lua is implemented as a library written in C. It does not have a main program, as there is no need to invoke something automatically; it works as in embedded mode and calls the embedding program. This code can invoke other functions, assign variables, and read and write the data. Having been written in C, it can also be extended; however, the official release will only add features that have been approved by a committee. 1: Introduction to Lua 5 Variables In simple computing terminology, a variable is a location that holds a value and can be accessed by giving it a name. Think of it as a filing cabinet in a company’s HR department. It can hold many files with details on the employees. When you need to access data from one of them, you can look it up via the file’s name tag. If you have two employees with the same first and last names, there need to be two files and the name tag would require some form of identification to distinguish between the two. Just as you cannot have two files with the same tag, you cannot have two variables with the same name. There has to be some point of differentiation (e.g., tag1 and tag2 instead of just tag). The names given to the variables can be a series of letters, digits, and underscores; however, they cannot begin with a digit. The names are case sensitive, so there is a difference between T and t. In addition to variables, Lua also uses keywords, which cannot be used for variable names, as Lua identifies them as commands for the code, not variable names. Here’s the list of system keywords, which cannot be used as variable names): and break do else elseif end false for function if in local nil not or repeat return then true until while 6 CHAPTER 1: Introduction to Lua Hello World, the Variable Way To begin with, we need to start Lua in interactive mode for the purpose of running all of our code. The way it works is to open a terminal in Mac OS X or nix, type lua, and press Enter. After doing this, you should see the screen shown in Figure 1-2. Under Windows, you can start the Lua console from the Start menu. Note In this book, most of the screenshots and references will be for the Mac OS X version. Figure 1-2. The Lua interactive shell running in the terminal on a Mac The on the line is the prompt where you can type the Lua code you want to run. We shall start with writing a simple Hello World example. Type the following at the prompt: print ("Hello World") You should see the text “Hello World” printed on the next line. The print function is used to display the text in the terminal. Let's take this a step further: 1: Introduction to Lua 7 message = "Hello World" print(message) What we have just done here is assign the string "Hello World" to the message variable; then we use the print function to display the value of message in the terminal. Just like strings, we can also print numbers, and the simplest way to do so is print(5) age = 1 print(age) print("Age :", age) print(1,2,3,4,5,"One") The aim of this is to demonstrate that using print, we can display variables, numbers, and strings to the terminal. Strings Strings in Lua can be enclosed in single or double quotes. So, for example, both 'Lua' and "Lua" are valid. Literal strings can be used in a manner similar to C by preceding them with a blackslash (\) and enclosing them in the single or double quotes. These can be used to include commonly used escape sequences such as \b, \t, \v, \r, \n, \\, \', and \". They can also be used to specify a numeric value with the format \ddd, where d is a digit. print("\65") There are times when you want to include chunks of text, and keeping track of the quotation marks can sometimes get a bit tricky, especially when trying to get them to match and line up. In such cases, you can use the long-bracket format, by which you enclose the text within and . Here’s an example: message = That's "Jack O'Neill", with two ll's If you used single quotes for enclosure in a scenario like this, you would get an error: message = 'That's "Jack O'Neill", with two ll's' Likewise, you would also get an error using the following line, as the single and double quotes need to have a matching pair or be escaped. message = "That's "Jack O'Neill", with two ll's" The correct way to declare the same would be to place a backslash before the literal quotes, like this: message = 'That\'s "Jack O\'Neill", with two ll\'s' or like this: message = "That's \"Jack O'Neill\", with two ll's" 8 CHAPTER 1: Introduction to Lua You will notice that it is easy to miss that, in which case the interpreter will only spawn errors. In such cases, using the long brackets is very helpful. Lua also has levels of nesting with long brackets; you can have various levels by inserting an equal sign between the two opening brackets and one between the two closing brackets, like so: testmsg = = One = print(testmsg) You can use this for some very interesting-looking source code where you can use testmsg = ====== One ====== Prints One 5 This is a decimal number 5.3 This is a floating point number 0.0531 This is a scientific notation number 65261 This is a hexadecimal number Values and Types In languages like C, you have to define a variable with a particular type. For example, you might need define a variable i as an integer (int), like so: int i; With Lua, you do not have to define the type of variable; you can simply assign the value, and the value can change on the fly. In Visual Basic 6 (not to be confused with Visual Basic.NET), this type of variable was called a variant variable, and had to be explicitly defined as follows: dim i as variant In contrast, Lua stores variables in memory. Lua stores a variable’s value and type together. All variables in Lua are first-class values. This simply means that these values can be stored in variables, passed to other functions as arguments, and returned from a function. There are eight different types of variables in Lua, which I’ll describe next. nil This is the same as null. If you have a variable that holds a reference to the last-held value and the garbage collector doesn’t clean it up, you can set the variable to nil to indicate that the space referenced can be garbage collected. 1: Introduction to Lua 9 boolean boolean variables are our trusty true and false. These are used to check for conditions; however, it should be noted that both nil and false will result in the condition being false and any other value resulting in true. trusted = false if (trusted) then print("Yes") end Nothing is printed trusted = 1 if (trusted) then print("Yes") end Yes is printed trusted = nil if (trusted) then print("Yes") end Nothing is printed number number variables are numbers that can be expressed as decimals, longs, integers, hexadecimals, and floats. Lua saves the numbers as double-precision floating-point numbers. string Lua strings are generally 8-bit clean strings (i.e., they can hold any 8-bit character, including embedded zeros). Unicode variables are a slightly different matter, but are handled by Lua if the platform supports Unicode. function In Lua, functions can also be stored and passed as variables. This functionality of being able to store and pass functions as parameters makes the functions in Lua “first-class functions.” userdata This is a memory block that is allocated from C, allowing C functions to store and access data. userdata variables cannot be created or manipulated in Lua, but only through the C API. thread This is a special type of variable; this specifies an independent thread of execution. This is not the same as the operating system thread. table table variables are what we would call arrays, associative arrays, hash tables, sets, records, lists, trees, and even objects in Lua. Note Tables, functions, and threads do not really hold any values—only references to them. 10 CHAPTER 1: Introduction to Lua Code Blocks and Scopes In Lua, every variable has a scope, which means that it is accessible to the code depending on its life cycle as determined by the scope. Variables are either global or local. By default, variables are defined as global unless explicitly defined as local. In code, variables set between a do and an end block are not accessible outside of the block, and any local variables that are set outside of the block are accessible inside the block. Let us look at this with an example: i = 1 print("i = ", i) local i = 2 print("i = ", i) is a simple term given to the process of converting a string into a number following the 3 is printed In many languages, attempting such an arithmetic operation between two different data types (in this case a string and a number) would fail. In some other scripting languages, this code would instead add the value to the string, resulting in the string "12". However, in Lua, this outputs the value 3, where one is converted into numeric 1 and then added to the value of two to output 3. However, if we wanted to add the two strings "1" and "2" to get "12", then we would need to use what is called concatenation. In Lua the concatenation operator is the double-dot (..). This combines the two strings and returns a new string that contains the two strings passed. Lua Operators The operators in Lua can be grouped into different types of operators, which include arithmetic, relational, and logical operators, among others. Arithmetic Operators These do not need much of an introduction; they are simple and straightforward. Table 1-1 lists them. 1: Introduction to Lua 11 Table 1-1. Arithmetic Operators Operator Description + Addition - Subtraction Multiplication / Division % Modulo Exponent - Unary negation Relational Operators These are the operators used for comparing or conditions. They’re listed in Table 1-2. Table 1-2. Relational Operators Operator Description == Equality (to check for equality between two values) = Not equal to (the opposite of equality) Less than Greater than = Less than or equal to = Greater than or equal to These operators will always result in a true or a false return value. It should be noted that when comparing two numbers or values, use the == where as a single = in Lua signifies assignment. Logical Operators The logical operators in Lua are and or not The way the and and or work in Lua is by what’s called the shortcut evaluation. It checks for a value, and checks further only if it is required. and returns the first arguments if the value is false or nil; if it isn’t, then it returns the second argument. or, on the other hand, returns the first value if the result is not false or nil, and returns the second argument if the first argument is false or nil. The best use of or is in functions for assigning default values: a = a or 5 Can be used to assign the value of 5 if the value of a is nil or false 12 CHAPTER 1: Introduction to Lua We can test how these work as follows: testing = nil print(testing) print(testing and 5) print(testing or 5) print(not testing) testing = 15 print(testing) print(testing and 5) print(testing or 5) print(not testing) operator can also be used with arrays.  Concatenation operator: ..  Length operator: ..). It is used to add print("one, two, " .. " buckle my shoe") The length operator returns the length of the string. print("this is a long string") prints 21 as the length of the string Summary The portability of Lua means that we can run our code on various devices and desktops. The small footprint of Lua and a very flexible and forgiving syntax allows for rapid prototyping and code testing. We have seen that Lua is increasing in popularity with game developers. In the next chapter, we shall take a closer look at the standard Lua libraries that provide all the commands that make up standard Lua. Lua Libraries In the previous chapter, you learned the reasons behind Lua and that Lua is, after all, made up of C code libraries. One of the advantages that the developers of Lua got from this architecture for Lua was that they could add functionality as required. Adding functionality involved writing new functions and making them available in Lua. It is quite a surprise that Lua does not have multiple distributions and remains as intended by the developers; there are not many modified versions. However, many developmental studios do modify, or rather adapt and customize, Lua for their own editors and tools. In this chapter, we shall look at the standard Lua libraries and namespaces that provide us with their functions. Then we’ll have a detailed look at the system- and table-related functions. Basic Functions Lua has some basic functions that are part of the Lua system, we’ll have a look at the following subsections. These form part of the core library and are generally available to most of the distributions. assert ( v , message ) This function is similar to the assert function used with C; it returns an error if the value of the argument v is false (either nil or false);. The message, if present, is displayed as an error; if absent, the default text “assertion failed” is displayed. assert(money 0,"you need to have some money to buy something") collectgarbage ( opt ,arg ) This function is a generic interface to the garbagecollector. The function acts differently depending on the parameter opt. The options that you can pass to this function as opt are 13 CHAPTER 2: Lua Libraries  collect: Performs a full garbage-collection cycle. This is the default option.  stop: Stops the garbage collector.  restart: Restarts the garbage collector.  count: Returns the total memory in use by Lua.  step: Performs a garbage-collection step. The step size is governed by arg.  setpause: Sets arg as the new value for pause and returns the previous value of pause.  setstepmul: Sets arg as the new value for the step multiplier and returns the previous value for step. Tip If you want to know the memory usage of your app and clear up the memory and objects, you can force thegarbagecollector to free up and reclaim the memory allocated and then print the amount of memory used after a cleanup by using theprint(collectgarbage("count")) command. You saw in Chapter 1 that Lua executes the code in chunks. This function opens the named file and executes its contents as a Lua chunk. When called with no arguments, it executes the contents from the standard input (stdin). It returns all values returned by the chunk. stdin is not available on iOS devices, and with CoronaSDK the function is sandboxed (i.e., disallowed). dofile("somefile.lua") error ( message ,level ) This function terminates the last protected function and returns the message as the error message. error("This operations is invalid") _G This is not exactly a function, but a global variable. Lua does not use this variable, but it holds all the global variables and function. getfenv ( f ) This function returns the current environment in use by the function. The function f can be a Lua function or number. 2: Lua Libraries 15 getmetatable ( object ) This function retrieves the metatable associated with the object. It returns nil if there is no metatable present. This is mostly used to add functionality to an object table. In some cases, this is also used as a signature of the object. So while the type function does not tell you much, the metatables can be compared with a list of known metatable signatures to get more information. ipairs ( t ) This function returns a function that returns three values, an iterator function, the table t and 0. It works with the array tables only. The following code will iterate over the pairs up to the first integer key missing from the table: t = 1,2,3,4,test = "test",5,6 t3 = nil for i,v in ipairs(t) do body print(i,v) end load ( func ,chunkname ) This function is similar to the dofile command; it loads a chunk using the function func. Each time the function is called, the function must return a string that concatenates with the previous result. When the chunk is complete, it returns nil and an error message. The chunkname is used for debugging. When the function is called and an error occurs, Lua displays debugging information, including the line number where the error occurred and the name of the Lua file in which the error occurred. When we have compiled chunks, there is no filename and hence, for debugging purposes, it is up to you, the developer, to provide that information in the form of the chunkname parameter. loadstring ( string ,chunkname ) This function is similar to load, but instead of loading the compiled bytecode from a file, it takes the compiled code (chunk) from a string. loadstring(compiledChunk, "OurChunk") next ( table ,index ) This function allows the program to iterate through all the fields of a table. The function returns multiple values. Internally, the function takes on system commands. t = "One", "Deux", "Drei", "Quarto" print(next(t, 3)) 16 CHAPTER 2: Lua Libraries pairs ( t ) This function is used to iterate through the keys and values in a table. t = one = "Eins",two = "Zwei", three = "Drei" for k,v in pairs(t) do body print(k,v) end pcall ( f, arg1, … ) f with the arguments in protected mode. This means that any errors f are not propagated outside of the function. stdout. It uses tostring and tonumber for conversion, This function is used to check if the value v1 is equal to v2. It returns a Boolean indicating the outcome of the comparison. rawget ( table, index ) This function returns the value of tableindex without invoking any metamethod. The table must be a valid table and the index a non-nil value. This is equivalent to tableindex rawest ( table, index, value ) This function sets the value of tableindex without invoking any metamethods. The table must be a valid table and the index a non-nil value. This is equivalent to tableindex = value select ( index, … ) This function returns all of the arguments passed to the function starting with the argument after the index specified. 2: Lua Libraries 17 setfenv ( f, table ) This function sets the environment to be given to the function f. f can be a Lua function or a number that specifies the value of the platform. setmetatable ( table, metatable ) This function is used to set the metatable for any table. tonumber( e ,base ) This function is used for converting between the numbers from string to numerical values. If the argument e is in a form that can be converted, it is converted and returned; otherwise, nil is returned. print( tonumber("42") ) print( tonumber("2A",16)) tostring ( e ) This function tries to convert the given argument to string format. If the passed parameter is a number, it is converted into a string. If it is an object and its metatable has a __tostring function, the __tostring function is called to convert the passed parameter. Note Lua converts between numbers and strings as required (and if possible). However, calling the tostring function is a way to tell Lua to convert the value into a string. Objects and tables are not automatically converted into strings; instead, the functiontostring (if present) is called, which returns the string representation of the object/table. type ( v ) This function returns the type of the arguments, coded as a string. The possible results are "nil", "number", "string", "boolean", "table", "thread", and "userdata". print(type("Hello World")) print(type(4)) print(type()) unpack ( list , i , j ) This function returns the elements from an array table. This function is equivalent to return listi, listi + 1, . . . , listj 18 CHAPTER 2: Lua Libraries Manually, this code can only be written for a fixed number of elements, and we cannot use a loop, as we have values to return. The parameter i specifies the start element and j specifies the last element, by default. (When these values are not provided, i is 1 and j is the length of the list as defined by the operator.) local color = 255,255,255 function tableToParams(theTable) return unpack( theTable) end print( tableToParams(color)) pcall function, except that with this call, you can specify a new error f, it is not propagated, and xpcall catches the error err function with the original error object function spawnError() this function shall spawn an error local this = someFunctionNotDeclared() end print(xpcall(spawnError, function(err) print("Error:", err) return 1 end)) System Libraries The commonly bundled system libraries that you will end up using while working with Lua are  table  string  math  file  os The table namespace provides us with the functions related to array manipulation, as these functions are not applicable to hash arrays or associative arrays. This is explained in detail in the following section. The string namespace provides us with functions to deal with string manipulation. These allow for searching, splitting, and replacing strings, and are quite helpful for parsing and displaying information. We shall have a close look at the string namespace in Chapter 5. CHAPTER 2: Lua Libraries 19 The math namespace provides all the math-related functions; these are the basis for all the logic in most games. The math namespace provides all math-related functions that can help calculate things like where the player is, where the objects are, whether the player won or lost, and much more. We shall look at this namespace in detail in Chapter 4. The file namespace, covered in Chapter 3, provides file-related functions, including those that allow the user to read, write, and delete files. Note that file operations do not include much file system–related functionality, and there is a third-party library called Lua File System (LFS) that offers the missing functionality. The os namespace provides functions that are related to OS-specific functions, including functions that deal with things like time, date, and locale. We shall look into this further ahead in the “OS Functions” section of this chapter. The way to use these libraries is to prefix the library name followed by a dot and the function. This is a good way of separating the functionality available in the library from the common or global area. With libraries, variables and functions can be part of the namespace. For example, if we had a function a1, and the namespace myFunc had a function defined as a1, these two would be completely different functions. To access these functions, simply add the namespace as a prefix in front of the function name, as follows: call the global a1 function a1() calling the a1 function available in the namespace myFunc myFunc.a1() Note There is no function calleda1, so these commands will not work; these are just for illustration purposes. Table Functions You may have already noticed that in Lua, if anything is not a string or a number, then it is an object (i.e., a table). Tables are the most important data type in Lua. There are a handful of functions to manipulate end work with the tables. These are useful functions for working with array-type tables. The functions available are described in the following subsections. table.concat ( aTable ,sep ,i ,j ) This function returns the elements of an array (if they are either strings or numbers) concatenated as a string. These are separated by a separator, as indicated by sep, which is a blank string by default. If no parameters are passed for i and j, then i is the first element and j is the length of the table. If i is larger than j, then an empty string is returned. If you were to write this function yourself, it would look like return aTablei..sep..aTablei + 1 . . . sep..aTablej. local aryTable = 1, "deux", 3, "vier", 5 print( table.concat( aryTable, ",", 1,3)) print(table.concat(aryTable)) 20 CHAPTER 2: Lua Libraries table.insert ( aTable, pos, value ) This function is used to insert a value into the array table, as indicated by aTable. The value is inserted at the position indicated by pos; if no value is indicated for pos, then it is assigned the default value of the length of the table plus 1 (i.e., at the end of the table). local aryTable = 1, 3, 4, 5 table.insert(aryTable, 2, 2) print(table.concat(aryTable, ",") table.insert(aryTable, 6) print(table.concat(aryTable, ",") 1 that the operator returns the length of an array, but only of a contiguous section. So, if table.maxn, on the other hand, print(aryTable, table.maxn(aryTable)) table.remove ( aTable , pos ) This function is like insert, but with the difference that it removes an element from the array table and returns the element being removed. In bothinsert andremove, the elements are shifted to accommodate the new index as required. The default position for pos is the length of the table (i.e., the last element). local aryTable = 1, 2, 3, 4, 5 table.remove(aryTable, 2, 2) print(table.concat(aryTable, ",") table.remove(aryTable) print(table.concat(aryTable, ",") print(aryTable3) table.sort ( aTable , comp ) This function is very useful when working with a series of values that need to be sorted. When no comp is specified, it uses the standard Lua operator to compare two values, which works fine with numeric values. However, there could be situations where you might need to sort multidimensional arrays or arrays that contain non-numeric data. For such cases, the comp function is used. comp receives two table elements and returns true when the first is less than the second.

Advise: Why You Wasting Money in Costly SEO Tools, Use World's Best Free SEO Tool Ubersuggest.