DEV Community: DR

Building a Wordle Clone with Lua! 🕹

DR — Thu, 25 Jan 2024 19:53:14 +0000

Introduction

Hey there! 👋

The topic of today's post is Wordle - specifically, creating a console version of the game with our language of the month, Lua. I've created a demo and published it, along with this write-up detailing how it was built and the concepts we can learn from it.

If you're new to the 12 in 24 series, I'm learning and building projects with a new programming language every month - this month, it's the Lua scripting language. You can find source code for the projects I build in the official GitHub repository (check it out, this week's folder contains code for both this and two other bonus projects!).

With all that in mind, let's jump right in!

Preparation

I already have a Lua environment set up from the beginning of the month, but if you don't you could take a look at my introductory post where I walk through what the language is and how to install a suitable environment.

To create this program, I needed to think through several details to translate the original game to a console version.

I need a word list from somewhere.
The original game relies heavily on the use of color, so I need to find some way to color the text from the terminal (all white won't work).
I need to set up some advanced logic to handle edge cases (repeated words, words that aren't in the dictionary, win conditions). There's a lot more to this game than meets the eye.

File Handling & Reading

To begin, I set up a basic program structure.

mkdir WordleClone
cd WordleClone

touch words.txt # Words will be added later
touch main.lua

code main.lua # Open the file in VSCode

To fill the word list, I chose to use a Wordle list that I found on GitHub. You can use it or not, the program works regardless of the choice of word list you pick.

Next, we'll navigate to our main.lua file and process the file in the following manner.

file = io.open("words.txt", "r")

words = {}

for line in file:lines() do
   table.insert(words, string.upper(line))
end

file:close()

This opens the file, initializes a table (words), and inserts every line (one word to one line) to our words table. Finally, the file is closed.

After this, we'll pick a word and then transform the table to a set-like form (this is to make our lives easier when we start validating words).

mystery_word = string.upper(words[math.random(#words)])

word_bank = {}

for _, value in ipairs(words) do
    word_bank[value] = true
end

-- Clear the original words array to conserve memory in use.
words = {}

Terminal Colors

Normally text in the terminal is a very light gray (that's the default for standard output). However, there's a way we can change this - with ANSI escape codes.

These codes provide a way to change the foreground and background color of text by adding additional characters to the beginning and end of a string. In the below image, you can see the different number codes (especially 90, 92, and 93, which will be used later in the program) - how these codes are used is explained below.

Source: Wikipedia

ANSI escape codes for creating colored text are created in the following manner.

"\27[COLORm" .. text .. "\27[0m"

A color code itself is a string in the format \27[COLORm - where COLOR is the code found above in the table. The string above is formed when I color the text (\27COLORm), append the text (text), and append a default color code (0) to make sure the original code doesn't affect anything except the text I've specified it to.

I created a function in Lua to do just this. It takes an uncolored string and a color code, and returns the colored string (remember, it can be stored as a string because all it is is an extra padding on the front and back of the original string).

function colorText(text, color)
    return "\27[" .. (color or 0) .. "m" .. text .. "\27[0m"
end

I also made some global variables representing the color codes, to make it easier to understand in the code itself. Any time you can avoid using magic numbers like 90 or 92, go for it.

GRAY, GREEN, YELLOW = 90, 92, 93

Coloring Words

This is pretty heavy, so bear with me.

The classic Wordle coloring is as follows.

Green if the letter is in the right place in the word.
Yellow if the letter is in word, but in the wrong place.
Gray if the word does not contain the letter in any place.

I've come up with the following scheme to color words according to the pattern.

Iterate through the word. If the current character is the same in both the target word and the guessed word, mutate both the strings to have "-" instead of that character in that position. Finally, color the letter green and push it to a table, indexing it at the same position as it was in the string.
Iterate through the word again. If the current character is in both the target word and the guessed word, do the same replacement, color the letter yellow, and push it to the table at the same indexed position as it was in the string. If the check fails and the letter is not in each word, color it gray and push it in the same fashion.
Return the table, concatenated so that it forms a single, multicolored string.

Here's the function I came up with that accomplishes this.

function colorWord(word, target)
    str = {}
    word, target = string.upper(word), string.upper(target)

    for i = 1, #word, 1 do
        char = string.sub(word, i, i)
        
        if char == string.sub(target, i, i) then
            word = string.sub(word, 0, i - 1) .. "-" .. string.sub(word, i + 1, #word)
            target = string.sub(target, 0, i - 1) .. "-" .. string.sub(target, i + 1, #target)
            str[i] = colorText(char, GREEN)
        end
    end

    for i = 1, #word, 1 do
        char = string.sub(word, i, i)

        if string.find(target, char) ~= nil and char ~= "-" then
            word = string.sub(word, 0, i - 1) .. "-" .. string.sub(word, i + 1, #word)
            str[i] = colorText(char, YELLOW)
        elseif str[i] == nil then
            str[i] = colorText(char, GRAY)
        end
    end

    return table.concat(str, "")
end

It's a bit convoluted, but it accomplishes the purpose (as far as I've seen). My algorithm might just be super inefficient - a possible circumstance.

Drawing the Table

Drawing the classic Wordle grid is easy - we'll create six lines based off the gameTable table and just fill the line with "-----" if there's no grid entry. Finally, we'll color the line with our colorWord function to create the actual color outputted to the terminal.

In addition to this, I also wanted to make it look good by creating a fancy text box around it. Check out the function below, which I think creates some pretty decent output.

function drawTable(refTable)
    print(" _________ ")
    print("|         |")

    for i = 1, 6, 1 do
        print("|  " .. (colorWord(refTable[i] or "-----", mystery_word)) .. "  |")
    end

    print("|_________|")

end

Validating Guesses

To validate guesses, we have to confirm two things: that the word is five letters long, and that the word is found in our word bank of legal words. I've created another function to handle this - it's pretty straightforward and gets the job done.

function validateGuess(guess)
    return #guess == 5 and word_bank[string.upper(guess)] ~= nil
end

Game Loop

Now it's time to actually get the game running. We'll start by initializing a few variables to keep track of the game state.

counter = 0 -- number of guesses used
gameTable = {} -- table holding all the guesses
msg = "\nWelcome to Wordle! Type a five-letter word to start." -- message displayed

I snuck a message variable in there because we're going to use it later - I think the game makes more sense when I'm giving the user details about what they're doing (in the future, it'll display error messages for repeats and invalid words).

Here's the main loop. I'll explain bits and pieces are we go.

while counter < 6 do

    io.write("\27[2J\27[1;1H")
    drawTable(gameTable)
    print(msg)

    io.write("Enter a guess: ")
    userGuess = string.upper(io.read())

    if validateGuess(userGuess) then
        if word_bank[userGuess] then
            table.insert(gameTable, userGuess)
            word_bank[userGuess] = false
            msg = ""

            if userGuess == mystery_word then
                break
            end

            counter = counter + 1
        else
            msg = "\nYou already guessed that - try another word."
        end
    else
        msg = "\nThat's not a valid word according to the list."
    end
    
end

While there are still guesses to go (up to six, just like in the original Wordle), we'll do a few things.

io.write("\27[2J\27[1;1H") clears the terminal. It's an easy way to declutter some of the hustle and bustle of the screen, and I like using it for games like this - it really smooths everything out and adds that extra sparkle to the finished product.
Draw the table (drawTable) and print our message.
Grab the user's guess, store it, and convert it to uppercase (string.upper).
If the guess is a valid one according to the validateGuess function, we'll check if it's contained in the word bank and if it hasn't been used before (word_bank[word] == false means that it's been used and so the current guess is a repeat - in this case, we'll issue the first error message from the top about the repeated word).
If all of the above is true, then we'll put the guess in gameTable, set the value in word_bank to false, and set the message to a new line (no special message required). If the guess is completely equal to the mystery chosen word, we'll break out of the loop and go straight to the end screen (more on that in a bit). If it's not completely equal, we'll increment the counter by 1.
If the message isn't a valid word (according to the validateGuess function), we'll issue the last error message about an invalid input.

With that, we've completed our main game loop. Let's move on to the last part of the game, creating our end screen.

End Screen

The function to write our end screen to the console takes a single variable, the guesses counter that keep track of how many guesses have been used in the game. Let's take a look.

function endGameScreen(guesses)
    io.write("\27[2J\27[1;1H")
    drawTable(gameTable)
    print("")

    if guesses >= 6 then
        print("That's too bad! The word was " .. mystery_word .. ".")
        print("Better luck next time :)")
    else
        print("That's right! The word was " .. mystery_word .. ".")
        print("It took you " .. guesses + 1 .. (guesses ~= 0 and " guesses. Nice!" or " guess. Wow!"))
    end
end

At the start, we clear the terminal and draw the game table (drawTable). After, we move to a conditional that describes two cases - a win and a loss.

If the number of guesses used is greater than or equal to 6, we know the user has lost (because the guesses passed starts at 0, so 6 real guesses is equal to a value of 5). In that case, we print the mystery word and issue a consolation.
If the number of guesses is in the winning number (0-5), we know that the user has won and issue a celebratory statement (grammatically altered because I need it to be absolutely correct for all edge cases).

With that, the program is completed.

Code and Conclusion

I'm not going to overwhelm you with the full 100+ lines of code here, but I'll encourage you to check it out in the GitHub repository (along with code for two other mini-projects I built this month).

Stay tuned for a final project coming at the end of the month, where I'll be using the LOVE2D game engine to create a game with a GUI (should be a refreshing change from console apps)!

Enjoyed this post? Check out some others from this month!

Lua Quick Reference

DR — Fri, 05 Jan 2024 20:19:54 +0000

Quick Links

Basics
Operators
Conditionals
Loops
Functions
Tables
Files

Basics

Console Output & Comments

print("Hello, world!") -- This is a comment.

Variables

local a = "String type"
b = true -- global
c, d = 5, nil

print(type(c), type(d)) -- number    nil

Strings

a = "Double"
b = 'Single'
c = [[
multiline
string
]]

string.upper(a)   -- DOUBLE
string.lower(a)   -- double
string.reverse(b) -- elgniS
string.len(b)     -- 6
#b                -- 6
a .. b            -- DoubleSingle

Operators

Arithmetic

a, b = 10, 5

a + b -- 15
a - b -- 5
a * b -- 50
a / b -- 2
a ^ b -- 100000.0
a % b -- 0
-a    -- -10

Relational

a, b = 4, 6

a == b -- false
a ~= b -- true
a > b  -- false
a < b  -- true
a <= b -- false
a >= b -- true

Logical

a, b = true, false

a and b -- false
a or b  -- true
not b   -- true

Conditionals

if condition then
    statements()
elseif other_condition then
    statements()
else
    statements()
end

Loops

`while` loop

i = 0

while i < 10
do
    print(i)
    i = i + 1
end -- returns 0, 1, 2, 3, 4, 5, 6, 7, 8, 9

`for` loop

for i = 0, 10, 1
do
    print(i)
end -- returns 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10

`repeat` loop

i = 0;

repeat
    print(i)
    i = i + 1
until i > 10 -- returns 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10

`break` statement

for i = 10, 0, -1
do
    print(i)
    if i == 5 then
        break
    end
end -- returns 10, 9, 8, 7, 6, 5

Functions

function average(num1, num2)
    return (num1 + num2) / 2
end

print(average(10, 20)) -- 15.0

Tables

fruits = {"Banana", "Orange"}
print(fruits[1]) -- Banana

-- Removing elements

fruits[3] = "Apple"
table.remove(fruits) -- Apple
print(fruits[3]) -- nil

table.remove(fruits, 1) -- Banana
print(fruits[1]) -- Orange
print(#fruits) -- 1

-- Inserting elements

table.insert(fruits, "Mango")
table.insert(fruits, 2, "Papaya")

print(fruits[2]) -- Papaya
print(#fruits) -- 3

table.concat(fruits, " and ") -- Orange and Papaya and Mango

table.sort(fruits)

for key, value in ipairs(fruits) do
    print(key, value)
end

--[[
1       Mango
2       Orange
3       Papaya
]]

Files

Implicit

-- Writing

file = io.open("test.txt", "w")
io.output(file)

io.write("This creates a file and writes this line at the top!")

io.close(file) -- true

-- Reading

file = io.open("test.txt", "r")
io.input(file)

print(io.read()) -- This creates a file and writes this line at the top!

io.close(file) -- true

-- Appending

file = io.open("test.txt", "a")
io.output(file)

io.write("Appending to the test file!")

io.close(file) -- true

Explicit

-- Writing

file = io.open("test.txt", "w")

file:write("This creates a file and writes this line at the top!")

file:close() -- true

-- Reading

file = io.open("test.txt", "r")

file:read() -- This creates a file and writes this line at the top!

file:close() -- true

-- Appending

file = io.open("test.txt", "a")

file:write("Appending to the test file!")

file:close() -- true

The Lua Tutorial

DR — Fri, 05 Jan 2024 13:00:00 +0000

Introduction

My goal for this post is to run through the basics of the Lua scripting language. This is stuff I've learned over the past few days, and it's not the deepest explanation you'll ever see, but it's how I'm interpreting the language so I'll note it that way.

If you haven't set up an environment or don't really know what I'm talking about, I'd recommend reading my last post that went through our main goals and installation processes.

And no, I don't fully intend for you to read this one top to bottom. It's a lot of stuff, and probably pretty dry unless you like learning languages in an hour (which I've tried, it's not fun). It's for your reference - not for a thrilling read.

That being said, it's the springboard for interesting things that I'll be making in the coming month, so it's important. Additionally, if you've ever wanted to learn Lua (or any other language I'll be playing with over the year), now's the time! I'm putting all of this material out there in the hopes that someone will find it useful - even if not today, then maybe in the future.

Without further ado, let's get into Lua.

Basics

The print function outputs a line to the console. If multiple parameters are passed, it prints each one on the same line with a tab character (\t) as the delimiter. This function outputs any data type with a type coercion to string similar to JavaScript.

print("Hello, world!") -- "Hello, world!"
print(1, 2, 3)         -- "1    2    3"

You might also notice the -- next to the intended output - that's a comment. Comments, as in any other language, aren't executed when it comes time to run the code. This makes them useful for explaining why the code works in human language without having the computer try to understand them.

Variables are relatively simple - there's no explicit type declaration, and there are only a few technical things to keep in mind when declaring and assigning them.

x = 5 -- global variable x is initialized with a value of 5

do
    local x = 10 -- local variable x is initialized with a value of 10
    print(x) -- 10
end

print(x) -- 5 (global value)

A variable's scope is determined by its block (the do..end in the code simply creates another block, similar to {} in JavaScript). Local variables are limited to their chunk or block, while global variables are available throughout the namespace.

I'll quickly note that Lua allows multi-variable assignment in one line, unlike some other notable languages.

a, b = 5, 4 -- a is now equal to 5, b is equal to 4

Now, we can talk data types - classifications for the data that variables hold. There are four basic data types in Lua - strings, numbers, Booleans, and nil.

Strings

A string is an immutable sequence of characters which can be declared with single quotes, double quotes, or double brackets.
When using single or double quotes, you can use escape characters to use quotes and other escape sequences (full list found here).

single = 'It\'s a string.'
double = "This is also a \"string\"."
bracket = [[
Here's a multiline string.
Escape characters don't work in here!
]]

print(single)
print(double)
print(bracket)

--[[

Output:

It's a string.
This is also a "string".
Here's a multiline string.
Escape characters don't work in here!

]]

It may also be noted that --[[ comment ]] is a multiline comment. This might make more sense now that double bracket strings have been introduced, because in the grand scheme of things it's just commenting out a multiline string.

Numbers

A number stores a numeric value (positive, negative, and zero) in a double-precision floating-point form. Constants may include optional decimal and exponent parts.

num_1 = 3
num_2 = 1.23
num_3 = 4e+2 -- 4 * 10^2

print(num_1)
print(num_2)
print(num_3)

--[[

Output:

3
1.23
400.0

]]

Booleans

A Boolean value represents true or false. When other values are tested in a condition, everything except false and nil evaluate to true.

bool_true = true
bool_false = false

print(bool_true)
print(bool_false)

--[[

Output:

true
false

]]

Nil

nil is the absence of a value. It's assigned to global variables by default, and you can assign it to a global variable to, in essence, delete it.

nil_value = nil

print(nil_value)

--[[

Output:

nil

]]

As a final note, you can use type to get the data type of any variable.

str = "hi"
num = 4
bool = true
n = nil

print(type(str))
print(type(num))
print(type(bool))
print(type(n))

--[[

Output:

string
number
boolean
nil

]]

Operators

Operators perform operations on data. Whether it's in variable form or a constant value, Lua provides several helpful operators spread among three main categories that lend needed functionality to the language.

Arithmetic

This is the kind that we're all familiar with: plus, minus, multiply, divide. Simple math concepts that make it possible to put that calculator logic into your programs.

We'll start this entire operator section with two variables: num_1 and num_2.

num_1, num_2 = 11, 2

Note that we're using the multi-variable assignment pattern, mentioned earlier in our discussion of variables.

There are seven main arithmetic operators in Lua: +, -, *, /, ^ (exponentiation), % (modulus or remainder), and - (negation). Yes, the negation and subtraction operators are the same symbol - don't get them confused. One is used in a unary fashion on one variable (negation), and the other is used to combine two pieces of data (subtraction).

print(num_1 + num_2) -- 13
print(num_1 - num_2) -- 9
print(num_1 * num_2) -- 22
print(num_1 / num_2) -- 5.5
print(num_1 % num_2) -- 1
print(num_1 ^ num_2) -- 121.0 (converts to float)
print(-num_1) -- -11

There's also an eighth, newly added operator that does floor division or integer division (//). However, it's only available in versions 5.3 and up, so in an effort to be inclusive to all versions I'll just be going about the old divide-and-round-down method.

Relational

Relational operators compare data instead of performing an operation on it as the arithmetic operators do. They're the ones that we'll use in things like conditionals and loops, because they return a Boolean value that evaluates to true or false.

There are six of these: == (equal), ~= (not equal), < (less than), > (greater than), <= (less than or equal to), and >= (greater than or equal to).

print(num_1 == num_2) -- false
print(num_1 ~= num_2) -- true
print(num_1 < num_2) -- false
print(num_1 > num_2) -- true
print(num_1 <= num_2) -- false
print(num_1 >= num_2) -- true

Logical

Logical operators work with Boolean values to give programs a structured logic. Using and, or, and not, we can create more complex conditional checks and combine the operators we have already for more readable code.

-- The and keyword returns the first argument if it is false and the second argument otherwise.
print(num_1 and num_2) -- 2
-- The or keyword returns the first argument if it is true and the second argument otherwise.
print(num_1 or num_2) -- 11
-- The not keyword returns the opposite (true -> false, false -> true) of the given value.
-- Any value except nil and false itself is treated as a true value.
print(not num_1) -- false

Miscellaneous

There are an additional two operators that I'll note: .. and #.

The concatenation (..) operator combines two strings. The # operator gets the length of a string or table (another data structure we'll get to in a second).

str_1, str_2 = "This is one half", "and this is the other half."

print(str_1 .. " " .. str_2) -- This is one half and this is the other half.
print(#str_1) -- 16

Control Structures

The first basic type of control structure is a conditional. This is the classic if-else block that many programmers will recognize from other languages. The formatting is similar to many other scripts as well, with a few differences. Here's the main form.

if condition then
    -- condition == true
elseif other_condition then
    -- other_condition == true and condition == false
else
    -- other_condition == false and condition == false
end

This example obviously includes all three keywords: if, elseif, and else. In reality, all you need is the if to create a conditional, but these extra are provided to give more depth. As with other languages, you can create as many elseif conditions as you need. Just remember to cap it with an end to show that the block has completed!

Here's one more example for good measure.

num_1 = 5
num_2 = 2

if num_1 > num_2 then
    print(num_1 .. " is greater than " .. num_2)
elseif num_1 < num_2 then
    print(num_1 .. " is less than " .. num_2)
else
    print(num_1 .. " is equal to " .. num_2)
end

Besides conditionals, Lua also offers three types of loops: while, for, and repeat.

The while loop takes a condition and loops through a set of given statements until the condition is true. It is worth noting that the statements are initially only executed if the condition is true; if it is false then they won't be executed at all and the program will continue onward.

i = 0

while (i < 10)
do
    print(i)
    i = i + 1
end -- returns 0, 1, 2, 3, 4, 5, 6, 7, 8, 9

Note the do...end statements, creating a block of code.

The for loop takes a series of conditions and executes a group of statements a known number of times (given by the conditions). It's generally used for when we know the number of times that we need to iterate through, whether that's a hard-coded constant or a variable.

for j = 0, 10, 1
do
    print(j)
end -- returns 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10

The conditions work like this: in the first argument, we pass a variable that will be manipulated by the loop structure. The second argument is a cap that ends the loop when the first initial variable gets to it. The third is the step value, which can be negative as well as positive. If you're confused, here's the official reference page which clears some things up.

The repeat loop is a while loop that checks at the end instead of at the beginning. It has a completely different set of use cases, but it's still aimed at situations where we don't know the exact number of iterations.

k = 0;

repeat
    print(k)
    k = k + 1

    if (k == 7) then
        break;
    end
until (k > 10) -- returns 0, 1, 2, 3, 4, 5, 6

You'll notice that I also made use of the break keyword. When used in any of these three loops, execution of the statements is immediately halted (as we can see with the example above).

Functions

Functions in Lua are relatively straightforward. A simple function in any language has a few basic components: a name for future use, a place to include parameters from outside the function, and a way to return values from the function to the outside sphere. Lua includes all three of these in a basic function format.

function square(number)
    return number * number
end

print(square(3)) -- 9

Note the classic Lua form of creating a new chunk between the function and end keywords. This of course also means that number is undefined outside of the function, so don't try to access it.

As a side note, parameters that are not filled relapse to a value of nil - so keep track of your function calls to avoid any unexpected behavior!

Tables & Iterators

There's only one advanced data type in Lua - and it's not an array, object, dictionary, or tuple. It's called a table, and it's a flexible listing option that combines the best of several advanced data types in other languages.

The #1 thing to remember when dealing with tables is that they're indexed starting at 1. If you create a table like the one below, you might be surprised at what this means.

fruits = {"Banana", "Orange", "Apple"}
print(fruits[1]) -- Banana

However, they also function similarly to JavaScript objects in that you can set values equal to certain keys without listing the values or keys in the original object. My favorite part of this? We can use all sorts of odd characters (even emojis!) to represent keys.

fruits = {"Banana", "Orange", "Apple"}
fruits["🥭"] = "Mango"

print(fruits[1]) -- Banana
print(fruits["🥭"]) -- Mango

To remove an element, use the table.remove method. This method has one optional parameter (the 1 below), showing which element to remove. If this isn't specified, it removes the last item.

fruits = {"Banana", "Orange", "Apple"}

print(fruits[1]) -- Banana
print(#fruits) -- 3

table.remove(fruits, 1)

print(fruits[1]) -- Orange
print(#fruits) -- 2

To insert an element, use the table.insert method. This method has one optional parameter. Usually, it'll take two: the table to alter and the value to add, but it can also take a third which is an index.

fruits = {"Banana", "Orange", "Apple"}

print(fruits[1]) -- Banana
print(#fruits) -- 3

table.insert(fruits, "Mango") -- insert Mango to the fruits table at the last index
table.insert(fruits, 1, "Papaya") -- insert Papaya to the fruits table at index 1

print(fruits[1]) -- Papaya
print(#fruits) -- 5

To put the entire table into a string, use table.concat. This method combines all of the values into a single string using an optional delimiter.

fruits = {"Banana", "Orange", "Apple"}

print(table.concat(fruits)) -- BananaOrangeApple
print(table.concat(fruits, " and ")) -- Banana and Orange and Apple

To sort a table, use table.sort.

fruits = {"Banana", "Orange", "Apple"}

print(fruits[1]) -- Banana
table.sort(fruits)
print(fruits[1]) -- Apple

Iterators

Often when we're working with tables, we want to iterate through them in order to perform some sort of action or maybe just print the whole thing accurately. For this purpose, I present the iterator.

fruits = {"Banana", "Orange", "Apple"}

for k, v in ipairs(fruits) do
    print(k, v)
end

--[[

1       Banana
2       Orange
3       Apple

]]

Using ipairs, we can quickly loop over tables. More importantly, we have the exact values of each key and value - which will come in more use when we start building bigger programs.

Alternatively, you can go the primitive route - which gets the same result. I'd encourage going with the industry standard and using ipairs, though.

fruits = {"Banana", "Orange", "Apple"}

for i = 1, #fruits, 1 do
    print(i, fruits[i])
end

--[[

1       Banana
2       Orange
3       Apple

]]

File I/O

When dealing with reading and writing to files in Lua, we have two choices: either implicit or explicit file descriptors. They both use the same io library, but are accessed in different ways.

Let's look at implicit first.

file = io.open("test.txt", "a")
io.output(file)

io.write("Writing to the test file!")

io.close(file)

Firstly, Lua will create a file if one isn't already existing. Secondly, we open the file in append mode ("a"), and set the output to that file. In explicit descriptors, we'll skip this step. Finally, we'll write a line to the file and close it to prevent leaks.

Explicit file descriptors are only a bit different. Here's the exact same example with them implemented instead of the implicit style.

file = io.open("test.txt", "a")

file:write("Writing to the test file!")

file:close()

As you can see, it's much shorter because we're directly calling the methods on the file. In addition, it's easier to manage when you're reading and writing from and to multiple files at once, because you don't have to keep calling io.output with each different name.

I/O in Lua is a fascinating concept, which I'm hoping to explore more deeply in the future. If you're curious, here's the official documentation for the io library as well as more example for usage.

Conclusion

2,900 words later, I've reached the end. But this is really only scratching the surface. My respect for this language has definitely grown - it's fun to compare it to other languages and see what's the same and what's different.

So what's after the basics? We're going to start making programs (small ones to start with). For the next week, I'll be making programs to test my newfound knowledge - I'm posting them all with the code next Friday, don't miss it.

Until then... I'm going to go take a nap. Cheers!

Hey there! Thanks for reading my post. If you enjoyed, leave a like and share 💖

If you're new to the series, I'm breaking down twelve popular programming languages over the year of 2024 and exploring what they have to offer as opposed to others. This is, of course, a valiant attempt to revive my programming "career" and publish interesting content.

Want to keep up with my shenanigans? Check out the GitHub repository, which is where I'm stockpiling my projects over the year. You can also follow me here on DEV to get my latest posts straight to your notifications!

Gearing up for Lua

DR — Mon, 01 Jan 2024 13:00:00 +0000

Introduction

From 2022 to 2023, Stack Overflow tracked changes in the popularity of a bunch of programming languages via their annual survey (excellent reading, if you haven't already). Many of them hopped up or down one or two spaces on the global leaderboard, but only one leaped up an impressive seven spaces. This language is commonly used to make games, is fast and cross-compatible, and has a simple syntax comparable to Python or Ruby.

Any guesses?

This month, we're talking about Lua. It's not always a first choice when it comes to programming, but I think there's a lot to enjoy about this little language. Heck, I'm a big game development fan myself - I would look into it even if that was the only reason to.

I'm not going to talk your ear off with the history - here's a short video that takes you through the basics, if you're curious. Focus on the big picture, we're talking syntax later.

And here's their official explanation that talks about where it came from and what it's used for. Overall, I'm super excited to work with this language and I totally lucked out getting this instead of something like Rust or C++ to start with.

Ecosystem

Lua doesn't have a super expansive community around it like other, more popular, languages, but it's got a couple of neat features that make it worth playing around with.

LuaRocks is a package manager for Lua modules, similar to npm in JavaScript or pip in Python. It's free software and allows you to "create and install Lua modules as self-contained packages called rocks" (downloadable on Unix and Windows systems). I'm not going to be using it heavily, but I'm hoping to be able to play around with it later this month.

Programming Gems is a collection of some articles detailing how to program well in Lua. It's also freely available on the Lua website, and though it's a bit random, you might find something fun to play around with.

If you're familiar with awesome-lists, you'll be happy to know that an awesome-lua repository does in fact exist. This list contains more interesting stuff about the language, along with going deeper into certain niches that I'm not even going to start to touch.

Lua is also useful in that it plays well with C (partially because much of it is built in ANSI C to begin with). I won't be touching on this much, but there look to be a bunch of interesting articles on the topic you could investigate deeper (here's one to get you started).

Probably the most important piece of software we'll be playing around with is a game engine called LÖVE. Lua is well known around developer circles as being a good scripting language when it comes to making games, and this engine is one of the more popular. I'll be going through installation at the end of this post.

System

I'm running code for the year on a WSL 2 setup (Windows 10) with VSCode. Terminal snippets are aimed at Unix, but it's easy to translate to Mac or Windows itself if you don't want that specific workflow.

Alternatively, you can always set up a target environment online that comes with the language preinstalled. This works well for me in particular when I'm on a machine that isn't mine (school laptop, etc.) that I don't want to mess with.

Replit (https://replit.com/new/lua)
OneCompiler (https://onecompiler.com/lua/)
myCompiler (https://www.mycompiler.io/online-lua-compiler)

My top pick here would be Replit because of the expanse of their features, including a shell so you can run commands similarly to what I'll be doing. However, hardware limitations cap pretty quick on the free tier, so don't expect to run anything huge.

This month...

This month, I'm working with Lua. This post is the first of five that will take you through my learning process, over which I'll be talking about the language and building some cool side projects.

Here's our timeline, for anyone who's curious.

1/1: Introduction
1/5: Syntax exploration (technical knowledge) and cheatsheet
1/12: Mini-projects and code released
1/29: Final projects and code released
1/31: Wrap-up and next month's language

Alright, let's get coding!

Installation

Lua

As per the official website, here's how to get the latest version of Lua installed on your machine.

curl -R -O http://www.lua.org/ftp/lua-5.4.6.tar.gz
tar zxf lua-5.4.6.tar.gz
cd lua-5.4.6
make all test

From there, it should be as simple as running lua --version to see if you're up and running.

If this doesn't work for you, you might try this alternative version.

sudo apt update
sudo apt install lua5.4

This can be tested the same way, or just use lua to start an interactive shell session (similar to Ruby or Python, if you're familiar with either).

If you're still having problems, you could head to their downloads page and see if you can find any more relevant information. Both of these worked for me so I'm not going into any more depth, but additional resources do exist. These will also come in handy if you're not on a Unix system.

LuaRocks

Specific instructions to download LuaRocks can be found on their website, but here's the quick start that should work for Unix systems.

$ wget https://luarocks.org/releases/luarocks-3.9.2.tar.gz
$ tar zxpf luarocks-3.9.2.tar.gz
$ cd luarocks-3.9.2
$ ./configure && make && sudo make install
$ sudo luarocks install luasocket
$ lua
Lua 5.3.5 Copyright (C) 1994-2018 Lua.org, PUC-Rio
> require "socket"

This depends on Lua being installed, so make sure to do that first (instructions above!).

LÖVE2D

If you have Lua installed, you can easily install LOVE with a few shell commands.

sudo add-apt-repository ppa:bartbes/love-stable
sudo apt update
sudo apt install love

Test with love --version.

Small note.
When I ran these and then tried to launch a window with the love command, it gave me an error similar to this. This is 100% because of WSL and so if you're not using it, feel free to ignore.

Unable to create OpenGL window 
This program requires a graphics card and video drivers which support OpenGL 2.1 or OpenGL ES 2.

A simple fix (thanks GPT!) is running this code.

sudo apt install libgl1-mesa-glx

WSL can be tricky sometimes. Check the manual or search around if you're using it and come upon a problem, they're usually easier to fix than they look.

As always, if you're having issues, their site might be a good place to start.

Conclusion

So that's the Lua installation. A bit rough around the edges, but not super hard.

Join me on Friday (1/5), where I'll be talking about how to start your coding journey with your newfound materials and giving you a free cheatsheet to keep these ideas fresh in your mind.

Happy coding and have a great end to your holidays :)

Hey there! Thanks for reading my post. If you enjoyed, leave a like and share 💖

1 Year. 12 Languages.

DR — Thu, 28 Dec 2023 01:36:54 +0000

Introduction

2024 is almost here, and it's resolution season. Many have already started to set goals for the coming year, which vary widely from improving fitness to traveling more (there's an interesting Forbes article about the specifics of this year's targets, if you're interested).

It's a bittersweet year for me, because it's my last full year in high school. That means that I'm definitely not going to have as much time as I used to for things like learning programming at my own pace in the future. I've toyed with the idea of learning something new for a while now, but I've consistently lacked a drive to put in the work of teaching myself a whole new language.

So... I've decided this is the year. Why put it off any longer?

But I wondered what exactly would be the best use of my time. I had a couple of things I wanted to complete as a developer that were in the back of my mind, but I wasn't sure how to prioritize or exclude as to make the most of the year.

Complete freeCodeCamp certifications for front-end development.
Learn Rust, Python, Ruby, and C++.
Start blogging again (creating content once or twice a week).

Besides from these smaller goals, I also wanted to determine once and for all if learning to code was a universal language - if the concepts I learned in one language could enable me to easily pick up another.

Plans?

In the end, I've decided to take a route that I believe will hit the majority of my personal goals as well as give me valuable experience with new languages and beef up my toolkit.

I'll be exploring a new language for each month of 2024.
These languages aren't specifically beginner-friendly, they're just ones that I've been wanting to take a look at for a while now.
And of course, I'll be posting updates in the form of a blog post every so often.

For each language, I'll be taking you on a syntax deep dive followed by a bunch of mini projects and one final project. While I can't explain the full depth of a language's complexity in just a month, I'll make sure to cover important topics and what you need to get started.

At the end of the year, I'll come back around with a reflection of my year in code and see if I'm able to answer the universal code question.

Topics

Here's the full list of languages so you can see what's on the radar. I won't necessarily be doing them in this exact order, but they're all on a wheel that I'm going to spin each month to pick.

Python
TypeScript
C#
C/C++
Go
Lua
Rust
Kotlin
WebAssembly
Zig
Ruby
Bash

If you're curious about where I'm at during any point, check the GitHub repository (the first language drop is already live, check it out!). This is where I'll be keeping all the code for the project and it'll be updated frequently as I complete things.

Onward

I'm super excited that you're joining me on this journey! Please chime in with any thoughts about topics to cover or things I'm doing wrong - I'm still a beginner too, and expert opinions are invaluable.

Without any further ado, let's get this series started. Make sure to follow and stay tuned for the January kickoff, dropping 1/1/2024.

Happy New Year! 🎆

So I might be doing this wrong...

DR — Fri, 06 Oct 2023 13:44:10 +0000

Introduction

We're six days into Hacktoberfest, and I'm quickly realizing that my goals are going to be a bit harder to reach than I initially envisioned.

Why?

I'm pretty new to open source. Not an expert, but I know about the workflow and how to do the simple stuff like make a PR.

So in theory, I'm technically capable of doing this. 100%.

The issue that I've been combating for the past week hasn't been technically challenging, it's been more of a mental struggle. I'm always hearing that open source needs more contributors, but looking around at repositories I find that every issue that is manageable is always being snapped up before I get to it.

Is this a problem on my end? Should I be quicker on the uptake when issues are posted? Am I not looking hard enough?

What I'm doing

My current Hacktoberfest finding schema looks something like this.

Go to the Hacktoberfest projects site.
Sort the projects by JavaScript, and find the ones that have between 0 and 50 stars.
Sort by most recently updated.

And honestly, I've been getting a whole bunch of this.

I actually contributed to one, but it got shut down a few days ago because it turned out that repos like it were generating a ton of low quality contributions.

So what do I do? I'm being told that there's plenty of work, I'm not finding anything obvious to work on that fits with the values of the event.

What am I doing wrong?

So I've thought about it, and I've come to a conclusion.

Issues that are listed aren't the only things to fix.

This made sense. An issue on my end was that everything that was documented was being snatched up; everything that was on the table was being taken too fast.

What if I took something that wasn't on the table?

A new feature, a typo in the content, etc. Something that no one has noticed yet.

Tackling things like these would let me contribute 1) to something other than a list of stuff, and 2) with a guaranteed issue.

Going forward

I've got 26 days left (including today, because you can always do something valuable with the time in front of you). That's plenty of time to find contributions in the wild. Fingers crossed.

Anyone else have thoughts on contributing to the event? Where are you finding your repositories?

As always, thanks for reading and have a great rest of your day!

Hacktoberfest Pledge 🎉

DR — Wed, 27 Sep 2023 12:56:18 +0000

So... Hacktoberfest is starting again.

And this is fantastic news! This year celebrates the 10th year of the competition's existence, and I'm super hyped to actively participate this year.

About

For those who are unaware, Hacktoberfest is a month-long tribute to open source. During the duration of the event, participants are encouraged to make four high-quality PR/MRs to open source codebases.

If you don't do open source normally, the event serves as a great way to break into the community with your first contribution - spurred on by rewards. Though there's no merch this year, you can still win a digital badge pack and maybe get a tree planted in your name!

Finding Codebases

One of the problems I run into the most is finding that first repository to contribute to.

Luckily for us, there are a bunch of repositories that have open pickings. You'll have to move quick, but if you play your cards right you should find plenty of issues to fix.

Don't know how to code as well as the pros? Hacktoberfest is encouraging low-code and no-code contributions this year. Doing open source doesn't always involve getting your hands dirty inside the complex workings of the base itself - sometimes there are little things like documentation that need things to be fixed or clarified.

You can start finding repositories to contribute to at a few locations - these are my favorite.

In addition, the official Hacktoberfest page provides more sources.

How to contribute

So you're ready to start. Step zero will be registering for the event, which you can do on the official page. Then, you'll need to find a repository you can contribute to.

There are a few basic steps to contributing to a repository on GitHub or GitLab. There have been many tutorials made on it, so I'm not going to waste words here. However, I'll say that if you're interested in learning how the flow works, you should check out these tutorials.

Once you're done, you can make your first contribution - and you can do it right now.

You'll need to find a first contributions repository (I used this one), and from there it'll be pretty self-explanatory. Good luck - you'll do great!

Pledge

This year, I'm going to push myself out of my comfort zone and attempt to complete the challenge in its entirety. Last year, I joined the event super late to the game and only had about a week to do my four PRs. I only officially ever finished one, but it was a helpful start and gave me some hints as to how the GitHub flow works.

I'll be posting updates occasionally as to where I find my PRs, and at the conclusion of the month I'll be posting a wrap-up - be sure to follow so you don't miss anything!

Are you joining Hacktoberfest? What do you hope to get out of it?

Here's to open source! 🎃

Post-Vacation Pull Request

DR — Thu, 29 Jun 2023 10:51:02 +0000

So I just got home from vacation.

What better way to ease back into my normal life than to contribute to an open source project?

The issue with that is that usually everything that someone of my abilities could tackle has already been snapped up.

Guess what? I found an untouched repository with absolutely zero code contributions required. You're welcome.

I made a request, and I never make requests. It's that easy.

Go check out the original post about making an impact in open source here.

Happy contributing! ✌

6 Must-Try Coding Problem Websites 💻

DR — Sat, 10 Jun 2023 15:53:13 +0000

Do you know your language?

No, really.

A lot of us (myself included) can learn the basics of a programming language and think that we've mastered every possible dimension.

And while all you really need are the basics to get started, it's helpful to test your newfound knowledge as you begin to dive deeper into the specific technicalities of your particular choice.

To test, we'll turn to some of the simplest free resources out there - coding practice problems. Solving these problems turns a threefold profit: gaining experience with your particular language, strengthening your problem-solving and critical thinking skills (take that, AI!), and in some cases learning about and becoming comfortable with DSA (tech interviews, anyone?).

And yes, LeetCode isn't the only option.

Ready to get started? Let's explore this list of my favorite coding practice sites.

Codewars

I really love the Codewars platform. Why?

They're really fun problems. While other platforms might have you finding primes under 1000, Codewars features unique problems like Vigenère cipher cracking and fraction/mixed number converters.

The system revolves around "honor", a measurement of your contribution to the platform and your competency at solving kata (practice problems).

It features many different language options and opportunities to contribute your own solutions once you solve enough kata, besides from their remixing/refactoring challenges called Kumites.

Get stuck on a problem and need help? There's an active Discord community that's ready to point you in the right direction.

There is a paid plan, Codewars Red, which goes for about $48 USD a year - but the subscription is not required to have a blast on the platform with all the free offerings.

Codewars also connects developers searching for a job with opportunities through their platform Qualified Jobs, so if you're looking for hire then you might want to make an account and check around.

CodinGame

This is probably my top pick to spend time on as of the time I'm writing this post.

CodinGame was introduced to me probably about a month ago by one of my friends, who was just enthralled about the code golf aspect of it. I'm actually writing another post right now about golfing and Ruby, make sure to drop a follow so you don't miss it.

The platform revolves around games. It's learning - through gaming. And who doesn't like games? Whether you're clashing it out with other coders around the world to solve a coding problem or personally optimizing a particular solution by yourself, it's super fun to do.

Plus, it gives me the satisfaction of seeing that I'm currently in the top 2% of all users (that's worth a friend request, right?) with their live ranking system. This is a great touch that's missing from a lot of other platforms, but if you're not one for competition it might not be a great choice.

CodinGame also provides certifications to prove your skills that measure things like speed, efficiency, and proficiency in a certain language.

LeetCode

Here's the classic. Pretty much everyone knows about LeetCode's platform nowadays, and for good reason. It's an expansive library of over 2500 questions grouped into topic-specific lists. Mainly used for interview preparation, it's also a good platform to just spend time working through problems for the sheer knowledge about problem-solving and DSA you'll learn.

But fear not, you don't have to just do problems from 1 onward. LeetCode offers fun contests and incentives frequently as a reason to solve challenges. I recently participated in the 30 Days of LC challenge, from which I earned 100 LeetCoins (LC currency which can be used to exchange for rewards) and a whole lot of knowledge.

The platform does offer a paid plan, which though pricey ($159 a year) will probably check out if you devote time studying for interviews. Who knows, a job-specific preparation (available with premium) might just pay off in the form of getting a job at a big tech company someday.

Is it the most exciting platform? No, not in my opinion.

Will it equip you with problem-solving skills that will come in clutch in real world applications like tech interviews? Most certainly, and often that's more important than having fun initially. You've got to have the job to enjoy the job.

GeeksForGeeks

If you've read my posts before, you've probably seen that I recommend GeeksForGeeks as one of my favorite platforms - and it's because it literally does everything. Tutorials? Got it. Code examples? Got that too. Interview prep and coding problems? Check and check.

In their Practice portal, you can find many problems that you might find useful, especially if you're looking to prep for DSA. These problems are also grouped into helpful lists that categorize by data structure, company, or experience level suggested.

There's no paid plan in general, but GFG courses are available for purchase at any time. If you get on their email list and wait a bit, you might just get a better deal during a sale incentive they'll occasionally push.

It's not the most complex or in-depth study, and it's not the most exciting platform to learn on, but the resources that are available will make it well worth your time.

Project Euler

While all the other platforms have built-in editors and code checkers that will measure the efficiency and speed of the code you're running, the next two challenge websites have a different take on problems - off-site solutions.

What does that mean? A prompt is given, and it's up to you to find the answer. The only input from you that is required is the answer, not the code. You can write the code however you want to, as long as the answer is correct.

Project Euler is one of these platforms. The problems start pretty easy, but get very hard as you work your way up the list. I like the freedom to come up with the answer on your own, but a feature I find slightly annoying is the fact that every time you get an answer wrong, you have to wait a progressively larger time span before a new submission is accepted.

A unique feature of Project Euler's platform is that its problems are on lockdown. Above problem 100, no solutions are allowed to be shared publicly or else account shutdown is threatened. While you can google the answer to any LeetCode question (granted you won't learn anything by cheating), Project Euler answers are much harder to come by - and perhaps that's why the popularity of this platform is much lower than others.

Project Euler offers a couple less than 900 questions, but this doesn't cut down on the depth of the platform as working through all 900 will take you quite a while.

Everything is free, so no paid plan is offered or required.

Would I recommend it for any use? No. If you're looking to study for a specific interview or preparation track, then use LeetCode or GFG's platform. If you're looking to go on a programming adventure and use your skills of any level, then this and the next option might be good to look into.

Advent of Code

I really enjoy Advent of Code. The platform is laid out really well, and I love the style of the whole thing. The challenges are all Christmas-themed, which is super unique and contributes a lot to the feel of the website.

Canonically, you're supposed to do each problem on the day it's released - December 1st through 25th. In doing so, you'll qualify for a placement on the leaderboard (but good luck beating the cult that surrounds this every December).

In contrast to Project Euler, solutions for each problem are publicly available anywhere from GitHub to private blogs. If you get stuck on a problem, these solutions are always around to push you in the right direction. If you really feel like blazing your own trail and challenging yourself, pick some rare script like Befunge-93.

Coming in too late to solve the problems on the exact days they're issued? Don't worry, each problem is still available for you to solve today.

The use case is the same as that of Project Euler. If you're specifically studying for something, this isn't a great choice. However, I think it's a great way to test your knowledge and problem-solving skills - because it's formatted the way it is, each problem strengthens problem-solving skills instead of specific language skills.

Conclusion

Coding challenges are some of the best ways to boost your problem-solving skills along with other good qualities like language familiarity, coding speed, and optimization.

If you're not doing coding challenges every day, it's definitely a habit you should develop. Pick one of these platforms and give it a go. I promise it's worth your time.

I hope you enjoyed this article! If you want to see more from me, don't forget to drop a like and a follow. Thanks, and see you in the next post! ✏

Crossposting Hashnode to DEV

DR — Fri, 02 Jun 2023 17:26:29 +0000

If you're like me, you might have multiple blogs. Medium, Hashnode, and DEV are all super popular choices to blog under, and I'm a fan of all of them for different reasons.

I own accounts on all three platforms, but I only really consistently use two - DEV and Hashnode. DEV because I've accumulated quite the following (800+ followers) and Hashnode because, well, the markdown editor looks cool.

Think I make different content for both blogs? Think again. I don't have the time or interest to keep two completely separate blogs up and running.

Instead, I use some of the really useful features form each platform to quickly and efficiently cross-post on each platform. In this article, I'll walk you through how to publish articles from Hashnode to DEV and vice versa.

Hashnode to DEV

This is my preferred method, only because it looks nicer to write in their editor, wrapped in with the fact that I personally think their system for storing drafts looks cleaner and nicer than DEV's.

So you've written your article, published it on Hashnode, and are ready to post it to DEV? Here's a handy list of how to do it super easily.

Start by copying the markdown from the article using Hashnode's copy markdown feature, found in the menu bar above your article.

Create a new post on DEV.
Paste the markdown from Hashnode into your DEV post.
Copy and paste your title into the article where it belongs and add associated tags for maximum exposure.
Add the canonical URL to the DEV post from your Hashnode article to show that it was originally published there if you wish.

You're done!

Header Images

Recommended ratio dimensions for header images do vary between platforms.

Hashnode recommends a 1600 to 840 ratio.
DEV recommends a 100 to 42 ratio (1600 to 672).

I'd recommend a tool like Figma for making custom thumbnails so you can easily change size, but for an easier and just as good-looking experience you can just go with a free image from Unsplash.

DEV to Hashnode

To go from the other way around (DEV to Hashnode), you can follow this handy list.

Copy all of the markdown (Ctrl-A when the editor is selected, Ctrl-C) from the DEV article and paste it in a new Hashnode draft.
Copy and paste the title into the title area, then hit publish to add some article details before you officially publish the article.
Optionally include the DEV link in the canonical URL section.

Add any tags and finalize the publishing.
You're done!

Fin.

Hope you enjoyed! Don't forget to drop a follow and a like if you like my posts. 👋

7 Must-Know JS Object Methods 🔥

DR — Tue, 30 May 2023 20:34:50 +0000

I'm sure many of you are familiar with the Object data type. Many of the data types that we use in everyday programming inherit from this type, like objects and arrays. But did you know about these seven methods and what they're capable of?

Let's dive right in.

Object.assign()

Ever want some properties to carry over from one object to another? This method provides that functionality!

const obj = {
    a: 0,
    b: 1,
    c: 2
};
const ex = {
    c: 3,
    d: 4,
    e: 5
};

Object.assign(obj, ex);
console.log(Object.entries(obj)); // [["a", 0], ["b", 1], ["c", 3], ["d", 4], ["e", 5]]

This method takes the first argument (the target) and adds the properties from the second (or more, all together are called the sources) to it, overwriting any properties from the original object that have the same name.

Let's look at an example that has more than one source.

const obj = {
    a: 0,
    b: 1,
    c: 2
};
const arr = [
    { d: 3 },
    { e: 4, f: 5 }
]

Object.assign(obj, ...arr);
console.log(Object.entries(obj)); // [["a", 0], ["b", 1], ["c", 2], ["d", 3], ["e", 4], ["f", 5]]

Object.freeze()

When we want to keep a variable from being altered, we use a constant (defined with const as the variable declaration). However, this sometimes is ineffective - especially when we're dealing with arrays or objects where properties can still be overwritten. This is where Object.freeze() comes in.

const obj = {
    a: 0,
    b: 1,
    c: 2
};

Object.freeze(obj);
obj.d = 3;

console.log(Object.entries(obj)); // [["a", 0], ["b", 1], ["c", 2]]

Note that this is in non-strict mode. When in strict mode, an error will be thrown if an attempt is made to modify the frozen object.

It works with arrays too.

const arr = ["a", "b", "c"];

Object.freeze(arr);
arr[3] = "d";

console.log(arr); // ["a", "b", "c"]

Hence we can create fully constant variables with the power of freezing.

Object.isFrozen()

Don't know whether or not an object is frozen? Check using this method!

const obj = {
    a: 0,
    b: 1,
    c: 2
};

console.log(Object.isFrozen(obj)); // false

Object.freeze(obj);
console.log(Object.isFrozen(obj)); // true

You might be wondering how you unfreeze an object. Short answer - you can't.

The best workaround to reusing a frozen object is by creating a copy that isn't frozen. That's about as far as you can get.

However, there are a few fixes like Object.seal() and Object.preventExtensions(). These methods allow some mutation of the frozen object, but it will never respond quite the same way. If you're freezing an object, plan for it to stay frozen - it's a pretty big security risk otherwise.

Object.entries()

This method is pretty useful as it allows us to create a full list of keys and values. It's also useful when working with data structures like Map - it makes conversion to and from the structure easy. Let's take a look at how it works.

const obj = {
    a: 0,
    b: 1,
    c: 2
};

console.log(Object.entries(obj)); // [["a", 0], ["b", 1], ["c", 2]]

As you can see, it's returning an array. Not just any array though, it's an array that's full of other arrays - each representing a key-value pair.

And yes, it works with arrays too.

const arr = ["a", "b", "c"];

console.log(Object.entries(arr)); // [["0", "a"], ["1", "b"], ["2", "c"]]

Why is this useful? For one, it provides a clean way to iterate through lists.

const obj = {
    a: 0,
    b: 1,
    c: 2
};

let objList = Object.entries(obj);
for (let i = 0; i < objList.length; i++) {
    console.log(`${objList[i][0]}: ${objList[i][1]}`)
}

// "a: 0"
// "b: 1"
// "c: 2"

Apart from that, it's helpful when used to convert an object to a map.

const obj = {
    a: 0,
    b: 1,
    c: 2
};

const map = new Map(Object.entries(obj));
console.log(map.size); // 3
console.log(map.get("a")); // 0

Object.fromEntries()

This is Object.entries() working backwards. It takes an array of arrays representing key-value pairs and creates an object. Let's start with the map we just created to demonstrate the difference.

const obj = {
    a: 0,
    b: 1,
    c: 2
};

const map = new Map(Object.entries(obj));
const newObj = Object.fromEntries(map);

console.log(Object.entries(obj)); // [["a", 0], ["b", 1], ["c", 2]]
console.log(Object.entries(newObj)); // [["a", 0], ["b", 1], ["c", 2]]

Even though we can't check for equality without working through some long-winded process, we can print out the entries and see that they are in fact the same.

You don't have to work from a map though, you can easily create a custom array and plug it in to create the same object.

const arr = [
    ["a", 0],
    ["b", 1],
    ["c", 2]
];

console.log(Object.fromEntries(arr)); // { a: 0, b: 1, c: 2 }

Object.keys()

This method returns an array of all keys that are defined by a given object. Consider the following object, which has three key-value pairs.

const obj = {
    a: 0,
    b: 1,
    c: 2
};

console.log(Object.keys(obj)); // ["a", "b", "c"]

You can also pass an array as an argument with some interesting results.

const arr = ["a", "b", "c"];

console.log(Object.keys(arr)); // ["0", "1", "2"]

This behavior is due to the fact that arrays are indexed with numbers, so in a way they're like objects that have numbers connected to values. Heck, we could make an object that behaves exactly similar to this array that produces exactly the same result.

const arr = ["a", "b", "c"];

console.log(Object.keys(arr)); // ["0", "1", "2"]

const obj = {
    "0": "a",
    "1": "b",
    "2": "c"
};

console.log(Object.keys(obj)); // ["0", "1", "2"]

One of the possible uses of this method is to iterate through an object - once we know how many keys an object has, we can go through each one and print out it and its respective value.

const obj = {
    a: 0,
    b: 1,
    c: 2
};

let keys = Object.keys(obj);
console.log(keys); // ["a", "b", "c"]

for (let i = 0; i < keys.length; i++) {
    console.log(`${keys[i]}: ${obj[keys[i]]}`);
}

// "a: 0"
// "b: 1"
// "c: 2"

Object.values()

This method functions in largely the same way as Object.keys() - it takes something like an object and returns an array of the values associated with each key, not the keys associated with each value.

We can take the same code that we used earlier and substitute the new method in place of the old one to see what it returns.

const obj = {
    a: 0,
    b: 1,
    c: 2
};

console.log(Object.values(obj)); // [0, 1, 2]

We can pass an array to the method, but this functions exactly the same as simply calling the array itself because all it's doing is returning an array of the elements.

const arr = ["a", "b", "c"];

console.log(Object.values(arr)); // ["a", "b", "c"]
console.log(arr); // ["a", "b", "c"]

I'm sure you can think of more than one use case for this method as well (iterating through an object, finding the size of an object, etc.

I've thought of one that I'll write here - I want to find the size of any object with a handy method that I'm taking from the Set data structure in JS - Object.size. My problem is that this method doesn't exist - yet! Let's create it by using our newfound knowledge.

const obj = {
    a: 0,
    b: 1,
    c: 2
};

Object.prototype.size = function() {
    return Object.values(this).length;
};

console.log(obj.size()); // 3

obj.d = 3;

console.log(obj.size()); // 4

That's just fantastic, although you should keep in mind that adding methods like this to a larger class like Object is generally frowned upon. We can make our code better by just creating a function that we pass an object to.

const getObjectSize = function(obj) {
    return Object.values(obj).length;
};

Don't forget ES6 syntax!

const getObjectSize = obj => Object.values(obj.length);

Fin.

Hope you enjoyed!

Don't forget to drop a like and a follow if you like my posts. Later :)

#2665: Counter II

DR — Tue, 16 May 2023 15:48:10 +0000

Number 3 on the 30 Days Challenge is #2665, Counter II. This challenge is primarily an add-on to the last day, so be sure to check out my post on #2620 for concept detailing.

Process

The instructions given are pretty simple.

Write a function createCounter. It should accept an initial integer init. It should return an object with three functions.

The three functions are:

increment() increases the current value by 1 and then returns it.
decrement() reduces the current value by 1 and then returns it.
reset() sets the current value to init and then returns it.

There are also some straightforward tests included.

const counter = createCounter(5)
counter.increment(); // 6
counter.reset(); // 5
counter.decrement(); // 4

We're basically dealing with a glorified version of the previous challenge. All we're gonna do is write it the same way, but with reset and decrement functions added. Both are simple to implement, but we'll start with what we have.

Let's write a function that has the basic functionality and the increment function included in a return object.

function createCounter(init) {
  let i = 0;
  return {
    increment: () => init + ++i
  }
}

We declare a private variable i and return an object with an increment function that increases i by 1 and returns the new value.

But in the last challenge you used i++, not ++i. What's the deal?

It's because in the last problem, we needed the counter to return init the first time it was called. For this function, we need it to always return init plus an incremented value of i. Since ++i returns the new value, it's just like adding 1 the first time around, 2 the second, etc.

The decrement logic will use an almost identical structure.

function createCounter(init) {
  let i = 0;
  return {
    increment: () => init + ++i,
    decrement: () => init + --i
  }
}

This should make sense if you understand that --i is the same as ++i, it just works in the opposite way.

Now we write the reset function, which we're told sets the value that will be returned back to init. How did we accomplish this the first time? By setting i back to 0.

function createCounter(init) {
  let i = 0;
  return {
    increment: () => init + ++i,
    decrement: () => init + --i,
    reset: () => {
      i = 0;
      return init;
    }
  }
}

And that's the solution.

Conclusion.

Incrementing operators can be confusing. Once you learn the cheatsheet for how they work, the solution to the problem begins to make sense.

i++ - increments i then returns i - 1
++i - increments i then returns i
i-- - decrements i then returns i + 1
--i - decrements i then returns i

If you found this helpful, be sure to leave a 💖 on the post and a ⭐ on the Github repo!

Follow for more LC content :)

DEV Community: DR

Building a Wordle Clone with Lua! 🕹

Introduction

Preparation

File Handling & Reading

Terminal Colors

Coloring Words

Drawing the Table

Validating Guesses

Game Loop

End Screen

Code and Conclusion

Lua Quick Reference

Quick Links

Basics

Console Output & Comments

Variables

Strings

Operators

Arithmetic

Relational

Logical

Conditionals

Loops

while loop

for loop

repeat loop

break statement

Functions

Tables

Files

Implicit

Explicit

The Lua Tutorial

Introduction

Basics

Strings

Numbers

Booleans

Nil

Operators

Arithmetic

Relational

Logical

Miscellaneous

Control Structures

Functions

Tables & Iterators

Iterators

File I/O

Conclusion

Gearing up for Lua

Introduction

Ecosystem

System

This month...

Installation

Lua

LuaRocks

LÖVE2D

Conclusion

1 Year. 12 Languages.

Introduction

Plans?

Topics

Onward

So I might be doing this wrong...

Introduction

What I'm doing

What am I doing wrong?

Going forward

Hacktoberfest Pledge 🎉

About

Finding Codebases

How to contribute

Pledge

Post-Vacation Pull Request

6 Must-Try Coding Problem Websites 💻

Codewars

CodinGame

`while` loop

`for` loop

`repeat` loop

`break` statement