Typescript: typeof this.xxx fornece o erro "identificador esperado".

eu diria que nenhum dos dois ... é apenas uma sintaxe errada ... tente "var copy = typeof (this.data = {});" ... tendo dito isso, eu não usaria este código ... é confuso .. .

@giancarloa hmm, você não deve adicionar esses colchetes. o código acima é apenas um gatilho de problema mínimo, não o código em produção. Em algumas situações, você pode querer usar um código como este.

aqui, se você levar this para qualquer coisa diferente disso, tudo bem e nenhum erro será relatado. por exemplo

class Test {
    static data = {};
    constructor() {
        var copy: typeof Test.data = {};
    }
}

De acordo com as especificações

_TypeQueryExpression: _
_Identificador_
_TypeQueryExpression_ . _IdentifierName_

Portanto, isso é esperado.

Acho que não é permitido porque algo assim

function foo() {
    var x: typeof this.x;
}

é perfeitamente válido, porque this mais ou menos tem o tipo any . Portanto, embora possa fazer sentido em uma classe, não faz sentido em nenhum outro contexto, a menos que tenhamos # 229.

@DanielRosenwasser OO hmm ... então espero que você considere atualizar as especificações. ri muito.

É algo a se considerar; se seus membros não forem particulares, você pode facilmente contornar isso com o seguinte nesse meio tempo.

self = this;
var x: typeof self.data;

Esperando por este recurso.
Acho que o caso mais simples deve ser apoiado
var a: typeof this.x = 1;

E um tipo recursivo de membro deve levar ao erro.

Obrigado.

Parece que isso deve funcionar se mudarmos a gramática.

@RyanCavanaugh , mas é apropriado permitir no contexto que dei? Isso inevitavelmente levará as pessoas a fazerem isso e receberem any como seu tipo.

Sintaticamente correto não significa que deveria realmente fazer sentido, IMO.
um aviso pode ser feito para essa causa, no entanto.

Já deixamos você escrever typeof foo.bar onde foo é do tipo any , e já deixamos você escrever this.x em outras posições de expressão pontilhada quando o tipo de this é any . Não vejo por que seu cruzamento em typeof this.x merece uma exceção.

Apenas para adicionar outro caso de uso. Algum tempo atrás eu fiz as definições de tipo para lodash e algumas das assinaturas suportadas são realmente apelidos para outros métodos. Eu os havia declarado assim:

interface LoDashArrayWrapper<T> {
    rest(): LoDashArrayWrapper<T>;
    rest(
        callback: ListIterator<T, boolean>,
        thisArg?: any): LoDashArrayWrapper<T>;
    rest(n: number): LoDashArrayWrapper<T>;
    rest(pluckValue: string): LoDashArrayWrapper<T>;
    rest(whereValue: {}): LoDashArrayWrapper<T>;

    drop: typeof rest;

    tail: typeof rest;
}

Isso funcionou bem com a versão 1.0 do compilador. Mas ele não compila mais. E não vejo nenhuma outra opção além de duplicar todo o conjunto de assinaturas para cada alias, pois não consigo pensar em um TypeQueryExpression que expresse isso.

@juanevp E quanto à interface de funções?

interface LoDashArrayWrapper<T> {
    rest: LoDashArrayWrapperOperation<T>;
    drop: LoDashArrayWrapperOperation<T>;
    tail: LoDashArrayWrapperOperation<T>;
}

interface LoDashArrayWrapperOperation<T> {
    (): LoDashArrayWrapper<T>;
    (
        callback: ListIterator<T, boolean>,
        thisArg?: any): LoDashArrayWrapper<T>;
    (n: number): LoDashArrayWrapper<T>;
    (pluckValue: string): LoDashArrayWrapper<T>;
    (whereValue: {}): LoDashArrayWrapper<T>;
}

Aprovado. Deve ser extremamente fácil consertar? Certifique-se de que isso não cause a emissão de _this = this nas funções de seta, embora

Isso está relacionado? Eu recebo [ts] Identifier expected. com o seguinte:

class UserState {
    <strong i="7">@observable</strong> state = {
        name : "",
        id : "",
    };

    <strong i="8">@action</strong>
    changeUser(user: typeof this.state) { // Error is here
        Object.assign(this.state, user);
    }
}

export const userState = new UserState();

Seria útil poder usar this.state no caso acima.

Hmmm Acabei de encontrar este problema :(

Estou definindo um objeto em minha classe.
Então estou definindo outro objeto que tem um parâmetro de tipo que precisa ser o tipo acima.

thing = {
    a: 1,
    b: 2
};
multi: CMultiDataset<typeof this.thing>;

Nesse caso, não é apropriado apenas mudar para uma variável estática e dizer typeof ClassName.thing porque será diferente em cada instância. Além disso, multi precisa ser uma variável de classe e, portanto, deve ter seu tipo no momento da declaração da classe.

@RyanCavanaugh @DanielRosenwasser @mhegazy parece ser uma solução relativamente fácil? Parece que perdeu a atenção com o passar dos anos ... Alguma chance de ser implementado?

@ sam-s4s hoje em dia você deve ser capaz de escrever CMultiDataset<this["thing"]> , ao invés. Os acessos indexados _do_ funcionam com this (polimórfico, mesmo), ao contrário de typeof .

Obrigado @weswigham - Eu descobri que posso fazer CMultiDataset<ClassName['thing']> que principalmente me tira de problemas :)

Não consegui encontrar nenhuma combinação usando this que funcionasse ...

@ sam-s4s hoje em dia você deve ser capaz de escrever CMultiDataset<this["thing"]> , ao invés. Os acessos indexados _do_ funcionam com this (polimórfico, mesmo), ao contrário de typeof .

Acabei de tentar, mas não funciona no TypeScript 3.4.4, no entanto, o do @ sam-s4s funciona ( ClassName['thing'] ). Acho que faria mais sentido this funcionar, em vez de apenas poder usar o "ClassName"?

Se eu tiver algo como
`` `texto datilografado
public groupByTypes = ['Nenhum', 'Foo', 'Bar'] como const;

public groupBy: typeof groupByTypes [número];
`` What is the proposed workaround? And I cannot make groupByTypes` estático