问题[typescript](coding)

有没有办法声明一个 Typescript 函数，如果传入的值是静态已知为特定类型的，则会导致 tsc 拒绝对它的调用，否则接受调用？

在下面的示例中，我有一个包装传递值的函数，但如果传入的值已被包装，我希望该函数静态拒绝调用。

此时，我能做到的最好的事情是，如果传入了包装值，则使静态分析器期望函数返回的值为“从不”。

class WrappedValue<T> {
    constructor(readonly value:T) {}
}

function wrap<T>( value:T) : WrappedValue<T> {
    return new WrappedValue(value)
}

type SingleWrapped<RR> = RR extends WrappedValue<unknown> ? never : WrappedValue<RR>;

function wrap_strict<TT>(retvalIn:TT) : SingleWrapped<TT> {
    if (retvalIn instanceof WrappedValue) {
        throw new Error('strict failure')
    } else {
        //@ts-expect-error   TODO: How do we avoid the error below:   TS2322: Type 'WrappedValue<TT>' is not assignable to type 'SingleWrapped<TT>'.
        let retval  : SingleWrapped<TT> =  wrap<TT>(retvalIn);
        return retval;
      }
}

const xx1 = wrap_strict(2)
xx1.value
const xx2 = wrap_strict(wrap(3))
// TODO: is there a way to cause tsc to complain on the line above rather than the line below?
xx2.value   // tsc complains about this line because xx2  is of type  never

我正在将我的网站移植到 Astro - 它基本上运行良好，但有一个 TypeScript 错误，我无法找到适当的解决方案。

我的网站使用Utterances进行评论，这是通过页面内的脚本标签实现的，如下所示：

<script
    src="https://utteranc.es/client.js"
    repo="[ENTER REPO HERE]"
    issue-term="url"
    theme="github-light"
    crossorigin="anonymous"
    async></script>

这可以正常工作，但它会导致组件的类型检查失败，因为大多数属性都不是规范的一部分：

Type '{ src: string; repo: string; "issue-term": string; theme: string; crossorigin: string; async: true; }' is not assignable to type 'ScriptHTMLAttributes & AstroScriptAttributes & AstroDefineVarsAttribute'.
  Property 'repo' does not exist on type 'ScriptHTMLAttributes & AstroScriptAttributes & AstroDefineVarsAttribute'.

话语实际上应该data-在这里使用属性（我认为 TypeScript 可以很好地处理），但它已经好几年没有更新了，所以我认为它不会很快得到支持。

除了完全禁用该行的类型检查之外@ts-ignore，还有什么方法可以告诉 TypeScript 这是可以的吗？

我正在尝试在我的项目中创建一个 StompJS 集成，以便复用相同主题的连接和订阅。我正在使用 TypeScript，但遇到了一个问题，无论我做什么，TS 都会报错。​​如果我抑制它，代码就可以正常工作，但这感觉像是在作弊。

const RESULT_PARSER_BY_TOPIC = {
    '/topic/user': (value: string): { id: string } => JSON.parse(value),
    '/topic/game': (value: string): string => value,
    '/topic/messages': (value: string): number => parseInt(value, 10),
} as const;
type Topic = keyof typeof RESULT_PARSER_BY_TOPIC;
type ResultParser<_Topic extends Topic> = typeof RESULT_PARSER_BY_TOPIC[_Topic];
type Result<_Topic extends Topic> = ReturnType<ResultParser<_Topic>>;
type Consumer<_Topic extends Topic> = (value: Result<_Topic>) => void;
type Unsubscribable = { unsubscribe: () => void };
type Subscription<_Topic extends Topic> = {
    producer: Promise<Unsubscribable>;
    consumers: Set<Consumer<_Topic>>;
};
export type Unsubscribe = () => void;

const SUBSCRIPTION_BY_TOPIC: Partial<{
    [_Topic in Topic]: Subscription<_Topic> // I think problem is with this type
}> = {};

export function subscribe<_Topic extends Topic>(
    topic: _Topic,
    callback: Consumer<_Topic>
): Unsubscribe {
    if (SUBSCRIPTION_BY_TOPIC[topic] === undefined) {
        SUBSCRIPTION_BY_TOPIC[topic] = { // <-- I get the error here 
            consumers: new Set(),
            producer: subscribeToTopic(topic)
        } as Subscription<_Topic>;
    }
    SUBSCRIPTION_BY_TOPIC[topic].consumers.add(callback);
    return () => {
        // some clean up logic...
    };
}

所有这些的目标是拥有一个易于使用的订阅方法。它应该验证主题和消费者参数是否兼容：

subscribe('/topic/user', (value) => {...}); // should infere that "value" is { id: string }
subscribe('/topic/game', (value) => {...}); // should infere that "value" is string

//if parameter mismatch there should be an error
subscribe('/topic/messages', (value: boolean) => {...}); // <- error: "(value: number) => void" expected

但是，当我尝试将新的订阅分配到订阅映射时（当有人订阅新主题时，就会发生这种情况，否则我会重用现有的主题订阅），我用它来跟踪该主题是否仍有活跃订阅者（在清理逻辑中：如果最后一个订阅者取消订阅，我也会取消订阅该主题），出现了类型错误。错误如下：

TS2322:
Type Subscription<_Topic> is not assignable to type Partial<{
    "/topic/user": Subscription<"/topic/user">;
    "/topic/game": Subscription<"/topic/game">;
    "/topic/messages": Subscription<"/topic/messages">;
}>[_Topic]

Type Subscription<_Topic> is not assignable to type Subscription<"/topic/user"> & Subscription<"/topic/game"> & Subscription<"/topic/messages">

Type Subscription<_Topic> is not assignable to type Subscription<"/topic/user">

Type _Topic is not assignable to type "/topic/user"

Type "/topic/user" | "/topic/game" | "/topic/messages" is not assignable to type "/topic/user"

Type "/topic/game" is not assignable to type "/topic/user"

这行代码特别让我困惑：

Type Subscription<_Topic> is not assignable to type Subscription<"/topic/user"> & Subscription<"/topic/game"> & Subscription<"/topic/messages">

就好像 TS 无法解析我试图为特定键分配值，而不是映射中的任何键。

我尝试将代码的不同部分强制转换为相应的类型，但没有任何有意义的结果。“有效”的做法是将“Subscription.consumers”类型更改为 Set<any>：

type Subscription = {
    producer: Promise<Unsubscribable>;
    consumers: Set<any>;
};

但我想避免这种情况，这个 TS 项目的全部意义在于让我学习如何更好地使用 TS。

我以为我已经解决了这个问题，但现在我又遇到了这个问题。

考虑一下这个联盟：

type Handler<T> = (value: T) => void;
type Foo = { a: string; b: Handler<string> } | { a : number; b: Handler<number> }

给定一些对象x遵循Foo 我希望能够做到

x.b(x.a);

而不会出现以下错误：

Argument of type 'string | number' is not assignable to parameter of type 'never'.
  Type 'string' is not assignable to type 'never'.(2345)

这是我一直在探索的一次尝试，但并没有产生不同的结果：

type Handler<T> = (value: T) => void;
type Correlated<A> = A extends string ? Handler<string> :
                     A extends number ? Handler<number> :
                     never;

type Foo<A extends string | number = string | number> = {
  a: A;
  b: Correlated<A>;
};

function apply<T extends Foo<A>, A extends string | number = T["a"]>(x: T) {
  x.b(x.a);
}

有没有办法从Foo.a的类型缩小到属性Foo.b的正确相关类型？

假设我有这样的东西：

type TIn = {
    xa?: number;
    xb?: string;
    xc?: boolean;
    // ...
}

type TOut = {
    ya: number | undefined;
    yb: string | undefined;
    yc: TPerson | undefined;
    // ...
}

type TPerson = {
    name: string;
    age: number;
}

function fn(input: TIn): TOut {
    // ...
}

现在，假设我想强制对输入字段进行静态可空性检查。例如：

• 当xa为 a 时number，相关的ya也为 a number；

• 既xa然 有undefined,ya也 将 有undefined;

• 当xb为 时string，相关的yb可以是string或undefined；

• 既xb然 有undefined,yb也 将 有undefined;

等等。

在 C# 中，有特殊的属性来指示编译器如何静态检查可空性。

https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/attributes/nullable-analysis

我想知道 TypeScript 中是否有任何“代理”（我的意思是使用类型和实用程序）来实现更完整的可空性检查。

此外，这不是针对“此示例”的定制解决方案，而是针对任何情况使用的模块化工具。

编辑：这是一次尝试解决，虽然不起作用，但为了清楚起见添加。

以下是所谓的帮助者：

//maps TResult when T1 is not undefined
//undefined otheriwse
type TNotNull<T1, TResult> = T1 extends {}
    ? TResult
    : undefined;

//maps TResult | undefined when T1 is not undefined
//undefined otheriwse
type TMaybeNull<T1, TResult> = T1 extends {}
    ? TResult | undefined
    : undefined;

//maps TResult when both T1 and T2 are not undefined
//undefined otheriwse
type TNotNullWhenBoth<T1, T2, TResult> = T1 extends {}
    ? T2 extends {} ? TResult : undefined
    : undefined;

可能还有更多（更多参数、更复杂的逻辑等）

现在，作为示例，让我们定义函数的输入契约：

type TIn = {
    a?: number;
    b?: number;
    s?: string;
}

对于输出类型，我们的想法是使用假定的助手来组成它：

type TOut<T extends TIn> = {
    inv_a: TNotNull<T["a"], number>;
    flag: TMaybeNull<T["b"], boolean>;
    str: TNotNull<T["s"], string>;
    sum: TNotNullWhenBoth<T["a"], T["b"], number>;
}

也就是说inv_a：

• 当a是数字时，inv_a也是数字
• 当a未定义时，inv_a也是未定义的

为了flag：

• 当b为数字时，flag为布尔值或未定义
• 当b未定义时，flag也是未定义的

对于str，类似地inv_a：

• 当s是字符串时，str也是字符串
• 当s未定义时，str也是未定义的

对于sum，逻辑与 相同inv_a，但两个参数进行 AND 运算：

• 当和都是a数字b时，sum也是数字
• sum否则将未定义

最后，让我们编写函数。在这里，实现并不重要。在函数外部，我们只需要始终满足输入/输出契约即可。

const flags: Array<boolean> = new Array(10);
flags[3] = true;

function fn(input: TIn): TOut<TIn> {
    const { a, b, s } = input;
    //just an example of implementation
    const inv_a = typeof a === "number"
        ? 1 / a
        : void 0;
    const flag = typeof b === "number"
        ? flags[b]
        : void 0;
    const str = typeof s === "string"
        ? s + "hello!"
        : void 0;
    const sum = typeof a === "number" && typeof b === "number"
        ? a + b
        : void 0;
    return { inv_a, flag, str, sum }
}

此时，这里有一些使用案例以及预期结果推断的方式：

//expected inference: all undefined
//actual inference: inv_a:number|undefined; flag:boolean|undefined; etc
const { inv_a, flag, str, sum } = fn({});

//expected inference: flag:boolean | undefined; rest undefined
//actual inference: inv_a:number|undefined; flag:boolean|undefined; etc
const { inv_a, flag, str, sum } = fn({ b: 3 });

//expected inference: inv_a:number; str:string; flag, sum:undefined
//actual inference: inv_a:number|undefined; flag:boolean|undefined; etc
const { inv_a, flag, str, sum } = fn({ a: 5, s: "xyz" });

//expected inference: inv_a, sum:number; flag, str:undefined
//actual inference: inv_a:number|undefined; flag:boolean|undefined; etc
const { inv_a, flag, str, sum } = fn({ a: 5, b: 3 });

不幸的是，它不起作用。

我设计了一个函数来在无限（或未知）嵌套的对象数组中搜索对象。

我的设计：

const findActualParent = (parentId:Number, serviceList: Service[] | Service) =>{
    for (const service of serviceList){
        if(service.id == parentId){
            return service
        }
        if(service.children?.length>0){
            let actualParent: Service = findActualParent(parentId, service.children)!
            return actualParent!
        }
    }
    return null
}

这个函数（以及我的应用程序）运行良好，直到我尝试构建应用程序进行部署（npm run build）。它无法构建，并出现引用我的新函数的 TypeScript 错误：

Type must have a '[Symbol.iterator]()' method that returns an iterator

我花了很多时间研究这个问题，大多数答案都建议在我的compilerOptionsin中添加不同的 ES 版本tsconfig。尝试了多个版本，但没有一个适合我（我的选择是["dom", "dom.iterable", "esnext"]）。

然后我在网上偶然发现了另一篇帖子，跟我的问题有点无关。它与数组上的展开运算符有关，但我在我的实现中尝试了一下。它有效吗？我用下面的代码更新了我的搜索循环：for (const service of serviceList as any[])

所以本质上，我把一个严格类型的数组传入函数，然后在函数内部撤销该类型。通过这样的修改，应用程序的构建和部署都非常顺利。

有人能解释一下为什么这个方法有效吗？或者我迭代类型数组的方法是否错误？如果错误，请提出一个无论 ES/TS 版本如何都能正常工作的解决方案。

谢谢

我正在尝试创建一个可以将任何属性类型从一种类型转换为另一种类型的泛型。如果我使用新的转换类型创建新对象，则此方法有效；但如果我尝试使用旧的接口类型进行动态转换，则会抛出错误：

代码：

export type ConvertTypes<B, F, T> = { [K in keyof B]: B[K] extends F ? T : B[K] }
export type ConvertStringToDate<T> = ConvertTypes<T, string, Date>

interface ITest {
  aa: number;
  bb: string;
  cc: Date;
}

// Working
const test :ITest = {
  aa: 1,
  bb: 'test',
  cc: new Date()
}

// Working
const test2: ConvertStringToDate<ITest> = {
  aa: 1,
  bb: new Date(),
  cc: new Date()
}

let test3: ConvertStringToDate<ITest>

// Not Working
for (let field of Object.keys(test)) {
  test3[field] = typeof test[field] === 'string' ? new Date() : test[field]
}

错误：

Element implicitly has an 'any' type because expression of type 'string' can't be used to index type 'ConvertTypes<ITest, string, Date>'.
  No index signature with a parameter of type 'string' was found on type 'ConvertTypes<ITest, string, Date>'.
Element implicitly has an 'any' type because expression of type 'string' can't be used to index type 'ITest'.
  No index signature with a parameter of type 'string' was found on type 'ITest'.
Element implicitly has an 'any' type because expression of type 'string' can't be used to index type 'ITest'.
  No index signature with a parameter of type 'string' was found on type 'ITest'.

经过测试的代码应该可以正常工作，并将值从test变量转换为新变量test3。

当编写与 DOM/Node 无关的脚本时，将文件types的属性设置为 很有帮助，以确保您不会意外使用任何特定于环境的全局变量。tsconfig[]

不幸的是，console这被认为是全球性的。

据我所知，如果不拖入一堆其他东西，就没有任何价值可以进入lib包括。console

有没有办法只用 tsconfig 来实现这个？还是我只需要创建一个d.ts描述控制台的文件并使用它？

我浏览了https://www.typescriptlang.org/tsconfig/#lib上的 lib 文档，但在那里（或相关源代码中）没有看到任何定义Console接口的内容。

这是我的 TypeScript 代码：

// Enum
enum Direction {
    North = 1,
    East,
    West,
    South
}

console.log(Direction.East);

// Literal types
function yesOrNoQuestion(ans: "yes" | "no"): void {
    console.log("You said", ans);
}

yesOrNoQuestion("yes");

// Tuple
type rgb = [red: number, green: number, blue: number];
const color: rgb = [10, 255, 255];
console.log(color);

const tuple: [boolean, string] = [true, "yes"];
console.log(tuple);

这是编译后的代码：

"use strict";
// Enum
var Direction;
(function (Direction) {
    Direction[Direction["North"] = 1] = "North";
    Direction[Direction["East"] = 2] = "East";
    Direction[Direction["West"] = 3] = "West";
    Direction[Direction["South"] = 4] = "South";
})(Direction || (Direction = {}));
console.log(Direction.East);
// Literal types
function yesOrNoQuestion(ans) {
    console.log("You said", ans);
}
yesOrNoQuestion("yes");
const color = [10, 255, 255];
console.log(color);
const tuple = [true, "yes"];
console.log(tuple);

我的 TS 代码中有 3 条注释（枚举、字面量类型和元组）。但是，编译后的代码只有前两条注释。这有什么原因吗？TS 应该保留所有注释或删除所有注释。为什么只删除特定的注释？

我没有在我的中明确设置“removeComments” tsconfig.json：

{
    "compilerOptions": {
        "target": "ES6",
        "strict": true,
        "strictNullChecks": true,
        "strictFunctionTypes": true,
        "alwaysStrict": true
    }
}

我使用npx tsc命令进行编译。

我期望的是：

• 保留所有三条评论，或者
• 删除所有三条评论

但是 TypeScript 只保留了前两个。我没有明确设置“removeComments”。

所以，我想知道：

• TypeScript 是否有任何规则或逻辑来保留/删除某些评论？
• 这是由于优化或代码转换造成的吗？
• 或者这只是一个配置问题？

我编写了一个函数，它返回一个解决世界饥饿问题的函数，但前提是仍然有人饥饿，否则返回空。

当且仅当有人仍然感到饥饿时，才会创建内部函数，并将其包含在是否仍然感到饥饿的 const 变量中。

在执行此函数期间，我们从逻辑上知道变量已被缩小为true或"fileNotFound。

@ahejlsberg 在问题 #56908 中承认它应该可以工作：

我们目前在闭包中保留 const 变量的类型改进

但TypeScript 却抱怨。

操场上展示的类型：

type IsStillHungry = true | false | 'fileNotFound' | undefined

function solveWorldHungerStrategy(opts: { isAnyoneStillHungry: IsStillHungry }) {

  const condition = opts.isAnyoneStillHungry

  if (condition) {
    
    condition
    // ^? const condition: true | "fileNotFound"

    function pretendToSolveWorldHunger() {

      condition
      // ^? const condition: boolean | "fileNotFound" | undefined

    }

    return pretendToSolveWorldHunger

  }

  return null

}