是否有方法更改*.d中定义的接口属性的类型?Ts在typescript中?
例如: x.d.ts中的接口定义为
interface A {
property: number;
}
我想在我写入的typescript文件中改变它
interface A {
property: Object;
}
甚至这个也可以
interface B extends A {
property: Object;
}
这种方法有效吗?当我试我的系统时，它不工作。只是想确认一下有没有可能?
当前回答
有趣的是，我花了一天的时间调查解决同一个案子的可能性。 我发现这样做是不可能的:
// a.ts - module
export interface A {
x: string | any;
}
// b.ts - module
import {A} from './a';
type SomeOtherType = {
coolStuff: number
}
interface B extends A {
x: SomeOtherType;
}
产生原因模块可能不知道应用程序中所有可用的类型。从各个地方移植所有东西，编写这样的代码是很无聊的。
export interface A {
x: A | B | C | D ... Million Types Later
}
您必须稍后定义类型，以使自动完成工作良好。
所以你可以欺骗一下:
// a.ts - module
export interface A {
x: string;
}
默认保留some类型，当不需要重写时，允许自动完成工作。
Then
// b.ts - module
import {A} from './a';
type SomeOtherType = {
coolStuff: number
}
// @ts-ignore
interface B extends A {
x: SomeOtherType;
}
在这里使用@ts-ignore标志禁用愚蠢的异常，告诉我们我们做错了什么。有趣的是，一切都按照预期进行。
在我的情况下，我减少了类型x的范围，它允许我做更严格的代码。例如，你有一个100个属性的列表，你把它减少到10个，以避免愚蠢的情况
其他回答
不能更改现有属性的类型。
你可以添加一个属性:
interface A {
newProperty: any;
}
而是改变现有的一种类型:
interface A {
property: any;
}
导致一个错误:
后续变量声明必须具有相同的类型。变量 'property'必须是'number'类型，但这里有'any'类型
当然，您可以拥有自己的接口来扩展现有的接口。在这种情况下，你可以重写一个类型到一个兼容的类型，例如:
interface A {
x: string | number;
}
interface B extends A {
x: number;
}
顺便说一下，你可能应该避免使用Object作为类型，而是使用any类型。
在任何类型的文档中，它声明:
any类型是使用现有JavaScript的强大方式， 允许您在过程中逐渐选择加入或退出类型检查 编译。您可能希望Object扮演类似的角色 在其他语言中是这样。但是Object类型的变量只允许你 要给它们赋值-你不能调用任意的方法 他们，甚至那些真实存在的人:
let notSure: any = 4;
notSure.ifItExists(); // okay, ifItExists might exist at runtime
notSure.toFixed(); // okay, toFixed exists (but the compiler doesn't check)
let prettySure: Object = 4;
prettySure.toFixed(); // Error: Property 'toFixed' doesn't exist on type 'Object'.
有趣的是，我花了一天的时间调查解决同一个案子的可能性。 我发现这样做是不可能的:
// a.ts - module
export interface A {
x: string | any;
}
// b.ts - module
import {A} from './a';
type SomeOtherType = {
coolStuff: number
}
interface B extends A {
x: SomeOtherType;
}
产生原因模块可能不知道应用程序中所有可用的类型。从各个地方移植所有东西，编写这样的代码是很无聊的。
export interface A {
x: A | B | C | D ... Million Types Later
}
您必须稍后定义类型，以使自动完成工作良好。
所以你可以欺骗一下:
// a.ts - module
export interface A {
x: string;
}
默认保留some类型，当不需要重写时，允许自动完成工作。
Then
// b.ts - module
import {A} from './a';
type SomeOtherType = {
coolStuff: number
}
// @ts-ignore
interface B extends A {
x: SomeOtherType;
}
在这里使用@ts-ignore标志禁用愚蠢的异常，告诉我们我们做错了什么。有趣的是，一切都按照预期进行。
在我的情况下，我减少了类型x的范围，它允许我做更严格的代码。例如，你有一个100个属性的列表，你把它减少到10个，以避免愚蠢的情况
我已经创建了这个类型，允许我轻松地覆盖嵌套接口:
export type DeepPartialAny<T> = {
[P in keyof T]?: T[P] extends Obj ? DeepPartialAny<T[P]> : any;
};
export type Override<A extends Obj, AOverride extends DeepPartialAny<A>> = { [K in keyof A]:
AOverride[K] extends never
? A[K]
: AOverride[K] extends Obj
? Override<A[K], AOverride[K]>
: AOverride[K]
};
然后你可以这样使用它:
interface Foo {
Bar: {
Baz: string;
};
}
type Foo2 = Override<Foo, { Bar: { Baz: number } }>;
const bar: Foo2['Bar']['Baz'] = 1; // number;
创建修饰符类型
type Modify<T, R extends {[P in keyof T]:any} > = Omit<T, keyof R> & R;
你可以
interface ModifiedInterface extends Modify<OriginalType, {
a: number;
b: number;
}> {}
它会给你一个类型自动完成
type ModifiedType = Modify<OriginalType, {
a: number;
b: number;
}>
interface ModifiedInterface extends Modify<OriginalType, {
a: number;
b: number;
}> {}
受到ZSkycat扩展的省略解决方案的启发，我想出了这个:
type Modify<T, R> =省略<T, R> & R键; //在typescript@3.5之前 type修改<T, R> =选择<T，排除<keyof T, keyof R>> & R
例子:
interface OriginalInterface {
a: string;
b: boolean;
c: number;
}
type ModifiedType = Modify<OriginalInterface , {
a: number;
b: number;
}>
// ModifiedType = { a: number; b: number; c: number; }
一步一步地:
type R0 = Omit<OriginalType, 'a' | 'b'> // { c: number; }
type R1 = R0 & {a: number, b: number } // { a: number; b: number; c: number; }
type T0 = Exclude<'a' | 'b' | 'c' , 'a' | 'b'> // 'c'
type T1 = Pick<OriginalType, T0> // { c: number; }
type T2 = T1 & {a: number, b: number } // { a: number; b: number; c: number; }
TypeScript实用工具类型
深度修改v3
interface Original {
a: {
a: string
b: { a: string }
c: string
d: string // <- keep this one
}
}
interface Overrides {
a: {
a: { a: number } // <- overwrite string with object
b: number // <- overwrite object with number
c: number // <- overwrite string with number
e: number // <- new property
}
}
type ModifiedType = ModifyDeep<Original, Overrides>
interface ModifiedInterface extends ModifyDeep<Original, Overrides> {}
const example: ModifiedType = {
a: {
a: { a: number },
b: number,
c: number,
d: string,
e: number,
}
}
在下面找到ModifyDeep。
