小编And*_*sta的帖子

异步生成器使用内部队列来处理next，throw和return方法的同步调用。

我试图构造一种情况，其中此队列对于成功进行迭代本身是必需的。因此，我正在寻找某些情况，而没有自定义重新实现队列的手动实现异步迭代接口是不够的。

以下是一个示例，但是效果不是很好，因为不能保持一般的时间一致性，但是迭代结果在每个步骤中都是正确的：

function aItsFactory() {
    let i = 1;
    return {
        async next() {
            if(i > 5) return Promise.resolve({ value: void 0, done: true });
            const res = await fetch(`https://jsonplaceholder.typicode.com/posts/${i++}`).then(x => x.json());
            return Promise.resolve({ value: res, done: false });
        },
        [Symbol.asyncIterator]() { 
            return this;
        }
    }
}

const ait = aItsFactory();


// general time consistency is lost, because e.g. the fourth call
// is started with the previous three and it …

我已经理解了这样的事情：

type GenericExample<T> = T extends (infer U) ? U : 'bar';

等于：

type GenericExample<T> = T extends T ? T : 'bar';

但是当事情变得更加复杂时，TypeScript 会抱怨：

type Types = 'text' | 'date' | 'articles' | 'params';

type MyExperiment<Type extends Types> =  { t : Type };

type MyExperimentsUnion = Types extends (infer U) ? MyExperiment<U> : never;
// Type 'U' does not satisfy the constraint 'Types'.
// Type 'U' is not assignable to type '"params"'.

所以我想问一下为什么这是错误的：在这种特殊情况下应该发生联合分布，所以推断的U类型应该是text，然后date …

我正在做一个项目,我遇到了一个问题.我将向您展示以下演示示例:

这是css代码:

    *, *::after, *::before {
    box-sizing: border-box;
    margin: 0;
    border: 0;
}

@media only screen and (max-width: 600px) {
    div {
        background: blue;
    }
}


@media only screen and (min-width: 601px) and (max-width: 1000px)  {
    div {
        background: green;
    }
}


@media only screen and (min-width: 1001px) {
    div {
        background: red;
    }
}

所以我的div应该是:

• 蓝色从0px到600px
• 绿色从601px到1000px
• 红色从1001px到...

相反,它是:

• 蓝色从0px到600px
• 白色在601px
• 绿色从602px到1000px
• 白色在1001px
• 红色从1002px到...

为什么？似乎(min-width:)不具有包容性.

所以我尝试过:

    *, *::after, *::before {
    box-sizing: border-box;
    margin: 0;
    border: 0;
} …

我无法正确地将任意长度元组的第一种类型推断为元组类型，以维护其标签：

type First1<T extends any[]> = T extends [infer FIRST, ...any[]] ? FIRST : never

type test1 = First1<[a: number, b: boolean, c: string]> // number


type First2<T extends any[]> = T extends [infer FIRST, ...any[]] ? [FIRST] : never

type test2 = First2<[a: number, b: boolean, c: string]> // [number] <-- obv no label


type First3<T extends any[]> = T extends [...infer FIRST, any, ...any[]] ? FIRST : never

type test3 = First3<[a: number, b: boolean, c: string]> // …

为什么班级母亲无法从班级孙女那里进入,如果班级女儿(孙女从哪个继承)继承了班级母亲,并且访问说明符设置为私人？我无法创建对象或指针.为什么？这种行为背后的逻辑是什么？如果我在孙女班中使用母亲物品会有什么问题？并且,连接到最后一个问题,为什么如果类女儿从类母亲继承并且访问说明符设置为PUBLIC或PROTECTED,我可以创建一个母对象到孙女类？这些问题不会回复给我吗？

#include <iostream>
#include <stdio.h>

using namespace std;

class mother
{
    public:
        mother(){};
};

class daughter : private mother
{
    public:
        daughter(){};
};

class granddaughter : public daughter
{ 
    public:
        granddaughter(){}; // ERROR
        mother* mother; // ERROR
};


int main(void){return 0;}