小编Nur*_*yev的帖子

所以我添加了这个设置

"typescript.tsserver.log": "verbose"

现在日志位于哪里？我已经搜索过/var/log但~/.config/Code/...没有成功。

我们的代码库使用许多向量。其中一些向量彼此共享对象，即它们包含std::shared_ptr共享对象。问题是：代码库仍处于活跃的开发阶段，通常需要将一些包含值的向量重写为包含共享指针的向量。这很乏味。所以我想出了一个想法：简单地将所有向量作为共享指针的向量。

问题是：可以吗？我应该注意哪些注意事项？会出现什么问题？

我做了一些简单且可能幼稚的测量，在初始化和查询值向量和共享指针向量时，它们之间的性能实际上没有区别。

如果性能不是问题，还有什么我应该注意的吗？

假设我有一个用 Rust 编写的程序和另一个用 C++ 编写的程序。鉴于它们都被编译为 Wasm，我可以以某种方式从另一个程序中调用一个函数吗？

我有一个像这样的大型:

type Large = {
    foo: 123,
    bar: 123,
    baz: 123
} | {
    foo: 123,
    bar: 123,
    baz: 123
} | {
    foo: 123,
    bar: 123,
    baz: 123
} | {
    foo: 123,
    bar: 123,
    baz: 123
} | {
    foo: 123,
    bar: 123,
    baz: 123
} | {
    foo: 123,
    bar: 123,
    baz: 123
} | {
    foo: 123,
    bar: 123,
    baz: 123
} | {
    foo: 123,
    bar: 123,
    baz: 123
} | {
    foo: 123,
    bar: …

为什么这会产生错误“其余元素类型必须是数组类型。”？

type QWE<T extends [number, string]> = [boolean, ...T]
                                                 ^^^^ the error is here

我有一个重载的函数：

interface FunctionWithOverload {
    (): {
        a: 1
        b: 1
    }

    <T>(arg: T): {
        a: 1
        b: 1
    } & (T extends number ? { c: 1 } : {})
}

const fwo: FunctionWithOverload = () => {return {} as any}

const result = fwo() // result has a nice type: {a: 1, b: 1}
const result1 = fwo(1) // result1 does not: {a: 1, b: 1} & {c: 1}

操场

如果将鼠标悬停在 上，您可以看到工具提示中result有一个很好的 type ，但有一个丑陋的 type 。{a:1,b:1} …

我原来的问题是这样的。

我做了以下类型，但由于循环引用错误它不起作用，我不知道如何解决它：

type Increment<T extends number, Tuple extends any[] = [any]> = 
T extends 0 ? 1 :
T extends 1 ? 2 :
T extends TupleUnshift<any, Tuple> ? 
TupleUnshift<any, TupleUnshift<any, Tuple>>['length'] :
Increment<T, TupleUnshift<any, TupleUnshift<any, Tuple>>>

最后它应该像这样工作：

type five = 5
type six = Increment<five> // 6

PSTupleUnshift来自这里。

这段代码：

let s = String::from("hi");

for (idx, ch) in s.chars().rev().enumerate() {
    println!("{} {}", idx, ch);
}

版画

let s = String::from("hi");

for (idx, ch) in s.chars().rev().enumerate() {
    println!("{} {}", idx, ch);
}

但我想知道真实的索引，以便它可以打印：

0 i
1 h

最好的方法是什么？目前，我只想到先从中获取.count()和减去每个对象idx，但是也许有一种更好的方法被我忽略了。

这段代码：

玩

fn main() {
    let text = "abcd";

    for char in text.chars() {
        if char == 'b' {
            // skip 2 chars
        }
        print!("{}", char);
    }
    // prints `abcd`, but I want `ad`
}

打印abcd，但如果b要找到，我想跳过2个字符，以便打印ad。我怎么做？

我试图将迭代器放入循环外的变量中，并在循环内操作该迭代器，但借阅检查器不允许这样做。

例子：

function a(...args: ???type of b() params???) {
  b(...args)
}

我想args成为 的b参数类型。

如果你想知道为什么我想要这个，那么它是为了代码可读性/封装。b是ed 函数，我不关心它在函数声明import层面的实现a