TypeScript Linked List

1.0.15 · active · verified Sun Apr 19

The `linked-list-typescript` package provides a straightforward, type-safe implementation of a doubly linked list in TypeScript. Currently stable at version 1.0.15, it emphasizes simplicity and strong typing through TypeScript generics. The library supports the JavaScript `Iterator` and `Iterable` protocols, enabling native iteration via `for...of` loops, spread syntax (`...`), and array destructuring. Key operations like retrieving head/tail elements, and removing head/tail are available. Unlike some data structures, it stores references to values rather than copies, which is important for understanding its behavior with mutable objects. The project appears to be in an active maintenance phase, with a focus on a stable 1.x release line.

Common errors

```
Argument of type 'string | number' is not assignable to parameter of type 'string'.
```
cause Attempting to initialize a `LinkedList<string>` with values that include numbers, or vice-versa, leading to a TypeScript type mismatch.

fix Ensure all initial values match the generic type `T` specified for the `LinkedList`. For mixed types, explicitly use `new LinkedList<any>(...)`.
```
TypeError: Cannot read properties of undefined (reading 'property_name')
```
cause Attempting to access a property on `list.head` or `list.tail` when the list is empty, causing `head`/`tail` to return `undefined` and subsequent property access to fail.

fix Before accessing properties on `list.head` or `list.tail`, verify that `list.head` (or `list.tail`) is not `undefined`, typically by checking `list.length > 0` or using optional chaining (`list.head?.property_name`).
```
TypeError: linked_list_typescript_1.default is not a constructor
```
cause Attempting to import `LinkedList` as a default export (`import LinkedList from 'linked-list-typescript'`) when it is provided as a named export.

fix Correct the import statement to use named exports: `import { LinkedList } from 'linked-list-typescript';`

Warnings

gotcha Incorrect type arguments for `LinkedList<T>` constructor will result in TypeScript compilation errors due to type inference or direct type checking.
Fix: Ensure all initial values passed to the `LinkedList` constructor conform to the specified generic type `T`. Use `LinkedList<any>` if heterogeneous types are intentionally required.
gotcha Accessing `head` or `tail` properties on an empty `LinkedList` instance will return `undefined` instead of throwing an error. This can lead to runtime issues if not checked.
Fix: Always check if the list is empty (e.g., `list.length === 0` or `list.head !== undefined`) before attempting to access `head` or `tail` and their properties.
gotcha The `LinkedList` stores values by reference, not by copy. Modifying objects after they have been added to the list will affect the values within the list.
Fix: Be aware that changes to referenced objects will be reflected in the list. If immutable values are desired, ensure objects are not modified after insertion or create defensive copies before adding them.

Install

npm install linked-list-typescript npm
yarn add linked-list-typescript yarn
pnpm add linked-list-typescript pnpm

Imports

LinkedList
wrong:
```
import LinkedList from 'linked-list-typescript';
```
correct:
```
import { LinkedList } from 'linked-list-typescript';
```
LinkedList is a named export. Ensure to use destructuring in the import statement. Both ESM and CommonJS named imports are supported.
LinkedList (CommonJS)
wrong:
```
const LinkedList = require('linked-list-typescript');
```
correct:
```
const { LinkedList } = require('linked-list-typescript');
```
For CommonJS environments, LinkedList is exported as a named property of the module object.
LinkedList<T> (Generics)
wrong:
```
const list = new LinkedList();
```
correct:
```
const list = new LinkedList<string>();
```
While `new LinkedList()` might work in some contexts, explicitly defining the generic type `T` (e.g., `<string>`) provides strong type checking and is recommended for TypeScript projects. Use `LinkedList<any>` for mixed types.

Quickstart

Demonstrates how to create a generic linked list, initialize it with values, iterate over its elements, deconstruct, and perform basic operations like removing the head, including usage with custom types.

import { LinkedList } from 'linked-list-typescript';

// Create a new linked list initialized with number values
let numberList = new LinkedList<number>(10, 20, 30);

console.log(`List length: ${numberList.length}`);
console.log(`Head value: ${numberList.head}`);
console.log(`Tail value: ${numberList.tail}`);

console.log("Iterating through the list using for...of:");
for (const item of numberList) {
    console.log(item);
}

// Deconstruct elements
let [first, second] = numberList;
console.log(`Destructured: first=${first}, second=${second}`);

// Remove an element from the head
const removed = numberList.removeHead();
console.log(`Removed head: ${removed}`);
console.log(`New head: ${numberList.head}`);

// Example with a custom type
class Item {
    constructor(public id: number, public name: string) {}
}
let item1 = new Item(1, "Apple");
let item2 = new Item(2, "Banana");

let itemList = new LinkedList<Item>(item1, item2);
console.log(`Custom type list head: ${itemList.head?.name}`); // Accessing property safely

view raw JSON →