const transformObject = <const K0 extends string, const K1 extends string>(obj: Record<K0, Record<K1, string>>) => {
let result: Partial<Record<K1, Partial<Record<K0, string>>>> = {};
for (const key of Object.keys(obj) as K0[]) {
for (const lang of Object.keys(obj[key]) as K1[]) {
(result[lang] ??= {} as Partial<Record<K0, string>>)[key] = obj[key][lang];
}
}
return result;
};
(Foo|Bar)[]
позволит передать в себя массив, каждый элемент которого может быть как Foo так и Bar. Проверить тип всех элементов можно лишь пройдя итерацией весь массив.Foo[] | Bar[]
, в этом случае достаточно проверки элемента с индексом 0.&
) как верно подметил Василий Банников )interface A extends B, C {}
interface B {}
type C = {}; // interface вполне может extends из type
interface A {
a: number;
}
interface A {
b: number;
}
const a: A = {a: 1, b: 2};
type A = B | C; // на interface такого не выразишь
function isPostField(field: string): field is keyof Post {
return field === 'title' || field === 'text';
}
export class SearchingPipe implements PipeTransform {
transform(posts: Post[], search: string, searhcField: string = 'title') {
if (!isPostField(searhcField) || !search.trim()) {
return posts;
}
return posts.filter((post) => {
return post[searhcField]
.toLocaleLowerCase()
.includes(search.toLocaleLowerCase());
});
}
}
type TypeMap = {
string: string;
number: number;
bigint: bigint;
boolean: boolean;
symbol: symbol;
undefined: undefined;
object: object;
function: Function;
};
type TypeName<T> = {
[K in keyof TypeMap]: T extends TypeMap[K] ? K : never;
}[keyof TypeMap];
const evgeniy = <T extends string | number>(x: T) => ({
resultedType: typeof x as TypeName<T>,
});
interface TableProps<T extends Record<string, unknown>> {
entities: T[] | null; // тут возможно еще стоит сделать это поле необязательным?
}
const Table = function <T extends Record<string, unknown>>({
entities,
}: TableProps<T>) {
// ...
return (<>
{entities?.map((entity, key) => {
return Object.entries(entity).map(([key, value], index) => {
// ...
});
})}
</>);
}
type ExtractGenerics<T extends readonly unknown[]> = T extends readonly []
? []
: T extends readonly [G<infer V>, ...infer Next]
? [V, ...ExtractGenerics<Next>]
: never;
function unwrap<C extends readonly G<unknown>[]>(containers: C) {
return containers.map(container => container.value) as ExtractGenerics<C>
}