推断rest元组类型中的泛型参数
是指在TypeScript中，当我们定义一个元组类型时，可以使用泛型参数来表示元组中每个元素的类型。而当我们使用rest元组类型时，可以通过推断来确定泛型参数的类型。
具体来说，rest元组类型是指在元组类型中使用了剩余参数（rest parameters）的情况。剩余参数是指在函数或方法的参数列表中使用三个点（...）来表示可以接收任意数量的参数，并将这些参数作为一个数组传递给函数或方法。
在推断rest元组类型中的泛型参数时，TypeScript会根据传入的参数值来推断泛型参数的类型。例如，假设我们定义了一个rest元组类型[T, ...Rest]，其中T表示第一个元素的类型，Rest表示剩余元素的类型数组。当我们使用这个类型时，TypeScript会根据传入的参数值来确定T和Rest的具体类型。
下面是一个示例：
function processTuple<T, Rest extends any[]>(tuple: [T, ...Rest]) {
const [first, ...rest] = tuple;
console.log(`First element: ${first}`);
console.log(`Rest elements: ${rest}`);
}
processTuple(['a', 1, true]); // 推断 T 为 string，Rest 为 [number, boolean]在上面的示例中，我们定义了一个processTuple函数，它接收一个rest元组类型的参数tuple。在函数内部，我们使用解构赋值将元组的第一个元素赋值给first变量，将剩余元素赋值给rest变量。然后，我们打印出第一个元素和剩余元素。
当我们调用processTuple函数并传入一个包含字符串、数字和布尔值的元组时，TypeScript会推断出泛型参数T的类型为string，剩余元素的类型数组Rest的类型为[number, boolean]。
总结起来，推断rest元组类型中的泛型参数是指在TypeScript中根据传入的参数值来确定泛型参数的类型，以便在使用rest元组类型时能够正确地推断出元组中每个元素的类型。
相关·内容
我想使用一个函数来构造数组作为参数，其中每个元素可能是不同的类型。类型的顺序是相关的，我需要将它们的顺序保持为一个元组。有一种方法：
const create = <T>(spec: (...args: any[]) => T) => spec;
const result = create(() => ['a', 2, 'a'] as const);
type t = ReturnType<typeof result>; // t is ['a', 2, 'a']
但是，这意味着开发人员必
浏览 5提问于2020-05-06得票数 1
回答已采纳
考虑一下
public class Tuple<T1, T2>
{
public Tuple(T1 v1, T2 v2)
{
V1 = v1;
V2 = v2;
}
public T1 V1 { get; set; }
public T2 V2 { get; set; }
}
public static class Tuple
{
// MAGIC!!
public static Tuple<T1, T2> New<T1, T2>(T1 v1, T2 v2)
浏览 1提问于2009-12-02得票数 0
回答已采纳
我们一直试图在代码库中用流注释我们的高阶组件，但没有取得很大的成功。
我们有
adapt高级组件，它接受适配器作为参数。
adaptDataProp，它接受只在props.data对象上调用的dataAdapter
以下是未实现流的实现
function adapt(adapter) {
return (Component) {
return (props) => <Component {...adapter(props)} />;
};
}
function adaptDataProp(dataAdapter) {
浏览 2提问于2017-08-03得票数 1
我在打字稿方面很新，我有一个问题我不知道如何解决。
基本上，我想从组件列表中创建一个元组列表。元组的第一个元素是元素的名称(MyComponents的键)，第二个元素是它的属性。
(见下文代码)
interface MyComponents {
Container: {
fluid?: boolean
className?: string
},
Tag: {
text?: string
className?: string
hidden: boolean
}
}
//Get the keys o
浏览 3提问于2021-04-23得票数 1
1回答
看看，我看到了10个定义：
/**
* Creates a Promise that is resolved with an array of results when all of the provided Promises
* resolve, or rejected when any Promise is rejected.
* @param values An array of Promises.
* @returns A new Promise.
*/
all<T1, T2, T3>(values: [T1 | PromiseLike<T1>, T2
浏览 0提问于2019-02-11得票数 0
回答已采纳
1回答
我试图为数组的函数创建一个类型，根据输入数组是否为空，它可以返回不同的类型。
我尝试将条件类型与元组结合使用。
第一次尝试
export const lastElement = <T, U extends T[]>(array: U): U extends [T, ...T[]] ? T : null => {
return array[array.length - 1]
}
上面的代码返回以下错误：
Type 'T' is not assignable to type 'U extends [T, ...T[]] ? T : null'.
浏览 6提问于2022-11-14得票数 2
2回答
元组实现
、
我已经实现了一些版本的元组类，我真的想从中学到更多。
你能告诉我在我的实现中我遗漏的一些要点吗？
class My_tuple<T1, T2> : EqualityComparer<My_tuple<T1, T2>>
{
#region Virables
public T1 First { get; private set; }
public T2 Second { get; private set; }
#endregion
#region Constractors
public My_tup
浏览 0提问于2010-08-16得票数 2
回答已采纳
这段代码
function myFilter(debts:Map<string, number>) : Map<string, number>{
return new Map([...debts]
.map(d => [d[0], Math.round(d[1] * 10) / 10]) // error
.filter(d => d[1] != 0)
)
}
给出一个错误，因为表面上map()可以产生[string | number][][]。
但这确实有效：
function myFilter(debts:Map<strin
浏览 6提问于2022-09-29得票数 0
回答已采纳
import encodeParam from './encodeParam'
interface UrlParam<T> {
name: string
defaultValue: T
encode: (value: T) => string | null
decode: (value: string) => T
}
function buildQueryString<T>(...params: [UrlParam<T>, T][]) {
const searchParams = new URLSearch
浏览 12提问于2020-12-01得票数 1
回答已采纳
为了提高可读性，我简化了代码。
interface OwnProps<T extends ElementType> {
as?: T;
}
type Props<T extends ElementType> = OwnProps<T> & ComponentPropsWithoutRef<T>;
const Component = <T extends ElementType = 'button'>({as, ...rest}: Props<T>) => {
const T
浏览 6提问于2022-05-25得票数 2
1回答
假设我有以下泛型类：
public class Control<TItem>
{
public Control(TItem item)
{
}
}
当我试图将匿名类型的对象传递给构造函数时，编译失败：
var objectOfAnonymousType = new { Foo = "bar" };
// cannot compile:
var control1 = new Control(objectOfAnonymousType);
但是，如果我不是通过构造函数，而是通过类之外的泛型方法来实现这一点的，那么它似乎是有效的：
// can
浏览 4提问于2015-01-08得票数 2
回答已采纳
我读过这个答案，它演示了元组类型推断。经过一些实验，我遇到了这种情况。
当我们的tuple函数有T extends string[]时，元组具有字符串文本类型。
export const tuple_0 = <T extends string[]>(...args: T): T => args;
const ALL_SUITS_0 = tuple_0('hearts', 'diamonds', 'spades', 'clubs');
type T0 = typeof ALL_SUITS_0; // [
浏览 0提问于2018-12-20得票数 2
回答已采纳
1回答
假设我有一个泛型类：
class SomeClass<Element> {
// What is the difference between this:
var array: [SomeClass]!
// and this declaration:
var array2: [SomeClass<Element>]!
}
这些声明之间有什么区别？
浏览 1提问于2016-06-11得票数 2
回答已采纳
2回答
下面是用于测试Type扩展方法的类的片段：
class Something
{
[StringLength(100, MinimumLength = 1, ErrorMessage = "Must have between 1 and 100 characters")]
public string SomePublicString { get; set; }
}
我有以下扩展方法：
public static class TypeExtensions
{
public static TAttributeType GetCustomAttribute<T, TA
浏览 3提问于2013-04-04得票数 5
回答已采纳
Expression<T>是一个可以计算为T的类 class Expression<T> {
evaluate(): T {
// ...
}
} Expression有一个解析表达式的静态parse方法。它的第二个参数指示预期的类型，并确定返回的Expression的泛型类型 export interface RGBA {
r: number;
g: number;
b: number;
a: number;
}
interface TypeMap {
string: string;
number: number;
co
浏览 16提问于2021-08-20得票数 1
2回答
在查看github上的一些代码时，我遇到了以下模式：
using System.Linq.Expressions;
public T SomeGenericMethod<TValue>(Expression<Func<T, TValue>> myExpr){
// ...
}
这是代码中唯一相关的部分。TValue实际上从未在方法体中使用，它只存在于Func<,>类型中。
它的用途如下所示：
myObj.SomeGenericMethod(x => x.SomeProperty)
注意，在调用SomeGenericMethod时不
浏览 6提问于2015-04-20得票数 2
回答已采纳
我有以下(简化型)： interface RequestActionMeta<Data, TransformedData> {
getData?: (data: Data, currentData: TransformedData) => TransformedData;
}
interface RequestAction<Data = any, TransformedData = Data> {
type: string;
request: any | any[];
meta?: RequestActionMeta<Data, Tran
浏览 19提问于2021-03-24得票数 1
回答已采纳
类型记录可以推断受数组类型约束的一般rest参数的元组类型。但这在我的案子里行不通。我试图传递一系列对[function, argument]，并希望键入-检查参数和函数类型是否匹配。有可能吗？
type User = {
name: string
age: number
}
function eatNumber(a: number) { }
function eatString(a: string) { }
function eatUser(a: User) { }
type FuncAndArg<F extends (arg: any) => void>
浏览 4提问于2019-11-17得票数 1
回答已采纳
1回答
在Swift书的中有两个语法声明：
explicit-member-expression -> postfix-expression . decimal-digits
explicit-member-expression -> postfix-expression . identifier generic-argument-clause[opt]
第一个用于访问元组：
var tuple = (1, 2, 3)
tuple.1 = tuple.2
第二个用于访问其他成员，如属性和函数：
struct S {
var property = 0
fun
浏览 6提问于2016-02-14得票数 2
回答已采纳
LINQ中的FirstOrDefault() and FirstOrDefault<string>()有什么区别？
有人能给我一些简单的解释吗？
TypedDataSet ds= codeComponent.GetAllCode("test");
string status = (from s in ds.Codes
where s.Name == "hello"
select s.Remarks).FirstOrDefault();
TypedDataSet ds= codeC
浏览 0提问于2012-02-23得票数 1
回答已采纳
1回答
函数中的泛型参数
、、
我已经编写了一个通用方法，用于将字典的内容写入Excel工作表。泛型工作得很好，因为Excel对象是dynamic，因此它可以无缝地处理我扔到字典中的任何基本数据类型。
在这样做的过程中，我注意到在函数调用方式上，我发现了一些出乎意料的事情。我想在这里问一下，是否有一种更好的方法来处理这个问题。
以下是功能：
private void WriteDictionary<T,U>(Excel.Range startCell, int keyColumnOffset, int valueColumnOffset, Dictionary<T,U> dictionary)
{
浏览 0提问于2018-03-16得票数 1
回答已采纳
( TypeScript操场上的完整代码：.)
我有一个用于计算的Result<T, E>类型，它的值为T，或者由于E类型的错误而失败。
type Result<T, E> =
| {ok: true, value: T}
| {ok: false, value: E};
我想编写一个助手函数，它可以按顺序运行Result-returning函数的列表。如果任何函数失败，请停止处理并返回错误。如果全部成功，则返回成功值的列表。
下面是如何为长度为3的列表实现该函数：
function sequenceFixed<T1, T2, T3, E>(
浏览 1提问于2021-01-31得票数 1
回答已采纳
type Tuple = [];
const tup: Tuple = [
((a, b) = {
// a: number; tup 2th item
// b: boolean; tup 3th item
}),
1,
false,
// more item enble.
];
第一个项目是一个函数，参数类型是tulpe的其余部分。
我尝试定义元组，但代码错误“类型别名' Tuple‘循环引用自身”。
type Tuple = [(...args: any) => void, ...Parameters<Tuple[0]>
浏览 9提问于2022-11-25得票数 1
2回答
public delegate T GenDel<T>();
class Program
{
public static void genMet<T>(GenDel<T> d) { }
static void Main(string[] args)
{
genMet(new GenDel<string>(() => "Works"));
genMet(() => "Works");
}
}
在上面的示例中，泛型方法
浏览 2提问于2012-12-11得票数 4
回答已采纳
我正在编写一个Roslyn分析器，并且已经认识到需要知道元组的类型。我已经检索了TypeInfo，在调试器中我可以看到有一个TupleElements挂在这个类型上，这正是我所需要的。但是，它似乎只能通过转换到TupleTypeSymbol来访问。
((Microsoft.CodeAnalysis.CSharp.Symbols.TupleTypeSymbol)typeInfo.Type).TupleElements
TupleTypeSymbol是不可访问的，因为它的保护级别，所以转换是不可能的。还有其他途径可以获取信息吗？
在我的类型是一个开放的泛型的场景中，我有很多相同的问题:有什么方法可
浏览 1提问于2019-03-03得票数 1
回答已采纳
请参阅以下简单示例：
public static void main(String[] args) throws FileNotFoundException, IOException {
List<Integer> li = createList();//ok, this mean that ArrayList<Integer> was returned
List<Double> ld = createList();//ok, ArrayList<Double> was returned
}
public static <
浏览 4提问于2014-07-23得票数 2
回答已采纳
2回答
在Eclipse中使用JDK1.8时，以下行没有原始类型警告：
1) ArrayList<Double> d1 = new ArrayList<>();
但是有一个编译器警告：
2) ArrayList<Double> d2 = new ArrayList();
在语法上，唯一的区别是尖括号"<>“。但在这两种情况下都没有实际指定的类型。如果尖括号为空，是否推断为Double类型？
浏览 4提问于2015-09-21得票数 1
回答已采纳
1回答
Im不断收到这样的错误：“属性'value‘在’从不‘类型上不存在。”
interface InputProps {
name: string;
icon?: ReactElement;
placeholder?: string;
}
const Input = ({ name, icon: Icon, ...rest }: InputProps) => {
const inputRef = useRef(null);
const [isFocused, setIsFocused] = useState(false);
const [isFilled,
浏览 0提问于2021-11-30得票数 0
回答已采纳
1回答
泛型与非泛型重载调用
、、、
当我像这样声明一个方法时：
void DoWork<T>(T a) { }
void DoWork(int a) { }
用这个来调用它：
int a = 1;
DoWork(a);
它将调用什么DoWork方法?为什么？我似乎在任何MSDN文档中都找不到它。
浏览 0提问于2012-03-29得票数 8
回答已采纳
考虑下面的代码，我创建了一个类，它的构造函数接收带有泛型类型的参数，用于定义第二个参数所接收的参数的类型，在回调函数的参数下面是MouseEvent，因为第一个参数的值：
class MyClass<T extends keyof HTMLElementEventMap>{
constructor(tagName: T, lister: (ev: HTMLElementEventMap[T]) => any) { }
}
new MyClass("click", ev => { })
// ^^ (param
浏览 4提问于2021-02-01得票数 0
回答已采纳
每当eclipse中的源代码中缺少泛型时，它建议我“推断泛型类型参数...”
问题是我不认为“推断泛型类型参数...”有没有真正推断出任何东西。它通常不会提出任何建议。
它适用于哪些场景？它怎麽工作?
在一些情况下，可以“推断”一些东西-- eclipse仍然是空白的。
浏览 0提问于2012-11-30得票数 8
回答已采纳
2回答
假设我们有这样的代码：
interface Vehicle {
bicycle(): string;
car(wheel: number): void;
bus(passanger: number): {
name: string;
age: number;
}[];
}
type Mapper<K extends keyof Vehicle> = (funcName: K, callback: Vehicle[K]) => void;
interface MapperB {
<K extend
浏览 4提问于2020-11-30得票数 2
回答已采纳
你能以某种方式将@typeparam串起来吗？
例如，在此场景中，将TItem传递给子程序，而不指定它
预期行为：
<Parent TItem="User">
<Child>
</Parent>
当前：
<Parent TItem="User">
<Child TItem="User">
</Parent>
浏览 3提问于2021-06-16得票数 2
回答已采纳
2回答
Java推断的泛型类型
、、、
我正在寻找一个类似的概念来推断捕获的泛型类型，类似于下面的方法片段，但是对于捕获泛型类型的类：
public <X, Y, Z> static void someMethod(ObjectInterface<X, Y, Z> object) {
// code that uses inferred generic type parameters X, Y and Z...
}
此代码段中的代码将捕获类型并将它们分配给泛型参数类型X、Y和Z。这允许在代码正文中使用泛型类型变量，并使方法的使用更加灵活。在这个片段中，如果调用方法时没有指定类型(即没有参数化)，那么J
浏览 2提问于2017-10-20得票数 2
回答已采纳
1回答
Index.razor.cs：
我正在开发一个网格组件，它将向它显示一个项目列表：
<Grid Items="Transactions">
<GridHeader>
<GridColumn TItem="Transaction">ID</GridColumn>
<GridColumn TItem="Transaction">Date</GridColumn>
</GridHeader>
</Grid>
浏览 10提问于2022-11-18得票数 0
回答已采纳
2回答
我希望将对象限制为某种类型，但也希望将其转换为"as const"，以便可以按字面意思键入某些属性。但是，当我将"as const“与下面代码中的类型定义一起使用时，推断的类型不是文字类型- "as const”被忽略。
interface IFilterBase {
type: string
...
}
const COST_FILTER: IFilterBase = {
type: "cost",
...
} as const
在上面的代码中，"as const“被忽略。COST_FILTER.type被推断
浏览 1提问于2019-07-17得票数 6
在这个链接中，微软说，
不能实例化静态类。换句话说，您不能使用新关键字创建类类型的变量。因为没有实例变量，所以可以使用类名本身访问静态类的成员。
我学的静态类和上面提到的一样。但是对于在框架中引入的.NET，框架4可以使用新的关键字来创建一个元组。
可变人口=新的元组(“纽约”，7891957、7781984、7894862、7071639、7322564、8008278)；
有人能解释一下这怎么可能吗？
浏览 3提问于2012-02-17得票数 4
回答已采纳
3回答
我有两个LINQ-to-SQL列表，我使用以下命令将它们合并成一个列表：
var mergedList = List1.Union(List2);
我假设Union命令将消除列表中的所有副本。是那么回事吗？无论如何，我正在尝试将合并列表的内容写入csv文件。当我尝试在以下位置调用列表时遇到错误：
WriteToCSVFile cf = new WriteToCSVFile(mergedList);
这是我如何构造我的类的：
public WriteToCSVFile(IEnumerable<T> mergedList)
我在这里做错了什么？
顺便说一句，以下是我得到的错误：
The
浏览 0提问于2012-01-26得票数 0
回答已采纳
我注意到以下代码在使用java spec 1.7在eclipse中编译时有效，但在1.6中不起作用。
HashMap<String, String> hashMap = new HashMap<>();
我想要一个解释，但是这个语法和为什么它在1.7中工作。
浏览 0提问于2013-05-17得票数 10
回答已采纳
因此，我可以很容易地用JSON编写任意类型的Newtonsoft.Json。
type X = {
Number: decimal
Sequence: decimal
NumList: decimal list
}
let createItem (n, s, nL) =
{Number = n;
Sequence = s;
NumList = nL}
let items =
[
(1M, 1M, [1M; 2M; 3M])
(2M, 2M, [2M; 4M; 6M])
(3M, 3M, [3M; 6M;
浏览 1提问于2016-10-26得票数 1
回答已采纳
1回答
有一些类似的问题，但我似乎找不到我想要的东西。
有一个C#库(OpenCVSharp)声明如下所示的重载方法：
public static void CalcHist(Mat[] images,
int[] channels, InputArray mask,
OutputArray hist, int dims, int[] histSize,
Rangef[] ranges, bool uniform = true, bool accumulate = false)
{
....
}
publ
浏览 0提问于2015-09-22得票数 4
回答已采纳
因此，这个函数应该接受一个满足interface TransactionActionModel的对象数组。这意味着它们都必须有一个名为"save“的函数来接收interface SaveOptions的参数。
当前，此saveUsingTransaction函数的返回类型是Promise<any[]>。
interface TransactionActionModel {
save: ({ session }: SaveOptions) => any;
}
const saveUsingTransaction = async (
newEntities
浏览 8提问于2022-09-23得票数 0
2回答
从官方的JavaJDK1.7指南中，我得到了这个引用，但我不明白它是如何工作的。有人能解释吗？换句话说，当钻石传递空字符串时，钻石是如何推断出整数类型的？
MyClass myObject =新MyClass<>("")；
在本例中，编译器为泛型类MyClass的形式类型参数X推断类型Integer。它为这个泛型类的构造函数的形式类型参数T推断类型字符串。
浏览 5提问于2013-10-25得票数 1
回答已采纳
关于以下扩展方法：
public static class Extensions
{
public static void P<T>(this T value) { }
public static TResult F<T, TResult>(this T value)
{
return default(TResult);
}
}
当我尝试将它们与各种类型参数选项一起使用时，我得到了以下结果：
1.P(); // Compiler just fine
1.P<int>(); // R# says "Ty
浏览 1提问于2015-06-16得票数 0
这一行代码在下面的代码中意味着什么？
return Promise.<SimpleResult>pure //why is the dot
我是Scala和Java 6的新手，相关的主题/术语是什么？
如果框架找不到请求的操作方法，则将调用onHandlerNotFound操作：
import play.*;
import play.mvc.*;
import play.mvc.Http.*;
import play.libs.F.*;
import static play.mvc.Results.*;
public class Global extends GlobalSe
浏览 3提问于2014-02-14得票数 1
回答已采纳
4回答
看看这三个类。Minatchi允许自己进行扩展，因此它的方法的返回类型也可以扩展。为了说明这一点，我使用了静态方法。
public class Minatchi<T extends Minatchi<?>>{
static public <T extends Minatchi<?>>
List<T> listAll(){
return
(List<T>) query();
}
}
所以我把米纳奇细分为女士
public class Lady
extends Minatchi&l
浏览 0提问于2010-01-14得票数 5
回答已采纳
1回答
我试着写这个转换器来处理所有的类型。所以我用了仿制药。但是收到以下编译时错误。
error CS0411: The type arguments for method 'SomeConverter.ConvertToList<T>(ArrayLike)' cannot be inferred from the usage. Try specifying the type arguments explicitly.
在ConvertToList中不显式地声明类型是可能的吗？如果没有，为什么不能在泛型方法中推断T？
using System;
using System.
浏览 2提问于2014-02-19得票数 0
回答已采纳
5回答
这个语法我已经看过几次了，现在我开始担心了，
例如：
iCalendar iCal = new iCalendar();
Event evt = iCal.Create<Event>();
浏览 2提问于2008-11-20得票数 46
回答已采纳
我有以下节目：
open System
open MathNet.Numerics
open MathNet.Numerics.LinearAlgebra
//entropy
let entropy v =
let pct = v / v.Sum()
let l1 = pct.Map (fun x -> System.Math.Log(x, 2.0))
let p = Vector.map2 (fun x y -> x * y) pct l1
let e = - p.Sum()
e
[<EntryPoint>]
let ma
浏览 2提问于2014-11-19得票数 1
回答已采纳
考虑以下Delphi 2010中泛型实用程序类的声明：
TEnumerableUtils = class
public
class function InferenceTest<T>(Param: T): T;
class function Count<T>(Enumerable: TEnumerable<T>): Integer; overload;
class function Count<T>(Enumerable: TEnumerable<T>; Filter: TPredicate<T>): Inte
浏览 1提问于2010-04-26得票数 6
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
即时通信 IM
实时音视频活动推荐
腾讯云开发者
