You can also download the Git Cheat Sheet in PDF format (along with some other resources) for free by joining my newsletter at flaviocopes.com/access.

Table of Contents

• Preface

• Basic Git Commands

• The Working Directory and the Staging Area

• Working with Branches

• Merging in Git

• Git Remotes

• Amending Commits

• Stashing in Git

• Git Tagging

• Reverting Changes in Git

• Viewing History Logs

• Git Diffs

• Git Flow

• Exploring Git References

• How to Configure Git

• Git Security

• How to Set Aliases in Git

• Rebasing in Git

• What is Cherry-Picking?

• Patching in Git

• Relative Dates in Git

• Git Blame

• Archiving in Git

• How to Track Files in Git

• Index Manipulation in Git

• Squashing in Git

• Data Integrity in Git

• Cleaning Up in Git

• Git Subtree

• How to Search in Git

• Bisecting in Git

• Git Attributes

• Git Checkout

• Git Reflog

• How to Handle Untracked Files in Git

• Force Pushing in Git

• Git Fetching and Pulling

• How to Handle Merge Conflicts in Git

• Working Trees in Git

• Submodules in Git

Preface

Welcome to this Git Cheat Sheet! It's an extensive guide I created to help empower both novice and seasoned developers with the knowledge you need to effectively utilize Git, the most popular version control system in the software industry.

This cheat sheet is designed to be your go-to resource, whether you're managing a solo project or collaborating within a large team. By providing clear explanations and practical examples, it should help demystify Git's complexities and transform them into intuitive, actionable insights.

Throughout this guide, you will explore a wide array of Git commands and concepts that form the backbone of software version control. From fundamental operations like initializing repositories and committing changes, to more advanced techniques such as branching, merging, and rebasing, this cheat sheet covers it all.

You'll also delve into specialized topics like squashing commits, bisecting to debug, handling submodules, and implementing subtrees. All this will help ensure that you're well-prepared to tackle any challenge that arises in your development process.

As you progress, you'll learn how to maintain data integrity, manage multiple working trees, and resolve merge conflicts efficiently. By the end, you'll not only have a deeper understanding of Git but also the confidence to use it to streamline your workflow and enhance collaboration with peers.

Prerequisites

To fully benefit from this cheat sheet, you should have a foundational knowledge of command-line operations and general programming principles. You should also be familiar with using a terminal or command prompt so you can better understand and apply the examples provided. Finally, having a basic grasp of version control concepts will enhance your ability to navigate through this guide effectively.

Basic Git Commands

In this section, you'll learn the fundamental Git commands that serve as the building blocks for efficiently managing and navigating your Git repositories.

Git is a distributed version control system that's essential for tracking changes in your codebase, collaborating with other developers, and maintaining the integrity of your project history. Understanding these basic commands is crucial for anyone looking to leverage the full power of Git in their development workflow.

We'll explore a variety of commands that cover key aspects of Git usage, such as initializing new repositories, committing changes, branching, and merging.

Each command is explained with a short sentence that describes its purpose along with its syntax, so you can effectively use it in real-world scenarios. Whether you're setting up a new project or working on an existing codebase, these commands will help you keep your work organized and maintain a seamless workflow.

git help

The git help command prints Git help information. It provides a quick reference to Git's basic usage and the most commonly used Git commands. This command is useful when you need a quick reminder of Git's functionality or want to explore available commands.

You can also use git help <command> to display help information for any specific Git command. For example, git help git prints the Git help specifically for the Git command itself.

These help commands are valuable resources for both beginners and experienced users to quickly access information about Git's features and usage.

git version

The git version command displays the version of Git installed on your system. This command is useful for verifying which version of Git you are currently using, which can be important for compatibility with certain features or when troubleshooting issues.

git init

The command git init is used to initialize a new Git repository in the current directory. This command creates a new subdirectory named .git that contains all the necessary metadata for the new repository. It's typically the first command you run when starting a new project that you want to manage with Git.

After running this command, you can begin tracking files and making commits in your new Git repository.

git clone <repository_url>

The git clone <repository_url> command creates a copy of a remote Git repository on your local machine. It downloads all the files, branches, and commit history, allowing you to start working with the project immediately.

git status

The git status command shows the current state of the Git repository's working directory and staging area. It displays information about which files have been modified, added, or deleted, and whether these changes are staged for the next commit.

The Working Directory and the Staging Area

The working directory and the staging area are fundamental concepts in Git that play crucial roles in the version control process.

The working directory is the environment where you actively make changes to your files, representing the current state of your project. It is essentially a sandbox where you can freely edit, delete, and create files as you develop your project. But these changes are local to your machine and not yet part of the version history.

On the other hand, the staging area, also known as the index, serves as an intermediary space between the working directory and the repository. It acts as a checkpoint where you can selectively organize changes before they are committed to the repository's history. This allows you to prepare a set of changes that are logically related, ensuring that each commit is meaningful and coherent.

The commands below will help you manage changes between the working directory and the staging area. They'll let you add files to the staging area, remove them, or modify the existing ones, giving you control over what will be included in the next commit.

By using these commands, you can ensure that only the intended updates are committed, making your project's history clear and organized. This process is essential for maintaining a clean and understandable history, as it allows you to track the evolution of your project with precision and clarity.

git checkout .

This command discards all changes in the working directory, reverting files to their last committed state. This command is useful for quickly undoing local modifications and restoring the working directory to a clean state.

git reset -p

This command allows you to interactively reset changes in the working directory. It provides a way to selectively undo modifications, giving you fine-grained control over which changes to keep or discard.

git add <file>

This command adds a specific file to the staging area in Git. This prepares the file for inclusion in the next commit, allowing you to selectively choose which changes to include in your version history.

git add -p

Allows you to interactively stage changes from your working directory by breaking them into chunks (hunks). This lets you review and selectively add parts of the changes to the index before committing.

git add -i

Enters the interactive mode of adding files. Provides a text-based interactive menu where you can select various actions to perform, such as staging individual changes, updating files, or viewing the status.

git rm <file>

Removes a file from the working directory and stages the removal.

git rm --cached <file>

Removes the specified file from the staging area (index) but leaves it intact in your working directory. This effectively un-tracks the file from version control.

git mv <old_path> <new_path>

This command is used to move or rename a file or directory within a Git repository. It automatically stages the change, making it ready for the next commit.

git commit -m "message"

This command is used to create a new commit in your Git repository. It saves the changes that have been staged (added to the index) along with a descriptive message. This message should briefly explain what changes were made in this commit.

Working with Branches

Git branches are parallel lines of development within a Git repository. They allow you to work on different features, bug fixes, or experiments independently from the main codebase.

Each branch can have its own commit history, and changes made in one branch do not affect others until they are merged. This helps you organize your work, and facilitates collaboration by enabling multiple developers to work on different aspects of a project simultaneously without interfering with each other's progress.

In this section we'll introduce commands that allow you to create, switch, list, rename, and delete branches in your Git repository. These commands help manage parallel lines of development, enabling you to work on different features or bug fixes independently. You'll also learn how to display commit histories and branch relationships, as well as manage remote branches.

git branch <branch_name>

Creates a new branch.

git checkout <branch_name>

Switches to the specified branch and updates the working directory.

git branch

Lists all branches.

git branch -d <branch_name>

Deletes a branch.

git push --delete <remote> <branch>

Deletes a remote branch.

git branch -m <old_name> <new_name>

Renames a branch.

git checkout -b <new_branch>

Creates and switches to a new branch named <new_branch>, based on the current branch.

git switch <branch>

Switches the working directory to the specified branch.

git show-branch <branch>

Displays a summary of the commit history and branch relationships for all or selected branches, showing where each branch diverged.

git show-branch --all

Same as above, but for all branches and their commits.

git branch -r

Lists all remote branches that your local repository is aware of.

git branch -a

Lists all branches in your repository, including both local and remote branches (the ones the local repository is aware of).

git branch --merged

Lists all branches that have been fully merged into the current branch, and can be safely deleted if no longer needed.

git branch --no-merged

Lists all branches that have not been fully merged into your current branch, showing branches with changes that haven't been integrated yet.

Merging in Git

The git merge command is used to combine the changes from one branch into another branch. It integrates the histories of both branches, creating a new commit that includes the changes from both sources.

This process allows multiple lines of development to be brought together, facilitating collaboration and ensuring that all updates are incorporated into the main project.

During a merge, conflicts may arise if changes overlap, requiring manual resolution to ensure a coherent final result.

git merge <branch>

Integrates the changes from the specified branch into your current branch, combining their histories.

git merge --no-ff <branch>

Merges the specified branch into your current branch, always creating a new merge commit even if a fast-forward merge is possible.

git merge --squash <branch>

Combines all the changes from the specified branch into a single commit, preparing the changes for a commit in the current branch without merging the branch’s history. This allows you to manually edit the commit message.

git merge --abort

Cancels an ongoing merge process and restores the state of your working directory and index to what it was before the merge started.

git merge -s ours <branch> or

git merge —-strategy=ours <branch>

These commands are functionally the same, but the second is the expanded (more explicit) version, while git merge -s ours <branch> is the shorthand version (which is commonly used). You'll see this a few times throughout this guide.

The git merge —-strategy=ours <branch> command (git merge -s ours <branch> for short) performs a merge using the "ours" strategy, which keeps the current branch's changes and discards changes from the specified branch. This effectively merges the histories without integrating the changes from the other branch.

git merge --strategy=theirs <branch>

Merges the specified branch into the current branch using the "theirs" strategy, which resolves all conflicts by favoring changes from the branch being merged. Note that the "theirs" strategy is not a built-in strategy and usually requires custom scripting or is used with tools to handle conflict resolution.

Git Remotes

Git remotes are references to remote repositories, which are versions of your project hosted on the internet or another network. They enable collaboration by allowing multiple users to share and sync changes with a central repository.

Common operations with remotes include git fetch to retrieve updates, git pull to fetch and merge changes, and git push to upload local commits to the remote repository.

Managing remotes involves adding, removing, and renaming remote connections, as well as configuring URLs for seamless collaboration.

git fetch

Fetches changes from a remote repository but does not merge them into your current branch.

git pull

Fetches changes from a remote repository and immediately merges them into your current branch.

git push

Uploads your local branch's changes to a remote repository.

git remote

Lists the names of remote repositories configured for your local repository.

git remote -v

Displays the URLs of the remote repositories associated with your local repository, showing both the fetched and pushed URLs.

git remote add <name> <url>

Adds a new remote repository with the specified name and URL to your local repository configuration.

git remote remove <name> or

git remote rm <name>

Deletes the specified remote repository connection from your local git configuration. git remote rm <name> is the shorthand version of the command.

git remote rename <old_name> <new_name>

Changes the name of an existing remote repository connection in your local Git configuration

git remote set-url <name> <newurl>

Changes the URL of an existing remote repository connection in your local Git configuration.

git fetch <remote>

Retrieves the latest changes from the specified remote repository, updating your local copy of the remote branches without merging them into your local branches.

git pull <remote>

Fetches changes from the specified remote repository and merges them into your current branch.

git remote update

Fetches updates for all remotes tracked by the repository.

git push <remote> <branch>

Uploads the specified branch from your local repository to the given remote repository.

git push <remote> --delete <branch>

Removes the specified branch from the remote repository.

git remote show <remote>

Displays detailed information about the specified remote repository, including its URL, fetch and push configurations, and the branches it tracks.

git ls-remote <repository>

Lists references (such as branches and tags) and their commit IDs from the specified remote repository. This command allows you to view the branches and tags available in a remote repository without cloning it.

git push origin <branch> --set-upstream

Pushes the local branch <branch> to the remote repository origin and sets up the local branch to track the remote branch. This lets future git push and git pull commands default to this remote branch.

git remote add upstream <repository>

Adds a new remote named upstream to your local repository, pointing to the specified <repository>. This is commonly used to track the original repository from which you forked, while origin typically refers to your own fork.

git fetch upstream

Retrieves updates from the upstream remote repository, updating your local references to the branches and tags from that remote without modifying your working directory or merging changes.

git pull upstream <branch>

Fetches updates from the <branch> of the upstream remote repository and merges those changes into your current branch. This is often used to integrate changes from the original repository into your own local branch.

git push origin <branch>

Uploads the local branch <branch> to the origin remote repository, making your branch and its commits available on the remote.

Amending Commits

Amending Git commits allows you to modify the most recent commit, typically to correct or update its contents or message. You can do this using the git commit --amend command, which opens the commit in your default text editor for changes.

Amending is particularly useful for fixing small mistakes or adding forgotten changes without creating a new commit, resulting in a cleaner and more accurate commit history.

git commit --amend

Modifies the most recent commit, combining staged changes.

git commit --amend -m "new message"

Amends the commit message of the most recent commit.

git commit --fixup=HEAD

Creates a new commit with the --fixup option that is intended to correct or amend the most recent commit (HEAD). The new commit is marked with a fixup! prefix in the commit message and will be used to automatically fix or amend the specified commit during an interactive rebase.

Stashing in Git

Git stashing is a feature that allows you to temporarily save changes in your working directory that are not yet ready to be committed.

By using the git stash command, you can set aside these changes and revert your working directory to a clean state, enabling you to switch branches or perform other tasks without losing progress. Later, you can reapply the stashed changes with git stash apply or git stash pop, allowing you to continue where you left off.

This functionality is especially useful for managing work in progress when you need to address an urgent issue or experiment with a different code path.

git stash

Temporarily saves your uncommitted changes, allowing you to switch branches or perform other operations without committing incomplete work.

There's an older version, git stash save, that allows you to specify a custom message. But it's largely been deprecated in favor of the simpler git stash.

git stash -m "message"

Same as above, but stores changes with a message. It also has an older version, git stash save "message", but git stash -m "message" is preferred for versions of Git 2.13 and newer.

git stash show

Displays a summary of the changes in the most recent stash entry, showing which files were modified.

git stash list

Shows all the stashed changes in your repository, displaying them in a numbered list.

git stash pop

Applies the most recent stash and then immediately removes it from the stash list.

git stash drop

Removes the most recent stash entry from the stash list without applying it to your working directory.

git stash apply

Reapplies the most recently stashed changes to your working directory without removing them from the stash list.

git stash clear

Clears and removes all stashed entries, permanently deleting all saved changes in your stash.

git stash branch <branch>

Creates a new branch named <branch> from the commit where you were before stashing your changes. Then it applies the stashed changes to that new branch.

This command effectively allows you to continue working on your stashed changes in a separate branch, preserving the original context and changes.

Git Tagging

Git tagging is a feature that allows you to mark specific points in your repository's history as important with a meaningful name, often used for releases or significant milestones.

Unlike branches, tags are typically immutable and do not change, serving as a permanent reference to a particular commit.

There are two types of tags in Git: lightweight tags, which are simple pointers to a commit, and annotated tags, which store additional metadata like the tagger's name, email, date, and a message.

Tags can be easily created, listed, pushed to remote repositories, and deleted, providing a convenient way to manage and reference key points in your project's development timeline.

git tag <tag_name>

Creates a new tag with the specified name pointing to the current commit (typically used to mark specific points in the commit history, like releases).

git tag -a <tag_name> -m "message"

Creates an annotated tag with the specified name and message, which includes additional metadata like the tagger's name, email, and date, and points to the current commit.

git tag -d <tag_name>

Deletes the specified tag from your local repository.

git tag -f <tag> <commit>

Forces a tag to point to a different commit.

git show <tag_name>

Displays detailed information about the specified tag, including the commit it points to and any associated tag messages or annotations.

git push origin <tag_name>

Uploads the specified tag to the remote repository, making it available to others.

git push origin --tags

Pushes all local tags to the remote repository, ensuring that all tags are synchronized with the remote.

git push --follow-tags

Pushes both commits and tags.

git fetch --tags

Retrieves all tags from the default remote repository and updates your local repository with them, without affecting your current branches.

Reverting Changes in Git

Reverting changes in Git involves undoing modifications made to a repository's history. You can do this using several commands, such as git revert. It creates a new commit that negates the changes of a specified previous commit, effectively reversing its effects while preserving the commit history.

Another method is using git reset, which changes the current HEAD to a specified commit and can update the staging area and working directory depending on the chosen options (--soft, --mixed, or --hard).

You can also use git checkout to discard changes in the working directory, reverting files to their state in the last commit.

These tools provide flexibility in managing and correcting changes, ensuring the repository remains accurate and clean.

git checkout -- <file>

Discards changes in the specified file from the working directory, reverting it to the state of the last commit and effectively undoing any modifications that haven't been staged.

git revert <commit>

Creates a new commit that undoes the changes in the specified commit, effectively reversing its effects while preserving the history.

git revert -n <commit>

Reverts a commit but does not commit the result.

git reset

Resets the current HEAD to the specified state, and optionally updates the staging area and working directory, depending on the options used (--soft, --mixed, or --hard).

git reset --soft <commit>

Moves HEAD to the specified commit, while keeping the index (staging area) and working directory unchanged, so all changes after the specified commit remain staged for committing. This is useful when you want to undo commits but keep the changes ready to be committed again.

git reset --mixed <commit>

Moves HEAD to the specified commit and updates the index (staging area) to match that commit. But it leaves the working directory unchanged, so changes after the specified commit are kept but are untracked.

git reset --hard <commit>

Moves HEAD to the specified commit and updates both the index (staging area) and working directory to match that commit. It discards all changes and untracked files after the specified commit.

Viewing History Logs

Git history refers to the record of all changes made to a repository over time. It includes a chronological sequence of commits, each representing a snapshot of the repository at a specific point.

This history allows you to track modifications, understand the evolution of the codebase, and collaborate effectively by providing a detailed log of who made changes, when, and why.

Tools like git log help you navigate this history, offering insights into the development process and aiding in debugging and project management.

git log

Displays the commits log.

git log --oneline

Displays a summary of commits with one line each.

git log --graph

Shows a graphical representation of the commit history.

git log --stat

Displays file statistics along with the commit history.

git log --pretty=format:"%h %s"

Formats the log output according to the specified format.

git log --pretty=format:"%h - %an, %ar : %s"

Provides a more human-readable format for logs.

git log --author=<author>

Shows commits made by the specified author.

git log --before=<date>

Shows commits made before the specified date.

git log --after=<date>

Shows commits made after the specified date (same as git log --since=<date>)

git log --cherry-pick

Omits commits that are equivalent between two branches.

git log --follow <file>

Shows commits for a file, including renames.

git log --show-signature

Displays GPG signature information for commits.

git shortlog

Summarizes git log output by author.

git shortlog -sn

Summarizes git log output by author, with commit counts.

git log --simplify-by-decoration

Shows only commits that are referenced by tags or branches.

git log --no-merges

Omits merge commits from the log.

git whatchanged

Lists commit data in a format similar to a commit log.

git diff-tree --pretty --name-only --root <commit>

Shows detailed information for a commit tree.

git log --first-parent

Only shows commits of the current branch and excludes those merged from other branches.

Git Diffs

Git diffs are a feature in Git that allows you to see the differences between various states in your repository. This can include differences between your working directory and the staging area, between the staging area and the last commit, or between any two commits or branches.

By displaying line-by-line changes in files, diffs help you review modifications before committing, merging, or applying changes, thus ensuring accuracy and consistency in your codebase.

git diff

Shows the differences between various states in your repository, such as between your working directory and the index (staging area), between the index and the last commit, or between two commits. It displays line-by-line changes in files, helping you review modifications before committing or merging.

git diff --stat

Shows a summary of changes between your working directory and the index (staging area), helping you see what files have been modified and how many lines have been added or removed.

git diff --stat <commit>

Views changes between a commit and the working directory.

git diff --stat <commit1> <commit2>

Provides a summary of changes between two commits, showing which files were altered and the extent of changes between them.

git diff --stat <branch1> <branch2>

Summarizes the differences between the two branches, indicating the files changed and the magnitude of changes.

git diff --name-only <commit>

Shows only the names of files that changed in the specified commit.

git diff --cached

Shows the differences between the staged changes (index) and the last commit, helping you review what will be included in the next commit.

git diff HEAD

Shows the differences between the working directory and the latest commit (HEAD), allowing you to see what changes have been made since the last commit.

git diff <branch1> <branch2>

Shows the differences between the tips of two branches, highlighting the changes between the commits at the end of each branch.

git difftool

Launches a diff tool to compare changes.

git difftool <commit1> <commit2>

Uses the diff tool to show the differences between two specified commits.

git difftool <branch1> <branch2>

Opens the diff tool to compare changes between two branches.

git cherry <branch>

Compares the commits in your current branch against another branch and shows which commits are unique to each branch. It is commonly used to identify which commits in one branch have not been applied to another branch.

Git Flow

Git Flow is a branching model for Git that provides a robust framework for managing larger projects. It defines a strict branching strategy designed around the project release cycle, with two primary branches (main and develop) and supporting branches for features, releases, and hotfixes.

This model helps in organizing work, ensuring a clean and manageable history, and facilitating collaboration by clearly defining roles and processes for different types of development work.

git flow init

Initializes a repository for a git-flow branching model.

git flow feature start <feature>

Starts a new feature branch in git-flow.

git flow feature finish <feature>

Finishes a feature branch in git-flow.

Exploring Git References

Git references, often referred to as refs, are pointers to specific commits or objects within a Git repository. These can include branches, tags, and other references like HEAD, which points to the current commit checked out in your working directory.

References are used to keep track of the structure and history of the repository. They help Git efficiently manage and navigate different points in the project's timeline.

Refs also provide a way to name and refer to particular commits, making it easier to work with and manipulate the repository's history.

git show-ref --heads

Lists references to all heads (branches).

git show-ref --tags

Lists references to all tags.

How to Configure Git

Git configuration involves setting up various options and preferences that control the behavior of your Git environment. This can include specifying your username and email, setting up default text editors, creating aliases for commonly used commands, and configuring global ignore files.

You can apply configuration settings at different levels: global (affecting all repositories on your system), local (affecting a single repository), and system-wide. These settings ensure a customized and consistent user experience, streamline workflows, and enhance the overall efficiency of version control operations.

git config --global user.name "Your Name"

Sets the user name on a global level.

git config --global user.email "your_email@example.com"

Sets the user email on a global level.

git config --global core.editor <editor>

Sets the default text editor.

git config --global core.excludesfile <file>

Sets the global ignore file.

git config --list

Lists all the configuration settings.

git config --list --show-origin

Lists all config variables, showing their origins.

git config <key>

Retrieves the value for the specified key.

git config --get <key>

Retrieves the value for the specified configuration key.

git config --unset <key>

Removes the specified configuration key.

git config --global --unset <key>

Removes the specified configuration key globally.

Git Security

Git GPG security involves using GNU Privacy Guard (GPG) to sign commits and tags, ensuring their authenticity and integrity. By configuring a GPG key and enabling automatic signing, you can verify that commits and tags were created by a trusted source. This helps prevent tampering and ensures the integrity of the repository's history.

This practice enhances security by providing cryptographic assurance that the changes come from a legitimate contributor.

git config --global user.signingKey <key>

Configures the GPG key for signing commits and tags.

git config --global commit.gpgSign true

Automatically signs all commits with GPG.

How to Set Aliases in Git

Git aliases are custom shortcuts that you can create to simplify and speed up your workflow by mapping longer Git commands to shorter, more memorable names.

By configuring aliases in your Git settings, you can quickly execute frequently used commands with less typing. This not only enhances productivity but also reduces the likelihood of errors.

For example, you can set an alias like git st to replace git status, or git co to replace git checkout.

You can define aliases globally to apply across all repositories or locally for individual projects, providing flexibility in how you streamline your Git operations.

git config --global alias.ci commit

Sets git ci as an alias for git commit.

git config --global alias.st status

Sets git st as an alias for git status.

git config --global alias.co checkout

Sets git co as an alias for git checkout.

git config --global alias.br branch

Sets git br as an alias for git branch.

git config --global alias.graph "log --graph --all --oneline --decorate"

Creates an alias for a detailed graph of the repository history.

Rebasing in Git

Git rebasing re-applies your changes on top of another branch's history, creating a cleaner and more linear project history.

In practice, this helps integrate updates smoothly by avoiding unnecessary merge commits, ensuring that the commit sequence is straightforward, and making it easier to understand the evolution of the project.

git rebase <branch>

The git rebase command is used to re-apply commits on top of another base tip. It allows you to move or combine a sequence of commits to a new base commit. This is commonly used to:

1. Keep a linear project history.

2. Integrate changes from one branch into another.

3. Update a feature branch with the latest changes from the main branch.

The basic usage is git rebase <branch>, which will rebase the current branch onto the specified branch.

git rebase --interactive <branch>

Starts an interactive rebase session, allowing you to modify commits starting from <base> up to the current HEAD. This lets you reorder, squash, edit, or delete commits, providing a way to clean up and refine commit history before pushing changes. Shorter version: git rebase -i <branch>

git rebase --continue

Continues the rebase process after resolving conflicts.

git rebase --abort

Aborts the rebase process and returns to the original branch.

git fetch --rebase

Fetches from the remote repository and rebases local changes.

What is Cherry-Picking?

Git cherry-picking is a process that allows you to apply the changes introduced by a specific commit from one branch into another branch. This is particularly useful when you want to selectively incorporate individual changes from different branches without merging the entire branch.

By using the git cherry-pick command, you can isolate and integrate only the desired commits, ensuring that specific modifications are included in your current branch while avoiding potential conflicts and unwanted changes from other parts of the branch.

git cherry-pick <commit>

Applies the changes introduced by an existing commit.

git cherry-pick --continue

Continues cherry-picking after resolving conflicts.

git cherry-pick --abort

Aborts the cherry-pick process.

git cherry-pick --no-commit <commit>

Cherry-picks a commit without automatically committing and allows further changes. Shorter version: git cherry-pick -n <commit>

Patching in Git

Git patching is a method used to apply changes from one repository to another or from one branch to another within the same repository. It involves creating patch files, which are text files representing differences between commits or branches. These patch files can then be applied to a repository using commands like git apply or git am, allowing changes to be transferred and integrated without directly merging branches.

Patching is particularly useful for sharing specific changes or updates across different codebases, ensuring that only the intended modifications are applied.

git apply <patch_file>

Applies changes to the working directory from a patch file.

git apply --check

Checks if patches can be applied cleanly.

git format-patch <since_commit>

Creates patch files for each commit since the specified commit.

git am <patch_file>

Applies patches from a mailbox.

git am --continue

Continues applying patches after resolving conflicts.

git am --abort

Aborts the patch application process.

git diff > <file.patch>

Creates a patch file from differences.

Relative Dates in Git

Git relative dates allow users to refer to specific points in the repository's history using human-readable time expressions. For instance, commands like main@{1.week.ago} or @{3.days.ago} enable you to access the state of a branch or view changes made since a certain time period relative to the current date.

This feature simplifies navigating the repository's timeline by using intuitive terms like "yesterday," "2 weeks ago," or specific dates, making it easier to track and manage the evolution of the codebase without needing to remember exact commit hashes or timestamps.

git show main@{1.week.ago}

Lets you see the state of your main branch one week ago.

git diff @{3.days.ago}

Shows what changes you've made in the last 3 days.

git checkout main@{2.weeks.ago}

Checks out your repository as it was 2 weeks ago.

git log @{1.month.ago}..HEAD

Shows you the log of commits from 1 month ago until now.

@{2024-06-01}

@{yesterday}

@{"1 week 2 days ago"}

Other usage examples.

Git Blame

Git blaming is a feature in Git that identifies the last modification made to each line of a file, attributing changes to specific commits and authors. You can do this using the git blame command, which provides a detailed annotation of the file, showing who made changes and when they were made.

This tool is particularly useful for tracking the history of a file, understanding the evolution of the code, and identifying the source of bugs or changes.

By pinpointing the exact commit and author responsible for each line, developers can gain insights into the development process and facilitate better collaboration and accountability within a team.

git blame <file>

Shows the last modification for each line of a file.

git blame <file> -L <start>,<end>

Limits the blame output to the specified line range.

git blame <file> <commit>

Shows the blame information up to the specified commit.

git blame <file> -C -C

Shows which revisions and authors last modified each line of a file, with copying detection.

The -C option detects lines moved or copied within the same file. Using it once (-C) detects lines moved or copied within the same file. Using the -C option twice (-C -C) makes Git inspect unmodified files as candidates for the source of copy. This means it will try to find the origin of copied lines not just in the same file but in other files as well.

git blame <file> --reverse

Works backwards, showing who last altered each line in the specified file.

git blame <file> --first-parent

Shows who most recently modified each line in a file, following only the first parent commit for merge changes.

Archiving in Git

Git archiving is a feature that allows you to create archive files, such as .tar or .zip, containing the contents of a specific commit, branch, or tag. This is useful for packaging a snapshot of your repository at a specific point in time, enabling you to distribute or backup the repository's state without including the entire Git history.

The git archive command is typically used for this purpose, providing a convenient way to export the current state of the project into a portable format.

git archive <format> <tree-ish>

Creates an archive file (for example, a .tar or .zip file) containing the contents of the specified tree-ish (like a commit, branch, or tag) in the given format. For example:

• git archive --format=tar HEAD creates a .tar archive of the current commit (HEAD).

• git archive --format=zip v1.0 creates a .zip archive of the files in the v1.0 tag.

This command is useful for packaging a snapshot of your repository at a specific point in time.

How to Track Files in Git

Git tracking refers to the process of monitoring and managing the files in a repository.

The command git ls-files lists all files that are being tracked by Git, providing a clear view of the files that are currently under version control. On the other hand, git ls-tree <branch> displays the contents of a tree object for a specified branch, showing the structure and files at that point in the repository.

Together, these commands help developers understand which files are included in the repository and how they are organized, ensuring efficient tracking and management of the project's codebase.

git ls-files

Lists all tracked files.

git ls-tree <branch>

Lists the contents of a tree object.

Index Manipulation in Git

Git index manipulation involves managing the staging area (also known as the index) where changes are prepared before committing. This can include marking files as "assume unchanged" to temporarily ignore changes, or resetting these markings to track changes again.

Index manipulation commands, such as git update-index, allow you to control which files are included in the next commit, providing flexibility in handling changes and optimizing the workflow for specific tasks.

git update-index --assume-unchanged <file>

Marks a file as assume unchanged.

git update-index --no-assume-unchanged <file>

Unmarks a file as assume unchanged.

Squashing in Git

Git squashing is the process of combining multiple commits into a single commit. Devs often do this to clean up the commit history before merging changes into a main branch, making the history more concise and easier to read.

Squashing can be performed using the interactive rebase command (git rebase -i), which lets you selectively merge, reorder, or edit commits. By squashing commits, you can consolidate redundant or minor changes, presenting a clearer narrative of the development process.

git rebase -i HEAD~<n>

Squashes commits interactively.

Data Integrity in Git

Git data integrity refers to the mechanisms and processes Git employs to ensure the accuracy and consistency of data within a repository.

Git uses cryptographic hashes (SHA-1 or SHA-256) to uniquely identify objects such as commits, trees, and blobs. This hashing not only provides a unique identifier for each object but also ensures that any modification to the object's content will result in a different hash, thus detecting any corruption or tampering.

You can use commands like git fsck to verify the connectivity and validity of objects in the database, ensuring the overall health and integrity of the repository.

git fsck

Verifies the connectivity and validity of objects in the database.

git fsck --unreachable

Finds objects in the repository that are not reachable from any reference.

git prune

Removes unreachable objects.

git gc

Runs a garbage collection process.

Git garbage collection is a maintenance process that cleans up and optimizes the repository by removing unnecessary files and compressing file revisions to save space. This process, triggered by the git gc command, consolidates and deletes unreachable objects, such as orphaned commits and unreferenced blobs, ensuring the repository remains efficient and performant.

Regular garbage collection helps manage storage effectively and keeps the repository's structure organized.

Cleaning Up in Git

Cleaning up in Git involves removing unnecessary files, references, and branches that are no longer needed. This helps to keep your repository organized and efficient.

Regular cleanup activities, such as pruning remote-tracking branches, deleting untracked files, and removing stale references, ensure that your repository remains manageable and free from clutter.

In practice, these actions can improve performance, reduce storage requirements, and make it easier to navigate and work within your project.

git fetch --prune

Removes references that no longer exist on the remote.

git remote prune <name>

Prunes all stale remote-tracking branches.

git fetch origin --prune

Cleans up outdated references from the remote repository.

git clean -f

Removes untracked files from the working directory, forcing the deletion of files not being tracked by Git.

git clean -fd

Removes untracked files and directories from the working directory, including any files and directories not tracked by Git.

git clean -i

Enters interactive mode for cleaning untracked files.

git clean -X

Removes only ignored files from the working directory.

Git Subtree

Git subtree is a mechanism for managing and integrating subprojects into a main repository. Unlike submodules, which treat the subproject as a separate entity with its own repository, subtrees allow you to include the contents of another repository directly within a subdirectory of your main repository.

This approach simplifies the workflow by eliminating the need for multiple repositories and enabling seamless integration, merging, and pulling of updates from the subproject. Subtrees provide a flexible and convenient way to manage dependencies and collaborate on projects that require incorporating external codebases.

git subtree add --prefix=<dir> <repository> <branch>

Adds a repository as a subtree.

git subtree merge --prefix=<dir> <branch>

Merges a subtree.

git subtree pull --prefix=<dir> <repository> <branch>

Pulls in new changes from the subtree's repository.

How to Search in Git

git grep is a powerful search command in Git that allows users to search for specific strings or patterns within the files of a repository. It searches through the working directory and the index, providing a quick and efficient way to locate occurrences of a specified pattern across multiple files.

This command is particularly useful for developers looking to find instances of code, comments, or text within a project, enabling them to navigate and understand large codebases with ease. With various options and flags, git grep lets you perform targeted searches, making it an essential tool for code analysis and maintenance.

git grep <pattern>

Searches for a string in the working directory and the index.

git grep -e <pattern>

Searches for a specific pattern.

Bisecting in Git

Git bisecting is a powerful debugging tool that helps identify the specific commit that introduced a bug or issue in a project. By performing a binary search through the commit history, git bisect efficiently narrows down the range of potential problem commits.

The process involves marking a known good commit and a known bad commit, and then repeatedly testing intermediate commits to determine whether they are good or bad.

This iterative approach quickly isolates the faulty commit, allowing developers to pinpoint the exact change that caused the problem. This facilitates faster and more accurate debugging.

git bisect start

Starts a bisect session.

git bisect bad

Marks the current version as bad.

git bisect good <commit>

Marks the specified commit as good.

git bisect reset

Ends a bisect session and returns to the original branch.

git bisect visualize

Launches a visual tool to assist with bisecting.

Git Attributes

Git attributes are settings that define how Git should handle specific files or paths within a repository. These attributes are defined in a file named .gitattributes, and they can control various behaviors such as text encoding, line-ending normalization, merge strategies, and diff algorithms.

By setting attributes, you can ensure consistent behavior across different environments and collaborators, making it easier to manage files with special requirements or complexities.

For example, you can mark certain files as binary to prevent Git from attempting to merge them, or specify custom diff drivers for more meaningful comparisons.

git check-attr <attribute> -- <file>

Shows the value of a specific attribute for the given file as defined in the .gitattributes configuration, helping you understand how Git is treating the file with respect to attributes like text encoding, merge behavior, or diff handling.

Git Checkout

git checkout is a versatile command in Git used to switch between different branches, tags, or commits within a repository. By updating the working directory and index to match the specified branch or commit, it allows you to view or work with the state of the repository at that point.

You can also use git checkout to create new branches, restore specific files from a commit, or even start a new branch with no history using the --orphan option. This command is essential for navigating and managing different versions of a project's codebase.

git checkout <commit>

Updates the working directory and index to match the specified commit, allowing you to view or work with the state of the repository at that commit. Just keep in mind that this leaves you in a "detached HEAD" state, meaning you're not on any branch.

git checkout -b <branch> <commit>

Creates a new branch named <branch> starting from the specified commit and switches to that branch, allowing you to begin working from that point in the commit history.

git checkout <commit> -- <file>

Restores the specified file from a specific commit into your working directory, replacing the current version of the file with the version from that commit without changing the commit history or index.

git checkout --orphan <new_branch>

Creates a new branch named <new_branch> with no commit history, effectively starting a new branch that begins with a clean working directory and index, as if it were a new repository.

Git Reflog

Git reflog is a powerful tool that records all changes made to the tips of branches and the HEAD reference in a Git repository. This includes actions such as commits, checkouts, merges, and resets.

By maintaining a history of these changes, reflog allows users to track recent modifications and recover lost commits, even if they are not part of the current branch history. It provides a way to navigate through the repository's state changes, making it an invaluable resource for debugging and undoing mistakes.

git reflog

Displays a log of all the changes to the HEAD reference and branch tips, including commits, checkouts, merges, and resets, allowing you to recover lost commits or track recent changes to the repository's state.

git reflog show <ref>

Displays the reflog for the specified reference (<ref>), showing a log of changes to that reference, including updates to HEAD or branch tips, along with associated commit messages and timestamps.

How to Handle Untracked Files in Git

git clean

git clean removes untracked files and directories from the working directory. By default, it only shows what would be removed without actually deleting anything.

To perform the actual cleanup, you need to use additional flags:

• git clean -f: Removes untracked files.

• git clean -fd: Removes untracked files and directories.

• git clean -fx: Removes untracked files, including those ignored by .gitignore.

• git clean -n: Shows which files would be removed without actually deleting them.

Force Pushing in Git

git push --force

Forces a push of your local branch to the remote repository, even if it results in a non-fast-forward merge. It overwrites the remote branch with your local changes.

This can be necessary when you have rewritten history (for example, with a rebase) and need to update the remote branch to match your local branch. But it can also potentially overwrite others' changes – so use it with caution.

Git Fetching and Pulling

git fetch --all

Retrieves updates from all remote repositories configured for your local repository, fetching changes from all branches and tags without modifying your local branches.

git pull --rebase

Fetches changes from the remote repository and rebases your local commits on top of the updated remote branch, rather than merging them. This keeps the commit history linear and avoids unnecessary merge commits.

How to Handle Merge Conflicts in Git

Handling merge conflicts in Git is an essential skill for collaborating on projects with multiple contributors.

Merge conflicts occur when changes in different branches or commits overlap or contradict each other, preventing an automatic merge. Resolving these conflicts involves reviewing and manually reconciling the differences to ensure that the final code integrates contributions from all parties accurately.

In practice, effectively managing merge conflicts helps maintain code integrity and facilitates smooth collaboration by ensuring that everyone's changes are correctly incorporated into the project's history.

git mergetool

This launches a merge tool to help you resolve conflicts that arise during a merge or rebase. It opens a graphical interface or a text-based tool configured in your Git settings, allowing you to manually resolve conflicts and finalize the merge.

git rerere

rerere stands for "reuse recorded resolution" and is a feature that helps automatically resolve conflicts in future merges or rebases by reusing conflict resolutions you've previously recorded.

Once enabled, Git records how you resolved conflicts. If the same conflicts arise again, it can apply the same resolutions automatically.

Working Trees in Git

Working trees in Git allow you to have multiple working directories associated with a single repository. This is particularly useful for working on multiple branches simultaneously without the need to constantly switch branches in the same directory.

By using working trees, you can easily manage different features, bug fixes, or experiments in isolated environments, improving workflow efficiency and reducing the risk of conflicts.

git worktree add ../new-branch feature-branch

Creates a new working tree in a directory named "new-branch" based on the "feature-branch".

git worktree list

Lists all working trees associated with the current repository, showing their paths and the branches they are checked out to.

git worktree remove <path>

Removes the specified working tree at the given <path>, deleting the working directory and detaching the branch.

git worktree prune

Removes references to nonexistent working trees, cleaning up the working tree list.

git worktree lock <path>

Locks the specified working tree at the given <path>, preventing it from being pruned.

git worktree unlock <path>

Unlocks the specified working tree at the given <path>, allowing it to be pruned if necessary.

Submodules in Git

Submodules in Git are a way to include and manage external repositories within your own repository. They are particularly useful for reusing code across multiple projects, maintaining dependencies, or integrating third-party libraries.

By using submodules, you can keep your main repository clean and modular, while still ensuring that all necessary components are included and version-controlled.

git submodule init

Initializes submodules in your repository. This command sets up the configuration necessary for the submodules, but doesn't actually clone them.

git submodule update

Clones and checks out the submodules into the specified paths. This is typically run after git submodule init.

git submodule add <repository> <path>

Adds a new submodule to your repository at the specified path, linking it to the specified repository.

git submodule status

Displays the status of all submodules, showing their commit hashes and whether they are up-to-date, modified, or uninitialized.

git submodule foreach <command>

Runs the specified command in each submodule. This is useful for performing batch operations across all submodules.

git submodule sync

Synchronizes the submodule URLs in your configuration file with those in the .gitmodules file, ensuring they are up-to-date.

git submodule deinit <path>

Unregisters the specified submodule, removing its configuration. This doesn't delete the submodule's working directory.

git submodule update --remote

Fetches and updates the submodules to the latest commit from their remote repositories.

git submodule set-url <path> <newurl>

Changes the URL of the specified submodule to the new URL.

git submodule absorbgitdirs

Absorbs the submodule's Git directory into the superproject to simplify the structure.

Thank you for reading! I hope this cheatsheet helps you work more easily in Git.

Express is a Web Framework built upon Node.js.

Node.js is an amazing tool for building networking services and applications.

Express builds on top of its features to provide easy to use functionality that satisfies the needs of the Web Server use-case. It's Open Source, free, easy to extend, and very performant.

There are also lots and lots of pre-built packages you can just drop in and use to do all kinds of things.

You can get a PDF and ePub version of this Express Handbook

Table of Contents

• How to Install Express

• The first "Hello, World" example

• Request Parameters

• How to Send a Response to the Client

• How to Send a JSON Response

• How to Manage Cookies

• How to Work with HTTP Headers

• How to Handle Redirects

• Routing in Express

• Templates in Express

• Express Middleware

• How to Serve Static Assets with Express

• How to Send Files to the Client

• Sessions in Express

• How to Validate Input in Express

• How to Sanitize Input in Express

• How to Handle Forms in Express

• How to Handle File Uploads in Forms in Express

How to Install Express

You can install Express into any project with npm.

If you're in an empty folder, first create a new Node.js project with this command:

npm init -y

then run this:

npm install express

to install Express into the project.

The First "Hello, World" Example

The first example we're going to create is a simple Express Web Server.

Copy this code:

const express = require('express')
const app = express()

app.get('/', (req, res) => res.send('Hello World!'))
app.listen(3000, () => console.log('Server ready'))

Save this to an index.js file in your project root folder, and start the server using this command:

node index.js

You can open the browser to port 3000 on localhost and you should see the Hello World! message.

Those 4 lines of code do a lot behind the scenes.

First, we import the express package to the express value.

We instantiate an application by calling the express() method.

Once we have the application object, we tell it to listen for GET requests on the / path, using the get() method.

There is a method for every HTTP verb: get(), post(), put(), delete(), and patch():

app.get('/', (req, res) => { /* */ })
app.post('/', (req, res) => { /* */ })
app.put('/', (req, res) => { /* */ })
app.delete('/', (req, res) => { /* */ })
app.patch('/', (req, res) => { /* */ })

Those methods accept a callback function – which is called when a request is started – and we need to handle it.

We pass in an arrow function:

(req, res) => res.send('Hello World!')

Express sends us two objects in this callback, which we called req and res. They represent the Request and the Response objects.

Both are standards and you can read more on them here and here.

Request is the HTTP request. It gives us all the request information, including the request parameters, the headers, the body of the request, and more.

Response is the HTTP response object that we'll send to the client.

What we do in this callback is send the 'Hello World!' string to the client, using the Response.send() method.

This method sets that string as the body, and it closes the connection.

The last line of the example actually starts the server, and tells it to listen on port 3000. We pass in a callback that is called when the server is ready to accept new requests.

Request Parameters

I mentioned how the Request object holds all the HTTP request information.

These are the main properties you'll likely use:

How to Send a Response to the Client

In the Hello World example, we used the send() method of the Response object to send a simple string as a response, and to close the connection:

(req, res) => res.send('Hello World!')

If you pass in a string, it sets the Content-Type header to text/html.

If you pass in an object or an array, it sets the application/json Content-Type header, and parses that parameter into JSON.

After this, send() closes the connection.

send() automatically sets the Content-Length HTTP response header, unlike end() which requires you to do that.

How to use end() to send an empty response

An alternative way to send the response, without any body, is by using the Response.end() method:

res.end()

How to set the HTTP response status

Use the status() method on the response object:

res.status(404).end()

or

res.status(404).send('File not found')

sendStatus() is a shortcut:

res.sendStatus(200)
// === res.status(200).send('OK')

res.sendStatus(403)
// === res.status(403).send('Forbidden')

res.sendStatus(404)
// === res.status(404).send('Not Found')

res.sendStatus(500)
// === res.status(500).send('Internal Server Error')

How to Send a JSON Response

When you listen for connections on a route in Express, the callback function will be invoked on every network call with a Request object instance and a Response object instance.

Example:

app.get('/', (req, res) => res.send('Hello World!'))

Here we used the Response.send() method, which accepts any string.

You can send JSON to the client by using Response.json(), a useful method.

It accepts an object or array, and converts it to JSON before sending it:

res.json({ username: 'Flavio' })

How to Manage Cookies

Use the Response.cookie() method to manipulate your cookies.

Examples:

res.cookie('username', 'Flavio')

This method accepts a third parameter, which contains various options:

res.cookie('username', 'Flavio', { domain: '.flaviocopes.com', path: '/administrator', secure: true })

res.cookie('username', 'Flavio', { expires: new Date(Date.now() + 900000), httpOnly: true })

The most useful parameters you can set are:

A cookie can be cleared with:

res.clearCookie('username')

How to Work with HTTP Headers

How to access HTTP headers values from a request

You can access all the HTTP headers using the Request.headers property:

app.get('/', (req, res) => {
  console.log(req.headers)
})

Use the Request.header() method to access one individual request header's value:

app.get('/', (req, res) => {
  req.header('User-Agent')
})

How to change any HTTP header value for a response

You can change any HTTP header value using Response.set():

res.set('Content-Type', 'text/html')

There is a shortcut for the Content-Type header, however:

res.type('.html')
// => 'text/html'

res.type('html')
// => 'text/html'

res.type('json')
// => 'application/json'

res.type('application/json')
// => 'application/json'

res.type('png')
// => image/png:

How to Handle Redirects

Redirects are common in Web Development. You can create a redirect using the Response.redirect() method:

res.redirect('/go-there')

This creates a 302 redirect.

A 301 redirect is made in this way:

res.redirect(301, '/go-there')

You can specify an absolute path (/go-there), an absolute URL (https://anothersite.com), a relative path (go-there) or use the .. to go back one level:

res.redirect('../go-there')
res.redirect('..')

You can also redirect back to the Referrer HTTP header value (defaulting to / if not set) using

res.redirect('back')

Routing in Express

Routing is the process of determining what should happen when a URL is called, or also which parts of the application should handle a specific incoming request.

In the Hello World example we used this code:

app.get('/', (req, res) => { /* */ })

This creates a route that maps accessing the root domain URL / using the HTTP GET method to the response we want to provide.

Named parameters

What if we want to listen for custom requests? Maybe we want to create a service that accepts a string and returns it as uppercase – and we don't want the parameter to be sent as a query string, but as part of the URL. In a case like that, we use named parameters:

app.get('/uppercase/:theValue', (req, res) => res.send(req.params.theValue.toUpperCase()))

If we send a request to /uppercase/test, we'll get TEST in the body of the response.

You can use multiple named parameters in the same URL, and they will all be stored in req.params.

How to use a regular expression to match a path

You can use regular expressions to match multiple paths with one statement:

app.get(/post/, (req, res) => { /* */ })

will match /post, /post/first, /thepost, /posting/something, and so on.

Templates in Express

Express is capable of handling server-side template engines.

Template engines allow us to add data to a view, and generate HTML dynamically.

Express uses Jade as the default. Jade is the old version of Pug, specifically Pug 1.0.

Note that the name was changed from Jade to Pug due to a trademark issue in 2016, when the project released version 2. You can still use Jade, aka Pug 1.0, but going forward, it's best to use Pug 2.0

Although the last version of Jade is getting old, it's still the default in Express for backward compatibility reasons.

In any new project, you should use Pug or another engine of your choice. The official site of Pug is https://pugjs.org/.

You can use many different template engines, including Pug, Handlebars, Mustache, EJS and more.

To use Pug we must first install it:

npm install pug

and when initializing the Express app, we need to set it:

const express = require('express')
const app = express()
app.set('view engine', 'pug')

We can now start writing our templates in .pug files.

Create an about view:

app.get('/about', (req, res) => {
  res.render('about')
})

and the template in views/about.pug:

p Hello from Flavio

This template will create a p tag with the content Hello from Flavio.

You can interpolate a variable using this code:

app.get('/about', (req, res) => {
  res.render('about', { name: 'Flavio' })
})

p Hello from #{name}

Look at the Pug guide for more information on how to use Pug.

This online converter from HTML to Pug will be a great help: https://html-to-pug.com/.

Express Middleware

A middleware is a function that hooks into the routing process, performing an arbitrary operation at some point in the chain (depending on what we want it to do).

It's commonly used to edit the request or response objects, or terminate the request before it reaches the route handler code.

Middleware is added to the execution stack like so:

app.use((req, res, next) => { /* */ })

This is similar to defining a route, but in addition to the Request and Response objects instances, we also have a reference to the next middleware function, which we assign to the variable next.

We always call next() at the end of our middleware function, in order to pass the execution to the next handler. That is unless we want to prematurely end the response and send it back to the client.

You typically use pre-made middleware, in the form of npm packages. You can find a big list of the available ones here.

One example is cookie-parser, which is used to parse cookies into the req.cookies object. You can install it using npm install cookie-parser and you use it like this:

const express = require('express')
const app = express()
const cookieParser = require('cookie-parser')

app.get('/', (req, res) => res.send('Hello World!'))

app.use(cookieParser())
app.listen(3000, () => console.log('Server ready'))

We can also set a middleware function to run for specific routes only (not for all), by using it as the second parameter of the route definition:

const myMiddleware = (req, res, next) => {
  /* ... */
  next()
}

app.get('/', myMiddleware, (req, res) => res.send('Hello World!'))

If you need to store data that's generated in a middleware to pass it down to subsequent middleware functions, or to the request handler, you can use the Request.locals object. It will attach that data to the current request:

req.locals.name = 'Flavio'

How to Serve Static Assets with Express

It's common to have images, CSS, and more in a public subfolder, and expose them to the root level:

const express = require('express')
const app = express()

app.use(express.static('public'))

/* ... */

app.listen(3000, () => console.log('Server ready'))

If you have an index.html file in public/, that will be served if you now hit the root domain URL (http://localhost:3000)

How to Send Files to the Client

Express provides a handy method to transfer a file as an attachment: Response.download().

Once a user hits a route that sends a file using this method, browsers will prompt the user to download.

The Response.download() method allows you to send a file attached to the request, and the browser, instead of showing it in the page, will save it to disk.

app.get('/', (req, res) => res.download('./file.pdf'))

In the context of an app:

const express = require('express')
const app = express()

app.get('/', (req, res) => res.download('./file.pdf'))
app.listen(3000, () => console.log('Server ready'))

You can set the file to be sent with a custom filename:

res.download('./file.pdf', 'user-facing-filename.pdf')

This method provides a callback function which you can use to execute code once the file has been sent:

res.download('./file.pdf', 'user-facing-filename.pdf', (err) => {
  if (err) {
    //handle error
    return
  } else {
    //do something
  }
})

Sessions in Express

By default Express requests are sequential and no request can be linked to another. There is no way to know if this request comes from a client that already performed a request previously.

Users cannot be identified unless using some kind of mechanism that makes it possible.

That's what sessions are.

When implemented, every user of your API or website will be assigned a unique session, and this allows you to store the user's state.

We'll use the express-session module, which is maintained by the Express team.

You can install it using this command:

npm install express-session

and once you're done, you can instantiate it in your application with this one:

const session = require('express-session')

This is a middleware, so you install it in Express using the following:

const express = require('express')
const session = require('express-session')

const app = express()
app.use(session({
  'secret': '343ji43j4n3jn4jk3n'
}))

After this is done, all the requests to the app routes are now using sessions.

secret is the only required parameter, but there are many more you can use. It should be a randomly unique string for your application.

The session is attached to the request, so you can access it using req.session here:

app.get('/', (req, res, next) => {
  // req.session
}

This object can be used to get data out of the session, and also to set data:

req.session.name = 'Flavio'
console.log(req.session.name) // 'Flavio'

This data is serialized as JSON when stored, so you are safe to use nested objects.

You can use sessions to communicate data to middleware that's executed later, or to retrieve it later on, on subsequent requests.

Where is the session data stored? It depends on how you set up the express-session module.

It can store session data in:

• memory, not meant for production

• a database like MySQL or Mongo

• a memory cache like Redis or Memcached

There is a big list of 3rd packages that implement a wide variety of different compatible caching stores in https://github.com/expressjs/session.

All solutions store the session id in a cookie, and keep the data server-side. The client will receive the session id in a cookie, and will send it along with every HTTP request.

We'll reference that server-side to associate the session id with the data stored locally.

Memory is the default, and it requires no special setup on your part. It's the simplest thing but it's meant only for development purposes.

The best choice is a memory cache like Redis, for which you need to setup its own infrastructure.

Another popular package to manage sessions in Express is cookie-session, which has a big difference: it stores data client-side in the cookie.

I do not recommend doing that because storing data in cookies means that it's stored client-side, and sent back and forth in every single request made by the user. It's also limited in size, as it can only store 4 kilobytes of data.

Cookies also need to be secured, but by default they are not, since secure Cookies are possible on HTTPS sites and you need to configure them if you have proxies.

How to Validate Input in Express

Let's see how to validate any data coming in as input in your Express endpoints.

Say you have a POST endpoint that accepts the name, email, and age parameters:

const express = require('express')
const app = express()

app.use(express.json())

app.post('/form', (req, res) => {
  const name  = req.body.name
  const email = req.body.email
  const age   = req.body.age
})

How do you perform server-side validation on those results to make sure that:

• name is a string of at least 3 characters?

• email is a real email?

• age is a number, between 0 and 110?

The best way to handle validation on any kind of input coming from outside in Express is by using the express-validator package:

npm install express-validator

You require the check and validationResult objects from the package:

const { check, validationResult } = require('express-validator');

We pass an array of check() calls as the second argument of the post() call. Every check() call accepts the parameter name as argument. Then we call validationResult() to verify there were no validation errors. If there are any, we tell them to the client:

app.post('/form', [
  check('name').isLength({ min: 3 }),
  check('email').isEmail(),
  check('age').isNumeric()
], (req, res) => {
  const errors = validationResult(req)
  if (!errors.isEmpty()) {
    return res.status(422).json({ errors: errors.array() })
  }

  const name  = req.body.name
  const email = req.body.email
  const age   = req.body.age
})

Notice I used:

• isLength()

• isEmail()

• isNumeric()

There are many more of these methods, all coming from validator.js, including:

• contains(), checks if value contains the specified value

• equals(), checks if value equals the specified value

• isAlpha()

• isAlphanumeric()

• isAscii()

• isBase64()

• isBoolean()

• isCurrency()

• isDecimal()

• isEmpty()

• isFQDN(), checks if it's a fully qualified domain name

• isFloat()

• isHash()

• isHexColor()

• isIP()

• isIn(), checks if the value is in an array of allowed values

• isInt()

• isJSON()

• isLatLong()

• isLength()

• isLowercase()

• isMobilePhone()

• isNumeric()

• isPostalCode()

• isURL()

• isUppercase()

• isWhitelisted(), checks the input against a whitelist of allowed characters

You can validate the input against a regular expression using matches().

Dates can be checked using:

• isAfter(), checks if the entered date is after the one you pass

• isBefore(), checks if the entered date is before the one you pass

• isISO8601()

• isRFC3339()

For exact details on how to use those validators, refer to the docs here.

All those checks can be combined by piping them:

check('name')
  .isAlpha()
  .isLength({ min: 10 })

If there is any error, the server automatically sends a response to communicate the error. For example if the email is not valid, this is what will be returned:

{
  "errors": [{
    "location": "body",
    "msg": "Invalid value",
    "param": "email"
  }]
}

This default error can be overridden for each check you perform, using withMessage():

check('name')
  .isAlpha()
  .withMessage('Must be only alphabetical chars')
  .isLength({ min: 10 })
  .withMessage('Must be at least 10 chars long')

What if you want to write your own special, custom validator? You can use the custom validator.

In the callback function you can reject the validation either by throwing an exception, or by returning a rejected promise:

app.post('/form', [
  check('name').isLength({ min: 3 }),
  check('email').custom(email => {
    if (alreadyHaveEmail(email)) {
      throw new Error('Email already registered')
    }
  }),
  check('age').isNumeric()
], (req, res) => {
  const name  = req.body.name
  const email = req.body.email
  const age   = req.body.age
})

The custom validator:

check('email').custom(email => {
  if (alreadyHaveEmail(email)) {
    throw new Error('Email already registered')
  }
})

can be rewritten like this:

check('email').custom(email => {
  if (alreadyHaveEmail(email)) {
    return Promise.reject('Email already registered')
  }
})

How to Sanitizing Input in Express

You've seen how to validate input that comes from the outside world to your Express app.

There's one thing you quickly learn when you run a public-facing server: never trust the input.

Even if you sanitize and make sure that people can't enter weird things using client-side code, you'll still be subject to people using tools (even just the browser devtools) to POST directly to your endpoints.

Or bots trying every possible combination of exploit known to humans.

What you need to do is sanitize your input.

The express-validator package you already use to validate input can also conveniently be used to perform sanitization.

Say you have a POST endpoint that accepts the name, email, and age parameters:

const express = require('express')
const app = express()

app.use(express.json())

app.post('/form', (req, res) => {
  const name  = req.body.name
  const email = req.body.email
  const age   = req.body.age
})

You might validate it using:

const express = require('express')
const app = express()

app.use(express.json())

app.post('/form', [
  check('name').isLength({ min: 3 }),
  check('email').isEmail(),
  check('age').isNumeric()
], (req, res) => {
  const name  = req.body.name
  const email = req.body.email
  const age   = req.body.age
})

You can add sanitization by piping the sanitization methods after the validation ones:

app.post('/form', [
  check('name').isLength({ min: 3 }).trim().escape(),
  check('email').isEmail().normalizeEmail(),
  check('age').isNumeric().trim().escape()
], (req, res) => {
  //...
})

Here I used the methods:

• trim() trims characters (whitespace by default) at the beginning and at the end of a string

• escape() replaces <, >, &, ', " and / with their corresponding HTML entities

• normalizeEmail() canonicalizes an email address. Accepts several options to lowercase email addresses or subaddresses (for example flavio+newsletters@gmail.com)

Other sanitization methods:

• blacklist() removes characters that appear in the blacklist

• whitelist() removes characters that do not appear in the whitelist

• unescape() replaces HTML encoded entities with <, >, &, ', " and /

• ltrim() like trim(), but only trims characters at the start of the string

• rtrim() like trim(), but only trims characters at the end of the string

• stripLow() removes ASCII control characters, which are normally invisible

Force conversion to a format:

• toBoolean() converts the input string to a boolean. Everything except for '0', 'false' and '' returns true. In strict mode only '1' and 'true' return true.

• toDate() converts the input string to a date, or null if the input is not a date

• toFloat() converts the input string to a float, or NaN if the input is not a float

• toInt() converts the input string to an integer, or NaN if the input is not an integer

Like with custom validators, you can create a custom sanitizer.

In the callback function you just return the sanitized value:

const sanitizeValue = value => {
  //sanitize...
}

app.post('/form', [
  check('value').customSanitizer(value => {
    return sanitizeValue(value)
  }),
], (req, res) => {
  const value  = req.body.value
})

How to Handle Forms in Express

This is an example of an HTML form:

<form method="POST" action="/submit-form">
  <input type="text" name="username" />
  <input type="submit" />
</form>

When the user presses the submit button, the browser will automatically make a POST request to the /submit-form URL on the same origin of the page. The browser sends the data contained, encoded as application/x-www-form-urlencoded. In this particular example, the form data contains the username input field value.

Forms can also send data using the GET method, but the vast majority of the forms you'll build will use POST.

The form data will be sent in the POST request body.

To extract it, you will need to use the express.urlencoded() middleware:

const express = require('express')
const app = express()

app.use(express.urlencoded({
  extended: true
}))

Now, you need to create a POST endpoint on the /submit-form route, and any data will be available on Request.body:

app.post('/submit-form', (req, res) => {
  const username = req.body.username
  //...
  res.end()
})

Don't forget to validate the data before using it with express-validator.

How to Handle File Uploads in Forms in Express

This is an example of an HTML form that allows a user to upload a file:

<form method="POST" action="/submit-form" enctype="multipart/form-data">
  <input type="file" name="document" />
  <input type="submit" />
</form>

Don't forget to add enctype="multipart/form-data" to the form, or files won't be uploaded.

When the user press the submit button, the browser will automatically make a POST request to the /submit-form URL on the same origin of the page. The browser sends the data contained, not encoded as as a normal form application/x-www-form-urlencoded, but as multipart/form-data.

On the server-side, handling multipart data can be tricky and error prone, so we are going to use a utility library called formidable. Here's the GitHub repo – it has over 4000 stars and is well-maintained.

You can install it using:

npm install formidable

Then include it in your Node.js file:

const express = require('express')
const app = express()
const formidable = require('formidable')

Now, in the POST endpoint on the /submit-form route, we instantiate a new Formidable form using formidable.IncomingForm():

app.post('/submit-form', (req, res) => {
  new formidable.IncomingForm()
})

After doing so, we need to be able to parse the form. We can do so synchronously by providing a callback, which means all files are processed. Once formidable is done, it makes them available:

app.post('/submit-form', (req, res) => {
  new formidable.IncomingForm().parse(req, (err, fields, files) => {
    if (err) {
      console.error('Error', err)
      throw err
    }
    console.log('Fields', fields)
    console.log('Files', files)
    for (const file of Object.entries(files)) {
      console.log(file)
    }
  })
})

Or, you can use events instead of a callback. For example, you can be notified when each file is parsed, or other events such as completion of file processing, receiving a non-file field, or if an error occurred:

app.post('/submit-form', (req, res) => {
  new formidable.IncomingForm().parse(req)
    .on('field', (name, field) => {
      console.log('Field', name, field)
    })
    .on('file', (name, file) => {
      console.log('Uploaded file', name, file)
    })
    .on('aborted', () => {
      console.error('Request aborted by the user')
    })
    .on('error', (err) => {
      console.error('Error', err)
      throw err
    })
    .on('end', () => {
      res.end()
    })
})

Whichever way you choose, you'll get one or more Formidable.File objects, which give you information about the file uploaded. These are some of the methods you can call:

• file.size, the file size in bytes

• file.path, the path the file is written to

• file.name, the name of the file

• file.type, the MIME type of the file

The path defaults to the temporary folder and can be modified if you listen for the fileBegin event:

app.post('/submit-form', (req, res) => {
  new formidable.IncomingForm().parse(req)
    .on('fileBegin', (name, file) => {
        file.path = __dirname + '/uploads/' + file.name
    })
    .on('file', (name, file) => {
      console.log('Uploaded file', name, file)
    })
    //...
})

Thank you for reading!

That's it for this handbook. And don't forget that you can get a PDF and ePub version of this Express Handbook if you'd like.

The Swift programming language was created by Apple in 2014. It's the official language that works with the whole Apple Operating Systems lineup: iOS, iPadOS, watchOS, macOS, and tvOS.

Swift is an open source, general purpose, compiled programming language that's statically typed.

Every value has a type assigned. The type of a value is always checked when used as an argument or returned, at compile time. If there is a mismatch, the program will not compile.

Swift's compiler is LLVM, and it is included within Xcode, the standard IDE you use for Apple software development.

Swift is a modern programming language that was designed to "fit" in an ecosystem that was previously designed for a different programming language called Objective-C.

Most of the software running on the iPhone and Mac today is based on Objective-C code, even for official Apple apps. But Swift usage is gaining traction year after year. While Objective-C will be used for years to maintain and improve existing apps, new applications are likely going to be created with Swift.

Before Apple introduced Swift, Objective-C was heavily developed to introduce new capabilities and features. But in the recent years this effort has decreased a lot in favor of Swift development.

This does not mean Objective-C is dead or not worth learning: Objective-C is still an essential tool for any Apple developer.

That said, I am not going to cover Objective-C here, because we're focusing on Swift – the present and future of the Apple platform.

In just 6 years, Swift has gone through 5 major versions, and we're now (at the time of writing) at version 5.

Swift is famously Apple's products language, but it is not an Apple-only language. You can use it on several other platforms.

It is open source, so porting the language to other platforms does not require any permission or licensing, and you can find Swift projects to create Web servers and APIs (https://github.com/vapor/vapor) as well as projects to interact with microcontrollers.

Swift is a general-purpose language, built with modern concepts, and it has a bright future.

What We'll Cover Here

The goal of this book is to get you up and running with Swift, starting from zero.

If you have a Mac or an iPad, I recommend you to download the Playgrounds application made by Apple from the App Store.

This app lets you run snippets of Swift code without having to create a full app first. It's a very handy way to test your code, not just when you start learning, but whenever you need to try some code.

It also contains a series of awesome examples and tutorials to expand your Swift and iOS knowledge.

Note: You can get a PDF and ePub version of this Swift Beginner's Handbook

• Introduction to Swift
• Variables in Swift
• Objects in Swift
• Operators in Swift
• Conditionals in Swift
• Loops in Swift
• How to Write Comments in Swift
• Semicolons in Swift
• Numbers in Swift
• Strings in Swift
• Booleans in Swift
• Arrays in Swift
• Sets in Swift
• Dictionaries in Swift
• Tuples in Swift
• Optionals and nil in Swift
• Enumerations in Swift
• Structures in Swift
• Classes in Swift
• Functions in Swift
• Protocols in Swift
• Where to Go From Here

Variables in Swift

Variables let us assign a value to a label. We define them using the var keyword:

var name = "Roger"
var age = 8

Once a variable is defined, we can change its value:

age = 9

Variables that you do not want to change can be defined as constants, using the let keyword:

let name = "Roger"
let age = 8

Changing the value of a constant is forbidden.

You can't change the value of a constant or you'll get this error

When you define a variable and you assign it a value, Swift implicitly infers the type of it.

8 is an Int value.

"Roger" is a String value.

A decimal number like 3.14 is a Double value.

You can also specify the type at initialization time:

let age: Int = 8

But it's typical to let Swift infer it, and it's mostly done when you declare a variable without initializing it.

You can declare a constant, and initialize it later:

let age : Int

age = 8

Once a variable is defined, it is bound to that type. You cannot assign to it a different type, unless you explicitly convert it.

You can't do this:

var age = 8
age = "nine"

Cannot assign value of type 'String' to type 'Int' error

Int and String are just two of the built-in data types provided by Swift.

Objects in Swift

In Swift, everything is an object. Even the 8 value we assigned to the age variable is an object.

In some languages, objects are a special type. But in Swift, everything is an object and this leads to one particular feature: every value can receive messages.

Each type can have multiple functions associated to it, which we call methods.

For example, talking about the 8 number value, we can call its isMultiple method, to check if the number is a multiple of another number:

isMultiple method

A String value has another set of methods.

A type also has instance variables. For example the String type has the instance variable count, which gives you the number of characters in a string:

instance variable count

Swift has 3 different object types, which we'll see more in details later on: classes, structs and enums.

Those are very different, but they have one thing in common: to object type, we can add methods, and to any value, of any object type, we can send messages.

Operators in Swift

We can use a wide set of operators to operate on values.

We can divide operators in many categories. The first is the number of targets: 1 for unary operators, 2 for binary operators or 3 for the one and only ternary operator.

Then we can divide operators based on the kind of operation they perform:

• assignment operator
• arithmetic operators
• compound assignment operators
• comparison operators
• range operators
• logical operators

plus some more advanced ones, including nil-coalescing, ternary conditional, overflow, bitwise and pointwise operators.

Note: Swift allows you to create your own operators and define how operators work on your types you define.

Assignment operator in Swift

You use the assignment operator to assign a value to a variable:

var age = 8

Or to assign a variable value to another variable:

var age = 8
var another = age

Arithmetic operators in Swift

Swift has a number of binary arithmetic operators: +, -, *, / (division), % (remainder):

1 + 1 //2
2 - 1 //1
2 * 2 //4
4 / 2 //2
4 % 3 //1
4 % 2 //0

- also works as a unary minus operator:

let hotTemperature = 20
let freezingTemperature = -20

You can also use + to concatenate String values:

"Roger" + " is a good dog"

Compound assignment operators in Swift

The compound assignment operators combine the assignment operator with arithmetic operators:

• +=
• -=
• *=
• /=
• %=

Example:

var age = 8
age += 1

Comparison operators in Swift

Swift defines a few comparison operators:

• ==
• !=
• >
• <
• >=
• <=

You can use those operators to get a boolean value (true or false) depending on the result:

let a = 1
let b = 2

a == b //false
a != b //true
a > b // false
a <= b //true

Range operators in Swift

Range operators are used in loops. They allow us to define a range:

0...3 //4 times
0..<3 //3 times

0...count //"count" times
0..<count //"count-1" times

Here's a sample usage:

let count = 3
for i in 0...count {
  //loop body
}

Logical operators in Swift

Swift gives us the following logical operators:

• !, the unary operator NOT
• &&, the binary operator AND
• ||, the binary operator OR

Sample usage:

let condition1 = true
let condition2 = false

!condition1 //false

condition1 && condition2 //false
condition1 || condition2 //true

Those are mostly used in the if conditional expression evaluation:

if condition1 && condition2 {
  //if body
}

Conditionals in Swift

if statements in Swift

if statements are the most popular way to perform a conditional check. We use the if keyword followed by a boolean expression, followed by a block containing code that is run if the condition is true:

let condition = true
if condition == true {
    // code executed if the condition is true
}

An else block is executed if the condition is false:

let condition = true
if condition == true {
    // code executed if the condition is true
} else {
    // code executed if the condition is false
}

You can optionally wrap the condition validation into parentheses if you prefer:

if (condition == true) {
    // ...
}

And you can also just write:

if condition {
    // runs if `condition` is `true`
}

or

if !condition {
    // runs if `condition` is `false`
}

One thing that separates Swift from many other languages is that it prevents bugs caused by erroneously doing an assignment instead of a comparison. This means you can't do this:

if condition = true {
    // The program does not compile
}

The reason is that the assignment operator does not return anything, but the if conditional must be a boolean expression.

switch statements in Swift

Switch statements are a handy way to create a conditional with multiple options:

var name = "Roger"

switch name {
case "Roger":
    print("Hello, mr. Roger!")
default: 
    print("Hello, \(name)")
}

When the code of a case ends, the switch exits automatically.

A switch in Swift needs to cover all cases. If the tag, name in this case, is a string that can have any value, we need to add a default case, mandatory.

Otherwise with an enumeration, you can simply list all the options:

enum Animal {
    case dog
    case cat
}

var animal: Animal = .dog

switch animal {
case .dog:
    print("Hello, dog!")
case .cat:
    print("Hello, cat!")
}

A case can be a Range:

var age = 20

switch age {
case 0..<18:
    print("You can't drive!!")
default: 
    print("You can drive")
}

Ternary conditional operator in Swift

The ternary conditional operator is a shorter version of an if expression. It allows us to execute an expression if a condition is true, and another expression if the condition is false.

Here is the syntax:

`condition` ? `value if true` : `value if false`

Example:

let num1 = 1
let num2 = 2

let smallerNumber = num1 < num2 ? num1 : num2 

// smallerNumber == 1

The syntax is shorter than an if statement, and sometimes it might make more sense to use it.

Loops in Swift

for-in loops in Swift

You can use for-in loops to iterate a specific amount of times, using a range operator:

for index in 0...3 {
  //iterate 4 times, `index` is: 0, 1, 2, 3
}

You can iterate over the elements of an array or set:

let list = ["a", "b", "c"]
for item in list {
  // `item` contains the element value
}

And on the elements of a dictionary:

let list = ["a": 1, "b": 2, "c": 2]
for (key, value) in list {
  // `key` contains the item key
  // `value` contains the item value
}

while loops in Swift

A while loop can be used to iterate on anything, and will run while the condition is true:

while [condition] {
    //statements...
}

The condition is checked at the start, before the loop block is executed.

Example:

var item = 0
while item <= 3 { //repeats 3 times
    print(item)
    item += 1
}

repeat-while loops in Swift

A repeat-while loop in Swift is similar to the while loop. But in this case the condition is checked at the end, after the loop block, so the loop block is executed at least once. Then the condition is checked, and if it is evaluated as true, the loop block is repeated:

repeat {
    //statements...
} while [condition]

Example:

var item = 0
repeat { //repeats 3 times
    print(item)
    item += 1
} while item < 3

continue and break statements in Swift

Swift provides you 2 statements that you can use to control the flow inside a loop: continue and break.

You use continue to stop the current iteration, and run the next iteration of the loop.

break ends the loop, not executing any other iteration.

Example:

let list = ["a", "b", "c"]
for item in list {
  if (item == "b") {
    break
  }
  //do something
}

How to Write Comments in Swift

A comment in Swift can take 2 forms: a single-line comment, and a multi-line comment.

A single-line comment looks like this:

//this is a comment

and and you can put it at the end of a line of code:

let a = 1 //this is a comment

A multi-line comment is written using this syntax:

/* this
 is
    a multi-line
 comment
*/

Swift allows you to nest multi-line comments:

/* this
 is
    a /* nested */ multi-line
 comment
*/

This is handy especially when commenting out large portions of code that already contain multi-line comments.

Semicolons in Swift

In Swift, semicolons are generally optional.

You can write statements on separate lines, and you don't need to add a semicolon:

let list = ["a", "b", "c"]
var a = 2

You can add a semicolon, but it adds nothing meaningful in this case:

let list = ["a", "b", "c"];
var a = 2;

But if you want to write more than one statement on the same line, then you need to add a semicolon:

var a = 2; let b = 3

Numbers in Swift

In Swift, numbers have 2 main types: Int and Double.

An Int is a number without decimal point. A Double is a number with decimal point.

Both use 64 bits, on modern computers that work with 64 bits, and 32 bit on 32-bit platforms.

The range of values they can store depends on the platform used, and can be retrieved using the int property of each type:

Range of int values

Then, in addition to Int and Double, we have lots of other numeric types. These were mostly used to interact with APIs built in the past and that needed to interact with C or Objective-C, and you must be aware that we have them:

• Int8 is an integer with 8 bits
• Int16 is an integer with 16 bits
• Int32 is an integer with 32 bits
• Int64 is an integer with 64 bits
• UInt8 is an unsigned integer with 8 bits
• UInt16 is an unsigned integer with 16 bits
• UInt32 is an unsigned integer with 32 bits
• UInt64 is an unsigned integer with 64 bits
• UInt is like Int, but unsigned, and it ranges from 0 to Int.max * 2.
• Float is a decimal number with 32 bits.

Then using Cocoa APIs you might use other numeric types like CLong, CGFloat, and more.

You will always use Int or Double in your code, and use those specific types only in particular cases.

Remember that you can always convert any of those types to Int and Double types, instantiating a number passing the value inside parentheses to Double() or Int():

let age : UInt8 = 3
let intAge = Int(age)

You can also convert a number from Double to Int:

let age = Double(3)
let count = Int(3.14)

How to convert a number from Double to Int

Strings in Swift

Strings are one of the most popular tools in programming.

In Swift, you can define a string using the string literal syntax:

let name = "Roger"

We use double quotes. Single quotes are not valid string delimiters.

A string can span over multiple lines using 3 double quotes:

let description = """
    a long
      long 
          long description
    """

You can use string interpolation to embed an expression in a string:

let age = 8

let name = """
    Roger, age \(age)
    Next year he will be \(age + 1)
    """

You can concatenate two strings with the + operator:

var name = "Roger"
name = name + " The Dog"

And you can append text to a string with the += operator:

var name = "Roger"
name += " The Dog"

Or using the append(_:) method:

var name = "Roger"
name.append(" The Dog")

You can count the characters in a string using the count string property:

let name = "Roger"
name.count //5

Any string comes with a set of useful methods, for example:

• removeFirst() to remove the first character
• removeLast() to remove the last character
• lowercased() to get a new string, lowercased
• uppercased() to get a new string, uppercased
• starts(with:) which returns true if the string starts with a specific substring
• contains() which returns true if the string contains a specific character

and many, many more.

When you need to reference an item in the string, since strings in Swift are unicode, we can't simply reference the letter o in let name = "Roger" using name[1]. You need to work with indexes.

Any string provides the starting index with the startIndex property:

let name = "Roger"
name.startIndex //0

To calculate a specific index in the string, you calculate it using the index(i:offsetBy:) method:

let name = "Roger"
let i = name.index(name.startIndex, offsetBy: 2)
name[i] //"g"

You can also use the index to get a substring:

let name = "Roger"
let i = name.index(name.startIndex, offsetBy: 2)
name.suffix(from: i) //"ger"

//Or using the subscript:

name[i...] //"ger"

When you get a substring from a string, the type of the result is Substring, not String.

let name = "Roger"
let i = name.index(name.startIndex, offsetBy: 2)
print(type(of: name.suffix(from: i))) 
//Substring

Substrings are more memory efficient, because you do not get a new string, but the same memory structure is used behind the scenes. But you need to be careful when you deal with strings a lot, as there are optimizations you can implement.

Strings are collections, and they can be iterated over in loops.

Booleans in Swift

Swift provides the Bool type, which can have two values: true and false.

var done = false
done = true

Booleans are especially useful with conditional control structures like if statements or the ternary conditional operator:

var done = true

if done == true {
    //code
}

Arrays in Swift

We use arrays to create a collection of items.

In this example we create an array holding 3 integers:

var list = [1, 2, 3]

We can access the first item using the syntax list[0], the second using list[1], and so on.

Elements in an array in Swift must have the same type.

The type can be inferred if you initialize the array at declaration time, like in the case above.

Otherwise the type of values an array can include must be declared, in this way:

var list: [Int] = []

Another shorthand syntax is:

var list = [Int]()

You can also explicitly declare the type at initialization, like this:

var list: [Int] = [1, 2, 3]

A quick way to initialize an array is to use the range operator:

var list = Array(1...4) //[1, 2, 3, 4]

To get the number of items in the array, use the count property:

var list = [1, 2, 3]
list.count //3

If an array is empty, its isEmpty property is true.

var list = [1, 2, 3]
list.isEmpty //false

You can append an item at the end of the array using the append() method:

var list: [Int] = [1, 2, 3]
list.append(4)

or you can insert an item at any position of the array using insert(newElement: <Type> at: Int):

var list: [Int] = [1, 2, 3]
list.insert(17, at: 2)
//list is [1, 2, 17, 3]

An array must be declared as var to be modified. If it's declared with let, you cannot modify it by adding or removing elements.

To remove one item from the array, use remove(at:) passing the index of the element to remove:

var list: [Int] = [1, 2, 3]
list.remove(1)
//list is [1, 3]

removeLast() and removeFirst() are two handy ways to remove the last and first element.

To remove all items from the array, you can use removeAll() or you can assign an empty array:

var list: [Int] = [1, 2, 3]
list.removeAll()
//or
list = []

The sort() method sorts the array:

var list = [3, 1, 2]
list.sort()
//list is [1, 2, 3]

There are a lot more methods, but those are the basic ones.

Arrays are equal when they contain the same elements, of the same type:

[1, 2, 3] == [1, 2, 3] //true

Arrays are passed by value, which means if you pass an array to a function, or return it from a function, the array is copied.

Arrays are collections, and they can be iterated over in loops.

Sets in Swift

You use sets to create collections of non-repeated items.

While an array can contain many times the same item, you only have unique items in a set.

You can declare a set of Int values in this way:

let set: Set<Int> = [1, 2, 3]

or you can initialize it from an array:

let set = Set([1, 2, 3])

You can add items to the set using insert():

var set = Set([1, 2, 3])
set.insert(17)

Unlike arrays, there is no order or position in a set. Items are retrieved and inserted randomly.

The way to print the content of a set so it's ordered is to transform it into an array using the sorted() method:

var set = Set([2, 1, 3])
let orderedList = set.sorted()

To check if a set contains an element, use the contains() method:

var set = Set([1, 2, 3])
set.contains(2) //true

To get the number of items in the set, use the count property:

let set = Set([1, 2, 3])
set.count //3

If a set is empty, its isEmpty property is true.

let set = Set([1, 2, 3])
set.isEmpty //false

To remove one item from the array, use remove() passing the value of the element:

var set = Set([1, 2, 3])
set.remove(1)
//set is [2, 3]

To remove all items from the set, you can use removeAll():

set.removeAll()

Sets, like arrays, are passed by value. This means that if you pass it to a function, or return it from a function, the set is copied.

Sets are great to perform set math operations like intersection, union, subtracting, and more.

These methods help with this:

• intersection(_:)
• symmetricDifference(_:)
• union(_:)
• subtracting(_:)
• isSubset(of:)
• isSuperset(of:)
• isStrictSubset(of:)
• isStrictSuperset(of:)
• isDisjoint(with:)

Sets are collections, and they can be iterated over in loops.

Dictionaries in Swift

We use dictionaries to create a collection of key-value pairs.

Here is how to create a dictionary with 1 key-value pair, where the key is a String and the value is an Int:

var dict = ["Roger": 8, "Syd": 7]

In this case the type is inferred. You can also explicitly set the type at declaration time:

var dict: [String: Int] = ["Roger": 8, "Syd": 7]

In this example we create an empty dictionary of Int keys and String values:

var dict = [String: Int]()

//or

var dict: [String: Int] = [:]

You can access the value assigned to a key using this syntax:

var dict = ["Roger": 8, "Syd": 7]

dict["Roger"] //8
dict["Syd"] //7

You can change the value assigned to a key in this way:

dict["Roger"] = 9

A dictionary must be declared as var to be modified. If it's declared with let, you cannot modify it by adding or removing elements.

Use the same syntax to add a new key/value pair:

dict["Tina"] = 4

To remove a key/value pair, assign the value to nil:

dict["Tina"] = nil

Or call the removeValue(forKey:) method:

dict.removeValue(forKey: "Tina")

To get the number of items in the dictionary, use the count property:

var dict = ["Roger": 8, "Syd": 7]
dict.count //2

If a dictionary is empty, its isEmpty property is true.

var dict = [String: Int]()
dict.isEmpty //true

There are a lot of methods related to dictionaries, but those are the basic ones.

Dictionaries are passed by value, which means if you pass it to a function, or return it from a function, the dictionary is copied.

Dictionaries are collections, and they can be iterated over in loops.

Tuples in Swift

You use tuples to group multiple values into a single collection. For example you can declare a variable dog containing a String and an Int value:

let dog : (String, Int)

And you can initialize them with a name and an age

let dog : (String, Int) = ("Roger", 8)

But as with any other variable, the type can be inferred during initialization:

let dog = ("Roger", 8)

You can use named elements:

let dog = (name: "Roger", age: 8)

dog.name //"Roger"
dog.age //8

Once a tuple is defined, you can decompose it to individual variables in this way:

let dog = ("Roger", 8)
let (name, age) = dog

and if you need to just get one of the values, you can use the special underscore keyword to ignore the other ones:

let dog = ("Roger", 8)
let (name, _) = dog

Tuples are an awesome tool for various needs.

The most obvious one is that they're a short way to group similar data.

Another one of those needs is returning multiple items from a function. A function can only return a single item, so a tuple is a convenient structure for that.

Another handy functionality allowed by tuples is swapping elements:

var a = 1
var b = 2

(a, b) = (b, a)

//a == 2
//b == 1

Optionals and nil in Swift

Optionals are one key feature of Swift.

When you don't know if a value will be present or absent, you declare the type as an optional.

The optional wraps another value with its own type. Or maybe not.

We declare an optional by adding a question mark after its type, like this:

var value: Int? = 10

Now value is not an Int value. It's an optional wrapping an Int value.

To find out if the optional wraps a value, you must unwrap it.

You do so using an exclamation mark:

var value: Int? = 10
print(value!) //10

Swift methods often return an optional. For example the Int type initializer accepts a string, and returns an Int optional:

Int type initializer takes in a string and returns an int optional

This is because it does not know if the string can be converted to a number.

If the optional does not contain a value, it evaluates as nil, and you cannot unwrap it:

Evaluating to nil

nil is a special value that cannot be assigned to a variable. Only to an optional:

You can only assign nil to an optional (not an int)

You typically use if statements to unwrap values in your code, like this:

var value: Int? = 2

if let age = value {
    print(age)
}

Enumerations in Swift

Enumerations are a way to group a set of different options under a common name.

Example:

enum Animal {
    case dog
    case cat
    case mouse
    case horse
}

This Animal enum is now a type.

A type whose value can only be one of the cases listed.

If you define a variable of type Animal:

var animal: Animal

you can later decide which value to assign it using this syntax:

var animal: Animal
animal = .dog

We can use enumerations in control structures like switches:

enum Animal {
    case dog
    case cat
    case mouse
    case horse
}

let animal = Animal.dog

switch animal {
case .dog: print("dog")
case .cat: print("cat")
default: print("another animal")
}

Enumeration values can be strings, characters, or numbers.

You can also define an enum on a single line:

enum Animal {
    case dog, cat, mouse, horse
}

And you can also add type declaration to the enumeration, and each case has a value of that type assigned:

enum Animal: Int {
    case dog = 1
    case cat = 2
    case mouse = 3
    case horse = 4
}

Once you have a variable, you can get this value using its rawValue property:

enum Animal: Int {
    case dog = 1
    case cat = 2
    case mouse = 3
    case horse = 4
}

var animal: Animal
animal = .dog

animal.rawValue //1

Enumerations are a value type. This means they are copied when passed to a function, or when returned from a function. And when we assign a variable pointing to an enumeration to another variable.

Structures in Swift

Structures are an essential Swift concept.

Structures are everywhere in Swift. Even the built-in types are structures.

We can create instances of structures, which we call objects.

In most languages, objects can only be created from classes. Swift has classes, too, but you can create objects also from structures. The official documentation actually advises that you should prefer structures because they are easier to use.

Structures are a light versions of classes.

A struct can:

• have properties
• have methods (functions)
• define subscripts
• define initializers
• conform to protocols
• be extended

One important thing classes allow is inheritance, so if you need that, you have classes.

A struct is defined using this syntax:

struct Dog {

}

Inside a structure you can define stored properties:

struct Dog {
    var age = 8
    var name = "Roger"
}

This structure definition defines a type. To create a new instance with this type, we use this syntax:

let roger = Dog()

Once you have an instance, you can access its properties using the dot syntax:

let roger = Dog()
roger.age
roger.name

The same dot syntax is used to update a property value:

roger.age = 9

You can also create a struct instance by passing the values of the properties:

let syd = Dog(age: 7, name: "Syd")
syd.age
syd.name

To do so, properties must be defined variables with var, not as constants (with let). It's also important to respect the order those properties are defined.

Structures can have instance methods: functions that belong to an instance of a structure.

struct Dog {
    var age = 8
    var name = "Roger"
    func bark() {
        print("\(name): wof!")
    }
}

And we also have type methods:

struct Dog {
    var age = 8
    var name = "Roger"
    func bark() {
        print("\(name): wof!")
    }
    static func hello() {
        print("Hello I am the Dog struct")
    }
}

This is invoked as Dog.hello().

Structures are a value type. This means they are copied when passed to a function, or when returned from a function. And when we assign a variable pointing to a structure to another variable.

This also means that if we want to update the properties of a structure we must define it using var and not let.

All types in Swift are defined as structures: Int, Double, String, arrays and dictionaries, and more are structures.

Classes in Swift

Classes are a bit similar to structures, but they have some key differences.

A class is defined using this syntax:

class Dog {

}

Inside a class you can define stored properties:

class Dog {
    var age = 0
}

A class definition defines a type. To create a new instance with this type, we use this syntax:

let roger = Dog()

Once you have an instance, you can access its properties using the dot syntax:

let roger = Dog()
roger.age

You use the same dot syntax to update a property value:

roger.age = 9

One big difference is that classes are reference types. Structures (and enumerations) are value types.

This means that assigning a class instance to another variable does not copy the instance. Both variables point to the same instance:

class Dog {
    var age = 0
}

let roger = Dog()
let syd = roger

roger.age = 9
//syd.age == 9

This also means we can define a reference to a class using let, and we can change its properties, as you saw in the example above.

We can create instances of classes, and we call them objects.

As with structs, classes can have properties, methods, and more.

Contrary to structs, we must define an initializer in order to initialize the values when we create an instance:

class Dog {
    var age : Int

    init(age: Int) {
        self.age = age
    }
}

let roger = Dog(age: 9)

You can only declare properties without initializing them if you have an initializer.

See the use of self. We need it because age is both an instance property and the init(age:) method parameter. self.age references the age instance property.

Classes can have instance methods: functions that belong to an instance of a class.

class Dog {
    var age = 8
    var name = "Roger"

    func bark() {
      print("\(name): wof!")
    }
}

And we also have type methods:

class Dog {
    var age = 8
    var name = "Roger"

    func bark() {
        print("\(name): wof!")
    }
    static func hello() {
        print("Hello I am the Dog struct")
    }
}

Invoked as Dog.hello().

One important thing classes allow is inheritance.

A class can inherit all the properties and methods from another class.

Say we have a class Animal. Every animal has an age:

class Animal {
    var age: Int
}

Not every animal has a name. Dogs have a name. So we create a Dog class extending from Animal:

class Dog: Animal {
    var name: String
}

Now we must add an initializer for both classes. In the Dog case, after we do the class-specific initialization, we can call the parent class initializer using super.init():

class Animal {
    var age: Int

    init(age: Int) {
        self.age = age
    }
}

class Dog: Animal {
    var name: String

    init(age: Int, name: String) {
        self.name = name
        super.init(age: age)
    }
}

var horse = Animal(age: 8)
var roger = Dog(age: 8, name: "Roger")

Animal is now a superclass, and Dog is a subclass.

There's more to say about classes, but this is a good introduction.

Functions in Swift

Your program's code is organized into functions.

You can declare a function using the func keyword:

func bark() {
    print("woof!")
}

Functions can be assigned to structures, classes and enumerations, and in this case we call them methods.

A function is invoked using its name:

bark()

A function can return a value:

func bark() -> String {
    print("woof!")
      return "barked successfully"
}

And you can assign it to a variable:

let result = bark()

A function can accept parameters. Each parameter has a name and a type:

func bark(times: Int) {
    for index in 0..<times {
        print("woof!")
    }
}

The name of a parameter is internal to the function.

We use the name of the parameter when we call the function to pass in its value:

bark(times: 3)

When we call the function we must pass all the parameters defined.

Here is a function that accepts multiple parameters:

func bark(times: Int, repeatBark: Bool) {
    for index in 0..<times {
        if repeatBark == true {
            print("woof woof!")
        } else {
            print("woof!")
        }            
    }
}

In this case you call it in this way:

bark(times: 3, repeat: true)

When we talk about this function, we don't call it bark(). We call it bark(times:repeat:).

This is because we can have multiple functions with the same name, but different set of parameters.

You can avoid using labels by using the _ keyword:

func bark(_ times: Int, repeatBark: Bool) {
    //...the function body
}

So you can invoke it in this way:

bark(3, repeat: true)

It's common in Swift and iOS APIs to have the first parameter with no label, and the other parameters labeled.

It makes for a nice and expressive API, when you design the names of the function and the parameters nicely.

You can only return one value from a function. If you need to return multiple values, it's common to return a tuple:

func bark() -> (String, Int) {
    print("woof!")
      return ("barked successfully", 1)
}

And you can assign the result to a tuple:

let (result, num) = bark()

print(result) //"barked successfully"
print(num) //1

You can nest functions inside other functions. When this happens, the inner function is invisible to outside the outer function.

Protocols in Swift

A protocol is a way to have different objects, of different types, have a common set of functionalities.

You define a protocol like this:

protocol Mammal {

}

Structs and classes can adopt a protocol in this way:

struct Dog: Mammal {

}

class Cat: Mammal {

}

A protocol can define properties and methods, without providing values and implementations, and a struct/class must implement them:

protocol Mammal {
    var age: Int { get set }
    func walk()
}

The property can be defined as get or get set. If it's get, the property must be implemented as read only, with a getter.

Any type that adopts the protocol must conform to the protocol by implementing those methods or providing those properties:

struct Dog: Mammal {
    var age: Int = 0
    func walk() {
        print("The dog is walking")
    }
}

class Cat: Mammal {
    var age: Int = 0
    func walk() {
        print("The cat is walking")
    }
}

Structs and classes can adopt multiple protocols:

struct Dog: Mammal, Animal {

}

class Cat: Mammal, Animal {

}

Notice that for classes, this is the same syntax used to define a superclass. If there is a superclass, list it as the first item in the list, after the colon.

Where to Go From Here

I hope this little handbook was useful in shining a light on how to get started with Swift. And I hope you are now interested to learn more about it!

I can now point you to a few places to learn more:

• The official Swift Language Guide
• The Swift Standard Library
• WWDC Swift videos

You can get a PDF and ePub version of this Swift Beginner's Handbook here.

It’s compiled, open source, and strongly typed.

Golang – also called Go – was created by Google engineers with these main goals:

• make their projects compile (and run) faster
• be simple so people can pick it up in little time
• be low level enough but also avoid some pitfalls of being too low level
• be portable (compiled Go programs are binaries that do not require other files to run and are cross-platform, so they can be distributed easily)
• be boring, stable, predictable, offer less opportunities to make mistakes
• make it easy to take advantage of multiprocessor systems

Go was meant to be a replacement for C and C++ codebases. It aims to make some things simpler like concurrency and memory management, with garbage collection.

Also, it was built to work along with C and C++ codebases, thanks to its C interoperability features.

You can use Go for many different tasks, and it can solve both simple problems and very complex ones.

You can use Go to create command line utilities and networking servers, and it's widely used in many different scenarios.

For example, Docker and Kubernetes are written in Go.

My favorite Static Site Generator (Hugo) is written in Go.

Caddy, a quite popular web server, is written in Go.

There’s lots of different, widely used tools that use this programming language under the hood.

This handbook will introduce you to the Go programming language so you can get started coding in Go.

You can get a PDF and ePub version of this Go Beginner's Handbook here.

Table of Contents

1. How to get started with Go
2. How to install Go
3. How to setup your editor
4. How to write Hello, World! in Go
5. How to compile and run a Go program
6. The Go workspace
7. Diving into the Go language
8. Variables in Go
9. Basic types in Go
10. Strings in Go
11. Arrays in Go
12. Slices in Go
13. Maps in Go
14. Loops in Go
15. Conditionals in Go
16. Operators in Go
17. Structs in Go
18. Functions in Go
19. Pointers in Go
20. Methods in Go
21. Interfaces in Go
22. Where to go from here

How to Get Started with Go

Here are a few things you should know before we dive into the specifics of the language.

First, https://go.dev is the homepage of the language. This will be your go-to resource to:

• Download the Go binaries (the go command and other related tools) from https://go.dev/doc/install
• Reference the official Go documentation https://go.dev/doc/
• See all the the Go packages https://pkg.go.dev/
• Access the Go Playground https://go.dev/play/

…and more.

How to Install Go

Go to https://go.dev/doc/install and download the package for your Operating System.

Run the installer, and at the end of the process you will have the go command available in your terminal:

Welcome to the Go installer

Successful installation modal

Open the terminal and run go version and you should see something like this:

Displaying the Go version you have

NOTE: you might have to open a new terminal before you can run the program, as the installer added the Go binaries folder to the path.

The exact location of the Go installation files will depend on your Operating System.

On macOS, it’s under /usr/local/go, with binaries in /usr/local/go/bin.

On Windows, it will be under C:\Program Files\go.

The Windows and Mac installers will set the Go binaries path automatically.

On a Mac you might also want to install Go via Homebrew using brew install golang. This will make it easier to update later.

On Linux you will have to add the Go binaries folder to your terminal path before you can run the go command after unpackaging the Linux package to /usr/local/go with this command:

echo 'export PATH=$PATH:/usr/local/go/bin' >> $HOME/.profile
source $HOME/.profile

How to Setup Your Editor

I recommend using Visual Studio Code (aka VS Code) as your editor.

Read Go in Visual Studio Code for a quick “up and running” setup. At the bare minimum, install the Go extension.

Go extension for VSCode

This extension will make your life easier, as it provides IntelliSense (syntax highlighting, autocompletion, on hover information, error highlighting…) and other things like auto formatting, menu options to install packages, testing, and more.

How to Write Hello, World! in Go

Now we’re ready to create our first Go program!

It’s a programmer's tradition to make the first program print the “Hello, World!” string to the terminal when it’s run. So we’ll do that first, and then we’ll explain how we did it.

Maybe you have a folder in your home directory where you keep all your coding projects and tests.

In there, create a new folder, for example call it hello.

In there, create a hello.go file (you can name it as you want).

Add this content:

package main

import "fmt"

func main() {
    fmt.Println("Hello, World!")
}

Go "Hello, World!" code

This is your first Go program!

Let’s analyze this line by line.

package main

We organize Go programs in packages.

Each .go file first declares which package it is part of.

A package can be composed by multiple files, or just one file.

A program can contain multiple packages.

The main package is the entry point of the program and identifies an executable program.

import "fmt"

We use the import keyword to import a package.

fmt is a built-in package provided by Go that provides input/output utility functions.

We have a large standard library ready to use that we can use for anything from network connectivity to math, crypto, image processing, filesystem access, and more.

You can read about all the features that this fmt package provides on the official documentation.

func main() {

}

Here we declare the main() function.

What’s a function? We’ll see more about them later, but in the meantime let’s say a function is a block of code that’s assigned a name, and contains some instructions.

The main function is special because what’s where the program starts.

In this simple case we just have one function – the program starts with that and then ends.

fmt.Println("Hello, World!")

This is the content of the function we defined.

We call the Println() function defined in the fmt package we previously imported, passing a string as a parameter.

This function, according to the docs "formats according to a format specifier and writes to standard output”.

Take a look at the docs because they are great. They even have examples you can run:

Go basic function example

We use the “dot” syntax fmt.Println() to specify that the function is provided by that package.

After the code executes the main function, it has nothing else to do and the execution ends.

How to Compile and Run a Go program

Now open the terminal in the hello folder and run the program using:

go run hello.go

Hello world output in Go

Our program ran successfully, and it printed “Hello, World!” to the terminal.

The go run tool first compiles and then runs the program specified.

You can create a binary using go build:

go build hello.go

This will create a hello file that’s a binary you can execute:

Executable binary in Go

In the introduction I mentioned that Go is portable.

Now you can distribute this binary and everyone can run the program as-is, because the binary is already packaged for execution.

The program will run on the same architecture we built it on.

We can create a different binary for a different architecture using the GOOS and GOARCH environment variables, like this:

GOOS=windows GOARCH=amd64 go build hello.go

This will create a hello.exe executable for 64-bit Windows machines:

Hello.exe executable

Setup for 64-bit macOS (Intel or Apple Silicon) is GOOS=darwin GOARCH=amd64 and Linux is GOOS=linux GOARCH=amd64.

This is one of the best features of Go.

The Go Workspace

One special thing about Go is what we call the workspace.

The workspace is the “home base” for Go.

By default Go picks the $HOME/go path, so you will see a go folder in your home.

It’s first created when you install a package (as we’ll see later) but also to store some tooling.

For example the moment I loaded the hello.go file in VS Code, it prompted me to install the [gopls](https://pkg.go.dev/golang.org/x/tools/gopls) command, the Delve debugger (dlv), and the staticcheck linter.

They were automatically installed under $HOME/go:

$HOME/go

When you install packages using go install, they will be stored here.

This is what we call GOPATH.

You can change the GOPATH environment variable to change where Go should install packages.

This is useful when working on different projects at the same time and you want to isolate the libraries you use.

Diving into the Go Language

Now that we've got the first notions in place, and we ran our first Hello, World! program, we can dive into the language.

The language has no semantically significant whitespace. This is like C, C++, Rust, Java, JavaScript, but unlike Python, where whitespace is meaningful and is used to create blocks instead of curly brackets.

Semicolons are optional, like in JavaScript (unlike in C, C++, Rust or Java).

Go takes indentation and visual order very seriously.

When we install Go we also get access to the gofmt command line tool which we can use to format Go programs. VS Code uses that under the hood to format Go source files.

This is very interesting and innovative because formatting and issues like tabs vs spaces or “should I put the curly brackets on the same line of the loop definition or in the next line” are a huge waste of time.

The language creators defined the rules, and everyone uses those rules.

This is great for projects with large teams.

I recommend you enable in the VS Code Settings “Format on Save” and “Format on Paste”:

VS Code settings for Go - Format on Paste and Format on Save

You can write comments in Go using the usual C / C++ / JavaScript / Java syntax:

// this is a line comment

/*
multi
line
comment
*/

Variables in Go

One of the first things you do in a programming language is defining a variable.

In Go we define variables using var:

var age = 20

You can define variables at the package level:

package main

import "fmt"

var age = 20

func main() {
    fmt.Println("Hello, World!")
}

or inside a function:

package main

import "fmt"

func main() {
    var age = 20

    fmt.Println("Hello, World!")
}

Defined at the package level, a variable is visible across all the files that compose the package. A package can be composed of multiple files, you just need to create another file and use the same package name at the top.

Defined at the function level, a variable is visible only within that function. It’s initialized when the function is called, and destroyed when the function ends the execution.

In the example we used:

var age = 20

we assign the value 20 to age.

This makes Go determine that the type of the variable age is int.

We’ll see more about types later, but you should know there are many different ones, starting with int, string, and bool.

We can also declare a variable without an existing value, but in this case we must set the type like this:

var age int
var name string
var done bool

When you know the value, you typically use the short variable declaration with the := operator:

age := 10
name := "Roger"

For the name of the variable you can use letters, digits, and the underscore _ as long as the name starts with a character or _.

Names are case sensitive.

If the name is long, it’s common to use camelCase. So to indicate the name of the car we use carName.

You can assign a new value to a variable with the assignment operator =

var age int
age = 10
age = 11

If you have a variable that never changes during the program you can declare it as a constant using const:

const age = 10

You can declare multiple variables on a single line:

var age, name

and initialize them too:

var age, name = 10, "Roger"

//or

age, name := 10, "Roger"

Declared variables that are not used in the program raise an error and the program does not compile.

You will see a warning in VS Code:

Warning for unused declared variables

and the error from the compiler:

Error in compiler for unused declared variables

If you declare a variable without initializing it to a value, it is assigned a value automatically that depends on the type – for example an integer is 0 and a string is an empty string.

Basic Types in Go

Go is a typed language.

We saw how you can declare a variable, specifying its type:

var age int

Or you can let Go infer the type from the initial value assigned:

var age = 10

The basic types in Go are:

• Integers (int, int8, int16, int32, rune, int64, uint, uintptr, uint8, uint16, uint64)
• Floats (float32, float64), useful to represent decimals
• Complex types (complex64, complex128), useful in math
• Byte (byte), represents a single ASCII character
• Strings (string), a set of bytes
• Booleans (bool), either true or false

We have a lot of different types to represent integers. You will use int most of the time, and you might choose a more specialized one for optimization (not something you need to think about when you are just learning).

An int type will default to be 64 bits when used on a 64 bit system, 32 bits on a 32 bit system, and so on.

uint is an int that’s unsigned, and you can use this to double the amount of values you can store if you know the number is not going to be negative.

All the above basic types are value types, which means they are passed by value to functions when passed as parameters, or when returned from functions.

Strings in Go

A string in Go is a sequence of byte values.

As we saw above, you can define a string using this syntax:

var name = "test"

It’s important to note that unlike other languages, strings are defined only using double quotes, not single quotes.

To get the length of a string, use the built-in len() function:

len(name) //4

You can access individual characters using square brackets, passing the index of the character you want to get:

name[0] //"t" (indexes start at 0)
name[1] //"e"

You can get a portion of the string using this syntax:

name[0:2] //"te"
name[:2]  //"te"
name[2:]  //"st"

Using this you can create a copy of the string using:

var newstring = name[:]

You can assign a string to a new variable like this:

var first = "test"
var second = first

Strings are immutable, so you cannot update the value of a string.

Even if you assign a new value to first using an assignment operator, the value second is still going to be "test":

var first = "test"
var second = first

first = "another test"

first  //"another test"
second //"test"

Strings are reference types, which means if you pass a string to a function, the reference to the string will be copied, not its value. But since strings are immutable, in this case it’s not a big difference in practice with passing an int, for example.

You can concatenate two strings using the + operator:

var first = "first"
var second = "second"

var word = first + " " + second  //"first second"

Go provides several string utilities in the the strings package.

We already saw how to import a package in the “Hello, World!” example.

Here’s how you can import strings:

package main

import (
    "strings"
)

And then you can use it.

For example we can use the HasPrefix() function to see if a string starts with a specific substring:

package main

import (
    "strings"
)

func main() {
    strings.HasPrefix("test", "te") // true
}

You can find the full list of methods here: https://pkg.go.dev/strings.

Here’s a list of methods you might use frequently:

• strings.ToUpper() returns a new string, uppercase
• strings.ToLower() returns a new string, lowercase
• strings.HasSuffix() checks if a string ends with a substring
• strings.HasPrefix() checks if a string starts with a substring
• strings.Contains() checks if a string contains a substring
• strings.Count() counts how many times a substring appears in a string
• strings.Join() used to join multiple strings and create a new one
• strings.Split() used to create an array of strings from a string, dividing the original one on a specific character, like a comma or a space
• strings.ReplaceAll() used to replace a portion in a string and replace it with a new one

Arrays in Go

Arrays are a sequence of items of a single type.

We define an array in this way:

var myArray [3]string //an array of 3 strings

and you can initialize the array with values using:

var myArray = [3]string{"First", "Second", "Third"}

In this case you can also let Go do some work and count the items for you:

var myArray = [...]string{"First", "Second", "Third"}

An array can only contain values of the same type.

The array cannot be resized – you have to explicitly define the length of an array in Go. That’s part of the type of an array. Also, you cannot use a variable to set the length of the array.

Due to this limitation, arrays are rarely used directly in Go. Instead we use slices (more on them later). Slices use arrays under the hood, so it’s still necessary to know how they work.

You can access an item in the array with the square brackets notation we already used in strings to access a single character:

myArray[0] //indexes start at 0
myArray[1]

You can set a new value for a specific position in the array:

myArray[2] = "Another"

And you can get the length of an array using the len() function:

len(myArray)

Arrays are value types. This means copying an array:

anotherArray := myArray

or passing an array to a function, or returning it from a function, creates a copy of the original array.

This is different from other programming languages out there.

Let’s make a simple example where we assign a new value to an array item after copying it. See, the copy doesn't change:

var myArray = [3]string{"First", "Second", "Third"}
myArrayCopy := myArray
myArray[2] = "Another"

myArray[2]     //"Another"
myArrayCopy[2] //"Third"

Remember you can only add a single type of items in an array, so setting the myArray[2] = 2 for example will raise an error.

Low-level elements are stored continuously in memory.

Slices in Go

A slice is a data structure similar to an array, but it can change in size.

Under the hood, slices use an array and they are an abstraction built on top of them that makes them more flexible and useful (think about arrays as lower level).

You will use slices in a way that’s very similar to how you use arrays in higher level languages.

You define a slice similarly to an array, omitting the length:

var mySlice []string //a slice of strings

You can initialize the slice with values:

var mySlice = []string{"First", "Second", "Third"}

//or

mySlice := []string{"First", "Second", "Third"}

You can create an empty slice of a specific length using the make() function:

mySlice := make([]string, 3) //a slice of 3 empty strings

You can create a new slice from an existing slice, appending one or more items to it:

mySlice := []string{"First", "Second", "Third"}

newSlice := append(mySlice, "Fourth", "Fifth")

Note that we need to assign the result of append() to a new slice, otherwise we’ll get a compiler error. The original slice is not modified – we’ll get a brand new one.

You can also use the copy() function to duplicate a slice so it does not share the same memory of the other one and is independent:

mySlice := []string{"First", "Second", "Third"}

newSlice := make([]string, 3)

copy(newSlice, mySlice)

If the slice you’re copying to does not have enough space (is shorter than the original) only the first items (until there’s space) will be copied.

You can initialize a slice from an array:

myArray := [3]string{"First", "Second", "Third"}

mySlice = myArray[:]

Multiple slices can use the same array as the underlying array:

myArray := [3]string{"First", "Second", "Third"}

mySlice := myArray[:]
mySlice2 := myArray[:]

mySlice[0] = "test"

fmt.Println(mySlice2[0]) //"test"

Those 2 slices now share the same memory. Modifying one slice modifies the underlying array and causes the other slice generated from the array to be modified, too.

As with arrays, each item in a slice is stored in memory in consecutive memory locations.

If you know you need to perform operations on the slice, you can request it to have more capacity than initially needed. This way, when you need more space, the space will be readily available (instead of finding and moving the slice to a new memory location with more space to grow and dispose via garbage collection of the old location).

We can specify the capacity by adding a third parameter to make():

newSlice := make([]string, 0, 10)
//an empty slice with capacity 10

As with strings, you can get a portion of a slice using this syntax:

mySlice := []string{"First", "Second", "Third"}

newSlice := mySlice[:2] //get the first 2 items
newSlice2 := mySlice[2:] //ignore the first 2 items
newSlice3 := mySlice[1:3] //new slice with items in position 1-2

Maps in Go

A map is a very useful data type in Go.

In other language it’s also called a dictionary or hash map or associative array.

Here’s how you create a map:

agesMap := make(map[string]int)

You don’t need to set how many items the map will hold.

You can add a new item to the map in this way:

agesMap["flavio"] = 39

You can also initialize the map with values directly using this syntax:

agesMap := map[string]int{"flavio": 39}

You can get the value associated with a key using:

age := agesMap["flavio"]

You can delete an item from the map using the delete() function in this way:

delete(agesMap, "flavio")

Loops in Go

One of Go’s best features is to give you fewer choices.

We have one loop statement: for.

You can use it like this:

for i := 0; i < 10; i++ {
    fmt.Println(i)
}

We first initialize a loop variable, then we set the condition we check for with each iteration to decide if the loop should end. Finally we have the post statement, executed at the end of each iteration, which in this case increments i.

i++ increments the i variable.

The < operator is used to compare i to the number 10 and returns true or false, determining if the loop body should be executed or not.

We don’t need parentheses around this block, unlike other languages like C or JavaScript.

Other languages offer different kind of loop structures, but Go only has this one. We can simulate a while loop, if you’re familiar with a language that has it, like this:

i := 0

for i < 10 {
    fmt.Println(i)
  i++
}

We can also completely omit the condition and use break to end the loop when we want:

i := 0

for {
    fmt.Println(i)

    if i < 10 {
        break
    }

  i++
}

I used a if statement inside the loop body, but we haven’t seen conditionals yet! We’ll do that next.

One thing I want to introduce now is range.

We can use for to iterate through an array using this syntax:

numbers := []int{1, 2, 3}

for i, num := range numbers {
    fmt.Printf("%d: %d\n", i, num)
}

//0: 1
//1: 2
//2: 3

Note: I used fmt.Printf() which allows us to print any value to the terminal using the verbs %d which mean decimal integer and \n means add a line terminator.

It’s common to use this syntax when you don’t need to use the index:

for _, num := range numbers {
  //...
}

We're using the special _ character that means “ignore this” to avoid the Go compiler raising an error saying “you’re not using the i variable!”.

Conditionals in Go

We use the if statement to execute different instructions depending on a condition:

if age < 18 {
    //underage
}

The else part is optional:

if age < 18 {
    //underage
} else {
  //adult
}

and can be combined with other ifs:

if age < 12 {
    //child
} else if age < 18  {
  //teen
} else {
    //adult
}

If you define any variable inside the if, that’s only visible inside the if (same applies to else and anywhere you open a new block with {}).

If you’re going to have many different if statements to check a single condition, it’s probably better to use switch:

switch age {
case 0: fmt.Println("Zero years old")
case 1: fmt.Println("One year old")
case 2: fmt.Println("Two years old")
case 3: fmt.Println("Three years old")
case 4: fmt.Println("Four years old")
default: fmt.Println(i + " years old")
}

Compared to C, JavaScript, and other languages, you don’t need to have a break after each case.

Operators in Go

We've used some operators so far in our code examples, like =, := and <.

Let’s talk a bit more about them.

We have assignment operators = and := we use to declare and initialize variables:

var a = 1

b := 1

We have comparison operators == and != that take 2 arguments and return a boolean:

var num = 1
num == 1 //true
num != 1 //false

and <, <=, >, >=:

var num = 1
num > 1 //false
num >= 1 //true
num < 1 //false
num <= 1 //true

We have binary (require two arguments) arithmetic operators, like +, -, *, /, %.

1 + 1 //2
1 - 1 //0
1 * 2 //2
2 / 2 //1
2 % 2 //0

+ can also join strings:

"a" + "b" //"ab"

We have unary operators ++ and -- to increment or decrement a number:

var num = 1
num++ // num == 2
num-- // num == 1

Note that unlike C or JavaScript we can’t prepend them to a number like ++num. Also, the operation does not return any value.

We have boolean operators that help us with making decisions based on true and false values: &&, || and !:

true && true  //true
true && false //false
true || false //true
false || false //false
!true  //false
!false //true

Those are the main ones.

Structs in Go

A struct is a type that contains one or more variables. It’s like a collection of variables. We call them fields. And they can have different types.

Here’s an example of a struct definition:

type Person struct {
    Name string
    Age int
}

Note that I used uppercase names for the fields, otherwise those will be private to the package. And when you pass the struct to a function provided by another package, like the ones we use to work with JSON or database, those fields cannot be accessed.

Once we define a struct we can initialize a variable with that type:

flavio := Person{"Flavio", 39}

and we can access the individual fields using the dot syntax:

flavio.Age //39
flavio.Name //"Flavio"

You can also initialize a new variable from a struct in this way:

flavio := Person{Age: 39, Name: "Flavio"}

This lets you initialize only one field, too:

flavio := Person{Age: 39}

or even initialize it without any value:

flavio := Person{}

//or

var flavio Person

and set the values later:

flavio.Name = "Flavio"
flavio.Age = 39

Structs are useful because you can group unrelated data and pass it around to/from functions, store in a slice, and more.

Once defined, a struct is a type like int or string and this means you can use it inside other structs, too:

type FullName struct {
    FirstName string
    LastName string
}

type Person struct {
    Name FullName
    Age int
}

Functions in Go

A function is a block of code that’s assigned a name, and contains some instructions.

In the “Hello, World!” example we created a main function, which is the entry point of the program.

package main

import "fmt"

func main() {
    fmt.Println("Hello, World!")
}

That’s a special function.

Usually we define functions with a custom name:

func doSomething() {

}

and then you can call them, like this:

doSomething()

A function can accept parameters, and we have to set the type of the parameters like this:

func doSomething(a int, b int) {

}

doSomething(1, 2)

a and b are the names we associate to the parameters internally to the function.

A function can return a value, like this:

func sumTwoNumbers(a int, b int) int {
    return a + b
}

result := sumTwoNumbers(1, 2)

Note that we specified the return value type.

A function in Go can return more than one value:

func performOperations(a int, b int) (int, int) {
    return a + b, a - b
}

sum, diff := performOperations(1, 2)

It’s interesting because many languages only allow one return value.

Any variable defined inside the function is local to the function.

A function can also accept an unlimited number of parameters, and in this case we call it a variadic function:

func sumNumbers(numbers ...int) int {
    sum := 0
    for _, number := range numbers {
        sum += number
    }
    return sum
}

total := sumNumbers(1, 2, 3, 4)

Pointers in Go

Go supports pointers.

Suppose you have a variable:

age := 20

Using &age you get the pointer to the variable, its memory address.

When you have the pointer to the variable, you can get the value it points to by using the * operator:

age := 20
ageptr = &age
agevalue = *ageptr

This is useful when you want to call a function and pass the variable as a parameter. Go by default copies the value of the variable inside the function, so this will not change the value of age:

func increment(a int) {
    a = a + 1
}

func main() {
    age := 20
    increment(age)

    //age is still 20
}

You can use pointers for this:

func increment(a *int) {
    *a = *a + 1
}

func main() {
    age := 20
    increment(&age)

    //age is now 21
}

Methods in Go

You can assign a function to a struct, and in this case we call it a method.

Example:

type Person struct {
    Name string
    Age int
}

func (p Person) Speak() {
    fmt.Println("Hello from " + p.Name)
}

func main() {
    flavio := Person{Age: 39, Name: "Flavio"}
    flavio.Speak()
}

You can declare methods to be pointer receiver or value receiver.

The above example shows a value receiver. It receives a copy of the struct instance.

This would be a pointer receiver that receives the pointer to the struct instance:

func (p *Person) Speak() {
    fmt.Println("Hello from " + p.Name)
}

Interfaces in Go

An interface is a type that defines one or more method signatures.

Methods are not implemented, just their signature: the name, parameter types and return value type.

Something like this:

type Speaker interface {
    Speak()
}

Now you could have a function accept any type that implements all the methods defined by the interface:

func SaySomething(s Speaker) {
    s.Speak()
}

And we can pass it any struct that implements those methods:

type Speaker interface {
    Speak()
}

type Person struct {
    Name string
    Age int
}

func (p Person) Speak() {
    fmt.Println("Hello from " + p.Name)
}

func SaySomething(s Speaker) {
    s.Speak()
}

func main() {
    flavio := Person{Age: 39, Name: "Flavio"}
    SaySomething(flavio)
}

Where to Go from Here

This handbook is an introduction to the Go programming language.

Beside these basics, there are many things to learn now.

Garbage collection, error handling, concurrency and networking, the filesystem APIs, and much more.

The sky is the limit.

My suggestion is to pick a program you want to build and just start, learning the things you need along the way.

It will be fun and rewarding.

Note: you can get a PDF and ePub version of this Go Beginner's Handbook here.

Statistics say it’s used by 80% of all websites. It’s the language that powers WordPress, the widely used content management system for websites.

And it also powers a lot of different frameworks that make Web Development easier, like Laravel. Speaking of Laravel, it may be one of the most compelling reasons to learn PHP these days.

Why Learn PHP?

PHP is quite a polarizing language. Some people love it, and some people hate it. If we move a step above the emotions and look at the language as a tool, PHP has a lot to offer.

Sure it’s not perfect. But let me tell you – no language is.

In this handbook, I’m going to help you learn PHP.

This book is a perfect introduction if you’re new to the language. It’s also perfect if you’ve done “some PHP” in the past and you want to get back to it.

I’ll explain modern PHP, version 8+.

PHP has evolved a lot in the last few years. So if the last time you tried it was PHP 5 or even PHP 4, you’ll be surprised at all the good things that PHP now offers.

Let’s go!

Here's what we'll cover in this handbook:

1. Introduction to PHP
2. What Kind of Language is PHP?
3. How to Setup PHP
4. How to Code Your First PHP Program
5. PHP Language Basics
6. How to Work with Strings in PHP
7. How to Use Built-in Functions for Numbers in PHP
8. How Arrays Work in PHP
9. How Conditionals Work in PHP
10. How Loops Work in PHP
11. How Functions Work in PHP
12. How to Loop Through Arrays with map(), filter(), and reduce() in PHP
13. Object Oriented Programming in PHP
14. How to Include Other PHP Files
15. Useful Constants, Functions and Variables for Filesystem in PHP
16. How to Handle Errors in PHP
17. How to Handle Exceptions in PHP
18. How to Work with Dates in PHP
19. How to Use Constants and Enums in PHP
20. How to Use PHP as a Web App Development Platform
21. How to Use Composer and Packagist
22. How to Deploy a PHP Application
23. Conclusion

Note that you can get a PDF, ePub, or Mobi version of this handbook for easier reference, or for reading on your Kindle or tablet.

Introduction to PHP

PHP is a programming language that many devs use to create Web Applications, among other things.

As a language, it had a humble beginning. It was first created in 1994 by Rasmus Lerdorf to build his personal website. He didn’t know at the time it would eventually become one of the most popular programming languages in the world. It became popular later on, in 1997/8, and exploded in the 2000s when PHP 4 landed.

You can use PHP to add a little interactivity to an HTML page.

Or you can use it as a Web Application engine that creates HTML pages dynamically and sends them to the browser.

It can scale to millions of page views.

Did you know Facebook is powered by PHP? Ever heard of Wikipedia? Slack? Etsy?

What Kind of Language is PHP?

Let’s get into some technical jargon.

Programming languages are divided into groups depending on their characteristics. For example interpreted/compiled, strongly/loosely typed, dynamically/statically typed.

PHP is often called a “scripting language” and it’s an interpreted language. If you’ve used compiled languages like C or Go or Swift, the main difference is that you don’t need to compile a PHP program before you run it.

Those languages are compiled and the compiler generates an executable program that you then run. It’s a 2-steps process.

The PHP interpreter is responsible for interpreting the instructions written in a PHP program when it’s executed. It’s just one step. You tell the interpreter to run the program. It's a completely different workflow.

PHP is a dynamically typed language. The types of variables are checked at runtime, rather than before the code is executed as happens for statically typed languages. (These also happen to be compiled – the two characteristics often go hand in hand.)

PHP is also loosely (weakly) typed. Compared to strongly typed languages like Swift, Go, C or Java, you don’t need to declare the types of your variables.

Being interpreted and loosely/dynamically typed will make bugs harder to find before they happen at runtime.

In compiled languages, you can often catch errors at compile time, something that does not happen in interpreted languages.

But on the other hand, an interpreted language has more flexibility.

Fun fact: PHP is written internally in C, a compiled and statically typed language.

In its nature, PHP is similar to JavaScript, another dynamically typed, loosely typed, and interpreted language.

PHP supports object-oriented programming, and also functional programming. You can use it as you prefer.

How to Setup PHP

There are many ways to install PHP on your local machine.

The most convenient way I’ve found to install PHP locally is to use MAMP.

MAMP is a tool that’s freely available for all the Operating Systems – Mac, Windows and Linux. It is a package that gives you all the tools you need to get up and running.

PHP is run by a HTTP Server, which is responsible for responding to HTTP requests, the ones made by the browser. So you access a URL with your browser, Chrome or Firefox or Safari, and the HTTP server responds with some HTML content.

The server is typically Apache or NGINX.

Then to do anything non-trivial you’ll need a database, like MySQL.

MAMP is a package that provides all of that, and more, and gives you a nice interface to start/stop everything at once.

Of course, you can set up each piece on its own if you like, and many tutorials explain how to do that. But I like simple and practical tools, and MAMP is one of those.

You can follow this handbook with any kind of PHP installation method, not just MAMP.

That said, if you don’t have PHP installed yet and you want to use MAMP, go to https://www.mamp.info and install it.

The process will depend on your operating system, but once you’re done with the installation, you will have a “MAMP” application installed.

Start that, and you will see a window similar to this:

Make sure the PHP version selected is the latest available.

At the time of writing MAMP lets you pick 8.0.8.

NOTE: I noticed MAMP has a version that’s a bit behind, not the latest. You can install a more recent version of PHP by enabling the MAMP PRO Demo, then install the latest release from the MAMP PRO settings (in my case it was 8.1.0). Then close it and reopen MAMP (non-pro version). MAMP PRO has more features so you might want to use it, but it’s not necessary to follow this handbook.

Press the Start button at the top right. This will start the Apache HTTP server, with PHP enabled, and the MySQL database.

Go to the URL http://localhost:8888 and you will see a page similar to this:

We’re ready to write some PHP!

Open the folder listed as “Document root”. If you're using MAMP on a Mac it’s by default /Applications/MAMP/htdocs.

On Windows it’s C:\MAMP\htdocs.

Yours might be different depending on your configuration. Using MAMP you can find it in the user interface of the application.

In there, you will find a file named index.php.

That is responsible for printing the page shown above.

How to Code Your First PHP Program

When learning a new programming language we have this tradition of creating a “Hello, World!” application. Something that prints those strings.

Make sure MAMP is running, and open the htdocs folder as explained above.

Open the index.php file in a code editor.

I recommend using VS Code, as it’s a very simple and powerful code editor. You can check out https://flaviocopes.com/vscode/ for an introduction.

This is the code that generates the “Welcome to MAMP” page you saw in the browser.

Delete everything and replace it with:

<?php
echo 'Hello World';
?>

Save, refresh the page on http://localhost:8888, you should see this:

Great! That was your first PHP program.

Let’s explain what is happening here.

We have the Apache HTTP server listening on port 8888 on localhost, your computer.

When we access http://localhost:8888 with the browser, we’re making an HTTP request, asking for the content of the route /, the base URL.

Apache, by default, is configured to serve that route serving the index.html file included in the htdocs folder. That file does not exist – but as we have configured Apache to work with PHP, it will then search for an index.php file.

This file exists, and PHP code is executed server-side before Apache sends the page back to the browser.

In the PHP file, we have a <?php opening, which says “here starts some PHP code”.

We have an ending ?> that closes the PHP code snippet, and inside it, we use the echo instruction to print the string enclosed into quotes into the HTML.

A semicolon is required at the end of every statement.

We have this opening/closing structure because we can embed PHP inside HTML. PHP is a scripting language, and its goal is to be able to “decorate” an HTML page with dynamic data.

Note that with modern PHP, we generally avoid mixing PHP into the HTML. Instead, we use PHP as a “framework to generate the HTML” – for example using tools like Laravel. But we'll discuss plain PHP in this book, so it makes sense to start from the basics.

For example, something like this will give you the same result in the browser:

Hello
<?php
echo 'World';
?>

To the final user, who looks at the browser and has no idea of the code behind the scenes, there’s no difference at all.

The page is technically an HTML page, even though it does not contain HTML tags but just a Hello World string. But the browser can figure out how to display that in the window.

PHP Language Basics

After the first “Hello World”, it’s time to dive into the language features with more details.

How Variables Work in PHP

Variables in PHP start with the dollar sign $, followed by an identifier, which is a set of alphanumeric chars and the underscore _ char.

You can assign a variable any type of value, like strings (defined using single or double quotes):

$name = 'Flavio';

$name = "Flavio";

Or numbers:

$age = 20;

or any other type that PHP allows, as we’ll later see.

Once a variable is assigned a value, for example a string, we can reassign it a different type of value, like a number:

$name = 3;

PHP won’t complain that now the type is different.

Variable names are case-sensitive. $name is different from $Name.

It’s not a hard rule, but generally variable names are written in camelCase format, like this: $brandOfCar or $ageOfDog. We keep the first letter lowercase, and the letters of the subsequent words uppercase.

How to Write Comments in PHP

A very important part of any programming language is how you write comments.

You write single-line comments in PHP in this way:

// single line comment

Multi-line comments are defined in this way:

/*

this is a comment

*/

//or

/*
 *
 * this is a comment
 *
 */

//or to comment out a portion of code inside a line:

/* this is a comment */

What are Types in PHP?

I mentioned strings and numbers.

PHP has the following types:

• bool boolean values (true/false)
• int integer numbers (no decimals)
• float floating-point numbers (decimals)
• string strings
• array arrays
• object objects
• null a value that means “no value assigned”

and a few other more advanced ones.

How to Print the Value of a Variable in PHP

We can use the var_dump() built-in function to get the value of a variable:

$name = 'Flavio';

var_dump($name);

The var_dump($name) instruction will print string(6) "Flavio" to the page, which tells us the variable is a string of 6 characters.

If we used this code:

$age = 20;

var_dump($age);

we’d have int(20) back, saying the value is 20 and it’s an integer.

var_dump() is one of the essential tools in your PHP debugging tool belt.

How Operators Work in PHP

Once you have a few variables you can make operations with them:

$base = 20;
$height = 10;

$area = $base * $height;

The * I used to multiply $base by $height is the multiplication operator.

We have quite a few operators – so let’s do a quick roundup of the main ones.

To start with, here are the arithmetic operators: +, -, *, / (division), % (remainder) and ** (exponential).

We have the assignment operator =, which we already used to assign a value to a variable.

Next up we have comparison operators, like <, >, <=, >=. Those work like they do in math.

2 < 1; //false
1 <= 1; // true
1 <= 2; // true

== returns true if the two operands are equal.

=== returns true if the two operands are identical.

What’s the difference?

You’ll find it with experience, but for example:

1 == '1'; //true
1 === '1'; //false

We also have != to detect if operands are not equal:

1 != 1; //false
1 != '1'; //false
1 != 2; //true

//hint: <> works in the same way as !=, 1 <> 1

and !== to detect if operands are not identical:

1 !== 1; //false
1 !== '1'; //true

Logical operators work with boolean values:

// Logical AND with && or "and"

true && true; //true
true && false; //false
false && true; //false
false && false; //false

true and true; //true
true and false; //false
false and true; //false
false and false; //false

// Logical OR with || or "or"

true || true; // true
true || false //true
false || true //true
false || false //false

true or true; // true
true or false //true
false or true //true
false or false //false

// Logical XOR (one of the two is true, but not both)

true xor true; // false
true xor false //true
false xor true //true
false xor false //false

We also have the not operator:

$test = true

!$test //false

I used the boolean values true and false here, but in practice you’ll use expressions that evaluate to either true or false, for example:

1 > 2 || 2 > 1; //true

1 !== 2 && 2 > 2; //false

All of the operators listed above are binary, meaning they involve 2 operands.

PHP also has 2 unary operators: ++ and --:

$age = 20;
$age++;
//age is now 21

$age--;
//age is now 20

How to Work with Strings in PHP

I introduced the use of strings before when we talked about variables and we defined a string using this notation:

$name = 'Flavio'; //string defined with single quotes

$name = "Flavio"; //string defined with double quotes

The big difference between using single and double quotes is that with double quotes we can expand variables in this way:

$test = 'an example';

$example = "This is $test"; //This is an example

and with double quotes we can use escape characters (think new lines \n or tabs \t):

$example = "This is a line\nThis is a line";

/*
output is:

This is a line
This is a line
*/

PHP offers you a very comprehensive functions in its standard library (the library of functionalities that the language offers by default).

First, we can concatenate two strings using the . operator:

$firstName = 'Flavio';
$lastName = 'Copes';

$fullName = $firstName . ' ' . $lastName;

We can check the length of a string using the strlen() function:

$name = 'Flavio';
strlen($name); //6

This is the first time we've used a function.

A function is composed of an identifier (strlen in this case) followed by parentheses. Inside those parentheses, we pass one or more arguments to the function. In this case, we have one argument.

The function does something and when it’s done it can return a value. In this case, it returns the number 6. If there’s no value returned, the function returns null.

We’ll see how to define our own functions later.

We can get a portion of a string using substr():

$name = 'Flavio';
substr($name, 3); //"vio" - start at position 3, get all the rest
substr($name, 2, 2); //"av" - start at position 2, get 2 items

We can replace a portion of a string using str_replace():

$name = 'Flavio';
str_replace('avio', 'ower', $name); //"Flower"

Of course we can assign the result to a new variable:

$name = 'Flavio';
$itemObserved = str_replace('avio', 'ower', $name); //"Flower"

There are a lot more built-in functions you can use to work with strings.

Here is a brief non-comprehensive list just to show you the possibilities:

• trim() strips white space at the beginning and end of a string
• strtoupper() makes a string uppercase
• strtolower() makes a string lowercase
• ucfirst() makes the first character uppercase
• strpos() finds the firsts occurrence of a substring in the string
• explode() to split a string into an array
• implode() to join array elements in a string

You can find a full list here.

How to Use Built-in Functions for Numbers in PHP

I previously listed the few functions we commonly use for strings.

Let’s make a list of the functions we use with numbers:

• round() to round a decimal number, up/down depending if the value is > 0.5 or smaller
• ceil() to round a a decimal number up
• floor() to round a decimal number down
• rand() generates a random integer
• min() finds the lowest number in the numbers passed as arguments
• max() finds the highest number in the numbers passed as arguments
• is_nan() returns true if the number is not a number

There are a ton of different functions for all sorts of math operations like sine, cosine, tangents, logarithms, and so on. You can find a full list here.

How Arrays Work in PHP

Arrays are lists of values grouped under a common name.

You can define an empty array in two different ways:

$list = [];

$list = array();

An array can be initialized with values:

$list = [1, 2];

$list = array(1, 2);

Arrays can hold values of any type:

$list = [1, 'test'];

Even other arrays:

$list = [1, [2, 'test']];

You can access the element in an array using this notation:

$list = ['a', 'b'];
$list[0]; //'a' --the index starts at 0
$list[1]; //'b'

Once an array is created, you can append values to it in this way:

$list = ['a', 'b'];
$list[] = 'c';

/*
$list == [
  "a",
  "b",
  "c",
]
*/

You can use array_unshift() to add the item at the beginning of the array instead:

$list = ['b', 'c'];
array_unshift($list, 'a');

/*
$list == [
  "a",
  "b",
  "c",
]
*/

Count how many items are in an array using the built-in count() function:

$list = ['a', 'b'];

count($list); //2

Check if an array contains an item using the in_array() built-in function:

$list = ['a', 'b'];

in_array('b', $list); //true

If in addition to confirming existence, you need the index, use array_search():

$list = ['a', 'b'];

array_search('b', $list) //1

Useful Functions for Arrays in PHP

As with strings and numbers, PHP provides lots of very useful functions for arrays. We’ve seen count(), in_array(), array_search() – let’s see some more:

• is_array() to check if a variable is an array
• array_unique() to remove duplicate values from an array
• array_search() to search a value in the array and return the key
• array_reverse() to reverse an array
• array_reduce() to reduce an array to a single value using a callback function
• array_map() to apply a callback function to each item in the array. Typically used to create a new array by modifying the values of an existing array, without altering it.
• array_filter() to filter an array to a single value using a callback function
• max() to get the maximum value contained in the array
• min() to get the minimum value contained in the array
• array_rand() to get a random item from the array
• array_count_values() to count all the values in the array
• implode() to turn an array into a string
• array_pop() to remove the last item of the array and return its value
• array_shift() same as array_pop() but removes the first item instead of the last
• sort() to sort an array
• rsort() to sort an array in reverse order
• array_walk() similarly to array_map() does something for every item in the array, but in addition it can change values in the existing array

How to Use Associative Arrays in PHP

So far we’ve used arrays with an incremental, numeric index: 0, 1, 2…

You can also use arrays with named indexes (keys), and we call them associative arrays:

$list = ['first' => 'a', 'second' => 'b'];

$list['first'] //'a'
$list['second'] //'b'

We have some functions that are especially useful for associative arrays:

• array_key_exists() to check if a key exists in the array
• array_keys() to get all the keys from the array
• array_values() to get all the values from the array
• asort() to sort an associative array by value
• arsort() to sort an associative array in descending order by value
• ksort() to sort an associative array by key
• krsort() to sort an associative array in descending order by key

You can see all array-related functions here.

How Conditionals Work in PHP

I previously introduced comparison operators: <, >, <=, >=, ==, === , !=, !==... and so on.

Those operators are going to be super useful for one thing: conditionals.

Conditionals are the first control structure we see.

We can decide to do something, or something else, based on a comparison.

For example:

$age = 17;

if ($age > 18) {
  echo 'You can enter the pub';
}

The code inside the parentheses only executes if the condition evaluates to true.

Use else to do something else in case the condition is false:

$age = 17;

if ($age > 18) {
  echo 'You can enter the pub';
} else {
  echo 'You cannot enter the pub';
}

NOTE: I used cannot instead of can't because the single quote would terminate my string before it should. In this case you could escape the ' in this way: echo 'You can\'t enter the pub';

You can have multiple if statements chained using elseif:

$age = 17;

if ($age > 20) {
  echo 'You are 20+';
} elseif ($age > 18) {
  echo 'You are 18+';
} else {
  echo 'You are <18';
}

In addition to if, we have the switch statement.

We use this when we have a variable that could have a few different values, and we don’t have to have a long if / elseif block:

$age = 17

switch($age) {
  case 15:
        echo 'You are 15';
    break;
  case 16:
        echo 'You are 16';
    break;
  case 17:
        echo 'You are 17';
    break;
  case 18:
        echo 'You are 18';
    break;
  default:
    echo "You are $age";
}

I know the example does not have any logic, but I think it can help you understand how switch works.

The break; statement after each case is essential. If you don’t add that and the age is 17, you’d see this:

You are 17
You are 18
You are 17

Instead of just this:

You are 17

as you’d expect.

How Loops Work in PHP

Loops are another super useful control structure.

We have a few different kinds of loops in PHP: while, do while, for, and foreach.

Let’s see them all!

How to Use a while loop in PHP

A while loop is the simplest one. It keeps iterating while the condition evaluates to true:

while (true) {
  echo 'looping';
}

This would be an infinite loop, which is why we use variables and comparisons:

$counter = 0;

while ($counter < 10) {
  echo $counter;
  $counter++;
}

How to Use a do while loop in PHP

do while is similar, but slightly different in how the first iteration is performed:

$counter = 0;

do {
  echo $counter;
  $counter++;
} while ($counter < 10);

In the do while loop, first we do the first iteration, then we check the condition.

In the while loop, first we check the condition, then we do the iteration.

Do a simple test by setting $counter to 15 in the above examples, and see what happens.

You'll want to choose one kind of loop, or the other, depending on your use case.

How to Use a foreach Loop in PHP

You can use the foreach loop to easily iterate over an array:

$list = ['a', 'b', 'c'];

foreach ($list as $value) {
  echo $value;
}

You can also get the value of the index (or key in an associative array) in this way:

$list = ['a', 'b', 'c'];

foreach ($list as $key => $value) {
  echo $key;
}

How to Use a for Loop in PHP

The for loop is similar to while, but instead of defining the variable used in the conditional before the loop, and instead of incrementing the index variable manually, it’s all done in the first line:

for ($i = 0; $i < 10; $i++) {
  echo $i;
}

//result: 0123456789

You can use the for loop to iterate over an array in this way:

$list = ['a', 'b', 'c'];

for ($i = 0; $i < count($list); $i++) {
  echo $list[$i];
}

//result: abc

How to Use the break and continue Statements in PHP

In many cases you want the ability to stop a loop on demand.

For example you want to stop a for loop when the value of the variable in the array is 'b':

$list = ['a', 'b', 'c'];

for ($i = 0; $i < count($list); $i++) {
    if ($list[$i] == 'b') {
    break;
  }
  echo $list[$i];
}

//result: a

This makes the loop completely stop at that point, and the program execution continues at the next instruction after the loop.

If you just want to skip the current loop iteration and keep looking, use continue instead:

$list = ['a', 'b', 'c'];

for ($i = 0; $i < count($list); $i++) {
    if ($list[$i] == 'b') {
    continue;
  }
  echo $list[$i];
}

//result: ac

How Functions Work in PHP

Functions are one of the most important concepts in programming.

You can use functions to group together multiple instructions or multiple lines of code, and give them a name.

For example you can make a function that sends an email. Let’s call it sendEmail, and we'll define it like this:

function sendEmail() {
  //send an email
}

And you can call it anywhere else by using this syntax:

sendEmail();

You can also pass arguments to a function. For example when you send an email, you want to send it to someone – so you add the email as the first argument:

sendEmail('test@test.com');

Inside the function definition we get this parameter in this way (we call them parameters inside the function definition, and arguments when we call the function):

function sendEmail($to) {
  echo "send an email to $to";
}

You can send multiple arguments by separating them with commas:

sendEmail('test@test.com', 'subject', 'body of the email');

And we can get those parameters in the order they were defined:

function sendEmail($to, $subject, $body) {
  //...
}

We can optionally set the type of parameters:

function sendEmail(string $to, string $subject, string $body) {
  //...
}

Parameters can have a default value, so if they are omitted we can still have a value for them:

function sendEmail($to, $subject = 'test', $body = 'test') {
  //...
}

sendEmail('test@test.com')

A function can return a value. Only one value can be returned from a function, not more than one. You do that using the return keyword. If omitted, the function returns null.

The returned value is super useful as it tells you the result of the work done in the function, and lets you use its result after calling it:

function sendEmail($to) {
    return true;
}

$success = sendEmail('test@test.com');

if ($success) {
  echo 'email sent successfully';
} else {
  echo 'error sending the email';
}

We can optionally set the return type of a function using this syntax:

function sendEmail($to): bool {
    return true;
}

When you define a variable inside a function, that variable is local to the function, which means it’s not visible from outside. When the function ends, it just stops existing:

function sendEmail($to) {
    $test = 'a';
}

var_dump($test); //PHP Warning:  Undefined variable $test

Variables defined outside of the function are not accessible inside the function.

This enforces a good programming practice as we can be sure the function does not modify external variables and cause “side effects”.

Instead you return a value from the function, and the outside code that calls the function will take responsibility for updating the outside variable.

Like this:

$character = 'a';

function test() {
  return 'b';
}

$character = test();

You can pass the value of a variable by passing it as an argument to the function:

$character = 'a';

function test($c) {
  echo $c;
}

test($character);

But you can’t modify that value from within the function.

It’s passed by value, which means the function receives a copy of it, not the reference to the original variable.

That is still possible using this syntax (notice I used & in the parameter definition):

$character = 'a';

function test(&$c) {
  $c = 'b';
}

test($character);

echo $character; //'b'

The functions we've defined so far are named functions.

They have a name.

We also have anonymous functions, which can be useful in a lot of cases.

They don’t have a name, per se, but they are assigned to a variable. To call them, you invoke the variable with parentheses at the end:

$myfunction = function() {
  //do something here
};

$myfunction()

Note that you need a semicolon after the function definition, but then they work like named functions for return values and parameters.

Interestingly, they offer a way to access a variable defined outside the function through use():

$test = 'test';

$myfunction = function() use ($test) {
  echo $test;
  return 'ok';
};

$myfunction()

Another kind of function is an arrow function.

An arrow function is an anonymous function that’s just one expression (one line), and implicitly returns the value of that expression.

You define it in this way:

fn (arguments) => expression;

Here’s an example:

$printTest = fn() => 'test';

$printTest(); //'test'

You can pass parameters to an arrow function:

$multiply = fn($a, $b) => $a * $b;

$multiply(2, 4) //8

Note that as the next example shows, arrow functions have automatic access to the variables of the enclosing scope, without the need of use().

$a = 2;
$b = 4;

$multiply = fn() => $a * $b;

$multiply()

Arrow functions are super useful when you need to pass a callback function. We’ll see how to use them to perform some array operations later.

So we have in total 3 kinds of functions: named functions, anonymous functions, and arrow functions.

Each of them has its place, and you’ll learn how to use them properly over time, with practice.

How to Loop Through Arrays with map(), filter(), and reduce() in PHP

Another important set of looping structures, often used in functional programming, is the set of array_map() / array_filter() / array_reduce().

Those 3 built-in PHP functions take an array, and a callback function that in each iteration takes each item in the array.

array_map() returns a new array that contains the result of running the callback function on each item in the array:

$numbers = [1, 2, 3, 4];
$doubles = array_map(fn($value) => $value * 2, $numbers);

//$doubles is now [2, 4, 6, 8]

array_filter() generates a new array by only getting the items whose callback function returns true:

$numbers = [1, 2, 3, 4];
$even = array_filter($numbers, fn($value) => $value % 2 === 0)

//$even is now [2, 4]

array_reduce() is used to reduce an array to a single value.

For example we can use it to multiply all items in an array:

$numbers = [1, 2, 3, 4];

$result = array_reduce($numbers, fn($carry, $value) => $carry * $value, 1)

Notice the last parameter – it’s the initial value. If you omit that, the default value is 0 but that would not work for our multiplication example.

Note that in array_map() the order of the arguments is reversed. First you have the callback function and then the array. This is because we can pass multiple arrays using commas (array_map(fn($value) => $value * 2, $numbers, $otherNumbers, $anotherArray);). Ideally we’d like more consistency, but that’s what it is.

Object Oriented Programming in PHP

Let’s now jump head first into a big topic: object-oriented programming with PHP.

Object-oriented programming lets you create useful abstractions and make your code simpler to understand and manage.

How to Use Classes and Objects in PHP

To start with, you have classes and objects.

A class is a blueprint, or type, of object.

For example you have the class Dog, defined in this way:

class Dog {

}

Note that the class must be defined in uppercase.

Then you can create objects from this class – specific, individual dogs.

An object is assigned to a variable, and it’s instantiated using the new Classname() syntax:

$roger = new Dog();

You can create multiple objects from the same class, by assigning each object to a different variable:

$roger = new Dog();
$syd = new Dog();

How to Use Properties in PHP

Those objects will all share the same characteristics defined by the class. But once they are instantiated, they will have a life of their own.

For example, a Dog has a name, an age, and a fur color.

So we can define those as properties in the class:

class Dog {
  public $name;
  public $age;
  public $color;
}

They work like variables, but they are attached to the object, once it's instantiated from the class. The public keyword is the access modifier and sets the property to be publicly accessible.

You can assign values to those properties in this way:

class Dog {
  public $name;
  public $age;
  public $color;
}

$roger = new Dog();

$roger->name = 'Roger';
$roger->age = 10;
$roger->color = 'gray';

var_dump($roger);

/*
object(Dog)#1 (3) {
  ["name"]=> string(5) "Roger"
    ["age"]=> int(10)
    ["color"]=> string(4) "gray"
}
*/

Notice that the property is defined as public.

That is called an access modifier. You can use two other kinds of access modifiers: private and protected. Private makes the property inaccessible from outside the object. Only methods defined inside the object can access it.

We’ll see more about protected when we’ll talk about inheritance.

How to Use Methods in PHP

Did I say method? What is a method?

A method is a function defined inside the class, and it’s defined in this way:

class Dog {
  public function bark() {
    echo 'woof!';
  }
}

Methods are very useful to attach a behavior to an object. In this case we can make a dog bark.

Notice that I use the public keyword. That’s to say that you can invoke a method from outside the class. Like for properties, you can mark methods as private too, or protected, to restrict their access.

You invoke a method on the object instance like this:

class Dog {
  public function bark() {
    echo 'woof!';
  }
}

$roger = new Dog();

$roger->bark();

A method, just like a function, can define parameters and a return value, too.

Inside a method we can access the object’s properties using the special built-in $this variable, which, when referenced inside a method, points to the current object instance:

class Dog {
  public $name;

  public function bark() {
    echo $this->name . ' barked!';
  }
}

$roger = new Dog();
$roger->name = 'Roger';
$roger->bark();

Notice I used $this->name to set and access the $name property, and not $this->$name.

How to Use the Constructor Method in PHP

A special kind of method named __construct() is called a constructor.

class Dog {
    public function __construct() {

  }
}

You use this method to initialize the properties of an object when you create it, as it’s automatically invoked when calling new Classname().

class Dog {
  public $name;

    public function __construct($name) {
        $this->name = $name;
  }

  public function bark() {
    echo $this->name . ' barked!';
  }
}

$roger = new Dog('Roger');
$roger->bark();

This is such a common thing that PHP (starting in PHP 8) includes something called constructor promotion where it automatically does this thing:

class Dog {
  public $name;

    public function __construct($name) {
        $this->name = $name;
  }

  //...

By using the access modifier, the assignment from the parameter of the constructor to the local variable happens automatically:

class Dog {
    public function __construct(public $name) {
  }

  public function bark() {
    echo $this->name . ' barked!';
  }
}

$roger = new Dog('Roger');
$roger->name; //'Roger'
$roger->bark(); //'Roger barked!'

Properties can be typed.

You can require the name to be a string using public string $name:

class Dog {
  public string $name;

    public function __construct($name) {
        $this->name = $name;
  }

  public function bark() {
    echo $this->name . ' barked!';
  }
}

$roger = new Dog('Roger');
$roger->name; //'Roger'
$roger->bark(); //'Roger barked!'

Now all works fine in this example, but try changing that to public int $name to require it to be an integer.

PHP will raise an error if you initialize $name with a string:

TypeError: Dog::__construct():
Argument #1 ($name) must be of type int,
string given on line 14

Interesting, right?

We can enforce properties to have a specific type between string, int, float, string, object, array, bool and others.

What is Inheritance in PHP?

The fun in object oriented programming starts when we allow classes to inherit properties and methods from other classes.

Suppose you have an Animal class:

class Animal {

}

Every animal has an age, and every animal can eat. So we add an age property and an eat() method:

class Animal {
  public $age;

  public function eat() {
    echo 'the animal is eating';
  }
}

A dog is an animal and has an age and can eat too, so the Dog class – instead of reimplementing the same things we have in Animal – can extend that class:

class Dog extends Animal {

}

We can now instantiate a new object of class Dog and we have access to the properties and methods defined in Animal:

$roger = new Dog();
$roger->eat();

In this case we call Dog the child class and Animal the parent class.

Inside the child class we can use $this to reference any property or method defined in the parent, as if they were defined inside the child class.

It’s worth noting that while we can access the parent’s properties and methods from the child, we can’t do the reverse.

The parent class knows nothing about the child class.

protected Properties and Methods in PHP

Now that we've introduced inheritance, we can discuss protected. We already saw how we can use the public access modifier to set properties and methods callable from outside of a class, by the public.

private properties and methods can only be accessed from within the class.

protected properties and methods can be accessed from within the class and from child classes.

How to Override Methods in PHP

What happens if we have an eat() method in Animal and we want to customize it in Dog? We can override that method.

class Animal {
  public $age;

  public function eat() {
    echo 'the animal is eating';
  }
}

class Dog extends Animal {
  public function eat() {
    echo 'the dog is eating';
  }
}

Now any instance of Dog will use the Dog's implementation of the eat() method.

Static Properties and Methods in PHP

We’ve seen how to define properties and methods that belong to the instance of a class, an object.

Sometimes it’s useful to assign those to the class itself.

When this happens we call them static, and to reference or call them we don’t need to create an object from the class.

Let’s start with static properties. We define them with the static keyword:

class Utils {
  public static $version = '1.0';
}

We reference them from inside the class using the keyword self, which points to the class:

self::$version;

and from outside the class using:

Utils::version

This is what happens for static methods:

class Utils {
  public static function version() {
    return '1.0';
  }
}

From the outside of the class we can call them in this way:

Utils::version();

From inside the class, we can reference them using the self keyword, which refers to the current class:

self::version();

How to Compare Objects in PHP

When we talked about operators I mentioned we have the == operator to check if two values are equal and === to check if they are identical.

Mainly the difference is that == checks the object content, for example the '5' string is equal to the number 5, but it’s not identical to it.

When we use those operators to compare objects, == will check if the two objects have the same class and have the same values assigned to them.

=== on the other hand will check if they also refer to the same instance (object).

For example:

class Dog {
  public $name = 'Good dog';
}

$roger = new Dog();
$syd = new Dog();

echo $roger == $syd; //true

echo $roger === $syd; //false

How to Iterate over Object Properties in PHP

You can loop over all the public properties in an object using a foreach loop, like this:

class Dog {
  public $name = 'Good dog';
  public $age = 10;
  public $color = 'gray';
}

$dog = new Dog();

foreach ($dog as $key => $value) {
  echo $key . ': ' . $value . '<br>';
}

How to Clone Objects in PHP

When you have an object, you can clone it using the clone keyword:

class Dog {
  public $name;
}

$roger = new Dog();
$roger->name = 'Roger';

$syd = clone $roger;

This performs a shallow clone, which means that references to other variables will be copied as references – there will not a “recursive cloning” of them.

To do a deep clone you will need to do some more work.

What are Magic Methods in PHP?

Magic methods are special methods that we define in classes to perform some behavior when something special happens.

For example when a property is set, or accessed, or when the object is cloned.

We’ve seen __construct() before.

That’s a magic method.

There are others. For example we can set a “cloned” boolean property to true when the object is cloned:

class Dog {
  public $name;

  public function __clone() {
    $this->cloned = true;
  }
}

$roger = new Dog();
$roger->name = 'Roger';

$syd = clone $roger;
echo $syd->cloned;

Other magic methods include __call(), __get(), __set(), __isset(), __toString() and others.

You can see the full list here

How to Include Other PHP Files

We’re now done talking about the object oriented features of PHP.

Let’s now explore some other interesting topics!

Inside a PHP file you can include other PHP files. We have the following methods, all used for this use case, but they're all slightly different: include, include_once, require, and require_once.

include loads the content of another PHP file, using a relative path.

require does the same, but if there’s any error doing so, the program halts. include will only generate a warning.

You can decide to use one or the other depending on your use case. If you want your program to exit if it can’t import the file, use require.

include_once and require_once do the same thing as their corresponding functions without _once, but they make sure the file is included/required only once during the execution of the program.

This is useful if, for example, you have multiple files loading some other file, and you typically want to avoid loading that more than once.

My rule of thumb is to never use include or require because you might load the same file twice. include_once and require_once help you avoid this problem.

Use include_once when you want to conditionally load a file, for example “load this file instead of that”. In all other cases, use require_once.

Here’s an example:

require_once('test.php');

//now we have access to the functions, classes
//and variables defined in the `test.php` file

The above syntax includes the test.php file from the current folder, the file where this code is.

You can use relative paths:

require_once('../test.php');

to include a file in the parent folder or to go in a subfolder:

require_once('test/test.php');

You can use absolute paths:

require_once('/var/www/test/file.php');

In modern PHP codebases that use a framework, files are generally loaded automatically so you’ll have less need to use the above functions.

Useful Constants, Functions and Variables for Filesystem in PHP

Speaking of paths, PHP offers you several utilities to help you work with paths.

You can get the full path of the current file using:

• __FILE__, a magic constant
• $_SERVER['SCRIPT_FILENAME'] (more on $_SERVER later!)

You can get the full path of the folder where the current file is using:

• the getcwd() built-in function
• __DIR__, another magic constant
• combine __FILE__ with dirname() to get the current folder full path: dirname(__FILE__)
• use $_SERVER['DOCUMENT_ROOT']

How to Handle Errors in PHP

Every programmer makes errors. We’re humans, after all.

We might forget a semicolon. Or use the wrong variable name. Or pass the wrong argument to a function.

In PHP we have:

• Warnings
• Notices
• Errors

The first two are minor errors, and they do not stop the program execution. PHP will print a message, and that’s it.

Errors terminate the execution of the program, and will print a message telling you why.

There are many different kinds of errors, like parse errors, runtime fatal errors, startup fatal errors, and more.

They’re all errors.

I said “PHP will print a message”, but.. where?

This depends on your configuration.

In development mode it’s common to log PHP errors directly into the Web page, but also in an error log.

You want to see those errors as early as possible, so you can fix them.

In production, on the other hand, you don’t want to show them in the Web page, but you still want to know about them.

So what do you do? You log them to the error log.

This is all decided in the PHP configuration.

We haven’t talked about this yet, but there’s a file in your server configuration that decides a lot of things about how PHP runs.

It’s called php.ini.

The exact location of this file depends on your setup.

To find out where is yours, the easiest way is to add this to a PHP file and run it in your browser:

<?php
phpinfo();
?>

You will then see the location under “Loaded Configuration File”:

In my case it’s /Applications/MAMP/bin/php/php8.1.0/conf/php.ini.

Note that the information generated by phpinfo() contains a lot of other useful information. Remember that.

Using MAMP you can open the MAMP application folder and open bin/php. Go in your specific PHP version (8.1.0 in my case) then go in conf. In there you’ll find the php.ini file:

Open that file in an editor.

It contains a really long list of settings, with a great inline documentation for each one.

We’re particularly interested in display_errors:

In production you want its value to be Off, as the docs above it say.

The errors will not show up anymore in the website, but you will see them in the php_error.log file in the logs folder of MAMP in this case:

This file will be in a different folder depending on your setup.

You set this location in your php.ini:

The error log will contain all the error messages your application generates:

You can add information to the error log by using the error_log() function:

error_log('test');

It’s common to use a logger service for errors, like Monolog.

How to Handle Exceptions in PHP

Sometimes errors are unavoidable. Like if something completely unpredictable happens.

But many times, we can think ahead, and write code that can intercept an error, and do something sensible when this happens. Like showing a useful error message to the user, or trying a workaround.

We do so using exceptions.

Exceptions are used to make us, developers, aware of a problem.

We wrap some code that can potentially raise an exception into a try block, and we have a catch block right after that. That catch block will be executed if there’s an exception in the try block:

try {
  //do something
} catch (Throwable $e) {
  //we can do something here if an exception happens
}

Notice that we have an Exception object $e being passed to the catch block, and we can inspect that object to get more information about the exception, like this:

try {
  //do something
} catch (Throwable $e) {
  echo $e->getMessage();
}

Let’s look at an example.

Let's say that by mistake I divide a number by zero:

echo 1 / 0;

This will trigger a fatal error and the program is halted on that line:

Wrapping the operation in a try block and printing the error message in the catch block, the program ends successfully, telling me the problem:

try {
  echo 1 / 0;
} catch (Throwable $e) {
  echo $e->getMessage();
}

Of course this is a simple example but you can see the benefit: I can intercept the issue.

Each exception has a different class. For example we can catch this as DivisionByZeroError and this lets me filter the possible problems and handle them differently.

I can have a catch-all for any throwable error at the end, like this:

try {
  echo 1 / 0;
} catch (DivisionByZeroError $e) {
  echo 'Ooops I divided by zero!';
} catch (Throwable $e) {
  echo $e->getMessage();
}

And I can also append a finally {} block at the end of this try/catch structure to execute some code after the code is either executed successfully without problems, or there was a catch:

try {
  echo 1 / 0;
} catch (DivisionByZeroError $e) {
  echo 'Ooops I divided by zero!';
} catch (Throwable $e) {
  echo $e->getMessage();
} finally {
  echo ' ...done!';
}

You can use the built-in exceptions provided by PHP but you can also create your own exceptions.

How to Work with Dates in PHP

Working with dates and times is very common in programming. Let’s see what PHP provides.

We can get the current timestamp (number of seconds since Jan 1 1970 00:00:00 GMT) using time():

$timestamp = time();

When you have a timestamp you can format that as a date using date(), in the format you prefer:

echo date('Y-m-d', $timestamp);

Y is the 4-digit representation of the year, m is the month number (with a leading zero) and d is the number of the day of the month, with a leading zero.

See the full list of characters you can use to format the date here.

We can convert any date into a timestamp using strtotime(), which takes a string with a textual representation of a date and converts it into the number of seconds since Jan 1 1970:

echo strtotime('now');
echo strtotime('4 May 2020');
echo strtotime('+1 day');
echo strtotime('+1 month');
echo strtotime('last Sunday');

...it’s pretty flexible.

For dates, it’s common to use libraries that offer a lot more functionality than what the language can. A good option is Carbon.

How to Use Constants and Enums in PHP

We can define constants in PHP using the define() built-in function:

define('TEST', 'some value');

And then we can use TEST as if it was a variable, but without the $ sign:

define('TEST', 'some value');

echo TEST;

We use uppercase identifiers as a convention for constants.

Interestingly, inside classes we can define constant properties using the const keyword:

class Dog {
  const BREED = 'Siberian Husky';
}

By default they are public but we can mark them as private or protected:

class Dog {
  private const BREED = 'Siberian Husky';
}

Enums allow you to group constants under a common “root”. For example you want to have a Status enum that has 3 states: EATING SLEEPING RUNNING, the 3 states of a dog’s day.

So you have:

enum Status {
  case EATING;
  case SLEEPING;
  case RUNNING;
}

Now we can reference those constants in this way:

class Dog {
  public Status $status;
}

$dog = new Dog();

$dog->status = Status::RUNNING;

if ($dog->status == Status::SLEEPING) {
  //...
}

Enums are objects, they can have methods and lots more features than we can get into here in this short introduction.

How to Use PHP as a Web App Development Platform

PHP is a server-side language and it is typically used in two ways.

One is within an HTML page, so PHP is used to “add” stuff to the HTML which is manually defined in the .php file. This is a perfectly fine way to use PHP.

Another way considers PHP more like the engine that is responsible for generating an “application”. You don't write the HTML in a .php file, but instead you use a templating language to generate the HTML, and everything is managed by what we call the framework.

This is what happens when you use a modern framework like Laravel.

I would consider the first way a bit “out of fashion” these days, and if you’re just starting out you should know about those two different styles of using PHP.

But also consider using a framework like “easy mode” because frameworks give you tools to handle routing, tools to access data from a database, and they make it easier to build a more secure application. And they make it all faster to develop.

That said, we’re not going to talk about using frameworks in this handbook. But I will talk about the basic, fundamental building blocks of PHP. They are essentials that any PHP developer must know.

Just know that “in the real world” you might use your favorite framework’s way of doing things rather than the lower level features offered by PHP.

This does not apply just to PHP of course – it’s an “issue” that happens with any programming language.

How to Handle HTTP Requests in PHP

Let’s start with handling HTTP requests.

PHP offers file-based routing by default. You create an index.php file and that responds on the / path.

We saw that when we made the Hello World example in the beginning.

Similarly, you can create a test.php file and automatically that will be the file that Apache serves on the /test route.

How to Use $_GET, $_POST and $_REQUEST in PHP

Files respond to all HTTP requests, including GET, POST and other verbs.

For any request you can access all the query string data using the $_GET object. It's called superglobal and is automatically available in all our PHP files.

This is of course most useful in GET requests, but also other requests can send data as a query string.

For POST, PUT and DELETE requests you’re more likely to need the data posted as URL-encoded data or using the FormData object, which PHP makes available to you using $_POST.

There is also $_REQUEST which contains all of $_GET and $_POST combined in a single variable.

How to Use the $_SERVER Object in PHP

We also have the superglobal variable $_SERVER, which you use to get a lot of useful information.

You saw how to use phpinfo() before. Let’s use it again to see what $_SERVER offers us.

In your index.php file in the root of MAMP run:

<?php
phpinfo();
?>

Then generate the page at localhost:8888 and search $_SERVER. You will see all the configuration stored and the values assigned:

Important ones you might use are:

• $_SERVER['HTTP_HOST']
• $_SERVER['HTTP_USER_AGENT']
• $_SERVER['SERVER_NAME']
• $_SERVER['SERVER_ADDR']
• $_SERVER['SERVER_PORT']
• $_SERVER['DOCUMENT_ROOT']
• $_SERVER['REQUEST_URI']
• $_SERVER['SCRIPT_NAME']
• $_SERVER['REMOTE_ADDR']

How to Use Forms in PHP

Forms are the way the Web platform allows users to interact with a page and send data to the server.

Here is a simple form in HTML:

<form>
  <input type="text" name="name" />
  <input type="submit" />
</form>

You can put this in your index.php file like it was called index.html.

A PHP file assumes you write HTML in it with some “PHP sprinkles” using <?php ?> so the Web Server can post that to the client. Sometimes the PHP part takes all of the page, and that’s when you generate all the HTML via PHP – it’s kind of the opposite of the approach we're taking here now.

So we have this index.php file that generates this form using plain HTML:

Pressing the Submit button will make a GET request to the same URL sending the data via query string. Notice that the URL changed to localhost:8888/?name=test.

We can add some code to check if that parameter is set using the isset() function:

<form>
  <input type="text" name="name" />
  <input type="submit" />
</form>

<?php
if (isset($_GET['name'])) {
  echo '<p>The name is ' . $_GET['name'];
}
?>

See? We can get the information from the GET request query string through $_GET.

What you usually do with forms, though is you perform a POST request:

<form **method="POST"**>
  <input type="text" name="name" />
  <input type="submit" />
</form>

<?php
if (isset($_POST['name'])) {
  echo '<p>The name is ' . $_POST['name'];
}
?>

See, now we got the same information but the URL didn’t change. The form information was not appended to the URL.

This is because we’re using a POST request, which sends the data to the server in a different way, through URL-encoded data.

As mentioned above, PHP will still serve the index.php file as we’re still sending data to the same URL the form is on.

We’re mixing a bunch of code and we could separate the form request handler from the code that generates the form.

So we can have this in index.php:

<form **method="POST" action="/post.php"**>
  <input type="text" name="name" />
  <input type="submit" />
</form>

and we can create a new post.php file with:

<?php
if (isset($_POST['name'])) {
  echo '<p>The name is ' . $_POST['name'];
}
?>

PHP will display this content now after we submit the form, because we set the action HTML attribute on the form.

This example is very simple, but the post.php file is where we could, for example, save the data to the database, or to a file.

How to Use HTTP Headers in PHP

PHP lets us set the HTTP headers of a response through the header() function.

HTTP Headers are a way to send information back to the browser.

We can say the page generates a 500 Internal Server Error:

<?php
header('HTTP/1.1 500 Internal Server Error');
?>

Now you should see the status if you access the page with the Browser Developer Tools open:

We can set the content/type of a response:

header('Content-Type: text/json');

We can force a 301 redirect:

header('HTTP/1.1 301 Moved Permanently');
header('Location: https://flaviocopes.com');

We can use headers to say to the browser “cache this page”, “don’t cache this page”, and a lot more.

How to Use Cookies in PHP

Cookies are a browser feature.

When we send a response to the browser, we can set a cookie which will be stored by the browser, client-side.

Then, every request the browser makes will include the cookie back to us.

We can do many things with cookies. They are mostly used to create a personalized experience without you having to login to a service.

It’s important to note that cookies are domain-specific, so we can only read cookies we set on the current domain of our application, not other application’s cookies.

But JavaScript can read cookies (unless they are HttpOnly cookies but we’re starting to go into a rabbit hole) so cookies should not store any sensitive information.

We can use PHP to read the value of a cookie referencing the $_COOKIE superglobal:

if (isset($_COOKIE['name'])) {
  $name = $_COOKIE['name'];
}

The setcookie() function allows you to set a cookie:

setcookie('name', 'Flavio');

We can add a third parameter to say when the cookie will expire. If omitted, the cookie expires at the end of the session/when the browser is closed.

Use this code to make the cookie expire in 7 days:

setcookie('name', 'Flavio', time() + 3600 * 24 * 7);

We can only store a limited amount of data in a cookie, and users can clear the cookies client-side when they clear the browser data.

Also, they are specific to the browser / device, so we can set a cookie in the user’s browser, but if they change browser or device, the cookie will not be available.

Let’s do a simple example with the form we used before. We’re going to store the name entered as a cookie:

<?php
if (isset($_POST['name'])) {
  setcookie('name', $_POST['name']);
}
if (isset($_POST['name'])) {
  echo '<p>Hello ' . $_POST['name'];
} else {
  if (isset($_COOKIE['name'])) {
    echo '<p>Hello ' . $_COOKIE['name'];
  }
}
?>

<form method="POST">
  <input type="text" name="name" />
  <input type="submit" />
</form>

I added some conditionals to handle the case where the cookie was already set, and to display the name right after the form is submitted, when the cookie is not set yet (it will only be set for the next HTTP request).

If you open the Browser Developer Tools you should see the cookie in the Storage tab.

From there you can inspect its value, and delete it if you want.

How to Use Cookie-based Sessions in PHP

One very interesting use case for cookies is cookie-based sessions.

PHP offers us a very easy way to create a cookie-based session using session_start().

Try adding this:

<?php
session_start();
?>

in a PHP file, and load it in the browser.

You will see a new cookie named by default PHPSESSID with a value assigned.

That’s the session ID. This will be sent for every new request and PHP will use that to identify the session.

Similarly to how we used cookies, we can now use $_SESSION to store the information sent by the user – but this time it’s not stored client-side.

Only the session ID is.

The data is stored server-side by PHP.

<?php
session_start();

if (isset($_POST['name'])) {
  $_SESSION['name'] = $_POST['name'];
}
if (isset($_POST['name'])) {
  echo '<p>Hello ' . $_POST['name'];
} else {
  if (isset($_SESSION['name'])) {
    echo '<p>Hello ' . $_SESSION['name'];
  }
}
?>

<form method="POST">
  <input type="text" name="name" />
  <input type="submit" />
</form>

This works for simple use cases, but of course for intensive data you will need a database.

To clear the session data you can call session_unset().

To clear the session cookie use:

setcookie(session_name(), '');

How to Work with Files and Folders in PHP

PHP is a server-side language, and one of the handy things it provides is access to the filesystem.

You can check if a file exists using file_exists():

file_exists('test.txt') //true

Get the size of a file using filesize():

filesize('test.txt')

You can open a file using fopen(). Here we open the test.txt file in read-only mode and we get what we call a file descriptor in $file:

$file = fopen('test.txt', 'r')

We can terminate the file access by calling fclose($fd).

Read the content of a file into a variable like this:

$file = fopen('test.txt', 'r')

fread($file, filesize('test.txt'));

//or

while (!feof($file)) {
    $data .= fgets($file, 5000);
}

feof() checks that we haven’t reached the end of the file as fgets reads 5000 bytes at a time.

You can also read a file line by line using fgets():

$file = fopen('test.txt', 'r')

while(!feof($file)) {
  $line = fgets($file);
  //do something
}

To write to a file you must first open it in write mode, then use fwrite():

$data = 'test';
$file = fopen('test.txt', 'w')
fwrite($file, $data);
fclose($file);

We can delete a file using unlink():

unlink('test.txt')

Those are the basics, but of course there are more functions to work with files.

PHP and Databases

PHP offers various built-in libraries to work with databases, for example:

• PostgreSQL
• MySQL / MariaDB
• MongoDB

I won't cover this in the handbook because I think this is a big topic and one that would also require you to learn SQL.

I am also tempted to say that if you need a database you should use a framework or ORM that would save you security issues with SQL injection. Laravel’s Eloquent is a great example.

How to Work with JSON in PHP

JSON is a portable data format we use to represent data and send data from client to server.

Here’s an example of a JSON representation of an object that contains a string and a number:

{
  "name": "Flavio",
  "age": 35
}