DEV Community: Rafael Peretta

Linux Column Command: The Text Formatter You Did not Know You Needed

Rafael Peretta — Thu, 13 Mar 2025 09:50:39 +0000

Introduction

Have you ever tried to make sense of cluttered text output in your terminal? Perhaps you've found yourself squinting at disorganized data, wishing there was an easy way to transform it into neat, readable columns? Enter the column command – one of Linux's most underappreciated text-formatting utilities that can instantly transform messy text into beautifully aligned tabular displays.

While not as famous as commands like grep or awk, the column command is a powerful tool that belongs in every Linux user's toolkit. Whether you're a system administrator parsing configuration files, a data analyst examining CSV exports, or just someone who appreciates well-organized information, column can dramatically improve how you view and understand text data in the terminal.

In this guide, we'll explore what the column command is, its most practical use cases, and how it can make your command-line experience more efficient and visually pleasing. By the end, you'll wonder how you ever lived without this simple yet powerful formatting tool.

What is the Column Command?

The column command is a text processing utility that formats its input into multiple columns. Originally designed to format manual pages, it has evolved into a versatile text formatter that can handle various data formats including plain text, delimited data, and even JSON in some implementations.

At its core, column does one thing extremely well: it takes lines of text and arranges them into aligned columns that are much easier to read. Think of it as an instant table maker for your terminal – transforming cluttered text into structured, scannable information with minimal effort.

The Top 3 Most Useful Column Command Applications

Let's dive into the three most practical and powerful ways to use the column command in your daily Linux work.

1. Formatting Delimited Data with `-t` and `-s`

The most common and useful application of column is formatting delimited data into tables. This is perfect for CSV files, configuration files, or any output that uses a consistent delimiter between fields.

# Basic usage with tab-delimited input
cat data.txt | column -t

# Specify a different delimiter (like comma for CSV files)
cat data.csv | column -t -s,

# Specify both input delimiter and output delimiter
cat data.csv | column -t -s, -o " | "

Example in Action:

Let's say you have a CSV file containing information about Linux distributions:

Name,Version,Release Date,Desktop Environment
Ubuntu,22.04,2022-04-21,GNOME
Fedora,37,2022-11-15,GNOME
Debian,11,2021-08-14,Various
Arch Linux,Rolling,Continuous,Various
Linux Mint,21,2022-07-31,Cinnamon

When you view this file directly with cat, it's difficult to read:

$ cat distros.csv
Name,Version,Release Date,Desktop Environment
Ubuntu,22.04,2022-04-21,GNOME
Fedora,37,2022-11-15,GNOME
Debian,11,2021-08-14,Various
Arch Linux,Rolling,Continuous,Various
Linux Mint,21,2022-07-31,Cinnamon

But format it with column -t -s,:

$ cat distros.csv | column -t -s,
Name        Version  Release Date  Desktop Environment
Ubuntu      22.04    2022-04-21    GNOME
Fedora      37       2022-11-15    GNOME
Debian      11       2021-08-14    Various
Arch Linux  Rolling  Continuous    Various
Linux Mint  21       2022-07-31    Cinnamon

The difference is striking! Your previously cluttered CSV data is now displayed as a clean, readable table with properly aligned columns. This makes it much easier to scan and understand the information at a glance.

The -t flag tells column to create a table, while -s, specifies that commas are the field separators in the input. If you wanted to make the output even more visually distinct, you could add the -o option to specify an output delimiter:

$ cat distros.csv | column -t -s, -o " | "
Name        | Version | Release Date | Desktop Environment
Ubuntu      | 22.04   | 2022-04-21   | GNOME
Fedora      | 37      | 2022-11-15   | GNOME
Debian      | 11      | 2021-08-14   | Various
Arch Linux  | Rolling | Continuous   | Various
Linux Mint  | 21      | 2022-07-31   | Cinnamon

This makes the column command especially useful for quickly examining data files or the output of other commands without having to open a spreadsheet application.

2. Creating Multi-Column Lists with Default Mode

The second most useful application of column is its default behavior: transforming a long list into a multi-column display that efficiently uses terminal space.

# List files in multiple columns
ls | column

# Create a multi-column list from any command output
cat wordlist.txt | column

Example in Action:

Imagine you have a long list of package names:

$ cat packages.txt
nginx
postgresql
redis
mongodb
python3
nodejs
ruby
php
golang
rust
java
mysql
sqlite
apache2
git
docker
kubernetes
ansible
terraform
prometheus

Reading through this vertical list takes up a lot of space and requires scrolling. But when you pipe it through column:

$ cat packages.txt | column
nginx           postgresql      redis           mongodb         python3
nodejs          ruby            php             golang          rust
java            mysql           sqlite          apache2         git
docker          kubernetes      ansible         terraform       prometheus

The result is a compact, multi-column display that fits more information on screen at once. This is particularly useful for long lists of filenames, options, or any other data where you just need to scan through items quickly.

This default behavior is especially handy when combined with other commands:

$ dpkg --list | grep ^ii | awk '{print $2}' | column
adduser                   apparmor                 apt                      apt-utils
base-files                base-passwd              bash                     bsdutils
bzip2                     coreutils                dash                     debconf
debianutils               diffutils                dpkg                     e2fsprogs
fdisk                     findutils                gcc-10-base              gpgv
grep                      gzip                     hostname                 init-system-helpers
libacl1                   libapt-pkg6.0            libattr1                 libaudit-common
...

This outputs all installed packages in an easy-to-scan multi-column format, making much better use of your terminal space.

3. Working with Complex Output from System Commands

The third most powerful use case for column is formatting the output of system commands that produce structured but hard-to-read information.

# Format mount information
mount | column -t

# Format network connection data
netstat -tuln | column -t

# Format disk usage information
df -h | column -t

Example in Action:

The mount command is notoriously difficult to read in its raw output:

$ mount
sysfs on /sys type sysfs (rw,nosuid,nodev,noexec,relatime)
proc on /proc type proc (rw,nosuid,nodev,noexec,relatime)
udev on /dev type devtmpfs (rw,nosuid,relatime,size=8121732k,nr_inodes=2030433,mode=755)
devpts on /dev/pts type devpts (rw,nosuid,noexec,relatime,gid=5,mode=620,ptmxmode=000)
tmpfs on /run type tmpfs (rw,nosuid,noexec,relatime,size=1628440k,mode=755)
/dev/nvme0n1p2 on / type ext4 (rw,relatime,errors=remount-ro)
securityfs on /sys/kernel/security type securityfs (rw,nosuid,nodev,noexec,relatime)
...

But with column, it becomes dramatically more legible:

$ mount | column -t
sysfs        on  /sys                      type  sysfs        (rw,nosuid,nodev,noexec,relatime)
proc         on  /proc                     type  proc         (rw,nosuid,nodev,noexec,relatime)
udev         on  /dev                      type  devtmpfs     (rw,nosuid,relatime,size=8121732k,nr_inodes=2030433,mode=755)
devpts       on  /dev/pts                  type  devpts       (rw,nosuid,noexec,relatime,gid=5,mode=620,ptmxmode=000)
tmpfs        on  /run                      type  tmpfs        (rw,nosuid,noexec,relatime,size=1628440k,mode=755)
/dev/nvme0n1p2  on  /                      type  ext4         (rw,relatime,errors=remount-ro)
securityfs   on  /sys/kernel/security      type  securityfs   (rw,nosuid,nodev,noexec,relatime)
...

The aligned columns make it much easier to compare mount points, filesystem types, and options.

Similarly, the output of df (disk free) command becomes more readable:

$ df -h | column -t
Filesystem      Size   Used  Avail  Use%  Mounted on
udev            7.8G   0     7.8G   0%    /dev
tmpfs           1.6G   2.0M  1.6G   1%    /run
/dev/nvme0n1p2  457G   298G  137G   69%   /
tmpfs           7.8G   161M  7.6G   3%    /dev/shm
tmpfs           5.0M   4.0K  5.0M   1%    /run/lock
tmpfs           7.8G   0     7.8G   0%    /sys/fs/cgroup
/dev/nvme0n1p1  511M   6.1M  505M   2%    /boot/efi
tmpfs           1.6G   84K   1.6G   1%    /run/user/1000

This clean formatting makes it much easier to quickly assess disk usage across different filesystems.

Advanced Column Command Features

Beyond the top three use cases, column offers several advanced features worth knowing:

Table Headers with `--table-header`

Newer versions of column can properly handle table headers:

# Specify the first line as a header row
cat data.csv | column -t -s, --table-header

This ensures the header row is treated specially and may be visually distinguished in some implementations.

JSON Output with `-J`

Some modern versions of column (specifically the one from util-linux 2.36+) support JSON output:

# Output as JSON format
mount | column -J

This is useful for parsing the formatted data programmatically.

Custom Table Formatting with `-x` and `-c`

You can control the way column fills columns:

# Fill columns horizontally (default)
ls | column

# Fill columns vertically
ls | column -x

# Specify the number of columns
ls | column -c 3

Practical Column Command Applications in Daily Work

Here are some practical ways to incorporate column into your daily Linux workflow:

Enhance Configuration File Readability

# Make /etc/fstab more readable
cat /etc/fstab | grep -v ^# | column -t

Format the Output of Database Queries

# Format PostgreSQL tabular output
psql -c "SELECT * FROM users LIMIT 10" | column -t

Create Better-Looking Command Outputs in Scripts

# In a shell script
echo -e "USER\tHOME\tSHELL" > report.txt
cat /etc/passwd | cut -d: -f1,6,7 | tr ':' '\t' >> report.txt
column -t -s $'\t' report.txt

Format Process Information

# Format process information for specific users
ps -u username -o pid,ppid,cmd,%cpu,%mem | column -t

Frequently Asked Questions

How do I install the column command?

The column command is typically included in the util-linux package, which is installed by default on most Linux distributions. If you need to install it:

On Debian/Ubuntu:

sudo apt install bsdmainutils

On CentOS/RHEL:

sudo yum install util-linux

Can column handle very large files?

column reads the entire input into memory to calculate column widths, so it's not ideal for extremely large files. For very large datasets, consider using alternative tools like awk or processing the file in chunks.

How do I prevent column from interpreting certain characters?

If your data contains special characters that column might interpret, you can use the -n flag in some versions to disable this interpretation:

column -t -n file.txt

Can I use column with fixed-width input?

Yes, some versions of column support the -c option to specify column widths:

column -c 20,30,15 file.txt

However, this feature isn't universally available across all implementations.

How can I format the output of the ls command properly?

While ls already formats output in columns, you might want to combine it with other commands:

ls -la | awk 'NR>1 {print $1, $3, $4, $5, $9}' | column -t

This extracts specific fields from ls -la output and formats them neatly.

Your Next Steps with Column Command

Now that you understand the power of the column command, consider integrating it into your daily workflow:

Create aliases for your most frequently used column commands
Add it to your scripts to make their output more readable
Combine it with other text processing tools like awk, sed, and grep for more powerful formatting
Explore advanced options in your specific version of column using man column

The column command may seem simple, but its ability to instantly transform messy text into structured, readable tables makes it an invaluable addition to your Linux command-line repertoire.

Ready to Level Up Your Terminal Text Formatting?

Have you tried using the column command to improve the readability of your command-line output? Which formatting challenge will you tackle first? Share your experiences in the comments below or reach out with questions about using column in specific scenarios.

Remember, good formatting isn't just about aesthetics—it's about making information more accessible and understandable. With column in your toolkit, you're well-equipped to transform cluttered data into clean, readable tables that help you work more efficiently in the Linux terminal.

10 Essential Linux Commands Every Beginner Should Know: Your Path to Linux Mastery

Rafael Peretta — Sun, 09 Mar 2025 13:49:14 +0000

Introduction

Have you ever stared at a Linux terminal, cursor blinking expectantly, and felt completely lost? You're not alone. Learning Linux can feel overwhelming at first, but mastering just a handful of essential commands can transform you from a confused newcomer to a confident user. This guide will walk you through the ten most important Linux commands that form the foundation of your Linux journey. Whether you're setting up your first server, exploring cybersecurity, or simply curious about this powerful operating system, these commands will become your trusted companions.

Why Learning Command Line Is Worth Your Time

Before diving into specific commands, let's understand why the command line interface (CLI) remains so valuable in our graphical-interface world. The command line offers:

Efficiency: Accomplish tasks with a few keystrokes that would take multiple clicks in a GUI
Automation: Easily script repetitive tasks to save enormous amounts of time
Remote access: Manage servers and systems from anywhere with minimal bandwidth
Consistency: Commands work the same way across different Linux distributions

Now, let's explore the essential commands that will empower you to navigate and control your Linux system with confidence.

1. `ls` - List Directory Contents

The ls command is your window into the file system. It shows you what files and directories exist in your current location.

# Basic usage - list files in current directory
ls

# Show hidden files (those starting with a dot)
ls -a

# Show detailed information including permissions, size, and modification date
ls -l

# Combine options - detailed list including hidden files
ls -la

When you run ls -la, you'll see output like this:

total 32
drwxr-xr-x 4 user user 4096 Mar 01 14:25 .
drwxr-xr-x 25 user user 4096 Feb 28 09:12 ..
-rw-r--r-- 1 user user  220 Feb 25 2020 .bash_logout
-rw-r--r-- 1 user user 3771 Feb 25 2020 .bashrc
drwxr-xr-x 3 user user 4096 Mar 01 14:24 Documents
-rw-r--r-- 1 user user  807 Feb 25 2020 .profile
drwx------ 2 user user 4096 Mar 01 14:25 .ssh

The first column shows permissions, followed by the number of links, owner, group, file size, modification date, and finally the file or directory name.

2. `cd` - Change Directory

The cd command is how you navigate through the Linux file system hierarchy. Think of it as your way of moving between different rooms in your digital house.

# Move to a specific directory
cd Documents

# Move up one level to the parent directory
cd ..

# Move to your home directory from anywhere
cd ~

# Move to the previous directory you were in
cd -

# Move to the root directory
cd /

Understanding the Linux directory structure is key to effective navigation:

/ - The root directory (everything is inside this)
/home/username - Your home directory (where ~ points to)
/etc - System configuration files
/var - Variable data files (logs, etc.)
/usr - User binaries and program files

3. `pwd` - Print Working Directory

When exploring the file system, it's easy to get lost. The pwd command tells you exactly where you are.

pwd

This might output something like:

/home/username/Documents/projects

This simple but essential command helps maintain your sense of location within the file system hierarchy. I always recommend using it frequently when you're learning to navigate Linux.

4. `mkdir` - Make Directory

Creating new directories (folders) is a fundamental operation, and mkdir makes it simple.

# Create a single directory
mkdir projects

# Create nested directories (including parent directories if they don't exist)
mkdir -p projects/website/css

# Create multiple directories at once
mkdir documents downloads pictures

The -p option is particularly useful as it creates parent directories as needed, saving you from having to create each directory level separately.

5. `cp` - Copy Files and Directories

The cp command lets you duplicate files and directories.

# Copy a file
cp source.txt destination.txt

# Copy a file to another directory
cp report.pdf Documents/

# Copy a directory and its contents recursively
cp -r Projects/ Backup/

# Copy while preserving file attributes (permissions, timestamps)
cp -a config.ini config.backup

When copying files, be mindful of existing files—cp will overwrite a destination file without warning unless you use the -i (interactive) option.

6. `mv` - Move or Rename Files

The mv command serves double duty: it moves files between directories and renames them.

# Rename a file
mv oldname.txt newname.txt

# Move a file to another directory
mv document.pdf Documents/

# Move multiple files to a directory
mv file1.txt file2.txt file3.txt target_directory/

# Move and rename at the same time
mv report.doc Documents/final_report.doc

Like cp, mv will overwrite existing files without warning. Use mv -i if you want to be prompted before overwriting.

7. `rm` - Remove Files and Directories

The rm command deletes files and directories, and it's one command where caution is especially warranted—there's no trash bin or recycle folder for recovery.

# Remove a file
rm unwanted.txt

# Remove a file with confirmation prompt
rm -i importantfile.doc

# Remove a directory and its contents recursively
rm -r old_project/

# Force removal without confirmation (use with extreme caution)
rm -f locked.file

A word of caution: rm -rf / is a notorious command that would attempt to delete everything on your system. Linux distributions have safeguards against this, but it illustrates why careful typing is important when using rm.

8. `grep` - Search for Patterns

The grep command is a powerful search utility that finds text patterns in files.

# Search for a word in a file
grep "password" config.txt

# Search case-insensitively
grep -i "error" logfile.txt

# Show line numbers with matches
grep -n "function" script.js

# Search recursively through directories
grep -r "TODO" ~/projects/

# Show only the count of matching lines
grep -c "404" access.log

grep becomes even more powerful when combined with other commands using pipes (|), which we'll explore in a moment.

9. `cat` - Concatenate and Display Files

The cat command outputs file contents to the terminal, making it perfect for viewing short files.

# Display file contents
cat notes.txt

# Combine multiple files and display them
cat file1.txt file2.txt

# Create a new file with content (press Ctrl+D when finished)
cat > newfile.txt

# Display with line numbers
cat -n script.sh

For longer files, you might prefer less or more commands which provide pagination capabilities.

10. `sudo` - Execute Commands as Superuser

Many system-level operations require administrative privileges. The sudo command lets you execute commands with superuser (root) privileges.

# Install a package (on Debian/Ubuntu)
sudo apt install firefox

# Edit a system configuration file
sudo nano /etc/hosts

# Restart a system service
sudo systemctl restart apache2

# Update your system
sudo apt update && sudo apt upgrade

sudo invokes the system's security policy, typically prompting for your password. It's a powerful tool that should be used with care, as it provides the ability to make system-wide changes.

Bonus: Chaining Commands with Pipes and Redirects

Linux's true power emerges when you combine commands. This is done with pipes (|) and redirects (>, >>).

# Find all text files and list them sorted by size
find . -name "*.txt" | xargs ls -lS

# Count how many error lines are in a log file
grep "ERROR" application.log | wc -l

# Save the directory listing to a file
ls -la > directory_contents.txt

# Append command output to an existing file
echo "Backup completed on $(date)" >> backup_log.txt

These operators transform Linux from a collection of individual commands into an integrated environment where data can flow seamlessly between programs.

Common Linux Command Patterns for Beginners

Here are some typical command combinations that demonstrate Linux's practical power:

# Find large files (over 100MB)
find / -type f -size +100M -exec ls -lh {} \; 2>/dev/null

# Check disk space usage in human-readable format
df -h

# Monitor system processes
top

# Create a compressed archive
tar -czvf archive.tar.gz directory/

# Download a file from the internet
wget https://example.com/file.zip

Frequently Asked Questions

How do I get help with Linux commands?

Most commands accept the --help flag or have a manual page accessible via the man command:

ls --help
man grep

What's the difference between relative and absolute paths?

Absolute paths start from the root directory (/) and specify the complete path. Relative paths start from your current location. For example:

Absolute: /home/username/Documents/file.txt
Relative: Documents/file.txt (when you're in your home directory)

How can I find files in Linux?

The find command is your best friend:

# Find files by name
find /home -name "*.jpg"

# Find files modified in the last 7 days
find ~/Documents -mtime -7

How do I check system resources?

Use these commands to monitor your system:

# Memory usage
free -h

# Disk space
df -h

# CPU and memory usage by process
top

What's the safest way to delete files?

Always use the interactive flag with rm when learning:

rm -i file.txt

Or use trash-cli if available, which moves files to a recoverable trash bin:

trash file.txt

Your Next Steps in Linux Mastery

Now that you've learned these essential commands, you're ready to take your Linux skills further. Here are some suggestions:

Create a cheat sheet with these commands and their most common options
Practice regularly in a safe environment like a virtual machine
Explore shell scripting to automate repetitive tasks
Learn about package management specific to your Linux distribution
Join Linux communities where you can ask questions and share knowledge

The command line may seem intimidating at first, but it's the gateway to unlocking Linux's full potential. Take it step by step, and before long, you'll find yourself navigating with confidence and performing complex operations with ease.

Ready to Continue Your Linux Journey?

Have you tried all these commands? Which one do you find most useful in your daily work? Share your experience in the comments below or reach out with any questions about getting started with Linux. And if you found this guide helpful, don't forget to bookmark it for future reference as you build your command line skills!

DEV Community: Rafael Peretta

Linux Column Command: The Text Formatter You Did not Know You Needed

Introduction

What is the Column Command?

The Top 3 Most Useful Column Command Applications

1. Formatting Delimited Data with -t and -s

Example in Action:

2. Creating Multi-Column Lists with Default Mode

Example in Action:

3. Working with Complex Output from System Commands

Example in Action:

Advanced Column Command Features

Table Headers with --table-header

JSON Output with -J

Custom Table Formatting with -x and -c

Practical Column Command Applications in Daily Work

Enhance Configuration File Readability

Format the Output of Database Queries

Create Better-Looking Command Outputs in Scripts

Format Process Information

Frequently Asked Questions

How do I install the column command?

Can column handle very large files?

How do I prevent column from interpreting certain characters?

Can I use column with fixed-width input?

How can I format the output of the ls command properly?

Your Next Steps with Column Command

Ready to Level Up Your Terminal Text Formatting?

10 Essential Linux Commands Every Beginner Should Know: Your Path to Linux Mastery

Introduction

Why Learning Command Line Is Worth Your Time

1. ls - List Directory Contents

2. cd - Change Directory

3. pwd - Print Working Directory

4. mkdir - Make Directory

5. cp - Copy Files and Directories

6. mv - Move or Rename Files

7. rm - Remove Files and Directories

8. grep - Search for Patterns

9. cat - Concatenate and Display Files

10. sudo - Execute Commands as Superuser

Bonus: Chaining Commands with Pipes and Redirects

Common Linux Command Patterns for Beginners

Frequently Asked Questions

How do I get help with Linux commands?

What's the difference between relative and absolute paths?

How can I find files in Linux?

How do I check system resources?

What's the safest way to delete files?

Your Next Steps in Linux Mastery

Ready to Continue Your Linux Journey?

1. Formatting Delimited Data with `-t` and `-s`

Table Headers with `--table-header`

JSON Output with `-J`

Custom Table Formatting with `-x` and `-c`

1. `ls` - List Directory Contents

2. `cd` - Change Directory

3. `pwd` - Print Working Directory

4. `mkdir` - Make Directory

5. `cp` - Copy Files and Directories

6. `mv` - Move or Rename Files

7. `rm` - Remove Files and Directories

8. `grep` - Search for Patterns

9. `cat` - Concatenate and Display Files

10. `sudo` - Execute Commands as Superuser