For programs to be useful, we need to be able to work with some of the simplest units of data: numbers, strings, structures, boolean values, and the like.\nIn TypeScript, we support the same types as you would expect in JavaScript, with an extra enumeration type thrown in to help things along.
\nThe most basic datatype is the simple true/false value, which JavaScript and TypeScript call a boolean value.
\ntsletTryisDone : boolean = false;
As in JavaScript, all numbers in TypeScript are either floating point values or BigIntegers.\nThese floating point numbers get the type number, while BigIntegers get the type bigint.\nIn addition to hexadecimal and decimal literals, TypeScript also supports binary and octal literals introduced in ECMAScript 2015.
\ntsletTrydecimal : number = 6;\nlethex : number = 0xf00d;\nletbinary : number = 0b1010;\nletoctal : number = 0o744;\nletbig : bigint = 100n;
Another fundamental part of creating programs in JavaScript for webpages and servers alike is working with textual data.\nAs in other languages, we use the type string to refer to these textual datatypes.\nJust like JavaScript, TypeScript also uses double quotes (\") or single quotes (') to surround string data.
\ntsletTrycolor : string = \"blue\";\ncolor = \"red\";
You can also use template strings, which can span multiple lines and have embedded expressions.\nThese strings are surrounded by the backtick/backquote (`) character, and embedded expressions are of the form ${ expr }.
\ntsletTryfullName : string = `Bob Bobbington`;\nletage : number = 37;\nletsentence : string = `Hello, my name is ${fullName }.\n\nI'll be ${age + 1} years old next month.`;
This is equivalent to declaring sentence like so:
\ntsletTrysentence : string =\n \"Hello, my name is \" +\nfullName +\n \".\\n\\n\" +\n \"I'll be \" +\n (age + 1) +\n \" years old next month.\";
TypeScript, like JavaScript, allows you to work with arrays of values.\nArray types can be written in one of two ways.\nIn the first, you use the type of the elements followed by [] to denote an array of that element type:
\ntsletTrylist : number[] = [1, 2, 3];
The second way uses a generic array type, Array<elemType>:
\ntsletTrylist :Array <number> = [1, 2, 3];
Tuple types allow you to express an array with a fixed number of elements whose types are known, but need not be the same. For example, you may want to represent a value as a pair of a string and a number:
\nts// Declare a tuple type\nletTryx : [string, number];\n// Initialize it\nx = [\"hello\", 10]; // OK\n// Initialize it incorrectly\nx = [10 ,"hello" ]; // Error\nType 'number' is not assignable to type 'string'.Type 'string' is not assignable to type 'number'.2322
2322Type 'number' is not assignable to type 'string'.Type 'string' is not assignable to type 'number'.
When accessing an element with a known index, the correct type is retrieved:
\n\nts// OK\nTryconsole .log (x [0].substring (1));\n\nconsole .log (x [1]. 1));\nProperty 'substring' does not exist on type 'number'.2339Property 'substring' does not exist on type 'number'.substring (
Accessing an element outside the set of known indices fails with an error:
\n\ntsTryx [3 ] = \"world\";\nTuple type '[string, number]' of length '2' has no element at index '3'.2493Tuple type '[string, number]' of length '2' has no element at index '3'.\nconsole .log (x [5 ].toString ());\nObject is possibly 'undefined'.Tuple type '[string, number]' of length '2' has no element at index '5'.2532
2493Object is possibly 'undefined'.Tuple type '[string, number]' of length '2' has no element at index '5'.
A helpful addition to the standard set of datatypes from JavaScript is the enum.\nAs in languages like C#, an enum is a way of giving more friendly names to sets of numeric values.
\ntsenumTryColor {\nRed ,\nGreen ,\nBlue ,\n}\nletc :Color =Color .Green ;
By default, enums begin numbering their members starting at 0.\nYou can change this by manually setting the value of one of its members.\nFor example, we can start the previous example at 1 instead of 0:
\ntsenumTryColor {\nRed = 1,\nGreen ,\nBlue ,\n}\nletc :Color =Color .Green ;
Or, even manually set all the values in the enum:
\n\ntsenumTryColor {\nRed = 1,\nGreen = 2,\nBlue = 4,\n}\nletc :Color =Color .Green ;
A handy feature of enums is that you can also go from a numeric value to the name of that value in the enum.\nFor example, if we had the value 2 but weren’t sure what that mapped to in the Color enum above, we could look up the corresponding name:
\ntsenumTryColor {\nRed = 1,\nGreen ,\nBlue ,\n}\nletcolorName : string =Color [2];\n\n// Displays 'Green'\nconsole .log (colorName );
We may need to describe the type of variables that we do not know when we are writing an application.\nThese values may come from dynamic content – e.g. from the user – or we may want to intentionally accept all values in our API.\nIn these cases, we want to provide a type that tells the compiler and future readers that this variable could be anything, so we give it the unknown type.
\ntsletTrynotSure : unknown = 4;\nnotSure = \"maybe a string instead\";\n\n// OK, definitely a boolean\nnotSure = false;
If you have a variable with an unknown type, you can narrow it to something more specific by doing typeof checks, comparison checks, or more advanced type guards that will be discussed in a later chapter:
\ntsdeclare constTrymaybe : unknown;\n// 'maybe' could be a string, object, boolean, undefined, or other types\nconst: number = aNumber maybe ;\nType 'unknown' is not assignable to type 'number'.2322Type 'unknown' is not assignable to type 'number'.\nif (maybe === true) {\n // TypeScript knows that maybe is a boolean now\n constaBoolean : boolean =maybe ;\n // So, it cannot be a string\n const: string = aString maybe ;\nType 'boolean' is not assignable to type 'string'.2322Type 'boolean' is not assignable to type 'string'.}\n\nif (typeofmaybe === \"string\") {\n // TypeScript knows that maybe is a string\n constaString : string =maybe ;\n // So, it cannot be a boolean\n const: boolean = aBoolean maybe ;\nType 'string' is not assignable to type 'boolean'.2322Type 'string' is not assignable to type 'boolean'.}
In some situations, not all type information is available or it’s declaration would take an inappropriate amount of effort.\nThese may occur for values from code that has been written without TypeScript or a 3rd party library.\nIn these cases, we might want to opt-out of type checking.\nTo do so, we label these values with the any type:
\ntsdeclare functionTrygetValue (key : string): any;\n// OK, return value of 'getValue' is not checked\nconststr : string =getValue (\"myString\");
The any type is a powerful way to work with existing JavaScript, allowing you to gradually opt-in and opt-out of type checking during compilation.
Unlike unknown, variables of type any allow you to access arbitrary properties, even ones that don’t exist.\nThese properties include functions and TypeScript will not check their existence or type:
\ntsletTrylooselyTyped : any = 4;\n// OK, ifItExists might exist at runtime\nlooselyTyped .ifItExists ();\n// OK, toFixed exists (but the compiler doesn't check)\nlooselyTyped .toFixed ();\n\nletstrictlyTyped : unknown = 4;\n. strictlyTyped toFixed ();\nObject is of type 'unknown'.2571Object is of type 'unknown'.
The any will continue to propagate through your objects:
\ntsletTrylooselyTyped : any = {};\nletd =looselyTyped .a .b .c .d ;\n// ^ = let d: any
After all, remember that all the convenience of any comes at the cost of losing type safety.\nType safety is one of the main motivations for using TypeScript and you should try to avoid using any when not necessary.
void is a little like the opposite of any: the absence of having any type at all.\nYou may commonly see this as the return type of functions that do not return a value:
\ntsfunctionTrywarnUser (): void {\nconsole .log (\"This is my warning message\");\n}
Declaring variables of type void is not useful because you can only assign null (only if --strictNullChecks is not specified, see next section) or undefined to them:
\ntsletTryunusable : void =undefined ;\n// OK if `--strictNullChecks` is not given\nunusable = null;
In TypeScript, both undefined and null actually have their own types named undefined and null respectively.\nMuch like void, they’re not extremely useful on their own:
\nts// Not much else we can assign to these variables!\nletTryu : undefined =undefined ;\nletn : null = null;
By default null and undefined are subtypes of all other types.\nThat means you can assign null and undefined to something like number.
However, when using the --strictNullChecks flag, null and undefined are only assignable to unknown, any and their respective types (the one exception being that undefined is also assignable to void).\nThis helps avoid many common errors.\nIn cases where you want to pass in either a string or null or undefined, you can use the union type string | null | undefined.
Union types are an advanced topic that we’ll cover in a later chapter.
\n\n\nAs a note: we encourage the use of
\n--strictNullCheckswhen possible, but for the purposes of this handbook, we will assume it is turned off.
The never type represents the type of values that never occur.\nFor instance, never is the return type for a function expression or an arrow function expression that always throws an exception or one that never returns.\nVariables also acquire the type never when narrowed by any type guards that can never be true.
The never type is a subtype of, and assignable to, every type; however, no type is a subtype of, or assignable to, never (except never itself).\nEven any isn’t assignable to never.
Some examples of functions returning never:
\nts// Function returning never must not have a reachable end point\nfunctionTryerror (message : string): never {\n throw newError (message );\n}\n\n// Inferred return type is never\nfunctionfail () {\n returnerror (\"Something failed\");\n}\n\n// Function returning never must not have a reachable end point\nfunctioninfiniteLoop (): never {\n while (true) {}\n}
object is a type that represents the non-primitive type, i.e. anything that is not number, string, boolean, symbol, null, or undefined.
With object type, APIs like Object.create can be better represented. For example:
\ntsdeclare functionTrycreate (o : object | null): void;\n\n// OK\ncreate ({prop : 0 });\ncreate (null);\n\ncreate (42 );\nArgument of type '42' is not assignable to parameter of type 'object | null'.2345Argument of type '42' is not assignable to parameter of type 'object | null'.create ("string" );\nArgument of type '\"string\"' is not assignable to parameter of type 'object | null'.2345Argument of type '\"string\"' is not assignable to parameter of type 'object | null'.create (false );\nArgument of type 'false' is not assignable to parameter of type 'object | null'.2345Argument of type 'false' is not assignable to parameter of type 'object | null'.create ();\nArgument of type 'undefined' is not assignable to parameter of type 'object | null'.2345Argument of type 'undefined' is not assignable to parameter of type 'object | null'. undefined
Generally, you won’t need to use this.
\nSometimes you’ll end up in a situation where you’ll know more about a value than TypeScript does.\nUsually this will happen when you know the type of some entity could be more specific than its current type.
\nType assertions are a way to tell the compiler “trust me, I know what I’m doing.”\nA type assertion is like a type cast in other languages, but performs no special checking or restructuring of data.\nIt has no runtime impact, and is used purely by the compiler.\nTypeScript assumes that you, the programmer, have performed any special checks that you need.
\nType assertions have two forms.
\nOne is the as-syntax:
\ntsletTrysomeValue : any = \"this is a string\";\n\nletstrLength : number = (someValue as string).length ;
The other version is the “angle-bracket” syntax:
\n\ntsletTrysomeValue : any = \"this is a string\";\n\nletstrLength : number = (<string>someValue ).length ;
The two samples are equivalent.\nUsing one over the other is mostly a choice of preference; however, when using TypeScript with JSX, only as-style assertions are allowed.
letYou may have noticed that so far, we’ve been using the let keyword instead of JavaScript’s var keyword which you might be more familiar with.\nThe let keyword is actually a newer JavaScript construct that TypeScript makes available.\nYou can read in the Handbook Reference on Variable Declarations more about how let and const fix a lot of the problems with var.
Number, String, Boolean, Symbol and ObjectIt can be tempting to think that the types Number, String, Boolean, Symbol, or Object are the same as the lowercase versions recommended above.\nThese types do not refer to the language primitives however, and almost never should be used as a type.
\ntsfunctionTryreverse (s :String ):String {\n returns .split (\"\").reverse ().join (\"\");\n}\n\nreverse (\"hello world\");
Instead, use the types number, string, boolean, object and symbol.
","headings":[{"value":"Boolean","depth":2},{"value":"Number","depth":2},{"value":"String","depth":2},{"value":"Array","depth":2},{"value":"Tuple","depth":2},{"value":"Enum","depth":2},{"value":"Unknown","depth":2},{"value":"Any","depth":2},{"value":"Void","depth":2},{"value":"Null and Undefined","depth":2},{"value":"Never","depth":2},{"value":"Object","depth":2},{"value":"Type assertions","depth":2},{"value":"A note about let","depth":2},{"value":"About Number, String, Boolean, Symbol and Object","depth":2}],"frontmatter":{"permalink":"/docs/handbook/basic-types.html","title":"Basic Types","disable_toc":null,"oneline":"Step one in learning TypeScript: The basics types."}},"prev":{"childMarkdownRemark":{"frontmatter":{"title":"The TypeScript Handbook","oneline":"Your first step to learn TypeScript","permalink":"/docs/handbook/intro.html"}}},"next":{"childMarkdownRemark":{"frontmatter":{"title":"Interfaces","oneline":"How to write an interface with TypeScript","permalink":"/docs/handbook/interfaces.html"}}}},"pageContext":{"id":"basic-types","slug":"/docs/handbook/basic-types.html","repoPath":"/packages/documentation/copy/en/handbook-v1/Basic Types.md","previousID":"5fb0db72-aeb7-5f60-9a01-0e7ce9f98b1e","nextID":"ff57dbef-1065-53e7-b2ca-b1e8b6fb2597","lang":"en","modifiedTime":"2020-08-07T17:00:36.335Z"}}}tsfunctionTryreverse (s : string): string {\n returns .split (\"\").reverse ().join (\"\");\n}\n\nreverse (\"hello world\");