22

I am wondering if there is a way to ignore certain TypeScript errors upon compilation?

I basically have the same issues most people with large projects have around using the this keyword, and I don't want to put all my classes methods into the constructor.

So I have got an example like so:

TypeScript Example

Which seems to create perfectly valid JS and allows me to get around the this keyword issue, however as you can see in the example the typescript compiler tells me that I cannot compile that code as the keyword this is not valid within that scope. However I don't see why it is an error as it produces okay code.

So is there a way to tell it to ignore certain errors? I am sure given time there will be a nice way to manage the this keyword, but currently I find it pretty dire.

== Edit ==

(Do not read unless you care about context of this question and partial rant)

Just to add some context to all this to show that I'm not just some nut-job (I am sure a lot of you will still think I am) and that I have some good reasons why I want to be able to allow these errors to go through.

Here are some previous questions I have made which highlight some major problems (imo) with TypeScript current this implementation.

Using lawnchair with Typescript

Issue with child scoping of this in Typescript

https://typescript.codeplex.com/discussions/429350 (And some comments I make down the bottom)

The underlying problem I have is that I need to guarantee that all logic is within a consistent scope, I need to be able to access things within knockout, jQuery etc and the local instance of a class. I used to do this with the var self = this; within the class declaration in JavaScript and worked great. As mentioned in some of these previous questions I cannot do that now, so the only way I can guarantee the scope is to use lambda methods, and the only way I can define one of these as a method within a class is within the constructor, and this part is HEAVILY down to personal preference, but I find it horrific that people seem to think that using that syntax is classed as a recommended pattern and not just a work around.

I know TypeScript is in alpha phase and a lot will change, and I HOPE so much that we get some nicer way to deal with this but currently I either make everything a huge mess just to get typescript working (and this is within Hundreds of files which I'm migrating over to TypeScript ) or I just make the call that I know better than the compiler in this case (VERY DANGEROUS I KNOW) so I can keep my code nice and hopefully when a better pattern comes out for handling this I can migrate it then.

Also just on a side note I know a lot of people are loving the fact that TypeScript is embracing and trying to stay as close to the new JavaScript features and known syntax as possible which is great, but typescript is NOT the next version of JavaScript so I don't see a problem with adding some syntactic sugar to the language as people who want to use the latest and greatest official JavaScript implementation can still do so.

Improve this question
5
  • Why are you wanting to write with that syntax instead of the regular function syntax? The linked code is taking some pretty serious trade-offs in terms of performance/memory; it would be good to understand why. Commented Apr 15, 2013 at 15:51
  • I will make an edit to give some context to this, I dislike method declarations within the constructor, and due to Knockout, Jquery, Lawnchair and other libraries I use messing with the this context everywhere I have to put almost every method within the constructor to be able to access the this instance from the class, HOWEVER I very much dislike this approach and want to be able to just access the this instance outside of the constructor. As the normal method declaration syntax public someMethod(): string { return "hello"; } does not guarantee the this context, but lambdas do. Commented Apr 15, 2013 at 18:22
  • TypeScript no longer complains about your solution. :) Commented Feb 4, 2020 at 16:30
  • The linked example currently goes to the default typescript playground. Can someone fix the link to load the code correctly? Commented Jun 29, 2021 at 19:59
  • @SeanMcMillan I have fixed the link for you Commented Jul 22, 2021 at 7:54

3 Answers 3

Reset to default
31

The author's specific issue with this seems to be solved but the question is posed about ignoring errors, and for those who end up here looking how to ignore errors:

If properly fixing the error or using more decent workarounds like already suggested here are not an option, as of TypeScript 2.6 (released on Oct 31, 2017), now there is a way to ignore all errors from a specific line using // @ts-ignore comments before the target line.

The mendtioned documentation is succinct enough, but to recap:

// @ts-ignore
const s : string = false

disables error reporting for this line.

However, this should only be used as a last resort when fixing the error or using hacks like (x as any) is much more trouble than losing all type checking for a line.

As for specifying certain errors, the current (mid-2018) state is discussed here, in Design Meeting Notes (2/16/2018) and further comments, which is basically

"no conclusion yet"

and strong opposition to introducing this fine tuning.

Improve this answer
Sign up to request clarification or add additional context in comments.

1 Comment

As mentioned TS has changed a vast amount since this question was posted, and while we are all a bit wiser now if anyone goes here expecting to find how to ignore errors, this is the answer.
4

I think your question as posed is an XY problem. What you're going for is how can I ensure that some of my class methods are guaranteed to have a correct this context?

For that problem, I would propose this solution:

class LambdaMethods {
    constructor(private message: string) {
        this.DoSomething = this.DoSomething.bind(this);
    }

    public DoSomething() {
        alert(this.message);
    }
}

This has several benefits.

First, you're being explicit about what's going on. Most programmers are probably not going to understand the subtle semantics about what the difference between the member and method syntax are in terms of codegen.

Second, it makes it very clear, from looking at the constructor, which methods are going to have a guaranteed this context. Critically, from a performance, perspective, you don't want to write all your methods this way, just the ones that absolutely need it.

Finally, it preserves the OOP semantics of the class. You'll actually be able to use super.DoSomething from a derived class implementation of DoSomething.

Improve this answer

5 Comments

what does the bind method do? I assume it infers the this context but I haven't ever seen any reference to it before... if I am able to orchestrate scope at constructor level but define methods at class level then im happy with that compromise.
developer.mozilla.org/en-US/docs/JavaScript/Reference/…
Learn something new every day!
This is awesome, didn't know this was implemented for us, bravo
On a side note I have asked the question you mention in the XY problem previously to different people on forums and irc etc, however no one was able to give me an answer other than "put the method declarations in your constructor" so this left me with the option of just tricking Typescript into outputting the code I wanted, so although this is a case of XY it is not like I had not tried to get a straight answer previously, so I ran out of options if I wanted to continue using TS... I just wish this information was somewhere else so others could see ALL the possible ways to manage this in TS.
2

I'm sure you're aware of the standard form of defining a function without the arrow notation. There's another TypeScript expression that generates the exact same code but without the compile error:

class LambdaMethods {
    private message: string;
    public DoSomething: () => void;

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

So why is this legal and the other one isn't? Well according to the spec: an arrow function expression preserves the this of its enclosing context. So it preserves the meaning of this from the scope it was declared. But declaring a function at the class level this doesn't actually have a meaning.

Here's an example that's wrong for the exact same reason that might be more clear:

class LambdaMethods {
    private message: string;

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

    var a = this.message;  // can't do this
}

The way that initializer works by being combined with the constructor is an implementation detail that can't be relied upon. It could change.

I am sure given time there will be a nice way to manage the this keyword, but currently I find it pretty dire.

One of the high-level goals (that I love) in TypeScript is to extend the JavaScript language and work with it, not fight it. How this operates is tricky but worth learning.

Improve this answer

3 Comments

I dislike (and that's being nice) having to put my method declarations within the constructor. Given that I have xml style documentation around my code, and I have some large view model classes so it just becomes a hideous mess at the moment. So I do not want to continue down this path with Typescript unless I can at least make the code a bit more manageable (as im currently working on a branch anyway). As for the final point I know EXACTLY how this works in Javascript (see my edit for previous questions around best ways to use this in Typescript), I just dislike how it is used within TS.
So what's wrong with a standard function that doesn't use the arrow notation?
It does not guarantee the context of this and as mentioned in the edit, I need to have a consistent scope of this.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.