This tutorial shows you how to search a pattern in multiple files using grep.

Search in Selected Files with grep

You can select specific files and pass them as arguments to grep when searching for patterns. The selected files can be of different file types. You may combine a log file and a language-specific file, like the package.json:

grep "pattern" storage/logs/app.log package.json  

Search in a Specific Type of Files with grep

You may not know all the files in a directory and need a dynamic approach to select the files in which you want to search for the keyword. Use a glob pattern with grep to let the tool find all files matching the pattern.

grep "pattern" storage/logs/*.log  

The output will have the file name as a prefix of the matching line. Everything after the file name is the matching content found in the related file.

Here’s a preview of how the results will look like:

$ grep "pattern" storage/logs/*.log
storage/logs/app.log:{"hostname":"55ec743122e6", …}  
storage/logs/cms.log:{"hostname":"12ab554433f7", …}  

Search Recursively in Files of a Given Type with grep

You may add flags to grep when searching through files. For example, if you want to recursively find matches in your JavaScript files use the --recursive flag and a glob pattern for the file path.

Here’s a sample call for that:

grep -r "pattern" src/**/*.js  

Here’s a preview of how the results are printed. Notice that the output contains the line’s indention as well as comments.

src/utils/index.js:    //     you may use a different pattern here  
src/database/driver.js:   console.log('the b-tree pattern works nicely')  

That’s it!

You may need to detect whether a given value is a ULID string as opposed to a string with no specific meaning. This tutorial shows you how to detect whether a string is a ULID.

Detect if a String Value is a ULID in JavaScript

ULIDs follow a strict pattern by consisting of numbers and uppercase letters and always being 26 characters long. We can use this strict format to create a regular expression to test a given input value.

Here’s a helper function to determine whether a given value is a ULID:

const ulidPattern = /^[0-9A-HJKMNP-TV-Z]{26}$/;

/**
 * Determine whether the given `value` is a ULID.
 *
 * @param {string} value
 *
 * @returns {boolean}
 */
function isUlid(value) {  
  if (typeof value !== 'string') {
    throw new TypeError(`Invalid value passed to isUlid: expected string, received ${typeof value}`);
  }

  return ulidPattern.test(value);
}

That’s it!

A nice thing about grep is that it can search for a pattern in multiple files at the same time. Simultaneously search in selected files or use a glob pattern that resolves all files for you. This tutorial shows you how to search in multiple log files using grep.

Search in Selected Log Files with grep

grep allows you to search for a pattern in more than one file. You may search in selected log files if your application sends logs to different files. For example, you may search your default app.log and an extra delete-audit.log file. Add your selected files as separate arguments to grep:

grep "pattern" storage/logs/app.log storage/logs/delete-audit.log  

Search in all .log Files with grep

You can also use a glob pattern to search within all files having the .log file extension. The following line searches for the given pattern in all log files within the storage/logs directory. It won’t search through subdirectories and stay on the selected directory’s level to pick the files:

grep "pattern" storage/logs/*.log  

Examples

Here’s a sample output of how grep prints the matches to the console. Notice that a matching line is printed with the prefixed log file name. This helps you detect what log file could have more details:

$ grep "request" storage/logs/*.log
storage/logs/app.log:INFO: ======= request finished successful ======> {"took":"0.052s","status_code":200}  
storage/logs/delete-audit.log:DEBUG: User deletion requested {"userId":"1"}  
storage/logs/delete-audit.log:DEBUG: User successfully deleted {"userId":"1"}  

That’s it!

A use case to search through all files in a directory is finding information in application log files. You may want to retrieve more context information about a request and that could involve multiple files. This tutorial shows you how to search non-recursively through all files in a directory.

Search Non-Recursively all Files in a Directory with grep

You may provide a file or directory path to grep and it starts its search. A thing to keep in mind is that grep expects a file path by default. When passing a directory path to grep it will tell you that the path is a directory and you need to be more specific on what to search for:

$ grep "hostname" storage/logs
grep: data/logs: Is a directory  

Grepping all Files in a Directory

Use glob patterns in the directory path to tell grep to search all files in a given directory. A glob pattern representing all files in a directory is the *.

Here’s a code snippet showing you how to search for a pattern in the current directory:

# search through all files in the current directory
grep "pattern" *  

You may also search in a nested directory and append the * to the path provided to grep:

# search through all log files
grep "pattern" storage/logs/*  

That’s it!

Mentioned Resources

• Future Studio tutorial on searching recursively through all files in a directory

This tutorial shows you how to run a recursive search on all files in a directory.

Search Recursively in Subdirectories with grep

You can’t pass a directory path to grep. You’ll see an error message that your given path is a directory:

$ grep "hostname" storage/logs
grep: data/logs: Is a directory  

grep expects a file path by default. A directory path requires you to add specific options. For example, grep supports a --recursive flag to search through all files within the storage/logs directory:

grep --recursive "pattern" storage/logs

# use the "-r" shorthand for "--recursive"
grep -r "pattern" storage/logs  

The --recursive flag tells grep to take the path argument and treat it as a directory and the starting point for the search through all files within the directory itself or any subdirectory. Any match for the search pattern has the file name as a prefix in the output:

$ grep --recursive "hostname" storage/logs
storage/logs/default.log:{"hostname":"55ec743122e6", …}  
storage/logs/cms.log:{"hostname":"55ec743122e6", …}  
storage/logs/cli/default.log:{"hostname":"68ab13594b24", …}  
storage/logs/cli/delete-audit.log:{"hostname":"68ab13594b24", …}  

That’s it!

Mentioned Resources

• grep’s man page describing the --recursive flag

This tutorial shows you how to search a pattern case-insensitive in a file to see all matches, regardless the pattern’s writing style.

Case-Insensitive Search with grep

grep has a --ignore-case flag to ignore the casing when searching for a pattern in a file. This flag tells grep to treat all letters in the pattern and the text in the source file the same, no matter the casing.

You can use the --ignore-case flag or its shorthand -i for case-insensitive searching:

grep --ignore-case "pattern" storage/logs/app.log

# use the "-i" shorthand for "--ignore-case"
grep -i "pattern" storage/logs/app.log  

Examples

Let’s have a look at an example output of grep when searching for a string with the case-insensitive flag:

$ grep -i "request" storage/logs/app.log
INFO: ======= REQUEST FINISHED SUCCESSFUL ======> {"took":"0.052s","status_code":200}  

Here’s the related grep search without the case-insensitive flag. It won’t find a match because the search value request isn’t part of the app.log file:

$ grep -i "request" storage/logs/app.log

# empty output, nothing found

That’s it!

Mentioned Resources

• man page for grep’s --ignore-case flag

We’re using GitHub Actions for both examples: running our test suite and deployments. When deploying, we’re using the short git commit hash as part of the release identifier. But there’s one downside in GitHub Actions: they don’t provide the short git commit hash as a variable by default.

This tutorial shows you how to get the short, seven-character git commit hash within GitHub Actions.

Use the Short Git Commit Hash in GitHub Actions

GitHub Actions provide a comprehensive set of contextual information. For example, you’re receiving the context data for the environment or the job or specific github data.

The github context contains the github.sha variable that triggered the workflow. It’s the git commit SHA in full length, like ffac537e6cbbf934b08745a378932722df287a53.

You can retrieve the short commit SHA using bash parameter expansion. With parameter expansion, you can extract a substring from a given variable. You’re providing an offset and the substring length.

Here’s an example outlining the use of parameter expansion to retrieve the short git commit hash:

github_sha_hash=${{ github.sha }}  
github_sha_short="${github_sha_hash:0:7}"  

GitHub Actions Example Workflow With Short Git Commit Hash

The following GitHub Actions workflow shows you how to get and use short git SHA. We’re retrieving the full github.sha context variable and using parameter expansion to get the first seven characters from it. We’re also storing the short commit hash within a local github_sha_short variable that can be used later, in our case to echo out the value:

name: Production Deployment

on:  
  workflow_run:
    workflows: [Run tests]

jobs:  
  deploy:
    runs-on: ubuntu-24.04

    steps:
      …

      - name: Run your script
        run: |
          github_sha_hash=${{ github.sha }}
          github_sha_short="${github_sha_hash:0:7}"

          echo "GitHub Short Commit Hash hash: ${github_sha_short}"

That’s it!

Mentioned Resources

• GitHub Actions contextual information
• GitHub Actions github context data
• StackOverflow thread for bash parameter expansion

In this tutorial, we’re adding a new column to the beginning of a table using the ALTER TABLE … ADD COLUMN … FIRST syntax.

Adding a New First Column in a MySQL Table

MySQL allows you to add a new column to the beginning of a table. Use the ALTER TABLE … ADD COLUM query to add a new column. Then put the FIRST modified after the column name to make it the new, first column of that table.

Here’s an example of adding a new uuid column to the beginning of the table. This new uuid column pushes all other columns to their position:

ALTER TABLE users  
  ADD COLUMN uuid VARCHAR(50) FIRST;

You may add more than one column to your table and combine the positions as you want. For example, add a new column to the beginning and add another column after a given column in the table.

ALTER TABLE users  
  ADD COLUMN uuid VARCHAR(50) FIRST
  ADD COLUMN fullname VARCHAR(150) NULL AFTER lastname
  ADD COLUMN updatedon DATETIME;

The statement above adds the following fields to the users table:
- a new first uuid column - a fullname column after the existing lastname column - an updatedon column at the end, as the new last column in the table

That’s it!

Mentioned Resources

• Future Studio tutorial on adding a new MySQL column after an existing one

MySQL allows you to place a new column after an existing one using the AFTER <column-name> syntax. Read on to get more details.

Add a New Field After an Existing Column in a MySQL Table

Use the ALTER TABLE … ADD COLUMN syntax in MySQL to add a new column. This command supports the AFTER keyword telling MySQL to add a new column after an existing one.

Here’s a sample SQL query that adds a new fullname column after the existing lastname:

ALTER TABLE users  
  ADD COLUMN fullname VARCHAR(150) NULL AFTER lastname;

You can add multiple columns in a single statement and combine the creation with the AFTER syntax as well. Every new column defines their position using AFTER:

ALTER TABLE users  
  ADD COLUMN uuid VARCHAR(50) NULL AFTER id
  ADD COLUMN fullname VARCHAR(150) NULL AFTER uuid;

That’s it!

This tutorial shows you how to order values in MySQL by multiple columns that use the first non-null one.

Use the First Non-Null Value From a List of Fields

MySQL has the COALESCE function that returns the first non-NULL column from a given list, or NULL if all values are NULL.

Here’s a simple example showing the functionality of COALESCE:

SELECT COALESCE(NULL, 1);  
# 1

Let’s use the COALESCE function in another example. Let’s say you want to sort the users of your application based on when they confirmed their account. This sorting will show the newest users, that are allowed to interact with your app, at the beginning of the listing. If a user hasn’t confirmed their account, you want to use the registration date.

Here’s an example using COALESCE to retrieve the confirmation or creation date of a given user:

SELECT *  
FROM users  
ORDER BY COALESCE(confirmedon, createdon) DESC;  

You can also use COALESCE in the list of selected fields. The following example uses a named field confirmedonOrCreatedon that contains the first non-NULL value from the two fields:

SELECT  
  *,
  COALESCE(confirmedon, createdon) as confirmedonOrCreatedon
FROM users  
ORDER BY confirmedonOrCreatedon DESC;  

That’s it!

Mentioned Resources

• MySQL docs on the COALESCE function

You can rename columns in MySQL easily and this tutorial shows you how.

MySQL 8.x (and later)

You can rename columns in MySQL 8.0 (and above) using the ALTER TABLE command. The following syntax renames a column:

ALTER TABLE users RENAME COLUMN first_name TO firstname;  

The ALTER TABLE … RENAME COLUMN command is readable and understandable. It changes the column name but doesn’t allow you to the definition. For example, if you need to change the length of the VARCHAR field, you need to use the ALTER TABLE … CHANGE syntax. Read the next section for MySQL 5.6/5.7 for that syntax.

MySQL 5.6 and 5.7

In MySQL 5.x you must use the ALTER TABLE … CHANGE syntax to rename a column. You must provide the full column definition:

ALTER TABLE users CHANGE first_name firstname VARCHAR(100) NOT NULL;

# change column name + definition
ALTER TABLE users CHANGE first_name firstname VARCHAR(150) NOT NULL;  

Notice: any unstated attribute from the existing column definition goes back to default if you’re not restating the full column definition when renaming a column. For example, omitting NOT NULL in the definition will result in allowing NULL values.

That’s it!

Check if a Date is on a Weekend in JavaScript

The following code snippet outlines how to check whether a given date is on a weekend. We’re using the Date#getDay function to retrieve the number for the day of the week. This number is according to the local time and represents a day between 0 and 6:

• 0=Sunday
• 1=Monday
• 2=Tuesday
• …
• 6=Saturday

The numbers for Saturday 6 and Sunday 0 are a multiple of 6 and we can use the modulo operator to check for a remainder of 0 to detect the weekend:

function isWeekend(date) {  
  if (date instanceof Date) {
    return date.getDay() % 6 === 0
  }

  throw new Error('Cannot check if date is weekend: [date] parameter is not a Date')
}

Check if a Date is a Weekday in JavaScript

For weekdays, we’re using Date#getDay as well to retrieve the number for the day of the week. This time we’re checking for a remainder other than 0 to detect the days Monday to Friday:

function isWeekday(date) {  
  if (date instanceof Date) {
    return date.getDay() % 6 !== 0
  }

  throw new Error('Cannot check if date is week day: [date] parameter is not a Date')
}

That’s it!

Mentioned Resources

• MDN docs for Date#getDay

Editing large files with nano can be tedious, especially when the line of interest is hundreds of lines away from the start. This tutorial shows you how to open a file with nano at a given line number.

Open Files in nano Editor at Line Number

You can jump to a specific line in nano using nano +<line-number> app.js. The “plus” flag tells nano to jump to line n for the opening file:

# open my-file.js at line 377
nano +377 my-file.js  

Nano jumps to the last line of the selected file if you’re providing a line number that exceeds the total number of lines.

Notice: you can’t use a negative jump like nano -1 app.js to jump to the last line.

Enjoy!

Recently we prepared the directory structure on a local computer before cloning the remote repository. When cloning the repository we wanted git to put the contents into the current directory. This tutorial shows you how to do that.

Clone a Remote git Repository into the Current Directory

The git clone command allows you to clone a git repository from a remote machine to your local hard drive. The signature of git clone expects a repository URL as the first argument. You may provide an optional second argument which is the directory name in which to put the contents.

You may also use the dot . as the target directory for the clone. The dot represents the current directory and git properly resolves it:

# put a dot after the git repository URL to clone into the current directory
git clone git@github.com:user/my-project.git .  

That’s it!

Dotfiles are the “hidden” files on your hard disk that start with a dot. Typically, a file explorer hides such files. A common dotfile is the .bashrc file, or a directory example is the .git folder in a git repository.

This tutorial shows you how to display all files and folders in a directory, including dotfiles.

Display All Files and Folders

Use ls -a to display all files and folders in a file path. The -a flag is an alias for the —all flag and tells ls not to hide dotfiles:

ls -a

# or with full flag name
ls --all  

Example: Show All Files and Folders in Columns

Here’s an example showing all files and folders in a project directory. We’ve reduced the number of files and folders for a better overview. You can see that the ls -a command displays dotfiles like .gitignore and also hidden directories like .project. Also, it shows the implicit . and .. paths:

$ ls -a
.                  .gitignore         package.json
..                 .project           vite.config.ts

All Files and Folders as a List

Instead of printing them in columns, you can also list the files and folders. Append the -l flag or combine them in a single flag to ls -al. Notice, ls -la is the same as ls -al. You can change the order of flags as you want.

$ ls -al
.
..
.gitignore
package.json  
.project
vite.config.ts  

Display Almost All Files and Folders

The ls -a flag displays the implicit . and .. paths. The ls command offers the —almost-all flag to hide these paths. You may also use the -A alias instead of the full —almost-all:

ls -A

# or with full flag name
ls --almost-all  

Almost All Files and Folders in Columns

Displaying almost all files and folders in a given file path surfaces the dotfiles and hides the implicit . and .. paths.

$ ls -A
.gitignore         package.json
.project           vite.config.ts

Almost All Files and Folders as a List

You can also print the files and folders as a list. Append the -l flag to print the listing in combination with almost all files and folders:

$ ls -Al
.gitignore
package.json  
.project
vite.config.ts  

That’s it!