TypeScript in 100 Seconds
[Music]
typescript validate your javascript
ahead of time with static type checking
javascript is a dynamic language where
we can do all kinds of crazy things
like reference variables that don't
exist or work with objects of an unknown
shape the code is interpreted by a
browser
but if your code is broken you won't
catch it until runtime when the browser
rows an error
typescript prevents errors like this
from ever happening by extending
javascript with types
the language is a strict superset of
javascript which means when you open up
a ts file you can write plain javascript
with all of its extra features
being completely optional but notice in
the code here how the ide
is providing feedback about using a
variable that doesn't exist
instead of fixing this issue weeks later
in a stack trace after the company has
lost millions of dollars we can fix it
right here right now
the reason we get this instant feedback
is because typescript behaves like a
compiled language
where javascript is the compilation
target you can run the typescript
compiler
using the tsc command it will take the
ts file and transpile it into vanilla
javascript
and you can choose any flavor of
javascript you want if you need to
target ancient browsers
and that means you can use the latest
and greatest syntax features of
javascript without having to worry if
they'll be supported in an older
environment your typescript project will
likely have a ts config file
which provides an infinite number of
ways to customize the behavior of the
compiler
but the primary goal of typescript is to
enable static typing
one way it achieves that is by allowing
you to annotate your code with types
we can strongly type a variable using a
colon followed by its type like a string
boolean or number
that's known as an explicit type if we
then try to assign its value as the
wrong type we get an error
alternatively if we set an initial value
it will implicitly infer the type
however there may be cases where you
want to opt out of this behavior
in which case you can annotate with the
any type that allows you to loosely type
or opt out of type checking when working
with an array
use brackets to strongly type a list in
addition you can define your own custom
types and interfaces
which is especially powerful when
working with objects the car interface
here defines various types
of the properties on an object we can
then apply the interface to a plain
javascript object
the beauty of having strongly typed code
is that we get autocomplete everywhere
in our ide
we don't have to jump back and forth to
documentation or dig through stack
traces to figure out why our code's not
working
if you like typescript as much as i do
consider becoming a pro member at
fireship io for the next few days
everything will be 40 off including
lifetime memberships thanks for watching
and i will see you in the next one