Hubbry Logo
Tab-separated valuesTab-separated valuesMain
Open search
Tab-separated values
Community hub
Tab-separated values
logo
8 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
Tab-separated values
Tab-separated values
Tab-separated values
View on Wikipedia
from Wikipedia
Tab-separated values
Filename extension.tsv, .tab[1]
Internet media type
text/tab-separated-values
Uniform Type Identifier (UTI)public.tab-separated-values-text[2]
UTI conformationpublic.delimited-values-text[2]
Developed byUniversity of Minnesota Internet Gopher Team
Internet Assigned Numbers Authority
Initial releasec. June 1993; 32 years ago (1993-06)
Type of formatDelimiter-separated values format
Container fordatabase information organized as field separated lists
StandardIANA MIME type

Tab-separated values (TSV) is a text data format for storing tabular data where records are separated by newline and values within a record are separated by tabs.[3] The TSV format is a delimiter-separated values (DSV) and is similar to comma-separated values (CSV).

TSV is a relatively simple format and is widely supported. It is often used in data exchange to move tabular data between different computer programs that support the format. For example, a TSV file might be used to transfer information from a database to a spreadsheet.

Example

[edit]

The head of the Iris flower data set can be stored as a TSV using the following plain text (note that the HTML rendering may convert tabs to spaces): 

Sepal length	Sepal width	Petal length	Petal width	Species
5.1	3.5	1.4	0.2	I. setosa
4.9	3.0	1.4	0.2	I. setosa
4.7	3.2	1.3	0.2	I. setosa
4.6	3.1	1.5	0.2	I. setosa
5.0	3.6	1.4	0.2	I. setosa

The TSV plain text above corresponds to the following tabular data:

Sepal length Sepal width Petal length Petal width Species
5.1 3.5 1.4 0.2 I. setosa
4.9 3.0 1.4 0.2 I. setosa
4.7 3.2 1.3 0.2 I. setosa
4.6 3.1 1.5 0.2 I. setosa
5.0 3.6 1.4 0.2 I. setosa

Character escaping

[edit]

The IANA media type standard for TSV achieves simplicity by simply disallowing tabs within fields.[4]

Since the values in the TSV format cannot contain literal tabs or newline characters, a convention is necessary for lossless conversion of text values with these characters. A common convention is to perform the following escapes:[5][6]

escape sequence meaning
\n line feed
\t tab
\r carriage return
\\ backslash

Another common convention is to use the CSV convention from RFC 4180 and enclose values containing tabs or newlines in double quotes. This can lead to ambiguities.[7][8]

Line endings

[edit]

Records are typically separated by a line feed, as is typical for Unix platforms, or a carriage return and line feed, as is typical for Microsoft platforms. Some programs may expect the latter. The de-facto specification[9] specifies that records are separated by an EOL, but does not specify any specific newline.

See also

[edit]

References

[edit]

Further reading

[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

Tab-separated values

View on Grokipedia
from Grokipedia
Tab-separated values (TSV) is a for representing tabular data, where each line corresponds to a single record and the fields within each record are delimited by horizontal tab characters (U+0009). This structure enables straightforward storage and interchange of data such as text, numerical values, or scientific datasets between applications. The format is registered with the (IANA) as the text/tab-separated-values, originally submitted by the Internet Gopher Team. In a standard TSV file, the initial line typically lists the column headers, with subsequent lines providing the data records; each record must contain the same number of fields to maintain tabular integrity. Fields must not include tab characters or line breaks to prevent delimiter conflicts. Common file extensions include .tsv and .tab, and the format supports character sets specified via parameters for . TSV is favored in fields like bioinformatics, data analysis, and database management for its high human readability, rapid parsing, and compatibility with Unix utilities such as awk and sort. Unlike comma-separated values (CSV), TSV reduces parsing errors when data naturally contains commas or quotes, as tabs rarely appear in textual content, simplifying processing without extensive escaping. It is commonly used in platforms like NCBI Datasets for metadata export and in neuroimaging standards such as BIDS for organizing experimental data. Despite lacking a formal specification beyond its IANA registration, TSV's transparency and lack of proprietary restrictions ensure long-term sustainability.

Introduction

Definition and Purpose

Tab-separated values (TSV) is a format designed for representing tabular data, where each record occupies a single line and its constituent fields are delimited by horizontal tab characters (U+0009). This structure allows for the storage of text, numeric, or other simple data types in a delimited manner, with records separated by line breaks. The core purpose of TSV is to serve as a lightweight data interchange mechanism between diverse applications, including databases, spreadsheets, and word processors equipped with mail-merge capabilities. It functions as a for exchanging structured tabular information without dependence on proprietary or formats, promoting in environments handling spreadsheet-like or relational data. TSV's simplicity makes it ideal for non-complex datasets, enabling straightforward export and import operations across software tools while maintaining human readability and ease of parsing by machines. By avoiding embedded delimiters within fields, it supports reliable data transfer in scenarios where comma-separated alternatives might introduce conflicts.

History

Tab-separated values (TSV) emerged in the late 1970s and early 1980s alongside the development of early database and spreadsheet tools, particularly within UNIX systems for text processing. The cut command, a core UNIX utility from the system's early implementations, defaults to the tab character as its field delimiter, enabling the extraction of columns from tab-separated tabular data. Similarly, the paste command, introduced in early UNIX versions, merges lines using tabs as the default separator to form aligned columns, supporting basic data manipulation in plain text formats. Adoption expanded in the and with the proliferation of personal computing and spreadsheet software. , launched on September 30, 1985, for the Macintosh, included support for exporting worksheets as tab-delimited text files, allowing seamless data transfer to other applications and systems. This feature became a standard in subsequent versions, contributing to TSV's role as a reliable interchange format in professional and academic environments. In June 1993, the Internet Assigned Numbers Authority registered the MIME media type "text/tab-separated-values", submitted by the University of Minnesota Internet Gopher Team in connection with the Gopher protocol for distributed document search and retrieval. TSV has never received a dedicated formal standard, relying instead on de facto conventions influenced by related specifications like RFC 4180, published in October 2005, which outlines practices for delimited text files—such as record termination with CRLF and optional quoting—that apply analogously to TSV despite its focus on comma-separated values. In the 2000s, TSV evolved further in web and contexts, where its simplicity suited large-scale processing. , an open-source framework first released in April 2006, commonly employs TSV-like tab-delimited text files as input formats for distributed data storage and analysis, leveraging HDFS for handling massive datasets.

File Format

Basic Structure

A tab-separated values (TSV) file organizes tabular data as a sequence of records, where each record corresponds to a row in the table and consists of one or more fields representing columns. Each record is delimited by a line ending, forming a simple two-dimensional structure suitable for data interchange. TSV files often include an optional header row at the beginning, which defines the names of the fields in subsequent data rows, providing semantic context without requiring a formal schema. All records, including the header if present, must contain the same number of fields to maintain structural consistency. For example, a basic TSV file with a header and two rows might appear as follows, where tabs separate the fields:

Name Age [Address](/page/Address) Paul 23 1115 W Franklin Bessy the Cow 5 Big Farm Way

Name Age [Address](/page/Address) Paul 23 1115 W Franklin Bessy the Cow 5 Big Farm Way

This illustrates the row-column layout, with the first row naming the columns "Name," "Age," and "," followed by entries. The format's minimalism lies in its reliance solely on , without mandatory quotes around fields, embedded metadata, or predefined schemas, making it lightweight for applications like spreadsheets and databases.

Delimiters and Fields

In tab-separated values (TSV), the horizontal tab character (HT, ASCII 9) functions as the exclusive separating fields within each record, with no other characters permitted to serve this role. This design ensures straightforward parsing, as tools can reliably split content using the tab without ambiguity from alternative separators. Fields in TSV are defined as the sequences of characters occurring between consecutive tab delimiters, encompassing any printable characters except unescaped tabs to maintain structural . For instance, a field might contain text, numbers, or symbols like commas and quotes without issue, as long as tabs are not present unescaped. Parsing a TSV record involves dividing a line by tab characters to extract fields, where consecutive tabs explicitly denote empty fields—for example, the string field1\t\tfield3 produces three fields with the middle one null. This convention allows representation of missing data without additional markers. TSV inherently assumes single-line records, distinguishing it from formats that support embedded newlines in fields unless otherwise specified.

Records and Line Endings

In tab-separated values (TSV) files, each record corresponds to a single row of tabular data and is structured as a line of text terminated by a line ending, which delineates the boundary between consecutive rows. This design enables sequential processing of the file, where fields within a record are horizontally separated by tab characters, as detailed in the format's basic structure. TSV files support multiple line ending conventions to facilitate cross-platform interchange: LF (\n, ASCII 0x0A) commonly used in Unix and environments, CR+LF (\r\n, ASCII 0x0D followed by 0x0A) standard for Windows systems, and CR (\r, ASCII 0x0D) from legacy Macintosh systems. Robust parsers, such as Python's csv module configured with a tab delimiter, automatically recognize and normalize these variants—treating any of them as a record terminator—ensuring compatibility without manual conversion. Line endings play a critical role in by signaling the end of one record and the start of the next, allowing tools to iterate through rows reliably. This separation assumes no unescaped newlines within fields, preserving the one-record-per-line principle and preventing unintended row splits. For instance, a TSV file with mixed line endings, such as LF for the first record and CR+LF for the second, would still be correctly interpreted by compatible software, which normalizes all terminators to a consistent internal representation during reading. The following example demonstrates a two-record TSV (with LF endings shown for clarity):

Header1 Header2 Header3 Value1a Value1b Value1c Value2a Value2b Value2c

Header1 Header2 Header3 Value1a Value1b Value1c Value2a Value2b Value2c

In practice, if generated on a Windows system, the file might employ CR+LF after each line, but parsers like those in Python or LibreOffice Calc handle this transparently, outputting normalized rows without altering the data.

Data Handling

Character Escaping

Unlike comma-separated values (CSV), which have a formalized specification in RFC 4180, tab-separated values (TSV) lack a universal standard for character escaping, leading to varied implementations across tools and systems. The Internet Assigned Numbers Authority (IANA) registration for the text/tab-separated-values MIME type explicitly disallows tabs and newlines (line feed or carriage return) within field values, treating them as structural delimiters that must not appear in data to ensure simple parsing via tab splitting per line. In practice, when tabs or newlines must be included in field data—such as in exported database content or log files—common approaches borrow from CSV conventions or use explicit escape sequences. Many systems, including Python's csv module with the 'excel-tab' , enclose fields containing tabs or newlines in double quotes (the default quote character) to prevent unintended splitting, though TSV implementations often minimize quoting to maintain simplicity compared to CSV. Alternatively, the (W3C) specification for query results in TSV format employs backslash escapes within single-quoted literals, representing tabs as \t and newlines as \n. Failing to escape these delimiters can cause severe parsing errors; an unescaped tab within a field will be interpreted as a new field boundary, resulting in misaligned columns and across subsequent records. For instance, consider a TSV file intended to represent names and addresses:

Alice 123 Main St Bob 456 Oak Ave with a tab here Charlie 789 Pine Rd

Alice 123 Main St Bob 456 Oak Ave with a tab here Charlie 789 Pine Rd

Without escaping, the second record parses as three fields ("Bob", "456 Oak Ave with a ", "here") instead of two, shifting "Charlie" into the wrong column. To resolve this using quoting (as in Python's csv module):

Alice 123 Main St "Bob" "456 Oak Ave with a tab here" Charlie 789 Pine Rd

Alice 123 Main St "Bob" "456 Oak Ave with a tab here" Charlie 789 Pine Rd

Here, the quoted field preserves the internal tab, parsing correctly as two fields per record. Using backslash escapes (as in W3C TSV):

Alice 123 Main St Bob '456 Oak Ave with a \t tab here' Charlie 789 Pine Rd

Alice 123 Main St Bob '456 Oak Ave with a \t tab here' Charlie 789 Pine Rd

The \t within the single-quoted literal represents the literal tab, avoiding structural interpretation. These methods ensure but require consistent parser support, as not all TSV readers handle escapes uniformly. Broader issues with other special characters, such as quotes, are addressed separately.

Handling Special Characters

In tab-separated values (TSV) files, double quotes within fields are treated as literal characters rather than delimiters for quoting, as there is no standardized quoting mechanism like that in (CSV) formats. This approach simplifies parsing when fields do not contain tabs, allowing quotes to appear unchanged unless an application enforces custom rules, such as those in the Python csv module's excel-tab dialect, where quoting can be optionally enabled for fields containing line breaks or the quote character itself. Leading and trailing spaces in TSV fields are preserved by default, without automatic trimming, to ensure the exact data as entered is maintained across records. This preservation supports applications where whitespace is meaningful, such as in textual descriptions or aligned data imports, though it may necessitate manual adjustment in tools like spreadsheets for visual alignment. Control characters from the ASCII range 0-31 (excluding at ASCII 9) are typically disallowed or restricted in TSV fields to prevent disruptions, file corruption, or unintended line breaks during . Applications often implement filtering at the input level to remove or these characters, ensuring compatibility, as seen in common libraries where such controls trigger errors or require explicit handling beyond basic separation. For example, a TSV record might contain a field like John "Doe" Smith (with embedded quotes and trailing spaces), separated by a tab from another field such as Description with "quotes" and spaces. This parses directly into two fields—John "Doe" Smith and Description with "quotes" and spaces—without alteration, quoting, or trimming, demonstrating how non-delimiter special characters remain integral to the data.

Encoding Considerations

Tab-separated values (TSV) files in modern usage default to encoding, which supports a wide range of characters including , ensuring broad portability across systems. Legacy TSV files, however, often employ ASCII for basic English text or ISO-8859-1 for Western European languages, reflecting older system constraints. The (BOM) is optional in UTF-8 TSV files but can lead to parsing issues, such as Excel interpreting it as an extra or field, potentially shifting data columns. Encodings with multi-byte characters, such as UTF-16, introduce challenges for TSV parsing because tabs (U+0009) must align precisely with character boundaries to prevent field misalignment; otherwise, surrogate pairs or variable-length sequences may be split, resulting in garbled or incomplete fields. UTF-16 requires explicit decoder awareness, unlike UTF-8's compatibility with byte-oriented tools, making it less ideal for TSV despite support in some applications like pandas with specified encoding parameters. Best practices for TSV encoding emphasize explicit declaration to enhance : use HTTP headers like text/tab-separated-values; charset=[UTF-8](/page/UTF-8) for web-transmitted files, or embed metadata in file headers where supported. The IANA requires a character set parameter, reinforcing as the standard to avoid assumptions. For instance, parsing a encoded TSV file as ASCII can garble non-Latin characters, such as accented letters in ISO-8859-1 fields appearing as (e.g., "café" rendered as "café").

Comparison with Other Formats

Versus Comma-Separated Values (CSV)

Tab-separated values (TSV) and comma-separated values (CSV) are both delimited text formats for storing tabular data, but they differ primarily in their choice of , which impacts handling of special characters and approaches. TSV employs the tab character (ASCII 0x09) as the field separator, which is invisible in most text editors and aligns well with fixed-width displays, whereas CSV uses the visible (ASCII 0x2C). This tab in TSV reduces conflicts when data fields naturally contain commas, such as addresses or names (e.g., "New York, NY"), avoiding the need for additional processing that CSV requires. Unlike CSV, which follows a standardized quoting mechanism outlined in RFC 4180 to enclose fields containing delimiters, quotes, or line breaks (e.g., fields wrapped in double quotes with escaped internal quotes), TSV lacks a formal quoting standard. In TSV, tabs and newlines are typically disallowed within fields or escaped using sequences like \t and \n, resulting in simpler syntax but reduced robustness for datasets with embedded tabs. This absence of quoting makes TSV files more compact and faster to parse in basic scenarios, as splitting on tabs via regular expressions or string methods is straightforward without quote-handling logic. TSV is often favored in scenarios involving clipboard operations or Unix pipelines due to the tab's convenience on keyboards and compatibility with tools like the cut command, which defaults to tab delimiting for field extraction (e.g., cut -f1 input.tsv pipes columns efficiently). In contrast, CSV's delimiter suits broader interchange needs, such as web forms or attachments, where visibility aids manual inspection, though it demands more careful to handle quoted commas. However, TSV's reliance on absent tabs in data can lead to errors if tabs appear unescaped, underscoring the trade-off between simplicity and versatility.

Versus Fixed-Width Formats

Tab-separated values (TSV) files employ tabs as delimiters to separate fields of variable lengths, allowing data entries to occupy only the space they require without additional padding. In contrast, fixed-width formats rely on predefined positional offsets for each field, where shorter values are padded with spaces, zeros, or other characters to maintain consistent column widths across all records. This delimitation approach in TSV promotes efficiency in storage for datasets with varying field sizes, whereas fixed-width formats ensure uniform record lengths, which can simplify direct memory mapping in certain processing environments. Unlike fixed-width formats, which necessitate a separate or layout definition specifying exact column widths for accurate , TSV files have no inherent width requirements, enabling flexible handling of without prior structural knowledge. This schema independence in TSV facilitates easier adaptation to changing data patterns, as fields can expand or contract naturally within the tab boundaries. Fixed-width formats, however, demand precise alignment definitions to avoid misinterpretation of field boundaries, making them more rigid but potentially faster for bulk processing where the layout remains constant. TSV offers superior portability and human-readability, as its clear tab separations allow direct and in standard text editors without specialized tools, enhancing across diverse systems. Fixed-width files, while less intuitive for manual review due to their reliance on positional cues, excel in legacy mainframe environments like AS/400 systems, where fixed structures support aligned printing and efficient in resource-constrained hardware. This makes fixed-width preferable for applications requiring columnar alignment in reports or compatibility with older infrastructure. Converting TSV to fixed-width formats presents challenges, particularly in mapping variable-length fields to rigid widths, which can lead to of oversized data or excessive padding for shorter entries, potentially compromising . Such transformations require determining maximum field lengths from the source TSV data to define the fixed , and any overflow during conversion may result in rejected records or errors unless handled explicitly. This rigidity contrasts with TSV's inherent flexibility, often necessitating additional validation steps to prevent loss of .

Applications and Usage

Common Uses

Tab-separated values (TSV) are widely used for exporting data from applications, such as , where users can save worksheets as tab-delimited text files via the "Save As" dialog, selecting the "Text (Tab delimited) (*.txt)" format to facilitate plain-text without formatting. This approach ensures compatibility across systems, allowing the exported data to be imported into other tools for further . In bioinformatics, TSV is commonly used for metadata export in platforms like NCBI Datasets, where tools such as the dataformat CLI convert JSONL reports on assemblies or into TSV tables for easy analysis and sharing. It is also integral to standards like the Brain Imaging Data Structure (BIDS) in , where TSV files organize experimental metadata, such as participant information and event timings, in files like participants.tsv and events.tsv. In database management, TSV serves as a standard format for dumping query results, particularly in systems like , where the SELECT ... INTO OUTFILE statement exports rows to a file with fields terminated by tabs by default, enabling efficient data backups or transfers to external applications. This method is commonly employed in SQL-based environments to generate files for archival or integration purposes. TSV is prevalent in Unix and environments for data interchange in logs and simple datasets, leveraging the format's compatibility with command-line tools like cut and awk for processing tabular information without needing specialized software. For web-based data exchange, certain APIs, such as those provided by , return query results in TSV format to deliver statistical data in a lightweight, parseable structure suitable for automated ingestion. Clipboard operations between applications often utilize TSV implicitly, as copied tabular data from tools like spreadsheets or databases is typically tab-delimited, allowing seamless pasting into destinations like Excel or text editors while preserving column structure. In pipelines, TSV files are ingested into frameworks like for extract-transform-load (ETL) processes, where the spark.read.csv function with sep="\t" loads the data into DataFrames for distributed processing and analysis.

Software Support

Spreadsheet applications provide robust support for importing and exporting TSV files. Microsoft Excel allows users to import TSV files through the Text Import Wizard, where the file is opened via Data > From Text/CSV and the delimiter is set to Tab, enabling automatic column separation. For exporting, Excel supports saving worksheets as tab-delimited text files using the Save As command with the "Text (Tab delimited) (*.txt)" format. Google Sheets facilitates TSV import by selecting File > Import, uploading the file, and choosing Tab as the separator in the import settings, which parses the data into rows and columns. Exporting from Google Sheets to TSV is achieved via File > Download > Tab-separated values (.tsv, current sheet), producing a file with tab delimiters. LibreOffice Calc handles TSV import by opening the file directly or via File > Open, detecting tabs as delimiters in the Text Import dialog, and supports export as Text CSV (.csv) with Tab selected as the field separator. Programming languages offer libraries for reading and writing TSV files with minimal configuration. In Python, the built-in csv module supports TSV through custom dialects; for example, registering a 'tsv' dialect with delimiter='\t' allows seamless reading via csv.reader or writing via csv.writer. R's base utils package includes read.table(), which reads TSV files by default using whitespace (including tabs) as the separator, or explicitly with sep="\t" for strict tab delimiting. For Java, the OpenCSV library adapts CSV parsing for TSV by setting the CSVReader constructor's delimiter parameter to '\t', enabling efficient handling of tab-separated data streams. Command-line tools in Unix-like systems excel at manipulating TSV files for tasks like extraction and transformation. The cut command extracts specific fields from TSV using -d ′\t′tospecifytabasdelimiterand−ftoselectcolumns,suchascut−d'\t' to specify tab as delimiter and -f to select columns, such as cut -d '\t' -f 1,3 file.tsv. Awk processes TSV with -F '\t' to set the field separator, allowing complex operations like printing modified fields: awk -F '\t' 'BEGIN {OFS="\t"} {$2="new"; print}' file.tsv. Sed performs substitutions on TSV lines, such as replacing values in columns via s/ pattern / replacement /g, often combined with other tools for batch editing. Viewers like the tsv-utils suite provide formatted display of large TSV files, with commands such as tsv-preview rendering tables with aligned columns and headers. Database systems integrate TSV import natively for efficient bulk loading. MySQL's LOAD DATA INFILE statement defaults to tab-separated input, but can be specified with FIELDS TERMINATED BY '\t' to load TSV files directly into tables, as in LOAD DATA INFILE 'file.tsv' INTO TABLE mytable FIELDS TERMINATED BY '\t';. PostgreSQL's COPY command supports TSV via the text format, which uses tabs as delimiters by default, or explicitly with DELIMITER E'\t', for example: COPY mytable FROM 'file.tsv' WITH (FORMAT text, DELIMITER E'\t');.

Advantages and Limitations

Benefits

Tab-separated values (TSV) provide simplicity through their use of a single tab character as the , avoiding the need for quoting or escaping mechanisms required when contains common characters like commas. This format allows for straightforward manual inspection and editing in any basic , without the complexity of rules. The lack of quotes and escapes enhances , presenting in a clean, uncluttered manner that facilitates quick human review, particularly for datasets without embedded tabs. Unlike (CSV), TSV reduces ambiguities by relying solely on the tab , streamlining handling. TSV excels in processing efficiency, as tab-based splitting is a low-overhead operation that enables rapid of large files using simple functions, making it suitable for memory-constrained environments. Tools like and cut process TSV swiftly by designating the tab as the field separator, optimizing operations such as filtering and aggregation without extensive computational resources. is a key strength of TSV, stemming from its universal foundation, which circumvents binary compatibility issues like byte-order differences across platforms. As a widely supported format in text-based software and statistical tools, TSV enables seamless data transfer and integration between diverse systems without proprietary dependencies. When displayed in monospaced fonts, such as those used in console or terminal interfaces, TSV's tabs promote column alignment, creating a fixed-width visual layout that improves legibility without requiring additional reformatting tools.

Drawbacks

One significant drawback of the Tab-separated values (TSV) format is its vulnerability to embedded tabs within fields, which can act as unintended delimiters and cause misalignment during . For instance, textual data such as addresses or descriptions containing accidental tab characters will split fields incorrectly unless properly escaped or quoted, leading to or errors. The TSV format suffers from a lack of formal standardization, resulting in varying parser behaviors across tools and applications, which hampers interoperability. Unlike more rigorously defined formats, there is no universally adopted specification for handling quoting, escaping, or encoding special characters, leading to inconsistencies where one tool might interpret a file correctly while another fails. TSV provides poor native support for complex data structures, such as multi-line fields or hierarchical elements, making it unsuitable for datasets requiring nesting or advanced . This limitation contrasts with formats like or XML, which natively accommodate such features without additional workarounds, often necessitating data flattening or preprocessing for TSV compatibility. Additionally, TSV files exhibit display inconsistencies in environments using proportional fonts or web browsers, where tab characters may not align uniformly, distorting the tabular layout. This issue arises because tabs are interpreted variably—often as fixed-width spaces in monospaced fonts but unpredictably in proportional ones—potentially requiring fixed-width fonts for reliable viewing.

References

  1. https://www.iana.org/assignments/media-types/text/tab-separated-values
  2. https://www.loc.gov/preservation/digital/formats/fdd/fdd000533.shtml
  3. https://www.ncbi.nlm.nih.gov/datasets/docs/v2/reference-docs/file-formats/metadata-files/about-json-and-tabular/
  4. https://hopeness.medium.com/master-the-linux-cut-command-a-comprehensive-guide-2a9c2117a53d
  5. https://linuxhandbook.com/paste-command/
  6. https://www.neowin.net/news/a-quick-look-back-at-the-launch-of-the-first-version-of-microsoft-excel-38-years-ago-today/
  7. https://support.microsoft.com/en-us/office/import-or-export-text-txt-or-csv-files-5250ac4c-663c-47ce-937b-339e391393ba
  8. https://www.ietf.org/rfc/rfc4180.txt
  9. https://blog.matthewrathbone.com/2016/09/01/a-beginners-guide-to-hadoop-storage-formats.html
  10. https://docs.cloudera.com/cdw-runtime/cloud/impala-reference/topics/impala-file-formats.html
  11. http://ebay.github.io/tsv-utils/docs/comparing-tsv-and-csv.html
  12. https://bids.neuroimaging.io/getting_started/folders_and_files/metadata/tsv.html
  13. https://docs.python.org/3/library/csv.html
  14. https://www.w3.org/TR/sparql12-results-csv-tsv/
  15. https://support.microsoft.com/en-us/office/opening-csv-utf-8-files-correctly-in-excel-8a935af5-3416-4edd-ba7e-3dfd2bc4a032
  16. https://stackoverflow.com/questions/27896214/reading-tab-delimited-file-with-pandas-works-on-windows-but-not-on-mac
  17. https://support.microsoft.com/en-us/office/file-formats-that-are-supported-in-excel-0943ff2c-6014-4e8d-aaea-b83d51d46247
  18. https://www.loc.gov/preservation/digital/formats/fdd/fdd000323.shtml
  19. https://www.ibm.com/docs/en/cognos-planning/10.2.1?topic=maps-delimited-fixed-width-ascii-files
  20. https://support.adeptia.com/hc/en-us/articles/207876173-What-is-fixed-width-data-and-how-to-map-it
  21. https://docs.informatica.com/data-integration/powercenter/10-5/designer-guide/mappings/working-with-relational-targets-in-a-mapping/rejecting-truncated-and-overflow-data.html
  22. https://support.microsoft.com/en-us/office/save-a-workbook-to-text-format-txt-or-csv-3e9a9d6c-70da-4255-aa28-fcacf1f081e6
  23. https://www.ncbi.nlm.nih.gov/datasets/docs/v2/reference-docs/command-line/dataformat/tsv/dataformat_tsv_genome/
  24. https://dev.mysql.com/doc/refman/8.0/en/select-into.html
  25. https://genomicsaotearoa.github.io/shell-for-bioinformatics/6_inspectmanipulate3/
  26. https://ec.europa.eu/eurostat/web/user-guides/data-browser/api-data-access/api-faq/tsv-format
  27. https://www.johndcook.com/blog/r_excel_clipboard/
  28. https://spark.apache.org/docs/latest/sql-data-sources-load-save-functions.html
  29. https://opencsv.sourceforge.net/
  30. http://ebay.github.io/tsv-utils/
  31. https://www.postgresql.org/docs/current/sql-copy.html
  32. https://opensource.ebay.com/tsv-utils/docs/comparing-tsv-and-csv.html
  33. https://www.plan.org.au/wp-content/uploads/2024/05/Interoperability_and_Data_Sharing_Report_2024.pdf
  34. https://github.com/kkayal/tsv
  35. https://stackoverflow.com/questions/51553619/what-is-an-unescaped-tsv-what-are-the-advantages-of-using-it
  36. https://stackoverflow.com/questions/39298896/is-there-any-technical-difference-between-csv-a-tsv-or-a-txt-file
  37. https://www.w3.org/TR/tabular-data-model/
  38. https://www.ncbi.nlm.nih.gov/datasets/docs/v2/reference-docs/file-formats/metadata-files/why-jsonl/
  39. https://github.com/clue/reactphp-tsv
  40. https://medium.com/analytics-and-data/files-formats-for-data-engineers-part-1-standards-data-formats-98b48dc0bdfc
  41. https://github.com/microsoft/vscode/issues/108755
  42. https://forum.sublimetext.com/t/tab-size-with-proportional-fonts/8266
  43. https://www.imf.org/external/help/tsv.htm
Add your contribution
Related Hubs
User Avatar
No comments yet.