{"id":2250,"date":"2021-11-11T21:59:02","date_gmt":"2021-11-12T02:59:02","guid":{"rendered":"https:\/\/www.alpharithms.com\/?p=2250"},"modified":"2021-11-11T21:59:02","modified_gmt":"2021-11-12T02:59:02","slug":"tar-compress-extract-files-directories-in-linux","status":"publish","type":"post","link":"https:\/\/www.alpharithms.com\/tar-compress-extract-files-directories-in-linux-025921\/","title":{"rendered":"Using Tar to Compress & Extract Files and Directories in Linux"},"content":{"rendered":"

The tar utility provides a user-friendly means of compressing and extracting files from the terminal. This utility can help save disk space, make transferring data across networks more efficient, and help create a tidier file structure. Knowing the basics of the tar utility is a must-have skill for any developer.<\/p>\n

TL;DR<\/strong> – The tar command compresses and decompresses files. To compress files, the following syntax is used:<\/p>\n

# create an archive named 'output.tar.gz' containing 'file1.txt' and 'file2.txt'\r\n$ tar czvf output.tag.gz file1.txt file2.txt\r\n\r\n# extract content of 'output.tar.gz' to current working directory\r\n$ tar xvf output.tar.gz<\/pre>\n
These two examples are enough to deliver in most casual use-cases of needing the tar utility. However, there are many more features to this utility and several gotchas that any using it should be aware of. This article will dive into these issues and provide several more examples.<\/p>\n
Introduction<\/h2>\n
The tar<\/code> command is used in Linux systems for compression. This command is the common source of files ending in extensions like .tar.gz<\/code>, and .tar.bz<\/code> with the gz<\/code> and bz<\/code> indicating which compression algorithm was used. These resulting files are often referred to as\u00a0tarballs<\/em>. The linux.org documentation<\/a> for the tar<\/code> command describes it as follows:<\/p>\n
GNU `tar’ saves many files together into a single tape or disk archive and can restore individual files from the archive.<\/em><\/p>\n
Not many readers are likely to be compressing to “tapes” these days. Nonetheless, it’s interesting to know the utility traces its motivation back to the need to store data more efficiently when tape drives were heavily utilized. Now that we know the general purpose of the tar<\/code> utility let’s consider how to use it.<\/p>\n
Compressing Files Using Tar<\/h2>\n
\"tar
The -c flag indicates compression mode and can be used to compress entire directories, single, or multiple files<\/figcaption><\/figure>\n
The c<\/code> operation flag instructs the tar utility to use compression mode. This will compress file data into a single archive. This operation mode requires certain parameters to be passed along including the output filename and input files.<\/p>\n
Other options such as which compression algorithm and the verbosity level (what prints to console) are common as well. Let’s consider some examples using the following file structure:<\/p>\n
.\r\n\u2514\u2500\u2500 projectFolder\/\r\n    \u2514\u2500\u2500 files\/\r\n        \u251c\u2500\u2500 file1.txt\r\n        \u251c\u2500\u2500 file2.txt\r\n        \u2514\u2500\u2500 file3.txt<\/pre>\n
Now, with an instance of the terminal running and the current working directory set to projectFolder<\/code>, we issue the following command string:<\/p>\n
tar cvzf output.tar.gz files<\/code><\/p>\n
This is a tar directory<\/strong> command by which the entire files<\/code> directory (and all contained data) will be included in the resulting archive. When issuing this command we should see the console reflect the following output:<\/p>\n
$ tar cvzf output.tar.gz files\r\nfiles\/\r\nfiles\/file1.txt\r\nfiles\/file2.txt\r\nfiles\/file3.txt<\/pre>\n
This output is generated because we included the v<\/code> options flag indicating a verbosity level of 1, which simply outputs the name of all files included in the archive. Our project folder now reflects the following:<\/p>\n
.\r\n\u2514\u2500\u2500 projectFolder\/\r\n    \u251c\u2500\u2500 output.tar.gz  <----- New File\r\n    \u2514\u2500\u2500 files\/\r\n        \u251c\u2500\u2500 file1.txt\r\n        \u251c\u2500\u2500 file2.txt\r\n        \u2514\u2500\u2500 file3.txt<\/pre>\n
Note the appearance of a new file named output.tar.gz<\/code>. This file contains compressed versions of all files in the file directory. The f<\/code> flag indicates output.tar.gz as the endpoint for compressed data.<\/p>\n
Note<\/strong>: without the f<\/code> option specified tar will attempt to stream the compressed data to stdout<\/code>. In almost all cases this will result in unwanted behavior and an error.<\/p>\n
Extracting Files Using Tar<\/h2>\n
\"tar
The -x flag indicates the extraction operation mode and extracts contents to the current working directory by default.<\/figcaption><\/figure>\n
The tar utility provides an operation mode to extract files from archives as well. This operation mode is signified by the x<\/code> flag. Let’s consider a new project structure in which an output.tar.gz<\/code> file is already contained, run the tar utility in extraction mode, and consider the output. Here’s our starting file structure:<\/p>\n
.\r\n\u2514\u2500\u2500 projectFolder\/\r\n    \u2514\u2500\u2500 output.tar.gz<\/pre>\n
This is essentially going to be the reverse of our previous compression operation. From the projectFolder<\/code> directory, we input the following command:<\/p>\n
$ tar xvf output.tar.gz<\/code><\/p>\n
This command utilizes the x<\/code> operation flag, the v<\/code> verbosity flag, and the f<\/code> flag indicating the output filename. We should see the following output to the terminal window:<\/p>\n
$ tar xvf output.tar.gz\r\n\r\nfiles\/\r\nfiles\/file1.txt\r\nfiles\/file2.txt\r\nfiles\/file3.txt<\/pre>\n
This outputs each file within the archive that is being extracted. By default, the tar<\/code> utility will extract the files in an archive to the same directory unless the -C<\/code> option is specified followed by the desired output directory. Given our omission of such an option, our project folder now reflects the following structure:<\/p>\n
.\r\n\u2514\u2500\u2500 projectFolder\/\r\n    \u251c\u2500\u2500 output.tar.gz\r\n    \u2514\u2500\u2500 files\/\r\n        \u251c\u2500\u2500 file1.txt\r\n        \u251c\u2500\u2500 file2.txt\r\n        \u2514\u2500\u2500 file3.txt<\/pre>\n
Here we see the directory files<\/code> extracted along with file1.txt<\/code>, file2.txt<\/code>, and file3.txt<\/code>. This reflects the structure that was present in the archive we created in the previous step.<\/p>\n
Advanced Usage<\/h2>\n
The tar utility comes with a wide range of options to achieve<\/p>\n
    \n
  1. tar command<\/li>\n
  2. Operation mode<\/li>\n
  3. options<\/li>\n
  4. optional output filename<\/li>\n
  5. input file(s) or directory<\/li>\n<\/ol>\n
    These are the essential arguments to successfully run the tar utility. The tar command is always required but syntax differs afterward depending on the use case. For example, operation mode specifies whether one chooses to compress or decompress an archive. Let’s walk through some examples.<\/p>\n
    Compression Algorithms<\/h3>\n
    Tar supports both gzip<\/code> and bzip2<\/code> compression formats. These are indicated by the use of either the z<\/code> or j<\/code> flags respectively. Generally, these are better suited for different use cases:<\/p>\n