Typescript learning 1 - data types

explain

This article learns from the article of the great God of gold digging https://juejin.cn/post/7003171767560716302, The original author is the great rabbit God .

JavaScript Built in type

// number
let n:number=1;
// string
let s:string="str";
// boolean
let b:boolean=true;
// undefined
let u:undefined=undefined;
// null
let ne:null=null;
// object
let obj:object={};
// bigint
let bi:bigint=10n;
// symbol
let sy:symbol=Symbol("mySymbol");

Array

Two definitions ：

//  Define the way 1
let arr1:string[]={' Hello ','hello'};
//  Define the way 2
let arr2:Array<string>={' Hello ','hello'};

Tuple

//  Tuples can define arrays of different element types 
let t:[string,number,boolean]=['hello',522,false];

Tuples specify the length and element type of the array , An error will be reported if the type or length does not match . For arrays of uncertain type and length , It can be used any[] To define .

undefined and null

By default ,null and undefined Is a subtype of all types . in other words , You can put undefined and null Assign to variables of any type .

let m:number=2;
m=undefined;

void

void Means there is no type of . Declare the variable as void It doesn't make sense , It will only be declared as void.

Be careful , Functions that do not return a value will get undefined, But it still needs to be declared void, Otherwise, an error will be reported .

unknown and any

any Will skip the check of the value by the type checker , Any value can be assigned to any type .

let a: any = 123;
a = '456';
a = false;

unknown Can achieve the same effect .

let a: unknown = 123;
a = '456';
a = false;

The biggest difference is , Any type of value can be assigned to any, meanwhile any The value of type can also be assigned to any type ; But for the unknown , Any type of value can be assigned to it , But it can only be assigned to unknown and any.

let a: unknown = 123;
let b: any = 123;
let c: number = 123;
// c = a;// Report errors 
// a = c;// Sure 
// b = c;// Sure 
c = b;// Sure 

In the face of unknown Type before performing the operation , It must be narrowed down .

let obj: unknown = {
    x: 1,
}

// console.log(obj.getX());// Report errors 

// 1、 Use typeof
if (typeof obj === 'object' && obj !== null) {
    console.log(obj.toString());
}

// 2、 Types of assertions 
console.log((obj as object).toString())

never

never Represents a type of value that never exists , There are two situations ： Exception thrown during function execution , So there will never be a return value ; Function body is an endless loop , There will never be a return value .

//  Throw an exception 
function tErr(): never {
    throw new Error('error');
}

//  Dead cycle 
function noRes(): never {
    while (true);
}

never Combined with other types , There will be no never.

// type t = string | number
type t = string | number | never

Types of assertions

Similar to type conversion .

let str: any = "hello";
// 1、 Parenthesis grammar 
let l: number = (<string>str).length;
// 2、as grammar 
let l2: number = (str as string).length;

type inference

When the variable type is not specified ,TS It will automatically infer the specific type .

let s = 'hello';
// s = 123;// Report errors , Because above s To be inferred as string type 

let temp;
temp = 'hello';
temp = 1;// Sure , Because on the top temp To be inferred as any type 

Joint type

The type value is one of many types .

let a: string | number = 'hello';
a = 123;

Cross type

Combine multiple types into one type , Add the existing multiple types together to form a type , It contains all the types of features you need .

interface IA {
    name: string
    age: number
}

interface IB {
    name: string
    id: number
}

//  Need to include IA and IB All attributes of 
let a: IA & IB = {
    name: 'Jack',
    age: 11,
    id: 1
}

a both IA type , It's also IB type .