Lua for JavaScript Developers¶

This tutorial aims to bridge the gap for JavaScript developers who are looking to get up to speed with Lua, a lightweight, high-level, multi-paradigm programming language. We’ll explore the key differences and similarities between Lua and JavaScript, with examples to help you transition smoothly.

Introduction¶

Lua is known for its simplicity, small footprint, and good performance. It is commonly used in game development, embedded systems, and wherever a lightweight scripting language is needed. While JavaScript is primarily found in web development, Lua is often embedded in applications for extensibility.

Syntax Differences¶

Lua and JavaScript share C-like syntax, but there are several important differences:

1. Variable Declaration

   Lua uses local to declare variables to avoid global pollution. JavaScript uses var, let, or const.

   Lua - Declaring Variables¶

   local name = "Lua Developer"
   

   JavaScript - Declaring Variables¶

   let name = "JavaScript Developer";
   

2. Functions

   Function declaration is straightforward in both languages, yet Lua does not support arrow functions like JavaScript.

   Lua - Function Declaration¶

   function greet(name)
       print("Hello, " .. name)
   end
   

   JavaScript - Function Declaration¶

   function greet(name) {
       console.log(`Hello, ${name}`);
   }
   
   // ES6 Arrow Function
   const greet = (name) => console.log(`Hello, ${name}`);
   

3. Tables vs. Objects/Arrays

   Lua uses tables as the basic data structure, unlike JavaScript, which distinguishes between arrays and objects.

   Lua - Using Tables¶

   local person = {name = "Lua", age = 30}
   print(person.name)  -- Accessing table property
   

   JavaScript - Using Objects and Arrays¶

   let person = {name: "JavaScript", age: 30};
   console.log(person.name);  // Accessing object property
   
   let numbers = [1, 2, 3];
   console.log(numbers[0]);   // Accessing array element
   

4. Control Structures

   Control structures in Lua are similar to JavaScript but differ in syntax and some functionalities.

   Lua - Control Structures¶

   local score = 85
   if score > 80 then
       print("Great job!")
   elseif score > 50 then
       print("Good job!")
   else
       print("You can do better.")
   end
   

   JavaScript - Control Structures¶

   let score = 85;
   if (score > 80) {
       console.log("Great job!");
   } else if (score > 50) {
       console.log("Good job!");
   } else {
       console.log("You can do better.");
   }
   

Loops¶

Looping in Lua and JavaScript follows similar patterns, but with some key syntax differences. Here, we compare common looping constructs like for and while.

1. For Loop

   In Lua, the for loop can be used for both numeric ranges and generic iteration over tables. JavaScript’s for loop is similar but requires more explicit setup for numeric ranges, and uses for…in or for…of for object and array iteration respectively.

   Lua - Numeric for Loop¶

   for i = 1, 5 do
       print("Iteration " .. i)
   end
   

   JavaScript - Numeric for Loop¶

   for (let i = 1; i <= 5; i++) {
       console.log(`Iteration ${i}`);
   }
   

   In JavaScript, to iterate over elements of an array or properties of an object:

   JavaScript - Array Iteration with for…of¶

   let numbers = [1, 2, 3, 4, 5];
   for (let number of numbers) {
       console.log(`Number: ${number}`);
   }
   

   Lua - Generic for Loop for Tables¶

   local numbers = {1, 2, 3, 4, 5}
   for index, value in ipairs(numbers) do
       print("Number:", value)
   end
   

2. While Loop

   The while loop in both Lua and JavaScript operates under similar principles, executing a block of code as long as a specified condition is true.

   Lua - while Loop¶

   local count = 1
   while count <= 5 do
       print("Count " .. count)
   count = count + 1
   end
   

   JavaScript - while Loop¶

   let count = 1;
   while (count <= 5) {
       console.log(`Count ${count}`);
       count++;
   }
   

Conclusion¶

While Lua and JavaScript have their peculiarities, the transition from JavaScript to Lua is straightforward due to their similar high-level features. Lua’s simplicity and powerful integration capabilities make it an excellent choice for embedded scripting, game development, and more. The above examples should help JavaScript developers quickly adapt to Lua’s syntax and concepts.