Typescript double-sided dictionary: a comprehensive guide

Question

Typescript double-sided dictionary: a comprehensive guide

Looking for a dual-sided dictionary implementation in TypeScript that allows you to retrieve values using keys and vice versa.

An initial approach could be storing both items as keys:

dict = {"key": "value", "value": "key"}

But I am curious if there are alternative solutions available.

javascript typescript

Answer 1

Answer №1

If you're working with JavaScript, I recommend creating a function that can transform a standard dictionary into a double-sided dictionary:

function doubleDictionary(t) {
    var ret = Object.assign({}, t);
    for (var k in t) {
        ret[t[k]] = k;
    }
    return ret;
}
var foo = doubleDictionary({ a: "b", c: "d" });
console.log(foo.a); // "b"
console.log(foo.b); // "a"
console.log(foo.c); // "d"
console.log(foo.d); // "c"

For TypeScript, you can use the same function but enhance it with a signature to provide a strongly-typed return value to callers. Here's how you can do that:

// ObjToKeyValue<T> turns an object type into a union of key/value tuples:
// ObjToKeyValue<{a: string, b: number}> becomes ["a", string] | ["b", number]
type ObjToKeyValue<T> =
  { [K in keyof T]: [K, T[K]] }[keyof T];

// KeyValueToObj<T> turns a union of key/value tuples into an object type:
// KeyValueToObj<["a", string] | ["b", number]> becomes {a: string, b: number}
type KeyValueToObj<KV extends [keyof any, any]> =
  { [K in KV[0]]: KV extends [K, infer V] ? V : never };

// ReverseTuple<KV> swaps the keys and values in a union of key/value tuples:
// ReverseTuple<[1, 2] | [3, 4]> becomes [2, 1] | [4, 3]
type ReverseTuple<KV extends [any, any]> =
  KV extends [any, any] ? [KV[1], KV[0]] : never;

// ReverseObj<T> takes an object type whose properties are valid keys
// and returns a new object type where the keys and values are swapped:
// ReverseObj<{a: "b", c: "d"}> becomes {b: "a", d: "c"}
type ReverseObj<T extends Record<keyof T, keyof any>> =
  KeyValueToObj<ReverseTuple<ObjToKeyValue<T>>>;

// take an object type T and return an object of type T & ReverseObj<T>
// meaning it acts as both a forward and reverse mapping 
function doubleDictionary<
  S extends keyof any, // infer literals for property values if possible
  T extends Record<keyof T, S>
>(t: T) {
  const ret = Object.assign({}, t) as T & ReverseObj<T>; // return type
  for (let k in t) {
    ret[t[k]] = k as any; // need assertion here, compiler can't verify k
  }
  return ret;
}

With this implementation, you can achieve the same outcome as before while having the benefits of compile-time knowledge:

const foo = doubleDictionary({ a: "b", c: "d" });
// const foo: {a: "b", c: "d"} & {b: "a", d: "c"};
console.log(foo.a); // the compiler knows it is "b"
console.log(foo.b); // the compiler knows it is "a"
console.log(foo.c); // the compiler knows it is "d"
console.log(foo.d); // the compiler knows it is "c"

Code Link

I hope this explanation is helpful to you! Good luck with your coding!

Answer 2

If you're working with JavaScript, I recommend creating a function that can transform a standard dictionary into a double-sided dictionary:

function doubleDictionary(t) {
    var ret = Object.assign({}, t);
    for (var k in t) {
        ret[t[k]] = k;
    }
    return ret;
}
var foo = doubleDictionary({ a: "b", c: "d" });
console.log(foo.a); // "b"
console.log(foo.b); // "a"
console.log(foo.c); // "d"
console.log(foo.d); // "c"

For TypeScript, you can use the same function but enhance it with a signature to provide a strongly-typed return value to callers. Here's how you can do that:

// ObjToKeyValue<T> turns an object type into a union of key/value tuples:
// ObjToKeyValue<{a: string, b: number}> becomes ["a", string] | ["b", number]
type ObjToKeyValue<T> =
  { [K in keyof T]: [K, T[K]] }[keyof T];

// KeyValueToObj<T> turns a union of key/value tuples into an object type:
// KeyValueToObj<["a", string] | ["b", number]> becomes {a: string, b: number}
type KeyValueToObj<KV extends [keyof any, any]> =
  { [K in KV[0]]: KV extends [K, infer V] ? V : never };

// ReverseTuple<KV> swaps the keys and values in a union of key/value tuples:
// ReverseTuple<[1, 2] | [3, 4]> becomes [2, 1] | [4, 3]
type ReverseTuple<KV extends [any, any]> =
  KV extends [any, any] ? [KV[1], KV[0]] : never;

// ReverseObj<T> takes an object type whose properties are valid keys
// and returns a new object type where the keys and values are swapped:
// ReverseObj<{a: "b", c: "d"}> becomes {b: "a", d: "c"}
type ReverseObj<T extends Record<keyof T, keyof any>> =
  KeyValueToObj<ReverseTuple<ObjToKeyValue<T>>>;

// take an object type T and return an object of type T & ReverseObj<T>
// meaning it acts as both a forward and reverse mapping 
function doubleDictionary<
  S extends keyof any, // infer literals for property values if possible
  T extends Record<keyof T, S>
>(t: T) {
  const ret = Object.assign({}, t) as T & ReverseObj<T>; // return type
  for (let k in t) {
    ret[t[k]] = k as any; // need assertion here, compiler can't verify k
  }
  return ret;
}

With this implementation, you can achieve the same outcome as before while having the benefits of compile-time knowledge:

const foo = doubleDictionary({ a: "b", c: "d" });
// const foo: {a: "b", c: "d"} & {b: "a", d: "c"};
console.log(foo.a); // the compiler knows it is "b"
console.log(foo.b); // the compiler knows it is "a"
console.log(foo.c); // the compiler knows it is "d"
console.log(foo.d); // the compiler knows it is "c"

Code Link

I hope this explanation is helpful to you! Good luck with your coding!

Answer 3

Answer №2

Enums in Typescript automatically come with reverse mappings by default when they are numeric.

For example:

enum Enum {
    A
}
let a = Enum.A;
let nameOfA = Enum[a]; // "A"

Aside from that, it seems like there isn't a simpler way than what you already did.

Answer 4

Enums in Typescript automatically come with reverse mappings by default when they are numeric.

For example:

enum Enum {
    A
}
let a = Enum.A;
let nameOfA = Enum[a]; // "A"

Aside from that, it seems like there isn't a simpler way than what you already did.

Answer 5

Answer №3

Method: There are multiple ways to tackle this issue, but the approach outlined below seemed to be the most efficient within a limited time frame. By utilizing a Proxy, we were able to tap into the inherent functionality of the Object getter and incorporate some customized features.

Applications:

Retrieve value based on key. Using the conventional key lookup method will yield the expected value. e.g., console.log(dict.key) or console.log(dict['key'])

If no key or value is specified, the Proxy will return the object in its original initialization state. console.log(dict).

Obtain key based on value. Aiming for the value as a reference will trigger a search for the corresponding key, or if not found, retrieve all entries of the object. console.log(dict['value']); would show the associated key

This setup also facilitates modification. While values can be altered, there might be consideration towards making them immutable.

Note that this solution may not cover all scenarios, only addressing what was requested.

class DoubleSidedDictionary {
    constructor(init) {
        return new Proxy(init, {
            get(target, name) {
                if(typeof name !== 'string') {
                    return target;
                }
                if (target[name]) {
                    return target[name];
                }
                const entries = Object.entries(target);
                const entry = entries.filter(entry => name == entry[1]);
                return entry.length > 0 ? entry[0][0] : undefined;
            }
        });
    }
}

const dict = new DoubleSidedDictionary({"key": "value", "something": "else"});

This implementation accommodates stringified versions of various data types. It is essential to convert them back to their original forms when necessary.

Answer 6

Method: There are multiple ways to tackle this issue, but the approach outlined below seemed to be the most efficient within a limited time frame. By utilizing a Proxy, we were able to tap into the inherent functionality of the Object getter and incorporate some customized features.

Applications:

Retrieve value based on key. Using the conventional key lookup method will yield the expected value. e.g., console.log(dict.key) or console.log(dict['key'])

If no key or value is specified, the Proxy will return the object in its original initialization state. console.log(dict).

Obtain key based on value. Aiming for the value as a reference will trigger a search for the corresponding key, or if not found, retrieve all entries of the object. console.log(dict['value']); would show the associated key

This setup also facilitates modification. While values can be altered, there might be consideration towards making them immutable.

Note that this solution may not cover all scenarios, only addressing what was requested.

class DoubleSidedDictionary {
    constructor(init) {
        return new Proxy(init, {
            get(target, name) {
                if(typeof name !== 'string') {
                    return target;
                }
                if (target[name]) {
                    return target[name];
                }
                const entries = Object.entries(target);
                const entry = entries.filter(entry => name == entry[1]);
                return entry.length > 0 ? entry[0][0] : undefined;
            }
        });
    }
}

const dict = new DoubleSidedDictionary({"key": "value", "something": "else"});

This implementation accommodates stringified versions of various data types. It is essential to convert them back to their original forms when necessary.

Typescript double-sided dictionary: a comprehensive guide

Answer №1

Answer №2

Answer №3

Similar questions

What is the best way to transfer information between pages using onclick in node.js and express?

Sorting a list based on user-defined criteria in Ionic 3

Convert require imports to Node.js using the import statement

Utilizing the power of Node.js with Oracle seamlessly, without the need for the Oracle Instant

The FileSaver application generates a unique file with content that diverges from the original document

In the case that the prop is empty or undefined, display an error message before rendering the full component

Transmit information to the client-side webpage using Node.js

Utilizing titanium to develop a functionality that listens for button presses on any area of the screen

The dropdown navigation bar fails to close upon being clicked

Having trouble getting the ValidatorPipe to function properly in my nest.js application

Working with dynamic checkbox values in VueJS 2

Preventing users from navigating away from the page without choosing an answer in a React application

Continue looping in Javascript until an empty array is identified

Can you determine the sequence in which these code statements are placed on the call stack?

Steps for integrating a universal loader in Angular

Issue with Material UI Table not refreshing correctly after new data is added

Ways to confirm non-null values and bypass the row if it is

Guide to fetching and returning data from AJAX using a function

Vuetify offers a convenient solution for implementing multiple buttons in a Vue

What is the best way to extract the ID of an element that triggers an OnChange event?