Typescript – Basic types

Matters needing attention

• Automatic type judgment

  The TS compiler automatically determines the type of a variable when it is declared and assigned at the same time, so if you are declaring and assigning at the same time, you can omit the type declaration

• If you do not specify a type for a variable, the TS parser automatically determines that the variable is of type ANY

let a; // The type of a is any

• D is of type any, and it can be assigned to any variable

let s:string; 
let d; 
d= 10;
s = d; // No error will be reported
Copy the code

Type:

• literal

let a:10; That gives a a value of 10; We can assign a=10, but we cannot assign a field that is not 10; let b: ‘mail’| ’email’; And then you can assign mail or email to b. But you can’t assign anything else

• The joint type

let a: number | string;

• Unknown type Indicates the value of unknown type

When you do not know what type a value is, you can assign the value unknown. It differs from any in that any can be assigned to any variable. Unknown is not allowed

Unknown The method to assign to another variable

1. Type judgment

let e: unknown;
e = 10;
let s:string;
if(typeof e === "string"){
    s = e;
}
Copy the code

2. Types of assertions

// Type assertion, which can be used to tell the parser the actual type of a variable
/* * syntax: * variable as type * < type > variable * * */
s = e as string;
s = <string>e;
Copy the code

3. Never: The result is never returned

function error(message: string) :never {
  throw new Error(message);
}
Copy the code

4. Object represents a JS object

let a: object;
a = {};// Object can be an object
a = function () {};// object can also be function


// {} is used to specify which attributes can be included in the object
{attribute name: attribute value, attribute name: attribute value}
// Add? To the attribute name. , indicating that the property is optional
let b: {name: string, age? : number}; b = {name: Sun Wukong.age: 18};

// [propName: string]: any indicates any type of attribute
let c: {[propName: string]: any};
c = {name: 'Pig Eight Quit'.age: 18.gender: 'male'};

/* * Sets the type declaration of function structures: * syntax: (parameters: type, parameters: type...) => Return value * */
let d: (a: number ,b: number) = >number;
// d = function (n1: string, n2: string): number{
// return 10;
// }
Copy the code

5. Array an Array

Array type declaration:

• Type []
• Array < type >

// String [] represents an array of strings
let e: string[];
e = ['a'.'b'.'c'];

// number[] indicates the value
let f: number[];

let g: Array<number>;
g = [1.2.3];
Copy the code

6. Tuple a tuple is an array of fixed length

Syntax: [type, type, type]

let h: [string, number];
h = ['hello'.123];
Copy the code

7. Enum enumeration

enum Gender{
    Male,
    Female
}

let i: {name: string, gender: Gender};
i = {
    name: Sun Wukong.gender: Gender.Male // 'male'
}
console.log(i.gender === Gender.Male);
Copy the code

8. Type the alias

type myType = 1 | 2 | 3 | 4 | 5;// myType is the type alias
let k: myType;
let l: myType;
let m: myType;
Copy the code