Additional menu

CodingWithDrew

A Web and App Development Portfolio

You are here: Home / GoLang / Deck Of Cards Project Part 1

Deck Of Cards Project Part 1

If you haven't already, head over to https://codingwithdrew.com/category/golang/ and follow some of the prerequisite articles on how to use GoLang and set up your environment.

Overview:

We will create a package that will simulate playing cards you'd use for poker or the like.

Through the course of this project, we are going to create a number of functions that will simulate how we interact with the deck of cards. Eventually we will have the following functions:

  • newDeck -- create a list of playing cards. Essentially an array of strings where each element of an array will represent a single face of card.

    We haven't discussed an array just yet, but keep that question in your pocket, we will get there 😀

  • deal -- create a 'hand' of cards.
  • shuffle -- shuffles all the cards in the deck
  • newDeckFromFile -- load a list of cards from the local machine.
  • saveToFile -- save a list of cards to a file on the local machine
  • print -- log out of the contents of a deck of cards

How to organize the project

Currently our project files will be structured like this:

    ~/Dev/Cards/ Directory

    |-- main.go

main.go

  1. In your terminal run cd into your development directory. _i.e. ~/dev/

    💡 cd is used to "change directories. You can use it to navigate from one folder to another. cd .. for example would change directories up 1 level. and cd ~/ would change directories to your ~/ also known as your "root" directory.

  1. Run touch main.go

    💡 touch can be used to create a new file, it will also update the creation time stamp on a file if used more than once.

  1. Run code . which if you remember from our development setup will create a new VisualStudio Code workspace for you to work in.
    Remember we need some boilerplate for this main.go file:

     

    package main

func main(){

}
  1. Press command + option+ S to save your working directory and all files that changed. Let's take a moment to discuss some Go syntax

    💡 Go is what we consider a Statically typed language as opposed to a Dynamically typed language like Javascript. This means when we declare variables, we also have to declare what kind of value will be declared. Dynamically typed languages do not care what kind of value that you assign to their variables, this is not a better or worse characteristic. There are 3 other basic types of variables in go.

💡 There are 4 types of variables you can declare in go:

    1. bool -- can be true or false
    2. string -- can be text of any sort, including numbers but if you use numbers they will not be integers for math.
    3. int -- can be any whole number value you can type into a computer.
    4. float64 - can be a number with a decimal after it.

💡 This is one way to define a variable inside of go: https://share.codingwithdrew.com/2NuERK02

💡 Here is another way to define the same variable above that can make Go feel a bit more dynamically: https://share.codingwithdrew.com/Z4u6Px4d

💡 If you want to change the value of a variable, just use = instead of :=.

  1. Let's create a new variable or var and assign it a string that represents a playing card then use the "fmt" package to print it out. It should look like this:

     

    package main

func main(){

    var card string = "This is your first card"
    fmt.Println(card)
}

🚨 A pretty neat little thing just happened to our code, did you notice? When we saved, the Go extensions added to our VisualStudio code automatically added an import statement for "fmt" even though we didn't add it. This is because in our function we called fmt.Println().

💡 In the code above you will see there is fmt.Println(card) where card is an argument in a list of 1 arguments we passed to the function fmt.Println(). That function will call the card variable we declared as a string "This is your first card" and since we do not define the fmt function in our project, we have to import it, which is why VSCode automagically imports it when you save. Pretty neat stuff!

  1. Let's take what we've learned so far and apply it. Right now, when you call "card" you get "this is your first card" but what if we wanted it to be a result of a list of cards chosen at random? Wouldn't that be more realistic?

So the first thing we will need to do is create a new function. It will follow the same syntax as the main() function above. It should look like this:

    package main

    import "fmt"

    func main(){

        card := newCard()
        fmt.Println(card)
    }

    func myCard() {
        return "Ace of Diamonds"
    }

💡 Note the use of camel case. Camel case is the naming convention of combining words where the first letter of every word after the first one are capitalized. Example: learningGoIsFun().

  1. Press command + option+ S to save your working directory and all files that changed.

💡 If we run the code as is, we will have a compiler error because it will have trouble inferring the type of variable card is supposed to be. This is because we are declaring card without saying what type it is and assigning a function to it's value. To resolve this, we have to declare it as a string after the () but before the {}. Simply put, this means that "When executed, this function will return a value of type string".

💡 Important note, this is only required when using the := syntax.

Let's fix the issue with our code:

package main

import "fmt"

func main(){

    card := newCard()
    fmt.Println(card)
}

func myCard() string {
    return "Ace of Diamonds"
}
  1. Before we really can work with this project seriously, we need more tools in our tool box. Let's look at two different but similar data structures.

     

    1. array -- fixed length list of things.

       

      myList := []int{1,2,3,4,5}

    2. slice -- an array that can grow or shrink.

       

      mySlice := []string{"Reverse", "Two of Hearts", "Jack of Spades"}

💡 Slices & Arrays have to be declared with a data type and every element of a slice must be of the same type so you couldn't have a mySlice := ["string", 4, "float64", true]

So, how do we add a new element into a slice? Let's consider mySlice from above and how to add "ace of clubs to the end of the slice list

     mySlice := []string{"Reverse", "Two of Hearts", "Jack of Spades"}
     mySlice = append(myslice, "Ace of Clubs")

💡 It's important to recognize that by appending mySlice, we aren't editing the original variable but instead creating a new variable and adding "Ace of Clubs" to the end. This is an important distinction.

How do we iterate over our entire slice?

Let's write some code and then break it down:

  1. Modify main.go to look like this:

     

    package main

import "fmt"

func main() {

    cards := []string{"Ace of Clubs", myCard()}
    cards = append(cards, "King of Hearts")

    for i, card := range cards {
        fmt.Println(i, card)
    }
}

func myCard() string {
    return "Ace of Diamonds"
}

💡 In the code above, we are looping through all the values of cards and printing their value. Let's demonstrate!

🚨 If you forget to add string after declaring the myCard() function, you will get an error that looks like this:

./main.go:15:2: too many arguments to return
    have (string)
    want ()
  1. Press command + option+ S to save your working directory and all files that changed.
  1. We want to compile and execute our main.go file se we can see what happens when we run our code. From the terminal run go run main.go, the file output will look like this:

     

    % go run main.go
0 Ace of Clubs
1 Ace of Diamonds
2 King of Hearts

💡 The numbers you see in front of each value is the index or i which if you are familiar with any other coding language, arrays always start with 0 so the 3rd value in an array/slice would have an index of 2.

What is the code from step 10. really doing?

💡 https://share.codingwithdrew.com/KouZDD4A

💡 The most important element is the range cards, range is a keyword we use when we want to iterate over every single value inside of a slice.

💡 Note we are using the same := syntax in the code above. What we are doing is assigning a card to every element within cards. Normally, you wouldn't write out := if you were to write this code out in long form manually because you wouldn't be declaring a new variable but in a for loop, we are throwing out the previous values for the index (i) and the card.

  1. In terminal, let's save our work and stage our work in git.

    $ git add .

💡 git add followed by a file name will stage those files to a git repository. using git add . will add all files in the current directory to our git staging. The workflow for git is to save all changes, stage the changes, commit the changes to local repository, push the changes to the remote repository.

💡 You can see the status of your active git branch by running git status or see a readout of all the latest commits using git log (you can exit using q).

  1. Commit the staged changes using git commit -m "variables, slices, and loops".
  1. You should now be able to push those changes from your local git directory to the gitlab repository using git push origin/master or git push. Since we set up ed25519 SSH connection, you'll need to provide your passcode.