TYPESCRIPT 3.4.3
I want to make function like this
exportObjectUnit({ a: 1, b: 2, c: 3, d: 4 }, ['b', 'c'])
OUTPUT { a: 1, d: 4 };
I don't know how to typing this function's return type
export const exportObjectKey = <T, K extends keyof T>(value: T, exports: K[]) => {
const returnValue = {};
Object.keys(value)
.filter(key => {
if (exports.indexOf(key) !== -1) {
return false;
}
return true;
})
.map(key => {
returnValue[key] = value[key];
});
return returnValue as T;
};
If I use this function, return value still have types (With the exception of second string array parameter)
----------EDIT----------------
export const exportObjectKey = <T>(value: T, exports: Array<keyof T>) => {
const returnValue = {};
Object.keys(value)
.filter(key => {
if (exports.indexOf(key as keyof T) !== -1) {
return false;
}
return true;
})
.map(key => {
returnValue[key] = value[key];
});
return returnValue as T;
};
I don't know how to return. Removing seconds parameter array property from first object
-----------EDIT 2----------------
type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
export const exportObjectKey = <T, K extends keyof T>(value: T, omit: K): Omit<T, K> => {
delete value[omit];
return value;
};
export const exportObjectKeys = <T, K extends Array<keyof T>>(value: T, removes: K) =>
removes.reduce((object, key) => exportObjectKey(object, key), value);
// This is not perfect version
const a = { a: 1, b: 2, c: 3 };
const keyOmitOne = exportObjectKey(a, 'b');
// When I type keyOmitOne.
// Type definition available, It works (a, c)
// ------------------------------------------
// But, when I use exportObjectKeys
const b = { a: 1, b: 2, c: 3 };
const keyOmitArray = exportObjectKey(b, ['b', 'c']);
// I thought type definition works (a available)
// But there is no definition in b value)
It shouldn't be hard I guess?
type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>
function exportObjectUnit<T extends Object, K extends (keyof T)[]>(obj: T, ...keys: K): Omit<T, K[number]> {
keys.forEach(k => delete obj[k])
return obj
}
const t1 = exportObjectUnit({ a: 1, b: 2, c: 3, d: 4})
const t2 = exportObjectUnit({ a: 1, b: 2, c: 3, d: 4} , 'a')
const t3 = exportObjectUnit({ a: 1, b: 2, c: 3, d: 4} , 'a', 'b')
const t4 = exportObjectUnit({ a: 1, b: 2, c: 3, d: 4} , 'a', 'b', 'c')
const t5 = exportObjectUnit({ a: 1, b: 2, c: 3, d: 4} , 'a', 'b', 'c', 'd')
Not sure if this is what you want, but without generics, you could use index signature
to input and output an object with unknown keys.
type MyObject = { [key: string]: number }
function doSomething(obj: MyObject, arr: string[]) : MyObject {
let a : MyObject = {a:3, b:4}
return a
}
doSomething({a:4, b:4, c:4, d:2}, ["a", "d"])
The technical post webpages of this site follow the CC BY-SA 4.0 protocol. If you need to reprint, please indicate the site URL or the original address.Any question please contact:yoyou2525@163.com.