TypeScript in 5 minutes

For types like those which are outside your control you can use type guards[1]:

    if (value == null) {
        // TS knows value is null, doesn't let you access value .length for example
    } else if (Array.isArray(value)) {
        // TS knows value is an array
    } else {
        // TS knows that it's an object here
    }

However, having types like those in your own code (e.g. things like X[] | Y | null) is probably an antipattern and should be avoided. Using discriminated unions[2] is much better.

[1]: https://www.typescriptlang.org/docs/handbook/advanced-types.... ("Type Guards and Differentiating Types" section) [2]: [1]: https://www.typescriptlang.org/docs/handbook/advanced-types.... ("Discriminated Unions" section)

What you're "missing", I think, is that Typescript's types only exist at compile-time, so they aren't available through runtime operations like instanceof. It's like a more extensive case of Java generics erasure.

You’re not missing anything ; instanceof can be used to check prototype chain (class inheritance) but there is nothing similar for object interfaces (duck typing). And most Javascript objects are only loosely defined to conform to interfaces.

Good call. I love TypeScript, and wouldn't build a web app of even small scope without a typing solution at least as good as TypeScript, and it's the best.

But, as you say, pattern matching sum types is a weak point in practical use of TypeScript.

Since the types only exist at compile time, maybe there could be a heavier opt-in system that uses something like Symbols to do pattern matching:

  matchable type Shape = Circle | Square | Triangle;
  const myShape: Shape;
  match myShape {
    // uses symbol magic under the hood, eg. if (SymbolShapeCircle in o)
    case (c: Circle) { ... }
    case (other: Triangle | Square) { ... }
  }

Misclassifies an empty array as object since zero is falsy.

Typescript has flags for turning on more strictness, and I highly recommend using them. For example, strictNullChecks for your example above.

There’s a “strict” flag that you can use to turn on most of the more specific strictness flags all at once.

With the disclaimer that I don't get paid for my Typescript work (I use it for some personal projects, as it saves me a bit of time compared to C++), I have this as the compile scripts entry in my package.json:

    "compile": "tsc -p ./tsconfig.json",

I also have a start script, for running it from the command line:

    "start": "npm run compile && node ./.build/main.js"

tsc has some kind of file-watching mode, that I assume compiles when you save stuff, but I don't use that, because I'm not a monster.

Yeah, we use tsc for node. I typically just use ts-node for development, though, and tsc gets to hang out in CI/CD somewhere. I assume ts-node / webpack / etc all use tsc under the hood, though.

I use cc instead of make, and javac instead of Gradle fairly often for various purposes like debugging or experimenting. Is the js world different?

Yes. ts-node is great for development, but for deployment (in our ci/cd) we run tsc to compile the typescript down to javascript.

For node projects I use ts-node with nodemon watching for filechanges and takes care of restarting the server. And then to build the project for release thats done with tsc.

I use tsc -w, what do you use? I'm not using it on the frontend but for nodejs (i would use webpack on the frontend)

Depends on your IDE. In practice, tsc is a build step in CI/CD, not a dev tool (if you’re using a good IDE).

in a project I worked on, we used tsc with msbuild to build our frontend.

There's a couple of things going on that you might not be familiar with as it's a bit different to most languages:

The public modifier on these constructor parameters is actually introducing them as properties of the Student type:

constructor(public firstName: string, public middleInitial: string, public lastName: string) {}

Since the Student type has 'firstName' and 'lastName' properties, it meets the Person interface requirements. It doesn't need to declare that it is, but could and usually would just for readability and the additional assurance that you haven't forgotten something.

Great question!

No, you don't need to inherit or implement which is one of the great features of TypeScript!

In this example, the `greeter` function accepts any object that has a `firstName` and `lastName` property defined, regardless of what the object/type is called. No need for inheritance.

In fact, the `Person` interface is not even emitted in the JS output because interfaces are only used at compile time, not at run time.

TypeScript is one of the fastest-growing technologies in the JS ecosystem right now. It's unlikely the team is using the back button behavior as a way to get membership.

Incidentally, to which porn sites are you referring? Which of your favorite porn sites do you think do the best job with UI/UX?

this seems to be highly downvoted as i suppose people are reading it as a rude aside, but I read it as a feature worth highlighting. Microsoft has an excellent track record with language design, promotion, stability, and tooling.