Class CsvParseStream<T>

CsvParseStream transforms a stream of CSV-encoded text into a stream of parsed objects.

A CsvParseStream expects input conforming to RFC 4180.

Example: Usage with default options

import { CsvParseStream } from "@std/csv/parse-stream";
import { assertEquals } from "@std/assert/equals";
import { assertType, IsExact } from "@std/testing/types"

const source = ReadableStream.from([
  "name,age\n",
  "Alice,34\n",
  "Bob,24\n",
]);
const stream = source.pipeThrough(new CsvParseStream());
const result = await Array.fromAsync(stream);

assertEquals(result, [
  ["name", "age"],
  ["Alice", "34"],
  ["Bob", "24"],
]);
assertType<IsExact<typeof result, string[][]>>(true);

Example: Skip first row with `skipFirstRow: true`

import { CsvParseStream } from "@std/csv/parse-stream";
import { assertEquals } from "@std/assert/equals";
import { assertType, IsExact } from "@std/testing/types"

const source = ReadableStream.from([
  "name,age\n",
  "Alice,34\n",
  "Bob,24\n",
]);
const stream = source.pipeThrough(new CsvParseStream({ skipFirstRow: true }));
const result = await Array.fromAsync(stream);

assertEquals(result, [
  { name: "Alice", age: "34" },
  { name: "Bob", age: "24" },
]);
assertType<IsExact<typeof result, Record<string, string>[]>>(true);

Example: Specify columns with `columns` option

import { CsvParseStream } from "@std/csv/parse-stream";
import { assertEquals } from "@std/assert/equals";
import { assertType, IsExact } from "@std/testing/types"

const source = ReadableStream.from([
  "Alice,34\n",
  "Bob,24\n",
]);
const stream = source.pipeThrough(new CsvParseStream({
  columns: ["name", "age"]
}));
const result = await Array.fromAsync(stream);

assertEquals(result, [
  { name: "Alice", age: "34" },
  { name: "Bob", age: "24" },
]);
assertType<IsExact<typeof result, Record<"name" | "age", string>[]>>(true);

Example: Specify columns with `columns` option and skip first row with

skipFirstRow: true

import { CsvParseStream } from "@std/csv/parse-stream";
import { assertEquals } from "@std/assert/equals";
import { assertType, IsExact } from "@std/testing/types"

const source = ReadableStream.from([
  "Alice,34\n",
  "Bob,24\n",
]);
const stream = source.pipeThrough(new CsvParseStream({
  columns: ["name", "age"],
  skipFirstRow: true,
}));
const result = await Array.fromAsync(stream);

assertEquals(result, [{ name: "Bob", age: "24" }]);
assertType<IsExact<typeof result, Record<"name" | "age", string>[]>>(true);

Example: TSV (tab-separated values) with `separator: "\t"`

import { CsvParseStream } from "@std/csv/parse-stream";
import { assertEquals } from "@std/assert/equals";

const source = ReadableStream.from([
  "Alice\t34\n",
  "Bob\t24\n",
]);
const stream = source.pipeThrough(new CsvParseStream({
  separator: "\t",
}));
const result = await Array.fromAsync(stream);

assertEquals(result, [
  ["Alice", "34"],
  ["Bob", "24"],
]);

Example: Trim leading space with `trimLeadingSpace: true`

import { CsvParseStream } from "@std/csv/parse-stream";
import { assertEquals } from "@std/assert/equals";

const source = ReadableStream.from([
  "      Alice,34\n          ",
  "Bob,     24\n",
]);
const stream = source.pipeThrough(new CsvParseStream({
  trimLeadingSpace: true,
}));
const result = await Array.fromAsync(stream);

assertEquals(result, [
  ["Alice", "34"],
  ["Bob", "24"],
]);

Example: Quoted fields

import { CsvParseStream } from "@std/csv/parse-stream";
import { assertEquals } from "@std/assert/equals";

const source = ReadableStream.from([
  `"a ""word""","com`,
  `ma,","newline`,
  `\n"\nfoo,bar,b`,
  `az\n`,
]);
const stream = source.pipeThrough(new CsvParseStream());
const result = await Array.fromAsync(stream);

assertEquals(result, [
  ['a "word"', "comma,", "newline\n"],
  ["foo", "bar", "baz"]
]);

Example: Allow lazy quotes with `lazyQuotes: true`

import { CsvParseStream } from "@std/csv/parse-stream";
import { assertEquals } from "@std/assert/equals";

const source = ReadableStream.from([
  `a "word","1"`,
  `2",a","b`,
]);
const stream = source.pipeThrough(new CsvParseStream({
  lazyQuotes: true,
}));
const result = await Array.fromAsync(stream);

assertEquals(result, [['a "word"', '1"2', 'a"', 'b']]);

Example: Define comment prefix with `comment` option

import { CsvParseStream } from "@std/csv/parse-stream";
import { assertEquals } from "@std/assert/equals";

const source = ReadableStream.from([
  "Alice,34\n",
  "# THIS IS A COMMENT\n",
  "Bob,24\n",
]);
const stream = source.pipeThrough(new CsvParseStream({
  comment: "#",
}));
const result = await Array.fromAsync(stream);

assertEquals(result, [
  ["Alice", "34"],
  ["Bob", "24"],
]);

Example: Infer the number of fields from the first row with

fieldsPerRecord: 0

import { CsvParseStream } from "@std/csv/parse-stream";
import { assertEquals } from "@std/assert/equals";
import { assertRejects } from "@std/assert/rejects";

const source = ReadableStream.from([
  "Alice,34\n",
  "Bob,24,CA\n", // Note that this row has more fields than the first row
]);
const stream = source.pipeThrough(new CsvParseStream({
  fieldsPerRecord: 0,
}));
const reader = stream.getReader();
assertEquals(await reader.read(), { done: false, value: ["Alice", "34"] });
await assertRejects(
  () => reader.read(),
  SyntaxError,
  "Syntax error on line 2: expected 2 fields but got 3",
);

Example: Enforce the number of field for each row with `fieldsPerRecord: 2`

import { CsvParseStream } from "@std/csv/parse-stream";
import { assertEquals } from "@std/assert/equals";
import { assertRejects } from "@std/assert/rejects";

const source = ReadableStream.from([
  "Alice,34\n",
  "Bob,24,CA\n",
]);
const stream = source.pipeThrough(new CsvParseStream({
  fieldsPerRecord: 2,
}));
const reader = stream.getReader();
assertEquals(await reader.read(), { done: false, value: ["Alice", "34"] });
await assertRejects(
  () => reader.read(),
  SyntaxError,
  "Syntax error on line 2: expected 2 fields but got 3",
);

Type Parameters

const T extends CsvParseStreamOptions | undefined = undefined
The type of options for the stream.

Implements

TransformStream<string, RowType<T>>

Index

Constructors

constructor

Accessors

readable writable

Constructors

constructor

new CsvParseStream<const T>(options?): CsvParseStream<T>
Construct a new instance.
Type Parameters
- const T extends undefined | CsvParseStreamOptions = undefined
Parameters
- Optionaloptions: T
  Options for the stream.
Returns CsvParseStream<T>
- Defined in csv/parse_stream.ts:370

Accessors

readable

get readable(): ReadableStream<RowType<T>>

The instance's ReadableStream.

Returns ReadableStream<RowType<T>>

The instance's ReadableStream.

Example: Usage

import { CsvParseStream } from "@std/csv/parse-stream";
import { assertEquals } from "@std/assert/equals";

const source = ReadableStream.from([
  "name,age\n",
  "Alice,34\n",
  "Bob,24\n",
]);
const parseStream = new CsvParseStream({ skipFirstRow: true });
const parts = source.pipeTo(parseStream.writable);
assertEquals(await Array.fromAsync(parseStream.readable), [
  { name: "Alice", age: "34" },
  { name: "Bob", age: "24" },
]);

writable

get writable(): WritableStream<string>

The instance's WritableStream.

Returns WritableStream<string>

The instance's WritableStream.

Example: Usage

import { CsvParseStream } from "@std/csv/parse-stream";
import { assertEquals } from "@std/assert/equals";

const source = ReadableStream.from([
  "name,age\n",
  "Alice,34\n",
  "Bob,24\n",
]);
const parseStream = new CsvParseStream({ skipFirstRow: true });
const parts = source.pipeTo(parseStream.writable);
assertEquals(await Array.fromAsync(parseStream.readable), [
  { name: "Alice", age: "34" },
  { name: "Bob", age: "24" },
]);

Class CsvParseStream<T>

Example: Usage with default options

Example: Skip first row with `skipFirstRow: true`

Example: Specify columns with `columns` option

Example: Specify columns with `columns` option and skip first row with

Example: TSV (tab-separated values) with `separator: "\t"`

Example: Trim leading space with `trimLeadingSpace: true`

Example: Quoted fields

Example: Allow lazy quotes with `lazyQuotes: true`

Example: Define comment prefix with `comment` option

Example: Infer the number of fields from the first row with

Example: Enforce the number of field for each row with `fieldsPerRecord: 2`

Type Parameters

Implements

Index

Constructors

Accessors

Constructors

constructor

Type Parameters

Parameters

Returns CsvParseStream<T>

Accessors

readable

Returns ReadableStream<RowType<T>>

Example: Usage

writable

Returns WritableStream<string>

Example: Usage

Settings

On This Page