csplit and split Command Examples in Linux (Cheat Sheet)

Linux provides two powerful utilities to split files into smaller parts: csplit and split.

• csplit → pattern and structure aware
• split → size, line count, or fixed chunks

This guide explains when to use which, with practical examples.

split Command - Quick Cheat Sheet

This quick reference summarizes the most commonly used split command examples in Linux for dividing large files into smaller parts.

csplit Command - Quick Cheat Sheet

This quick reference summarizes the most commonly used csplit command examples in Linux for splitting files using patterns or line numbers.

How csplit and split Work

Think of file splitting as a two-step process:

input file  →  split rule  →  output files

The difference lies in how the split rule is defined.

• csplit looks inside the file content and splits when a pattern is found
• split ignores content and splits purely by size, lines, or count

In simple terms:

• csplit asks “where should I cut?”
• split asks “how big should each piece be?”

csplit vs split (Feature Comparison)

When to Use csplit vs split

Rule of thumb:
If you care what the content is → use csplit
If you care how big the output is → use split

csplit Examples

The csplit command splits files based on patterns or regular expressions, making it ideal for structured files such as XML, logs, or configuration outputs.

Split a file using a regex match

csplit my_file '/^<report>$/' '{*}'

This command splits the file every time a line exactly matching <report> is found.

• Each <report> ... </report> block is written to a separate file
• {*} tells csplit to repeat the split until the end of the file

This approach is commonly used for XML, JSON-like logs, or reports where sections are clearly marked.

Split based on a pattern and include the matched line

csplit --elide-empty-files my_file '/000/+1' '{*}'

Here, the file is split whenever the pattern 000 is encountered.

• +1 ensures the matching line is included in the next output file
• Useful when the delimiter line belongs to the data block itself

This is ideal for log files or data dumps where separators must be preserved.

Suppress the matched pattern from output files

csplit --suppress-matched my_file '/000/' '{*}'

This variation removes the delimiter line (000) entirely from all output files.

Use this when:

• The pattern is only a separator
• You do not want marker lines in the split results

Prevent creation of empty files

csplit --elide-empty-files my_file '/pattern/' '{*}'

Some patterns can produce empty output files during splitting.

The --elide-empty-files option ensures:

• Only non-empty files are created
• Cleaner output with fewer unnecessary files

Add a custom prefix and suffix to output files

csplit --prefix part --suffix-format "%02d.txt" my_file '/000/' '{*}'

This generates well-named output files such as:

• part00.txt
• part01.txt
• part02.txt

Using prefixes and formatted suffixes is recommended for:

• Automation scripts
• Easier file ordering
• Cleaner post-processing

Split only a limited number of times

csplit my_file '/000/' '{1}'

By limiting the repeat count:

• The pattern is applied only once
• Exactly two files are created

This is useful when you want to split a file into header and body sections instead of multiple fragments.

Conclusion

The csplit and split commands solve different file-splitting problems in Linux.

• Use csplit when the file has a clear structure and you need to split based on patterns, headers, or sections
• Use split when you need to divide files by size, line count, or into equal parts

Understanding both tools gives you complete control over file splitting and reassembly, making them essential utilities for Linux text processing, automation, and system administration tasks.

Also Read

• grep command examples (pattern matching in Linux)
• awk command practical examples
• tar command examples for archiving files
• find command examples for files and directories

Further Reading

• csplit man page
• split man page