Я пытаюсь понять, как выполнять рекурсивную печать в Typescript и получаю ошибку компиляции.
У меня есть следующие две функции –
getNestedProperty
— рекурсивная функция возвращает значение вложенных свойств объектаsum
— функция, которая берет массив объектов и суммирует значения вложенных свойствfunction getNestedProperty<T extends Record<string, T>, P extends keyof T>(obj: T, keys: string[]): T | T[P] {
const nestedKeys = [...keys];
const nestedKey = nestedKeys.shift();
if (nestedKey !== undefined) {
return getNestedProperty(obj[nestedKey], nestedKeys) as T;
} else {
return obj;
}
}
export function sum<T extends number | Record<string, T>>(array: T[], keys?: string[]): number {
const totalSum = array.reduce((accumulator: number, element: T) => {
if (typeof element === 'number') {
return accumulator + element;
}
if (keys === undefined) {
throw new Error(`keys not passed in as an argument and type of Array is not number`);
}
return accumulator + +getNestedProperty(element, keys);
}, 0);
return totalSum;
}
Я получаю эту ошибку при попытке вызвать функцию sum
const array = [
{ a: { b: 1 } },
{ a: { b: 3 } },
{ a: { b: 5 } }
];
const actual = Utils.sum(array, ['a', 'b']);
expect(actual).to.equal(1+3+5);
Error:
Argument of type '{ a: { b: number; }; }[]' is not assignable to parameter of type '(number | Record<string, { a: { b: number; }; }>)[]'.
Type '{ a: { b: number; }; }' is not assignable to type 'number | Record<string, { a: { b: number; }; }>'.
Type '{ a: { b: number; }; }' is not assignable to type 'Record<string, { a: { b: number; }; }>'.
Property 'a' is incompatible with index signature.
Property 'a' is missing in type '{ b: number; }' but required in type '{ a: { b: number; }; }'.ts(2345)
С другой стороны, если вам нужны дженерики, вам нужно будет определить некоторые глубоко рекурсивные условные типы, которые описывают глубокое индексирование, как показано в этой ссылке на игровую площадку. Вы бы предпочли увидеть эту версию вместо этого в ответе? Дайте мне знать так или иначе.
Спасибо за ответ @jcalz! Ваша первая ссылка на игровую площадку имеет смысл и похожа на ту, что была у меня ранее. Мне просто интересно, есть ли способ закодировать обе функции без явного указания любого типа.
Конечно, вы можете избежать any
, но вам почти наверняка понадобится какое-то утверждение типа для таких глубоко вложенных типов. Эта версия в одну сторону. Будет ли ответ, объясняющий это, приемлемым для вас? Если так, я напишу один (но это может быть не раньше, чем через 8 или 9 часов, потому что сейчас мне пора спать)
Да, это сработает, благодарю за ответ!
Проблема с универсальной функцией, сигнатура вызова которой выглядит как
declare function foo<T extends number | Record<string, T>>(t: T): void;
это то, что когда вы вызываете его с некоторым литералом объекта, например
foo({ a: 1 }) // error!
компилятор не использует ограничение number | Record<string, T>
в качестве места вывода для T
(как предлагалось, но никогда не применялось в microsoft/TypeScript#7234). Вместо этого он делает вывод T
только из переданного значения, а затем проверяет его на соответствие ограничению.
Таким образом, в приведенном выше вызове T
выводится как {a: 1}
, потому что это тип литерала {a: 1}
. А затем он сверяется с number | Record<string, T>
, который равен number | Record<string, {a: 1}>
. А {a: 1}
не расширяет number | Record<string, {a: 1}>
, поэтому значение не соответствует ограничению и возникает ошибка.
Единственный способ, которым вызов будет успешным, - это если переданное значение уже известно как рекурсивное желаемым образом, но этого не произойдет, если вы передаете литералы объекта.
Поэтому нам нужен другой подход.
Если вам не нужны дженерики, вы можете вместо этого сделать функции неуниверсальными и при необходимости заставить их действовать с соответствующим рекурсивным типом, например
type Summable = number | { [k: string]: Summable };
Таким образом, значение, полученное ранее, будет проверено на соответствие этому типу, который окажется успешным:
const val: Summable = { a: 1 }; // okay
Таким образом, вы можете выполнить рефакторинг:
function sum(array: Summable[], keys?: string[]): number {
const totalSum = array.reduce((accumulator: number, element) => {
if (typeof element === 'number') {
return accumulator + element;
}
if (keys === undefined) {
throw new Error(`keys not passed in as an argument and type of Array is not number`);
}
return accumulator + Number(getNestedProperty(element, keys));
}, 0);
return totalSum;
}
И возможно
function getNestedProperty(obj: unknown, keys: string[]): unknown {
const nestedKeys = [...keys];
const nestedKey = nestedKeys.shift();
if ((nestedKey !== undefined) && (typeof obj === "object") && obj && (nestedKey in obj)) {
const o = obj as Record<string, unknown>;
return getNestedProperty(o[nestedKey], nestedKeys);
} else {
return obj;
}
}
где мы просто собираемся сказать, что типы ввода и вывода getNestedProperty(obj, keys)
- это unknown
, потому что на самом деле нет ничего более полезного, чем сделать функцию универсальной.
Обратите внимание, что я бы, вероятно, реорганизовал реализацию
function getNestedProperty(obj: unknown, keys: string[]): unknown {
return keys.reduce((acc, k) =>
typeof acc === "object" && acc && k in acc ?
(acc as Record<string, unknown>)[k] : acc,
obj);
}
если вам не нужно, чтобы он был рекурсивным.
Если вам нужно сделать функцию универсальной, вам придется пройти через относительно болезненный процесс точного описания того, что будут делать функции. Например, getNestedProperty()
может выглядеть как
type DeepIdx<T, K extends PropertyKey[]> =
K extends [infer K0, ...infer KR extends PropertyKey[]] ?
K0 extends keyof T ? DeepIdx<T[K0], KR> : T : T;
function getNestedProperty<T, K extends PropertyKey[]>(
obj: T,
keys: [...K]
): DeepIdx<T, K> {
return keys.reduce<any>((acc, k) =>
typeof acc === "object" && acc && k in acc ? acc[k] : acc,
obj);
}
хотя я не собираюсь отвлекаться, чтобы объяснить, как именно это работает.
Ваши общие ограничения типа странны; такое ограничение, как
T extends number | Record<string, T>
илиT extends Record<string, T>
, вряд ли будет удовлетворено любым типом, который еще не известен как рекурсивный. Лично я бы, вероятно, просто сделал ваши функции неуниверсальными иsum
работал с известным рекурсивным типом, как показано в этой ссылке на игровую площадку. Это полностью отвечает на ваш вопрос? Если это так, я мог бы написать ответ, объясняющий; если нет, то что мне не хватает?