Back to Commands

join

text_processingLinux/Unix
The join command is one of the most frequently used commands in Linux/Unix-like operating systems. join Join lines of two files on a common field
See ExamplesView Syntax

Quick Reference

Command Name:

join

Category:

text_processing

Platform:

Linux/Unix

Basic Usage:

join [options] [arguments]

Common Use Cases

    Syntax

    join [options] file1 file2

    Options

    Option Description
    -a FILENUM Print unpairable lines from file FILENUM (1 or 2)
    -e STRING Replace missing input fields with STRING
    -i, --ignore-case Ignore case differences when comparing fields
    -j FIELD Equivalent to '-1 FIELD -2 FIELD'
    -o FORMAT Obey FORMAT while constructing output line
    -t CHAR Use CHAR as input and output field separator
    -v FILENUM Like -a FILENUM, but suppress joined output lines
    -1 FIELD Join on this FIELD of file 1
    -2 FIELD Join on this FIELD of file 2
    --check-order Check that input is correctly sorted, even if all input lines are pairable
    --nocheck-order Do not check that input is correctly sorted
    --header Treat first line in each file as field headers
    --help Display help and exit
    --version Output version information and exit

    Examples

    How to Use These Examples

    The examples below show common ways to use the join command. Try them in your terminal to see the results. You can copy any example by clicking on the code block.

    # Basic Examples Basic
    join file1.txt file2.txt
    Join two files on the first field.
    join -1 2 -2 3 file1.txt file2.txt
    Join file1 using field 2 and file2 using field 3.
    # Advanced Examples Advanced
    join -t : file1.txt file2.txt Use colon as the field separator. join -a 1 file1.txt file2.txt Output unpairable lines from file1. join -a 2 file1.txt file2.txt Output unpairable lines from file2. join -a 1 -a 2 file1.txt file2.txt Output unpairable lines from both files. join -o 1.2,2.3 file1.txt file2.txt Output only field 2 from file1 and field 3 from file2. join -e 'NULL' file1.txt file2.txt Replace missing fields with 'NULL'. join -i file1.txt file2.txt Ignore case when comparing join fields. join -v 1 file1.txt file2.txt Output only lines that are unpairable from file1.

    Try It Yourself

    Practice makes perfect! The best way to learn is by trying these examples on your own system with real files.

    Understanding Syntax

    Pay attention to the syntax coloring: commands, options, and file paths are highlighted differently.

    Notes

    The join command is a powerful text-processing utility in Unix and Linux that combines lines from two files based on a common field, similar to a relational database join operation. It's particularly useful for data processing, analysis, and transformation tasks that involve structured text files. Key features of join: 1. Database-like Joins: join performs operations similar to SQL joins on text files, enabling complex data manipulations without requiring a database system. It can perform the equivalent of inner joins, left outer joins, right outer joins, and full outer joins. 2. Field Selection: The command allows joining files on any field, not just the first one, providing flexibility when working with differently structured data files. 3. Custom Delimiters: join supports custom field separators through the -t option, making it compatible with various file formats like CSV (using commas) or TSV (using tabs). 4. Output Formatting: With the -o option, users can precisely control which fields appear in the output and in what order, allowing for data restructuring and selective output. 5. Case Sensitivity Control: The -i option enables case-insensitive matching, which is useful when dealing with inconsistent data formatting. 6. Empty Field Handling: The -e option allows specifying a replacement string for empty fields, improving the readability and processability of the output. 7. Unmatched Line Handling: Options like -a and -v control how lines without matching join fields are handled, enabling operations similar to outer joins in SQL. Common use cases for join include: - Combining data from multiple log files or reports based on common identifiers - Merging configuration files that share key fields - Data enrichment by adding information from one file to another - Finding records that exist in one file but not another (similar to SQL's EXCEPT operation) - Preparing data for further processing or analysis - Creating master datasets from multiple sources It's important to note that join requires input files to be sorted on the join fields for proper operation. This is typically done using the sort command before applying join. Modern versions of join include the --check-order option to verify this requirement is met. The join command is particularly valuable in shell scripts and data processing pipelines, where it can be combined with other text processing tools like sort, awk, sed, and cut to perform sophisticated data manipulations efficiently.

    Related Commands

    These commands are frequently used alongside join or serve similar purposes:

    sort
    awk
    paste
    cut
    comm
    uniq
    sed
    grep
    diff
    cmp
    Explore All Commands

    Use Cases

    Learn By Doing

    The best way to learn Linux commands is by practicing. Try out these examples in your terminal to build muscle memory and understand how the join command works in different scenarios.

    See ExamplesTry Lab Exercises
    $ join
    View All Commands