10 Essential Terminal Commands Every Developer Should Know

Sometimes, tasks that might take hours to code can be accomplished in minutes with the terminal.

This article assumes you’re already comfortable with basic commands like rm, pwd, and cd.

1. grep

Need to find where a function or variable is used in your codebase, or sift through logs to locate specific entries? grep can help you with that.

The grep command searches for specific patterns in files. It’s like having a supercharged search function that digs into file contents.

How and when to use grep

The basic syntax for the grep command goes as the following;

1
➜ grep "let's find something" file.[txt,json,js,md,etc]

Case-insensitive search: Add the -i flag to ignore case differences.

1
➜ grep -i "REact" compiler/apps/playground/app/index.tsx
2
? '[DEV] React Compiler Playground'
3
: 'React Compiler Playground'

Count occurrences: Use the -c flag to count the number of matching lines.

1
➜ grep -c "React" compiler/apps/playground/app/index.tsx
2
2

Analyzing logs: If you’re troubleshooting an issue, you can use grep to find specific error messages in logs.

1
➜ grep -i "Operation not supported on socket" system.log
2
09/24 08:51:01 INFO   :..settcpimage: Get TCP images rc - EDC8112I Operation not supported on socket.

Search for Multiple Patterns: You can search for multiple patterns by using the -e flag multiple times.

Match either “error” or “404” in system.log.

1
➜ grep -e "error" -e "404" system.log
2
npm error code E404
3
npm error 404  'trevorlasn.com@*' is not in this registry.
4
npm error A complete log of this run can be found in: /Users/trevorindreklasn/.npm/_logs/2024-08-20T16_41_32_846Z-debug-0.log

Recursive Search: To search for a pattern in all files within a directory and its subdirectories, use the -r (or —recursive) flag.

1
➜ grep -o -r "fs" node_modules | wc -l
2
22491

This will search through all files in the specified directory and its subdirectories. The -o option tells grep to print only the matched parts of the line.

The pipe | takes the output from the command on the left (grep) and uses it as input for the command on the right (wc -l). wc -l counts and displays the number of lines in its input.

2. man

The man command stands for “manual.” It helps you find detailed information about other commands and programs.

1
➜ man grep
2

3
NAME
4
     grep, egrep, fgrep, rgrep, bzgrep, bzegrep, bzfgrep, zgrep,
5
     zegrep, zfgrep – file pattern searcher
6

7
SYNOPSIS
8
     grep [-abcdDEFGHhIiJLlMmnOopqRSsUVvwXxZz] [-A num] [-B num]
9
          [-C num] [-e pattern] [-f file] [--binary-files=value]
10
          [--color[=when]] [--colour[=when]] [--context=num]
11
          [--label] [--line-buffered] [--null] [pattern] [file ...]
12

13
DESCRIPTION
14
     The grep utility searches any given input files, selecting
15
     lines that match one or more patterns.  By default, a pattern
16
     matches an input line if the regular expression (RE) in the
17
     pattern matches the input line without its trailing newline.
18
     An empty expression matches every line.  Each input line that
19
     matches at least one of the patterns is written to the standard
20
     output.
21

22
     grep is used for simple patterns and basic regular expressions
23
     (BREs); egrep can handle extended regular expressions (EREs).
24
     See re_format(7) for more information on regular expressions.
25
     fgrep is quicker than both grep and egrep, but can only handle
26
     fixed patterns (i.e., it does not interpret regular
27
     expressions).  Patterns may consist of one or more lines,
28
     allowing any of the pattern lines to match a portion of the
29
     input.
30

31
     zgrep, zegrep, and zfgrep act like grep, egrep, and fgrep,
32
     respectively, but accept input files compressed with the
33
     compress(1) or gzip(1) compression utilities.  bzgrep, bzegrep,
34
     and bzfgrep act like grep, egrep, and fgrep, respectively, but
35
     accept input files compressed with the bzip2(1) compression
36
     utility.
37

38
     The following options are available:
39

40
     -A num, --after-context=num
41
             Print num lines of trailing context after each match.
42
             See also the -B and -C options.
43
             ...

3. cat

The cat command is short for “concatenate.” It’s used to display the contents of a file, combine files, or create new ones.

1
➜  trevorlasn.com git:(master) ✗ cat astro.config.mjs
2
import { defineConfig } from "astro/config";
3
import mdx from "@astrojs/mdx";
4
import sitemap from "@astrojs/sitemap";
5
import tailwind from "@astrojs/tailwind";
6
import vercel from "@astrojs/vercel/static";
7
import partytown from "@astrojs/partytown";
8

9
// https://astro.build/config
10
export default defineConfig({
11
  site: "https://www.trevorlasn.com",
12
  integrations: [ mdx(), sitemap(), tailwind(), partytown({
13
    config: {
14
      forward: ["dataLayer.push"]
15
    }
16
  }), ],
17
  output: "static",
18
  adapter: vercel(),
19
});

Combining Files: One of the key features of cat is its ability to combine multiple files into one. For instance, if you want to merge file1.txt and file2.txt into file3.txt, you can do this:

1
➜ cat file1.txt file2.txt > file3.txt

This command above takes the content of file1.txt and file2.txt and merges them into file3.txt. The > operator is used to direct the combined output into a new file.

Creating New Files: You can also use cat to create new files. Type your text, and when you’re done, press Ctrl+D to save and exit.

1
➜ cat > newfile.txt
2
hey
3
➜ ls
4
newfile.txt
5
➜ cat newfile.txt
6
hey

cat is helpful for viewing smaller files, but for very large files, it can be overwhelming as it dumps everything at once. In such cases, it’s better to use commands like less or head to view files in a more controlled way.

4. head

You often don’t need to see all the content when working with large files. Instead of using cat to display everything, the head command lets you preview just the first few lines of a file.

This is especially useful for checking the structure of CSV files, logs, or any other large text files.

By default, head shows the first 10 lines of a file:

1
➜  trevorlasn.com git:(master) ✗ head package-lock.json
2
{
3
  "name": "trevorlasn.com",
4
  "version": "1.0.0",
5
  "lockfileVersion": 3,
6
  "requires": true,
7
  "packages": {
8
    "": {
9
      "name": "trevorlasn.com",
10
      "version": "1.0.0",
11
      "dependencies": {

If you need more or fewer lines, you can specify the exact number using the -n option:

1
➜  trevorlasn.com git:(master) ✗ head -n 5 package-lock.json
2
{
3
  "name": "trevorlasn.com",
4
  "version": "1.0.0",
5
  "lockfileVersion": 3,
6
  "requires": true,

Previewing CSV Headers: For CSV files, head is perfect for quickly checking the header or structure:

1
➜ head -n 1 username-password-recovery-code.csv
2
Username; Identifier;One-time password;Recovery code;First name;Last name;Department;Location

5. awk

awk is a powerful tool for pattern scanning and processing. It’s particularly useful for manipulating and analyzing text files and data streams.

With awk, you can filter, extract, and transform data in a file or from command output.

awk efficiently extracts and combines data from various sources using its associative arrays. Suppose you have two CSV files:

employees.csv

1
➜ cat employees.csv
2
ID,Name,Department
3
101,John Doe,Sales
4
102,Jane Smith,Engineering
5
103,Jim Brown,Sales

salaries.csv

1
➜ cat salaries.csv
2
ID,Salary
3
101,50000
4
102,60000
5
103,55000

Use awk to merge these files and display each employee’s name with their salary.

1
➜ awk -F',' '
2
    NR==FNR {salaries[$1]=$2; next}
3
    FNR==1 {next}
4
    {print $2, salaries[$1]}
5
' salaries.csv employees.csv
6
John Doe 50000
7
Jane Smith 60000
8
Jim Brown 55000

Rundown

• NR==FNR {salaries[$1]=$2; next}: While processing the first file (salaries.csv), store salaries in an associative array. The employee ID ($1) is the key, and the salary ($2) is the value. This runs only for the first file.
• FNR==1 {next}: Skip the header line of the second file (employees.csv).
• {print $2, salaries[$1]}: For each line in the second file (employees.csv), print the employee’s name ($2) and their salary from the array (salaries[$1]).

You can also save the results to a new file.

1
➜ awk -F',' '
2
    NR==FNR {salaries[$1]=$2; next}
3
    FNR==1 {next}
4
    {print $2, salaries[$1]}
5
' salaries.csv employees.csv > combined.csv
6

7
➜ cat combined.csv
8
John Doe 50000
9
Jane Smith 60000
10
Jim Brown 55000

6. sed

sed, short for Stream Editor, is a powerful tool for text processing in the terminal. It allows you to find, replace, insert, or delete text within files or streams of data.

You can use it for quick edits without opening a text editor, making it great for scripting and automation.

Replace a word or pattern in a file: Replacing “Trevor” with “John”.

1
➜ cat hello.md
2
My name is Trevor
3
➜ sed -i '' 's/Trevor/John/' hello.md
4
➜ cat hello.md
5
My name is John

If you want save the changes, use the -i option.

Print Specific Lines: Print only specific lines from a file.

1
➜  trevorlasn.com git:(master) ✗ sed -n '2,4p' package-lock.json
2
  "name": "trevorlasn.com",
3
  "version": "1.0.0",
4
  "lockfileVersion": 3,

This prints lines 2 through 4.

Regular Expressions: sed supports regular expressions, allowing for complex search-and-replace operations. For example, replace all digits with “X”:

1
➜ cat combined.csv
2
John Doe 50000
3
Jane Smith 60000
4
Jim Brown 55000
5
➜ sed 's/[0-9]/X/g' combined.csv
6
John Doe XXXXX
7
Jane Smith XXXXX
8
Jim Brown XXXXX

Renaming Files in Bulk: Let’s say you have multiple files with the extension .txt and you want to rename them to .md.

1
➜ ls
2
1.txt 2.txt 3.txt
3
➜ for file in *.txt; do
4
    mv "$file" "$(echo "$file" | sed 's/.txt$/.md/')"
5
  done
6
➜ ls
7
1.md 2.md 3.md

sed is highly versatile, and these examples just scratch the surface

7. tail

tail is the counterpart to head. It allows you to view the last few lines of a file rather than the first. It’s commonly used to monitor log files or check the end of a document. By default, tail shows the last 10 lines of a file.

1
➜  trevorlasn.com git:(master) ✗ tail package.json
2
  },
3
  "devDependencies": {
4
    "@typescript-eslint/eslint-plugin": "^7.3.1",
5
    "@typescript-eslint/parser": "^7.3.1",
6
    "eslint": "^8.57.0",
7
    "eslint-plugin-astro": "^0.32.0",
8
    "eslint-plugin-jsx-a11y": "^6.8.0",
9
    "typescript": "^5.4.2"
10
  }
11
}

Viewing More or Fewer Lines: You can adjust the number of lines shown using the -n option.

1
➜  trevorlasn.com git:(master) ✗ tail -n 15 package.json
2
    "astro": "^4.13.3",
3
    "clsx": "^2.1.0",
4
    "sharp": "^0.33.3",
5
    "tailwind-merge": "^2.2.2",
6
    "tailwindcss": "^3.4.1"
7
  },
8
  "devDependencies": {
9
    "@typescript-eslint/eslint-plugin": "^7.3.1",
10
    "@typescript-eslint/parser": "^7.3.1",
11
    "eslint": "^8.57.0",
12
    "eslint-plugin-astro": "^0.32.0",
13
    "eslint-plugin-jsx-a11y": "^6.8.0",
14
    "typescript": "^5.4.2"
15
  }
16
}

Real-Time File Monitoring: One of the most powerful features of tail is the -f option, which allows you to follow a file as it grows. This is especially useful for watching log files in real-time.

1
➜ tail -f 1.md
2
11
3
Changing file

As new lines are added to 1.md, tail will automatically display them.

8. chmod

Each file has three sets of permissions: owner, group, and others. These are typically represented in a format like rwxr-xr—

• r: Read permission
• w: Write permission
• x: Execute permission

1
➜ ls -l sensitive.md
2
-rw-r--r--@ 1 trevorindreklasn  staff  0 Aug 21 15:22 sensitive.md

The file permissions -rw-r—r— indicate that:

• Owner (trevorindreklasn): Has read (r) and write (w) permissions.
• Group (staff): Has read (r) permissions.
• Others: Have read (r) permissions.

The @ symbol indicates that the file has extended attributes, which are additional metadata beyond standard file permissions.

File permissions control who can read, write, or execute a file, ensuring security and proper access management by preventing unauthorized users from modifying or viewing sensitive data.

To restrict access to sensitive.md so that only the root user or superadmins can view and write to it, you can use the chmod command to modify the file’s permissions.

First, ensure the file is owned by the root user or a superadmin. You might need sudo for changing ownership:

1
➜ ls -l sensitive.md
2
-rw-r--r--@ 1 root  staff  0 Aug 21 15:22 sensitive.md
3

4
➜ sudo chown root:admin sensitive.md
5
➜ ls -l sensitive.md
6
-rw-r-----@ 1 root  admin  0 Aug 21 15:22 sensitive.md
7

8
➜ sudo chmod 600 sensitive.md
9
➜  textfiles ls -l sensitive.md
10
-rw-------  1 root  admin  0 Aug 21 15:22 sensitive.md

Only the owner (root) has read and write access. While the group and others have no permissions. This restricts access to the file, making it readable and writable only by the owner.

Improper file permissions can lead to security issues or system problems

• Unauthorized Access: File containing sensitive information, like passwords or financial data, has overly permissive settings (e.g., chmod 777), anyone on the system can read or modify it. This could lead to data breaches or unauthorized access to sensitive information.

• Malware Installation: A file or directory with write permissions for all users (e.g., chmod 777) could be exploited by attackers to place malicious scripts or software, potentially compromising the entire system.

• Data Corruption: If files that should be read-only (e.g., logs or system configurations) are accidentally given write permissions, users or applications might inadvertently corrupt or erase critical data, leading to system instability or loss of important information.

9. xargs

The xargs command builds and runs commands using input from other commands. It’s used to pass a list of items as arguments to another command.

Suppose you have a list of files that you want to delete.

1
➜ ls
2
1.txt        2.txt       2.md         3.md         sensitive.md
3

4
# Find all .txt files and delete them
5
➜ find . -name "*.txt" | xargs rm
6

7
➜  ls
8
2.md         3.md         sensitive.md

Instead of deleting them one by one, you can use xargs to pass the list of files to rm.

1
find . -name "*.tmp" | xargs rm

Creating Multiple Directories: If you have a list of directory names in a file and want to create all of them, you can use xargs with mkdir.

1
➜ cat dirs.txt
2
src
3
temp
4
utils
5
public
6

7
➜ ls
8
2.md         3.md         dirs.txt     sensitive.md
9

10
# Creates each directory listed in the file.
11
➜ cat dirs.txt | xargs mkdir
12

13
➜ ls
14
2.md         dirs.txt     sensitive.md temp
15
3.md         public       src          utils

Compressing Files: If you have multiple files that you want to compress using gzip, you can use xargs to pass the filenames to gzip.

1
# Compresses all .log files in the current directory
2
ls *.log | xargs gzip

10. find

Search and locate files and directories within your file system based on various criteria. It’s highly customizable and can be combined with other commands for complex tasks.

1
find [path] [expression]

The find command searches for occurrences of “astro” within the node_modules directory, returning paths to files and directories with that name, including executables and package files.

1
➜ trevorlasn.com git:(master) ✗ find node_modules -name "astro"
2
node_modules/.bin/astro
3
node_modules/astro
4
node_modules/astro/dist/runtime/server/render/astro

Cleanup old log files: Regularly delete log files older than a month to free up disk space.

1
➜ find /var/log -type f -name "*.log" -mtime +30 -delete

Backup important files: Locate and copy all .docx files from home directory to a backup location.

1
➜  find ~/Documents -name "*.docx" -exec cp {} /path/to/backup/ \;

The find command is incredibly versatile and can be tailored to suit a wide range of file management tasks.

Honorable Mentions

• jq: Slice, filter, map and transform structured data with the same ease that sed, awk, grep.
• cut: A command used to remove sections from each line of files.
• netstat: A network utility to display network connections, routing tables, and interface statistics.
• ping: A tool to test the reachability of a host on an IP network and measure round-trip time.
• ifconfig: A command to configure network interfaces (deprecated in favor of ip).
• telnet: A program to interact with remote hosts over a network using the Telnet protocol.
• sftp: An interactive file transfer program that uses the SSH protocol.
• wget: Network utility to retrieve files from the World Wide Web using HTTP and FTP.
• ps: Displays information about running processes.
• top: A task manager to view and manage running processes in real-time.
• kill: A command used to send signals to processes, typically to terminate them.
• comm: A command that compares two sorted files line by line.