Basic Types
Interfaces
Classes
Functions
Generics
Enums
Type Assertions
Advanced Types
Modules
Decorators
let isDone : boolean = false ;
let decimal : number = 6 ;
let color : string = "blue" ;
let list : number [ ] = [ 1 , 2 , 3 ] ;
let x : [ string , number ] = [ "hello" , 10 ] ; // Tuple
let notSure : any = 4 ;
notSure = "maybe a string instead" ;
notSure = false ; // okay, definitely a boolean
let uncertain : unknown = 4 ;
uncertain = "maybe a string" ;
uncertain = false ;
Void, Null, and Undefined
function warnUser ( ) : void {
console . log ( "This is my warning message" ) ;
}
let u : undefined = undefined ;
let n : null = null ;
function error ( message : string ) : never {
throw new Error ( message ) ;
}
interface LabelledValue {
label : string ;
}
function printLabel ( labelledObj : LabelledValue ) {
console . log ( labelledObj . label ) ;
}
let myObj = { size : 10 , label : "Size 10 Object" } ;
printLabel ( myObj ) ;
interface SquareConfig {
color ?: string ;
width ?: number ;
}
function createSquare ( config : SquareConfig ) : { color : string ; area : number } {
let newSquare = { color : "white" , area : 100 } ;
if ( config . color ) {
newSquare . color = config . color ;
}
if ( config . width ) {
newSquare . area = config . width * config . width ;
}
return newSquare ;
}
let mySquare = createSquare ( { color : "black" } ) ;
interface Point {
readonly x : number ;
readonly y : number ;
}
let p1 : Point = { x : 10 , y : 20 } ;
// p1.x = 5; // error!
class Greeter {
greeting : string ;
constructor ( message : string ) {
this . greeting = message ;
}
greet ( ) {
return "Hello, " + this . greeting ;
}
}
let greeter = new Greeter ( "world" ) ;
class Animal {
move ( distanceInMeters : number = 0 ) {
console . log ( `Animal moved \${distanceInMeters}m.` ) ;
}
}
class Dog extends Animal {
bark ( ) {
console . log ( 'Woof! Woof!' ) ;
}
}
const dog = new Dog ( ) ;
dog . bark ( ) ;
dog . move ( 10 ) ;
class Animal {
private name : string ;
protected age : number ;
public color : string ;
constructor ( name : string , age : number , color : string ) {
this . name = name ;
this . age = age ;
this . color = color ;
}
}
function add ( x : number , y : number ) : number {
return x + y ;
}
let myAdd : ( x : number , y : number ) => number =
function ( x : number , y : number ) : number { return x + y ; } ;
Optional and Default Parameters
function buildName ( firstName : string , lastName ?: string ) {
if ( lastName )
return firstName + " " + lastName ;
else
return firstName ;
}
function buildName2 ( firstName : string , lastName = "Smith" ) {
return firstName + " " + lastName ;
}
function buildName ( firstName : string , ...restOfName : string [ ] ) {
return firstName + " " + restOfName . join ( " " ) ;
}
let employeeName = buildName ( "Joseph" , "Samuel" , "Lucas" , "MacKinzie" ) ;
function identity < T > ( arg : T ) : T {
return arg ;
}
let output = identity < string > ( "myString" ) ;
let output2 = identity ( "myString" ) ; // type inference
interface GenericIdentityFn < T > {
( arg : T ) : T ;
}
let myIdentity : GenericIdentityFn < number > = identity ;
class GenericNumber < T > {
zeroValue : T ;
add : ( x : T , y : T ) => T ;
}
let myGenericNumber = new GenericNumber < number > ( ) ;
myGenericNumber . zeroValue = 0 ;
myGenericNumber . add = function ( x , y ) { return x + y ; } ;
enum Direction {
Up = 1 ,
Down ,
Left ,
Right ,
}
enum Direction {
Up = "UP" ,
Down = "DOWN" ,
Left = "LEFT" ,
Right = "RIGHT" ,
}
let someValue : any = "this is a string" ;
let strLength : number = ( < string > someValue ) . length ;
let someValue : any = "this is a string" ;
let strLength : number = ( someValue as string ) . length ;
function padLeft ( value : string , padding : string | number ) {
// ...
}
interface ErrorHandling {
success : boolean ;
error ?: { message : string } ;
}
interface ArtworksData {
artworks : { title : string } [ ] ;
}
type ArtworksResponse = ArtworksData & ErrorHandling ;
type Name = string ;
type NameResolver = ( ) => string ;
type NameOrResolver = Name | NameResolver ;
export interface StringValidator {
isAcceptable ( s : string ) : boolean ;
}
export const numberRegexp = / ^[0-9]+$/ ;
export class ZipCodeValidator implements StringValidator {
isAcceptable ( s : string ) {
return s . length === 5 && numberRegexp . test ( s ) ;
}
}
import { ZipCodeValidator } from "./ZipCodeValidator" ;
let myValidator = new ZipCodeValidator ( ) ;
function sealed ( constructor : Function ) {
Object . seal ( constructor ) ;
Object . seal ( constructor . prototype ) ;
}
@sealed
class Greeter {
greeting : string ;
constructor ( message : string ) {
this . greeting = message ;
}
greet ( ) {
return "Hello, " + this . greeting ;
}
}
function enumerable ( value : boolean ) {
return function ( target : any , propertyKey : string , descriptor : PropertyDescriptor ) {
descriptor . enumerable = value ;
} ;
}
class Greeter {
greeting : string ;
constructor ( message : string ) {
this . greeting = message ;
}
@enumerable ( false )
greet ( ) {
return "Hello, " + this . greeting ;
}
}