Ignorer certains Tapuscrit des erreurs de compilation?

Je me demandais si il existe un moyen d'ignorer certains Tapuscrit des erreurs lors de la compilation?

J'ai pratiquement les mêmes problèmes, la plupart des gens avec de grands projets ont autour de l'aide de l' ce mot-clé, et je ne veux pas mettre toutes mes classes, méthodes dans le constructeur.

Donc, j'ai eu un exemple comme:

Tapuscrit Exemple

Qui semble créer parfaitement valide JS et me permet d'obtenir autour de la ce mot clé en question, mais comme vous pouvez le voir dans l'exemple le tapuscrit compilateur me dit que je ne peut pas compiler ce code comme le mot-clé ce n'est pas valable dans ce champ d'application. Cependant, je ne vois pas pourquoi c'est une erreur car il produit bon code.

Donc, il y a une façon de dire de l'ignorer certaines erreurs? Je suis certain moment donné il y aura une belle façon de gérer la ce mot-clé, mais pour l'instant je le trouve assez désastreuse.

== Edit ==

(Ne pas lire, à moins que vous vous souciez de contexte de cette question et partielle coup de gueule)

Juste pour ajouter un peu de contexte à tout cela pour montrer que je ne suis pas juste un peu de noix-emploi (je suis sûr que beaucoup d'entre vous pense toujours que je suis) et que j'ai quelques bonnes raisons pourquoi je veux être en mesure de permettre à ces erreurs de passer à travers.

Voici quelques questions précédentes, j'ai fait qui mettent en évidence certains des problèmes majeurs (omi) avec Tapuscrit actuel ce mise en œuvre.

À l'aide de lawnchair avec Tapuscrit

Problème avec enfant de délimitation de l'étendue de ce en caractères d'imprimerie

https://typescript.codeplex.com/discussions/429350 (Et certains commentaires que je fais en bas)

Le problème sous-jacent que j'ai est que j'ai besoin de garantir que la logique est à l'intérieur d'un uniforme de la portée, j'ai besoin d'être en mesure d'accéder à des choses à l'intérieur de knock-out, jQuery etc et les locaux de l'instance d'une classe. J'ai utilisé pour ce faire avec le var self = this; dans la déclaration de classe en JavaScript et bien travaillé. Comme mentionné dans certaines de ces questions je ne peux pas le faire maintenant, donc la seule façon que je peux vous garantir que le champ est à utiliser lambda méthodes, et la seule façon que je peux définir l'un de ces comme une méthode dans une classe est dans le constructeur, et cette partie est FORTEMENT vers le bas à la préférence personnelle, mais je trouve ça horrible que les gens semblent penser que l'utilisation de cette syntaxe est classé comme un modèle recommandé et pas juste un travail autour de.

Je sais que la Machine est en phase alpha et beaucoup de choses vont changer, et j'ESPÈRE tellement que nous avons un peu plus agréable façon de traiter avec ce mais actuellement je soit faire tout ce qui est un énorme gâchis juste pour obtenir tapuscrit de travail (et c'est dans des Centaines de fichiers dont je suis la migration vers de la Machine ) ou je viens de faire l'appel que je connais mieux que le compilateur dans ce cas (TRÈS DANGEREUX, je le SAIS) donc je peux garder mon code de nice et j'espère quand un meilleur modèle qui vient de sortir pour la manipulation de ce que je peux migrer ensuite.

Aussi juste sur une note de côté, je sais que beaucoup de gens aiment le fait que la Machine est en embrassant et en essayant de rester aussi près de la nouvelle les fonctions JavaScript et connu de la syntaxe que possible, ce qui est grande, mais la machine n'est PAS la prochaine version de JavaScript donc je ne vois pas de problème avec l'ajout de certaines sucre syntaxique de la langue que les gens qui veulent utiliser la plus récente et la plus officielle JavaScript mise en œuvre peut encore le faire.

Pourquoi êtes-vous désireux d'écrire avec cette syntaxe de la fonction normale de la syntaxe? Liés code est assez grave compromis en termes de performance/de la mémoire; il serait bon de comprendre pourquoi.
Je vais faire un edit pour donner un contexte à présent, je n'aime pas les déclarations de méthode dans le constructeur, et en raison de knock-out, Jquery, Lawnchair et d'autres bibliothèques-je utiliser jouer avec le ce contexte de partout, je dois mettre presque chaque méthode dans le constructeur pour être en mesure d'accéder à la ce instance de la classe, mais je n'aime pas du tout cette approche et que vous voulez être en mesure de simplement accéder à cette instance en dehors du constructeur. Comme la méthode normale syntaxe de déclaration public someMethod(): string { return "hello"; } ne garantit pas la ce, mais lambdas ne.

OriginalL'auteur Grofit | 2013-04-15

6

L'auteur de la question spécifique avec this semble être résolu, mais la question est posée sur l'ignorer les erreurs, et pour ceux qui se retrouvent ici en regardant comment ignorer les erreurs:

Si correctement la fixation de l'erreur ou de l'utilisation de plus décent, des solutions de contournement comme déjà suggéré ici ne sont pas une option, comme de Tapuscrit 2.6 (sorti le 31 octobre 2017), il y a maintenant une façon d'ignorer toutes les erreurs de la ligne à l'aide de //@ts-ignore commentaires avant de la ligne de cible.

Le mendtioned documentation est assez succincte, mais pour résumer:
```
//@ts-ignore
const s : string = false
```
désactive les rapports d'erreur à cette ligne.

Cependant, cela ne devrait être utilisé qu'en dernier recours lors de la correction de l'erreur ou de l'utilisation de hacks comme (x as any) est beaucoup plus de mal que de perdre tous type de vérification pour une ligne.

Que, pour préciser certaines erreurs, le courant (de la mi-2018) est abordé ici, dans la Conception des Notes de Réunion (2/16/2018) et d'autres commentaires, qui est essentiellement

"aucune conclusion encore"

et de la forte opposition à l'introduction de cette fine tuning.

Comme mentionné TS a changé une grande quantité depuis que cette question a été posté, et alors que nous sommes tous un peu plus sage maintenant, si quelqu'un passe ici en attendant de trouver comment faire pour ignorer les erreurs, c'est la réponse.

OriginalL'auteur stsloth
5

Je pense que votre question est posée d'une XY problème. Ce que vous allez pour est comment puis-je m'assurer que certaines de mes méthodes de la classe sont la garantie d'avoir un bon this contexte?

Pour ce problème, je propose cette solution:
```
class LambdaMethods {
    constructor(private message: string) {
        this.DoSomething = this.DoSomething.bind(this);
    }

    public DoSomething() {
        alert(this.message);
    }
}
```
Ce qui a plusieurs avantages.

Tout d'abord, vous êtes d'être explicite sur ce qui se passe. La plupart des programmeurs n'allez probablement pas à comprendre la subtile de la sémantique à propos de ce qu'est la différence entre le membre et la syntaxe de méthode en termes de codegen.

Deuxième, il fait très clair, en regardant le constructeur, les méthodes qui vont avoir une garantie this contexte. De manière critique, à partir d'une performance, point de vue, vous ne voulez pas écrire toutes vos méthodes de cette façon, tout ceux qui ont absolument besoin.

Enfin, il préserve de la programmation orientée objet sémantique de la classe. Vous allez réellement être en mesure d'utiliser super.DoSomething à partir d'une classe dérivée de la mise en œuvre de DoSomething.

ce qui ne l' bind méthode? Je suppose qu'il déduit le ce contexte, mais je n'ai jamais vu aucune référence à l'avant... si je suis en mesure d'orchestrer portée au constructeur, mais de définir des méthodes au niveau de la classe puis im heureux avec ce compromis.
developer.mozilla.org/en-US/docs/JavaScript/Reference/...
Apprendre quelque chose de nouveau chaque jour!
C'est génial, n'est-ce pas cette a été mis en œuvre pour nous, bravo
Sur une note de côté, j'ai posé la question que vous mentionnez dans le XY problème, déjà pour différentes personnes sur les forums, irc, etc, toutefois, personne n'a été capable de me donner une réponse autre que "mettre les déclarations de méthode dans votre constructeur" donc, cela me laisse avec l'option de juste de tromper la Machine en sortie le code que je voulais, donc même si c'est un cas de XY c'est pas comme si j'avais pas essayé d'obtenir une réponse directe précédemment, alors, j'ai couru d'options si je voulais continuer à utiliser TS... je souhaite juste que cette information était ailleurs, afin que les autres puissent voir TOUS les moyens possibles pour gérer les ce en TS.

OriginalL'auteur Ryan Cavanaugh
2

Je suis sûr que vous êtes conscient de la forme standard de la définition d'une fonction sans la flèche de la notation. Il y a un autre texte dactylographié expression qui génère exactement le même code, mais sans l'erreur de compilation:
```
class LambdaMethods {
    private message: string;
    public DoSomething: () => void;

    constructor(message: string) {
        this.message = message;
        this.DoSomething = () => { alert(this.message); };
    }
}
```
Alors, pourquoi est-ce légal et l'autre ne l'est pas? Ainsi, selon le spec: an arrow function expression preserves the this of its enclosing context. Donc, il préserve le sens de this de la portée qu'elle a été déclarée. Mais la déclaration d'une fonction au niveau de la classe this n'ont pas réellement de sens.

Voici un exemple qui est mauvais pour exactement la même raison qui pourrait être plus clair:
```
class LambdaMethods {
    private message: string;

    constructor(message: string) {
        this.message = message;
    }

    var a = this.message;  //can't do this
}
```
La façon dont l'initialiseur fonctionne en combinaison avec le constructeur est un détail d'implémentation qui ne peut pas être invoqué. Il pourrait changer.

Je suis certain moment donné il y aura une belle façon de gérer le mot-clé this, mais pour l'instant je le trouve assez désastreuse.

L'un des objectifs de haut niveau (que j'adore) en caractères d'imprimerie est d'étendre le langage JavaScript et de travailler avec elle, de ne pas se battre. Comment this fonctionne est difficile, mais vaut la peine d'apprendre.

Je n'aime pas (et c'est d'être gentil) d'avoir à mettre mon déclarations de méthode dans le constructeur. Étant donné que je viens de style xml de la documentation autour de mon code, et j'ai un grand modèle de vue des classes de sorte qu'il devient juste un affreux gâchis en ce moment. Donc, je ne veux pas continuer dans cette voie avec la Machine, sauf si je peux au moins faire un peu le code plus facile à gérer (comme im travaillant actuellement sur une branche de toute façon). Comme pour le dernier point, je sais EXACTEMENT comment ce fonctionne en Javascript (voir mon edit pour les questions précédentes sur les meilleures façons d'utiliser ce en caractères d'imprimerie), je viens de détester la façon dont il est utilisé au sein de TS.
Quel est donc le problème avec une fonction standard qui n'utilise pas la flèche de la notation?
Il ne garantit pas que le contexte de ce et comme mentionné dans l'édition, j'ai besoin d'avoir un ensemble cohérent champ d'application de cette.

OriginalL'auteur Jeffery Grajkowski

Vous devez vous connecter pour publier un commentaire.