►
Description
Best Practices using TypeScript with Node.js - Bryan Hughes, Microsoft
The dynamic nature of JavaScript enables developers to iterate rapidly from concept to production. TypeScript is a superset of JavaScript that facilitates writing robust applications by giving you type-safety and features such as modules, classes and interfaces. Bryan Hughes will share best practices for integrating TypeScript into Node.js workflow and how teams can benefit from the features TypeScript offers.
About Bryan Hughes
Bryan Hughes is a Node.js engineer at Microsoft and member of the Node.js Technical Steering Comittee. Bryan is the creator of Raspi IO, a Raspberry Pi plugin for the Johnny-Five JavaScript robotics library. He also runs the NodeBots SF robotics meetup in San Francisco. Outside of tech, Bryan is an amateur photographer, a once upon a time pianist, and a wine aficionado.
A
I
thanks
everyone
yeah,
my
name
is
Brian
and
today
I'm
going
to
talk
about
typescript,
so
yeah
I
work
at
Microsoft
and
I
use
typescript.
Every
day
there
I
write
typescript
for
no
jaea,
a
combination
of
node
and
the
web,
but
I'm
actually
kind
of
new
to
it.
I
first
started
using
it
in
around
February
or
so
so
I'm
like
definitely
intermediate
level,
not
quite
advanced
yet,
but
you
know,
I've
learned
a
lot
along
the
way,
so
I
kind
of
want
to
talk
about
what
typescript
is
and
how
to
use
it
really
well
with
node.
A
But
first,
let's
talk
about
you
know
what
is
typescript
typescript
is
a
statically
typed
variant
of
JavaScript.
It's
a
compile
to
language.
Like
you
know,
a
lot
of
others
out
there.
The
big
thing
it
has
is
static
typing.
This
is
sort
of
the
the
key
feature
typescript
that
makes
it
different
from
vanilla
JavaScript.
A
For
those
of
you
who,
you
know,
don't
know
what
type
of
static
typing
is,
or
you
know,
come
from
a
pure
JavaScript
background,
static,
typing
basis,
just
means
that
whenever
we
create
a
variable,
there
is
a
type
that
is
associated
with
that
variable.
You
know
a
string
number
boolean,
something
like
that,
and
once
that
variable
has
a
type
that
type
can
never
be
changed.
You
know
once
it's
a
number,
it
will
always
have
to
be
some
number
and
then
everything
else
is
sort
of
just
built
on
top
of
this
basic
concepts.
A
A
So
looking
at
just
a
little
bit
of
basic
typescript
here
we
see
how
type
declarations
work
within
typescript.
We
have
a
simple
function:
combined
names.
It
takes
two
arguments
first
and
last
and
will
combine
them
together.
There's
a
couple
of
decorations
that
we
see
on
this
compared
to
usual
Java
scripts,
though
after
each
argument
you
see
that
there's
a
colon
and
then
there's
a
type.
A
So
what
this
says
is
that
first
and
last
are
both
strings
and
then,
after
the
closing
parenthesis
of
the
function,
arguments
is
another
colon
and
string,
and
that
part
means
that
the
return
type
of
this
function
is
also
a
string,
and
so
what
this
does
is
once
we
have
this,
then
every
time
this
function
is
called,
it
has
to
be
passed
those
types
of
arguments
and
if
you
try
to
pass
it
anything
else,
that's
you
know
not
into
either.
These
parameters
will
actually
get
a
compile-time
error.
A
So
after
this
function
we
create
two
variables,
the
first
name
and
last
name.
We
say
that
these
are
also
strings
and
we
assign
them
Philip
and
Frey.
So
then
we
can
call
this
method
and
log
it
out,
and
everything
is
nice
and
happy.
You
know
this
compiles
just
fine,
but
let's
say,
for
example,
we
did
costs
last
name:
colon
space
number
equals
10,
then
type
script
would
actually
not
even
compile.
So
you
know
with
static
typing
instead
of
having
a
lot
of
errors
happen
at
runtime,
which
is
the
typical
JavaScript
way.
A
They
move
that
to
compile
time
so
before
you
even
have
to
go
and
load
the
browser
run
your
app.
You
know
that
there's
an
issue
so
extending
on
this
is
the
concept
of
interfaces
which
are
pretty
central
in
typescript,
and
an
interface
is
basically
a
definition
that
says
that
objects
of
this
interface
type
must
conform
to
this
contract.
It's
basically
a
contract
for
object
layout.
It
says
you
know,
here's
the
properties
in
it
and
these
are
their
types.
A
So
in
this
case
we
have
a
person
interface
with
first
name
last
name
which
are
strings
and
then
an
age
which
is
a
number.
So
then,
whenever
we
create
a
variable-
and
we
assign
you
know
an
object
literal
to
it-
and
we
say
that
this
variable
Fry
conforms
to
this
contract
person
and
that
it
has
these
types,
and
so
when
this
happens,
typescript
will
check
and
make
sure
that
has
all
of
the
properties
listed
in
the
interface
that
they
are
the
correct
types
and
that
there
are
no
extra
properties
either.
A
It
has
to
match
that
exactly
extending
on
the
concept
of
interfaces
is
classes
classes
in
typescript.
Are
you
pretty
much
just
take
typical,
vanilla,
es6
classes
and
then
we've
added
just
a
couple
of
things?
On
top
of
that,
one
thing
classes
can
implement
interfaces,
so
we
say
in
this
case
ship
implements
I
ship,
and
so
what
happens
here
is
when
we
implement
this
class.
Typescript
will
make
short
now
all
of
the
properties
and
methods
signatures
from
the
interface
exist
in
the
class,
but
there
is
a
little
bit
of
a
difference
compared
with
object.
A
Literals
in
classes,
you
can
add
extra
things
that
are
not
defined
in
the
interface.
The
only
thing
is
that
the
the
things
in
the
interface
must
be
in
the
class.
There's
another
little
thing
going
on
here,
though,
you
see
this
public
and
private
kind
of
keyword
going
on.
So
this
is
another
idea
that
comes
see.
Postal
C,
sharp
Java,
all
those
languages
and
the
concept
of
this
is
this
modifier
in
front
of
a
method
or
variable
says
what
the
access
level
is
for
that
property.
A
A
You
know
it's
private
now
think
of
this
as
the
equivalent
of
like
underscore
variables
in
vanilla
JavaScript,
but
it
actually
does
a
little
better
than
underscore
variables
because
under
the
hood
it
uses
symbols
which
is
another
new
es6
feature,
and
with
that
it
means
it's
actually
impossible
for
someone
else
to
get
access
to
this
property.
You
know
there's
no
like
funky,
hidden
name
or
anything,
it's
like
genuinely
hidden.
So
this
is
great
for
hiding
implementation,
details
and
things
like
that.
A
Moving
on
to
modules
of
so
actually
typescript
just
uses
es6
modules,
there's
really
nothing
new.
On
top
of
that,
with
one
slight
exception,
and
that
is
that
we
can
also
import
interfaces
via
modules.
So
a
thing
about
an
interface,
it's
a
little
interesting
is
that
it's
not
actually
a
value.
You
know,
unlike
everything
in
JavaScript
interface,
is
just
you
know
this
contract.
There's
no,
like
you
know,
value
inside
a
v8
when
it's
running
and
things
like
that,
but
other
than
that,
it's
just
standard.
A
So
you
know
why
are
these
things
great?
You
know.
Why
does
this
make
typescript
a
compelling
language?
Well,
the
biggest
thing
is
type
safety,
and
what
type
safety
means
is
just
we
get
a
lot
of
guarantees
about
types.
You
know
it
basically
helps
us
catch
errors.
The
biggest
area
where
I
found
that
it's
helpful
is
that
it
reduces
typos.
A
You
know
think
if
we
think
in
JavaScript
how
many
times
have
we
been
trying
to
reference
a
property
on
an
object,
and
we
end
up
miss
typing
the
name
of
that
property,
and
we
just
leave
a
letter
off
or
something
like
that,
and
we
don't
notice
it.
Then
we
go
and
we
run
our
code
and
you
know
hope
that
we
get
a
really
nasty,
like
exception,
throw,
but
sometimes
that
doesn't
happen.
Sometimes
we
get
undefined
instead
of
zero
and
that's
not
very
obvious
in
logic
with
typescript.
This
is
always
caught
by
the
compiler.
A
A
compile
time
like
we're
guaranteed
to
know
that
there's
a
problem
instead
of
hoping
that
we
find
it
at
run
time
in
this
sort
of
going
on
for
this
is
that
it
really
reduces
the
chance
of
making
a
mistake
when
refactoring,
especially
when
it
comes
to
once
again
property,
is
on
objects.
You
know
in
vanilla
JavaScript
if
we
want
to
rename
a
property
name
on
an
object.
You
know
table,
we
have
to
go
through
and
grep
the
code
base
and
we
have
to
like
sort
of
look
at
each
line.
A
To
say:
oh,
is
this
actually
that
property
or
is
this
other
thing?
You
know
it's
kind
of
an
intensive
process,
so
jobs
cuz.
We
tend
to
just
try
and
avoid
refactoring
when
possible.
In
fact,
I
would
say
that's
sort
of
a
best
practice,
just
because
there's
a
risk,
but
in
typescript,
because
this
is
all
typed
ahead
of
time.
We
can
actually
refactor
with
a
lot
of
confidence.
You
know
when
we
rename
it.
We
can
know
for
certain
if
we
have
renamed
every
single
instance
of
that.
A
In
fact,
a
lot
of
tooling
built
on
top
of
typescript
can
even
like
basically
refactor
things
for
us.
We
basically
right-click
on
a
variable
or
something
like
that
and
say
rename
in
our
new
name
and
type
typescript
and
visual
studio
code
and
other
editors
can
just
rename
it
all
for
us,
and
we
have
complete
confidence
that
this
was
done
correctly.
So
here's
a
screenshot
of
vigil
studio
code,
visual
studio
code,
is
a
lightweight
editor
from
Microsoft.
A
It
will
look
for
all
the
other
files
that
import
this
module
and
it
will
rename
it
all
for
you
and
it's
100%
accurate
every
time
too,
because
once
again,
static
typing,
so
typescript
is
great
for
a
lot
of
projects.
I
think
most
projects
can
benefit
from
using
typescript.
You
know
at
least
a
little,
but
it
definitely
has
some
cases
where
it
really
shines
where
the
benefits
become.
You
know
really
obvious
and
really
helpful.
The
first
I
would
say
is
with
large
teams.
You
know,
there's
a
lot
of
people
working
on
a
single
codebase.
A
You
know,
in
addition
to
just
simply
catching
errors
and
things
like
that.
It
helps
with
like
discoverability
and
a
few
other
things
of
that
nature.
Yeah,
we
all
kind
of
write
classes
that
end
up
being
used
by
other
developers
on
our
team
and
things
like
that
and
in
an
ideal
world,
we're
documenting
everything
writing
about
to
comments,
and
talking
about
you
know
what
all
the
inputs
and
outputs
are
but
I
mean.
We
all
know
that
we
don't
really
do
that
very
often
and
with
typescript.
A
It
helps
because
it
can
be
somewhat
self
documenting,
or
at
least
partially.
You
know
we
want
to
use
some
method
that
someone
else
wrote
and
we
know
nothing
about
it.
What
typescript,
usually
I
found
I
can
just
look
at
the
signature
and
with
the
name
of
the
veil,
combined
with
the
type
you
kind
of
figure
out
how
to
use
it
without
having
to
go
bug
the
person
next
to
you,
who
you
know,
maybe
on
a
vacation
or
something
I'd,
also
say
it's
really
helpful
for
larger
projects
with
a
large
projects.
A
You
know
refactoring
becomes
much
much
more
complex.
You
know
bigger
the
project.
The
harder
refactor
is
in
regular
JavaScript,
because
the
chance
of
error
is
increased,
but
because
young
type
script
is
actually
typed
when
you
refactor
you
have
that
complete
confidence,
and
so
the
larger
the
project
gets.
You
don't
get
an
increase
in
complexity
of
like
refactoring
and
maintenance,
and
things
like
that.
A
A
So
okay,
I've
talked
about
you
know
types
of
things
like
that,
so
I
want
to
dive
into
the
type
system
a
little
bit
because
you
know
that
sometimes
it
can
be
some
confusion
around
that.
The
key
thing
is
that
types
and
typescript
are
native
JavaScript
types.
That's
really
what
it
is.
There
are
seven
types
in
typescript
as
there
is
in
JavaScript,
that
is
undefined
number
string,
boolean
object,
function
and
symbol,
and
that's
it.
There
were
no
other
types
and
typescript
a
lot
of
other
statically
typed
languages.
A
Do
you
have
other
types
like
you
know,
special
types
of
numbers
and
stubbles,
and
things
like
that,
but
typescript
doesn't
have
those
it's
like
they're,
just
straight-up,
JavaScript
types
and
classes
in
typescript
are
just
straight-up
standard,
javascript,
prototypical
yeah,
we
don't
type
script,
doesn't
try
and
hide
the
fact
that
it's
JavaScript
it
really
embraces
it
and
tries
to
think
you
know.
How
would
this
statically
type
feature?
Look
in
JavaScript?
What's
the
JavaScript
way
of
doing
that,
and
so
another
thing
with
types
you
know
kind
of
following
along
in
this
vein?
Is
that
types
are
opt-in?
A
You
don't
have
to
type
everything
so
which
this
means
is
that
vanilla,
JavaScript
is
straight-up.
Regular
little
JavaScript
is
actually
valid,
typescript
in
most
cases,
and
so
this
is
great.
If
you
want
to
you
know
transition
an
existing
code
base,
you
can
basically
start
by
renaming
the
extension
from
jst
s
and
you're
kind
of
done
it.
You
can
just
sort
of
add
types
as
you
go
over
time
and
the
way
it
does.
A
This
is,
if
there's
a
type
that
it
doesn't
know
what
it
is,
it
gives
it
a
type
of
any
when
the
type
is
an
e.
That
means
it
can
take
any
value
want.
It
basically
acts
like
a
standard,
JavaScript
variable
yeah,
so
it's
kind
of
like
a
backwards
compatibility
thing
now.
One
thing
it
does,
and
this
is
where
this
is.
Why
I
say
when,
if
you
just
rename
the
extension,
it
almost
always
works,
but
not
quite
is
that
typescript
types
are
inferred
when
possible.
A
A
Colon
number
equals
10,
and
this
is
really
handy
because
it
just
reduces
a
lot
of
typing
and
things
like
that,
and
it
actually
helps
typescript
feel
even
more
like
just
regular,
JavaScript,
okay,
so
how
to
use
typescript
with
node.
If
any
of
you
have
looked
at
typescript
in
the
past,
you
know
more
than
about
say
2
months
ago,
you
might
have
remember
it
being
kind
of
difficult
and
kind
of
unwieldy,
but
we
released
typescript
version
2
pretty
recently.
It
makes
a
lot
of
really
nice
improvements,
and
these
days
it's
actually
really
clean
and
simple.
A
Basically
this
right
here.
So
you
start
by
installing
the
typescript
compiler.
You
can
do
it
globally
or
locally
and
have
it
run
by
NPM,
run
scripts
or
whatever
else,
and
then
we
do.
This
NPM
install
just
save
at
type,
slash,
node
and
we'll
go
into
this
a
little
more
what
that
means.
But
basically
this
sets
up
the
new
sort
of
node
bindings.
We
say
this
is
a
node
project
and
then
finally
run
the
compiler.
We
give
it
this
their
flag.
A
We
give
it
a
directory,
it's
going
to
go
to
and
then
the
file
that
we're
going
to
compile,
but
there's
a
lot
more
complicated
configuration
we
can
do
if
we
want.
You
can
do
a
TS,
config
JSON
file,
and
this
works
a
lot
like
the
babel
config
if
you've
ever
used
it
before.
You
know
as
all
kinds
of
options
we
can
say.
You
know
what
sort
of
module
system
do
we
want
to
output
files
as
where
source
map
stuff
and
what
are
the
input
files
typescript
also
has
a
linter.
A
It's
called
TS
lint,
it's
really
really
similar
to
es
lint.
So
if
you've
used
es
lint
before
then
TS
lint
is
going
to
feel
right
at
home.
Like
the
way
you
configure
variables
the
types
of
things
you
configure
all
pretty
similar
so
same
thing:
npm
install
GTS,
lint,
anteus
lint
in
your
files.
I
wanna
talk
briefly
about
some
es6
considerations,
so
there
is
one
slight
difference
with
babel,
so
if
you're
used
to
babel,
this
is
one
thing
to
keep
in
mind.
A
Is
that
typescript
does
not
ship
with
a
runtime
there's
no
equivalent
to
babble
runtime
if
you've
used
that?
So
what
this
means
is
that
all
of
the
es6
and
a
lot
of
the
es7
syntax
is
handled
by
typescript,
but
the
runtime
of
operations
are
not
so
things
like
object,
assigned
symbol
and
what
like
and
things
like,
that,
those
are
not
poly
filled
by
typescript.
That
was
sort
of
intentional
choice
to
keep
type
scripts
small.
A
So
if
you
have
to
target
older
versions
of
node
or
if
you're
working
in
the
browser
you
might
have
to
do
something
complicated,
usually
the
recommended
way
is
to
go
to
typescript
es6,
which
basically
just
strips
out
the
types,
even
use
babel
to
go
the
rest
way
and
include
the
babel
runtime
editors.
We
have
really
good
support.
You
know
out
of
the
box
both
of
the
Visual
Studio
products.
A
Have
it
up
not
surprising
us
I
would
guess
all
the
JetBrains
IDs
have
support
out
of
the
box,
so
Web
Store
and
pycharm
IntelliJ
things
like
that,
and
then
all
the
other
major
ones
have
support
via
a
plugin.
You
know
sublime
Adam,
vim
Emacs,
so
whatever
editor
you're
used
to
using
you
know,
you
can
type
script
to
work
with
that
editor.
So
that
way,
you
can
just
stick
with
your
typical
workflows.
A
One
of
the
big
things
that
comes
up
is
okay,
so
you've
got
this
great
typed
code,
but
what
about
all
the
other
modules
out
there
that
are
not
written
in
typescript
well
to
work
with
those
we
use?
These
things
called
typescript
definition
files
and
a
definition
file
basically
says
that
we're
going
to
create
this
interface,
that
statically
typed
for
this
other
external
module
and
yes,
I,
can
be
exactly
the
same,
because
static
code
is,
by
definition,
more
slightly
more
limited
than
dynamic
code.
A
A
It
says:
we're
going
to
create
this
definition
file
for
this
module
called
planet,
it's
going
to
have
a
couple
of
functions
on
it
and
an
interface
that
gets
exported,
but
you
notice
these
have
no
implementation,
it's
just
the
signature
and
that's
enough
for
typescript
to
give
you
types
and
auto-completion
and
all
that
kind
of
great
stuff,
which
is
awesome.
It's
X,
if
you
have
to
like
write
it
for
all
the
modules
used,
especially
this
modules
use
modules,
use
modules,
use
modules.
A
So,
instead
we
have
this
concept
of
a
global
type
definition
file,
and
these
are
files
that
have
been
created.
You
know
sometimes
by
Microsoft,
sometimes
by
the
community.
We
get
contributions
from
everywhere
and
it's
basically
definition
files
for
all
of
the
popular
modules
there's
stored
in
the
types
scope
inside
in
NPM
itself
and
pretty
much
to
everything
you
use
these
days.
You
know
that's
at
least
reasonably
popular.
It
has
a
definition
file,
and
so
it
basically
just
looks
like
this.
A
You
just
do
NPM
install
just
save
at
types
last
Express,
and
once
you
run
this
command,
you
all
of
a
sudden
have
these
definition
files
for
Express,
which
is
awesome,
because
you
can
get
really
really
good
like
code
completion,
all
sorts
of
things
like
that
inside
of
you
know,
for
Express,
and
so
that
makes
it
you
know
quite
a
bit
easier
to
use
and
that's
kind
of
the
key
things
about
tech
scope.
There's
a
whole
lot
more
to
the
language.
You
can
go
to
typescript
languor
to
learn
more
but
yeah.
C
A
This
is
a
sort
of
clarified,
so
whenever
you
install
these
type
definitions,
it's
to
allow
IDs
to
do
that
whenever
you
install
these,
it
allows
it
to
do
it
much
better.
So
let
me
get
out
of
this
real,
quick
and
just
show
what
that's
like.
So
whenever
you
do
this
Auto
completion
you,
instead
of
just
giving
like,
say
the
name
of
it,
you
would
actually
get
the
name
and
then
you
would
also
also
install
Express
real
quick.
A
Express
and
then
you
could
do
you
know
bar
app
equals
Express
write
and
then
apt-get.
You
can
see
it's
actually
Auto
completed
all
the
information
for
the
get
property,
and
so
that's
what
that
type
definition
file
does
is
a
and
also,
if
there's
any
like
j
stock
comments
associated
with
that
method.
It'll
also
show
those
and
the
tech
completion
here.
So
the
kind
of
us
where
it
helps
is
it
just
it
gives
more
hints.
So
you
can
get
more
intelligent.
All
the
completion,
yeah.
B
A
There's
not
any
plans
I've
seen
some
conversations
happen
around
this.
Both
I
I
got
things
on
that
microscope,
I've
seen
them
outside
and
there
are
a
couple
of
things
inside
about
typescript
and
flow
that
are
different
and
are
like
just
fundamentally
incompatible
with
each
other.
Unfortunately,
it
mostly
has
to
do
with
how
like
null
types
work
null
is
like
treated
specially,
because
the
unroll
doesn't
have
an
implicit
type
to
it
and
so
like.