extracting the properties of a generic type to retrieve a specific object's attribute

Question

extracting the properties of a generic type to retrieve a specific object's attribute

Is it possible to destructure a generic lambda function parameter recursively to check if a property exists within an object? I want to keep the input types of this function as general as possible without extending T to any existing type.

Let's clarify with an example:

const binarySearch = <T, U>(array:T[], value:(T|U), getProperty?:(item:T, index?:number) => U):number => {}

Here, "U" could represent any of "T"s properties.

This function can be called by accessing a property using a lambda if it is an object array:

const index = binarySearch(objectArray, objectProperty, (obj) => obj.property)

Alternatively, it can be called by using the array value if it isn't:

const index = binarySearch(primitiveArray, primitive)

The expectation is for the function to behave like a normal binary search method but with more flexibility in accessing different property types without the need to create multiple similar functions for nested properties.

typescript typescript-generics

Answer 1

Answer №1

No special treatment is needed for primitives in this scenario. Simply pass the identity function for getProperty: i => i.

I am sufficiently interested in your goal to devise a universal solution on my own, complete with examples using 1) an array of numbers and 2) an array of objects with a date property:

const binarySearch = <T, U>(
  arr: T[], 
  getProperty:(item:T) => U, 
  searchedValue: U, 
  subArrayHeadIndex = 0, //for internal use w/recursion
): number | undefined => {
  const midPoint = Math.floor(arr.length / 2);
  const item = arr[midPoint];
  const propVal: U = getProperty(item);
  if(propVal === searchedValue){
    return subArrayHeadIndex + arr.indexOf(item);
  }
  const newStart = propVal > searchedValue ? 0 : midPoint + 1;
  const newEnd = propVal > searchedValue ? midPoint : arr.length;
  if (newStart === newEnd){
    console.log("couldn't find it")
    return -1
  }
  const newSubArrayHeadIndex = subArrayHeadIndex + (propVal > searchedValue ?  0: midPoint + 1);
  return binarySearch(arr.slice(newStart, newEnd), getProperty, searchedValue, newSubArrayHeadIndex);
}

Primitives case -- Determine the position of 29 in the following array:

const numbers = [2, 3, 6, 11, 13, 29, 35, 65, 89, 143, 144, 190, 2001];
console.log(binarySearch(numbers, i => i, 29));
// outputs "5"

Object case -- Discover the location of the item dated August 21, 1995 from the array:

const things = [
  { id: 1, date: 'January 17, 1995 03:24:00'},
  { id: 2, date: 'December 25, 1995 11:24:00'},
  { id: 3, date: 'January 27, 1995 05:43:00'},
  { id: 4, date: 'March 1, 1995 09:44:00'},
  { id: 5, date: 'April 10, 1995 13:20:00'},
  { id: 6, date: 'May 2, 1995 07:16:00'},
  { id: 7, date: 'May 24, 1995 15:55:00'},
  { id: 8, date: 'August 17, 1995 21:33:00'},
  { id: 9, date: 'August 21, 1995 21:49:00'},
  { id: 10, date: 'December 17, 1995 19:57:00'},
];

const getDayString = (dateStr: string) => {
  const date = new Date(dateStr)
  //using Korean here for convenient comparison -- the KR format is "yyyy. mm. dd."
  const d= date.toLocaleDateString("ko-KR", {
    year: "numeric",
    month: "2-digit",
    day: "2-digit"
  });
  return d;
}

console.log(binarySearch(things, i => getDayString(i.date), "1995. 08. 21."))
// outputs "8"

Answer 2

No special treatment is needed for primitives in this scenario. Simply pass the identity function for getProperty: i => i.

I am sufficiently interested in your goal to devise a universal solution on my own, complete with examples using 1) an array of numbers and 2) an array of objects with a date property:

const binarySearch = <T, U>(
  arr: T[], 
  getProperty:(item:T) => U, 
  searchedValue: U, 
  subArrayHeadIndex = 0, //for internal use w/recursion
): number | undefined => {
  const midPoint = Math.floor(arr.length / 2);
  const item = arr[midPoint];
  const propVal: U = getProperty(item);
  if(propVal === searchedValue){
    return subArrayHeadIndex + arr.indexOf(item);
  }
  const newStart = propVal > searchedValue ? 0 : midPoint + 1;
  const newEnd = propVal > searchedValue ? midPoint : arr.length;
  if (newStart === newEnd){
    console.log("couldn't find it")
    return -1
  }
  const newSubArrayHeadIndex = subArrayHeadIndex + (propVal > searchedValue ?  0: midPoint + 1);
  return binarySearch(arr.slice(newStart, newEnd), getProperty, searchedValue, newSubArrayHeadIndex);
}

Primitives case -- Determine the position of 29 in the following array:

const numbers = [2, 3, 6, 11, 13, 29, 35, 65, 89, 143, 144, 190, 2001];
console.log(binarySearch(numbers, i => i, 29));
// outputs "5"

Object case -- Discover the location of the item dated August 21, 1995 from the array:

const things = [
  { id: 1, date: 'January 17, 1995 03:24:00'},
  { id: 2, date: 'December 25, 1995 11:24:00'},
  { id: 3, date: 'January 27, 1995 05:43:00'},
  { id: 4, date: 'March 1, 1995 09:44:00'},
  { id: 5, date: 'April 10, 1995 13:20:00'},
  { id: 6, date: 'May 2, 1995 07:16:00'},
  { id: 7, date: 'May 24, 1995 15:55:00'},
  { id: 8, date: 'August 17, 1995 21:33:00'},
  { id: 9, date: 'August 21, 1995 21:49:00'},
  { id: 10, date: 'December 17, 1995 19:57:00'},
];

const getDayString = (dateStr: string) => {
  const date = new Date(dateStr)
  //using Korean here for convenient comparison -- the KR format is "yyyy. mm. dd."
  const d= date.toLocaleDateString("ko-KR", {
    year: "numeric",
    month: "2-digit",
    day: "2-digit"
  });
  return d;
}

console.log(binarySearch(things, i => getDayString(i.date), "1995. 08. 21."))
// outputs "8"

Answer 3

Answer №2

While working on other functions, I stumbled upon my own solution.

The getnestedkeys type function does not support nested arrays as I currently have no use for it. However, it could potentially be added as a second ternary after checking if the property type is an object.

I still prefer to make the getproperty parameter conditional to avoid having to always write `i => i` for any calls involving primitive arrays. This can easily be modified though.

Below is the code snippet:

export type getNestedKeyTypes<T extends object> = {
    [K in keyof T]:T[K] extends object ? getNestedKeyTypes<T[K]> : K[keyof K]
}[keyof T]

export const binarySearch = <T, U, V = T extends object ? getNestedKeyTypes<T> : T>
(arr:T[], value:V, getProperty?:(item:T) => (U&V)):number => {
    if(arr.length === 0) return -1
    const getArrayValue = (i:number) => getProperty ? getProperty(arr[i]) : arr[i]
    const getIndex = (upper:number, lower:number):number => {
        if(lower > upper) return -1
        const m = Math.round((upper+lower)/2)
        const av = getArrayValue(m)
        if(value === av) return m
        if(value > av) return getIndex(m-1, lower)
        return getIndex(upper, m+1)
    }
    return getIndex(0,arr.length-1)
}

Answer 4

While working on other functions, I stumbled upon my own solution.

The getnestedkeys type function does not support nested arrays as I currently have no use for it. However, it could potentially be added as a second ternary after checking if the property type is an object.

I still prefer to make the getproperty parameter conditional to avoid having to always write `i => i` for any calls involving primitive arrays. This can easily be modified though.

Below is the code snippet:

export type getNestedKeyTypes<T extends object> = {
    [K in keyof T]:T[K] extends object ? getNestedKeyTypes<T[K]> : K[keyof K]
}[keyof T]

export const binarySearch = <T, U, V = T extends object ? getNestedKeyTypes<T> : T>
(arr:T[], value:V, getProperty?:(item:T) => (U&V)):number => {
    if(arr.length === 0) return -1
    const getArrayValue = (i:number) => getProperty ? getProperty(arr[i]) : arr[i]
    const getIndex = (upper:number, lower:number):number => {
        if(lower > upper) return -1
        const m = Math.round((upper+lower)/2)
        const av = getArrayValue(m)
        if(value === av) return m
        if(value > av) return getIndex(m-1, lower)
        return getIndex(upper, m+1)
    }
    return getIndex(0,arr.length-1)
}

extracting the properties of a generic type to retrieve a specific object's attribute

Answer №1

Answer №2

Similar questions

What should I do when dealing with multiple submit buttons in NextJS?

Encountering an issue in the test file when using react-router-dom v6: "The 'history' property is not found on the 'IntrinsicAttributes & RouterProps' type."

How can we prevent transform Omit into Pick in Typescript when utilizing generics?

Typescript throwing error TS2307 when attempting to deploy a NodeJS app on Heroku platform

Steps to converting an enum or literal

Error: The variable "dispatcher.useMemo" is not recognized as an object

What is the best way to test chained function calls using sinon?

The type 'Navigator' does not have the property 'userAgentData' in its definition

NativeScript Error Code NG8001: Element 'ActionBar' is unrecognized

The test function is not recognized by Cordova when the device is ready

Is there a way to prevent the leaderboard from resetting each time I restart my client?

I encountered an issue while generating a crypto address on the Waves blockchain using the @waves/waves-crypto library in TypeScript

Describe the process of defining an Interface object array and effectively utilizing it

How can I update a dropdown menu depending on the selection made in another dropdown using Angular

When `Omit` is applied to a type that includes an index signature, it removes all field declarations that are not part of

Do interfaces in Typescript require nested properties to be mandatory?

Where does tsc retrieve its definitions from when utilizing npm definitions?

Implementing setState callback in TypeScript with React Hooks

Can Tailwind Merge function apply to Tailwind classes with prefixes?

Display sub-objects within Chart.js