在TypeScript中,有没有一种方法可以在不显式声明类型(例如,在泛型参数中)的情况下指示返回的是参数的类型?有点像是表示它是一个类型标识函数。
例如:
function foo(bar) {
// ...do crazy stuff to bar...
return bar;
}
var aString = foo('baz'); // aString is of string type
var aNumber = foo(6); // aNumber is of number type
我有一个接受两个参数的函数。基本上我想让Typescript检查,第二个参数不能包含第一个参数中的键。TS Sandbox interface Todo {
title: string;
description: string;
}
// here I hardcoded the 'title' key on the Omit utility type. My question is, how to make this dynamic, based on the key on the left argument.
function test<T>
为什么typescript不显示错误,以及如何使其工作? Typescript sandbox。 enum Animal {
BIRD = 'bird',
DOG = 'dog',
}
interface Smth<T extends Animal = Animal> {
id: number;
animalType: T;
config: T extends 'bird' ? number : string; // if its bird - should be a number
}
const smth:
我有这个typescript代码,使用的泛型过去在typescript 2.3下工作,但现在在typescript 2.4.1的更严格的类型强制下中断。
我写了这个最小的代码片段来演示这个问题:
class A {}
class B extends A {}
function helloA(clazz: typeof A) {}
helloA(B); // fine
class C<T> {
private c: T;
};
class D extends C<string> {}
function helloC(clazz: typeof C) {}
hel
B扩展了一个泛型类A。我需要能够推断出B的扩展A的泛型类型。参见下面的代码。 我在以前的Typescript版本中成功地使用了它,但对于我当前使用3.2.4的项目(也尝试了最新的3.4.5),推断的类型似乎是{}而不是string。 知道我做错了什么吗?这不可能已经改变了吧? class A<T> {
}
class B extends A<string> {
}
type GenericOf<T> = T extends A<infer X> ? X : never;
type t = GenericOf<B>; //
你知道如何才能做到这一点吗?
function getTest<T>(): T["test"] {
// ...
}
...or动态:
function getTest<T, U>(): T[U] {
// ...
}
不幸的是,编译器说是Type '“test”' cannot be used to index type 'T'。我使用的是TypeScript 2.4.2。
我想学习使用条件类型试图推断签名中类型的类型的算法。
示例1:这里的正确地推断了T为number
type Args<T> = { value: T }
function foo<T>(args: Args<T>) { return args; }
// correctly inferred as foo<number>
foo({ value: 123 });
示例2:条件类型和推断unknown
type StringOrNever<T> = T extends string ? string : never;
type Ar
是否可以从一个函数参数中推断出另一个参数?我想根据第一个论点的推论来推断第二个论点。 当前代码可以位于GitHub slickEventHandler.interface.ts上,如下所示 export type GetSlickEventType<T> =
T extends (infer U)[] ? U :
T extends (...args: any[]) => infer U ? U :
T extends SlickEvent<infer U> ? U : T;
export type GetEventType<T> =
如果一个函数的一个参数是两个类型的并集,我如何才能正确地推断返回类型? 我已经尝试了以下条件类型,但它不起作用(参见typescript错误的内联注释): TypeScript Playground type Status = 'statusType'
type GoalActivity = 'goalActivityType'
type Argument = { type: 'status'; status: Status | null } | { type: 'goalActivity'; goalActivity: Go
我已经创建了一个名为'ServerData‘的接口,它包含一个对象-我从Musixmatch请求的歌曲数据。我想用Axios获取一首歌曲,然后将其放入initialState,但由于我是新接触接口,我不确定如何处理我的响应,以便它可以适应ServerData接口。 当我将鼠标悬停在错误上时,它会显示:Type '{ randomSong: object; }' is not assignable to type 'never' 如果这是相关的,在我将TypeScript添加到项目中之前,Axios fetch工作得很好,我的前端能够获得歌曲数据,只是那
在我的项目中,我使用的是反应式打字本。对于状态管理,我使用的是React redux,对于函数处理,我使用的是redux-saga。为了粘合redux存储和函数,我使用了React的新钩子useSelector和useDispatch。我成功地提取了数据并能够在控制台中显示出来。。基于useSelector文档,我可以在不传递到状态的情况下呈现useSelector。当我映射useSelector的变量时,我得到了TypeScript错误:Object is of type 'unknown'. PS。我也是TypeScript中的新手。
这是我的反应功能组件
import R
似乎有一个无文档化的特性,它允许函数从传递为参数的函数中推断出一个类型。
我想弄明白为什么会起作用,如果是故意的。
给定一个Model,然后使用一个通用的update和apply函数,当使用update的结果作为参数时,我可以从apply中推断出一个类型
interface Model {
foo: number
bar: string
}
function apply<T>(fn: (t: T) => T) {};
function whyDoesThisWork() {
function update<T>(u: T exten
假设我创建了一个简单的函数来使输入加倍,
> let f1: (x: number) => number = x => x * 2;
> .type f1
let f1: (x: number) => number
如果我想取第一个值并将其加倍,我可以
let f2 = R.pipe( R.take(1), f1 );
let f2 = R.pipe( R.head, f1 );
这两种工作都是在f2([5,4,3])之外的TypeScript之外进行的。然而,有了TypeScript,
> let f2 = R.pipe( R.take(1), f1 );
不知道我想要什么typescript功能,但我想我需要一个通用的(如果那是一个typescript功能)。下面是我的要求。
下面是我到目前为止所知道的。
interface Event {
type: string;
}
type EventType<T extends Event> = T['type'];
type EventHandler<T extends Event> = (event:T): void;
// so far so good
type EventTypeAndHandlerTuple <T extends Event
如何获得应用于TypeScript中参数的泛型函数的类型?
例如,我如何在下面定义Apply?
declare function f<T>(t: T): T extends number ? boolean : object;
type ResForNumArg = Apply<typeof f, number>; // should be boolean
type ResForStringArg = Apply<typeof f, object>; // should be object
如果无法做到这一点,您可以通过创建一个类型别名来解决特定情
在TypeScript中,我们使用上下文类型,当泛型类型未定义时,TypeScript将尝试从返回值推断正确的类型。
在大多数情况下,它可以正常工作。但有时会变得很奇怪。在我的示例中,当函数参数未定义时,有时不使用泛型默认类型,也不需要它。
示例&
type State = { count: number }
declare function simple<T = State>(second?: T): T;
const { count: countA } = simple()
// in 4.0+ => countA: number
// in 3.9 =&
在TypeScript中,基本类型推断非常简单:
const bar = foo(); // bar: <type that foo returns>
考虑到泛型参数的默认值为{},由于回调函数返回的是number而不是{},因此预期下面的代码将导致类型错误是合理的
function foo<T = {}>(callback: () => T): T {
return callback();
}
let bar = foo(() => 1); // bar: number
但我们知道T是从回调返回值中推断出来的,它是:
function foo&l
考虑以下TypeScript示例:
type Book = {
name: string;
}
const getSomething = <T>() : T => {
// Magically returns something of type T
}
const book : Book = getSomething();
const anotherBook = getSomething<Book>();
我了解到,使用book,我们声明一个名为book的变量(类型为Book ),并通过调用泛型getSomething函数获得它的值,而不显式地
下面是一些打字脚本: let markdown = <HTMLTextAreaElement>document.getElementById(id);
let markdownoutput = <HTMLLabelElement>document.getElementById(output); 在上面的代码中,在使用element by id选择某些东西之前,我们声明了元素类型param.(<HTMLTextAreaElement>)它工作得很好。但是我们从中得到的好处是什么呢? 有人能帮我吗? typescript是如何处理这个问题并帮助我们的呢? 提前
在TypeScript中,有没有办法键入以下fn函数,以便TypeScript仍然知道result的类型是'hello' const hello = 'hello' // hello is of type 'hello'
const fn = (x: unknown) => x
const result = fn(hello) // result is of type unknown 对于泛型,可以传递类型: const hello = 'hello' // hello is of type 'hello
我试图提取一个通用的字符串文字类型,但是typescript推断只返回类型字符串。
所以从技术上讲,一旦字符串文字类型传递给函数,我们就不能再提取它了。
type Key<T extends string> = { key: T };
declare function getKey<T extends string>(key: T): Key<T>;
let someKey = getKey('check');
declare function updateWithKey<T, K extends string>(key: