TS initial use, TS type

ts Type statement

// Parameters a,b, The type of the return value of the function is declared as number type , If there is a non in the transmission parameter number Data of type , A red wavy line will be displayed 
function sum(a: number, b: number): number {
    
    return a + b
}

console.log(sum(1, 9)); //10

// Here a amount to const Defined ,a The value of is always 10
let a: 10;

//b The value of can only be  'male' perhaps 'female'
let b: 	'male' | 'female'

//b The value of can only be  boolean Type or string type 
let c: 	boolean | string

//any  Represents any type of , You can give d Assign any type of value ( It's equivalent to d Shut down the TS Type detection of )
let d: any 
d = true
// Equate to  let d

let s: string
s = d // d yes any type ,s Also became any type （ So try to avoid using any）

//unknown  Indicates an unknown type , You can also give d Assign any type of value 
let e: unknown
e = 'hellow'

let s: string
//s = e //  Grammar detection failed , because s yes string type ,e yes unknown type , Their types are different , Direct assignment is not allowed 

// If you just want to e The value is assigned to s, There are two solutions 
 Method 1 ：
if(typeof e === "string") {
    
	s  = e
}

 Method 2 ：
// Use type assertion 
s = e as string
 perhaps ： 
s = <string>e

// void  It is used to express empty , Take functions for example , It means that there is no return value 
function fn(): void {
    
}

function fn(): void {
    
	//return undefined
	//return;
	//return null
}

Once the function reports an error, it immediately terminates ,never Rarely used

// {}  Used to specify the object type 
let a: {
    name: string}
// a There are and only name attribute , And name Value must be string type 
a = {
    name: ' Pig eight quit '}


let b: {
    name: string, age?: number}
// b There must be name attribute , And name Value must be string type ;age not essential ;
b = {
    name: ' Pig eight quit '}
 perhaps 
b = {
    name: ' Pig eight quit ', age: 18}


let c: {
    name: string, [propName: string]: number}
// b There must be name attribute , And name Value must be string type ; Number of remaining attributes , Attribute names are not required , But it must be number type 
c = {
    name: ' Pig eight quit ', haha: 12, xixi: 99}


// () => {}  Used to specify the function object type 
let d: (a: number, b: number)=>number
// function d Only two are received number Parameters of type , And the return value must be number type 
d = function(n1: number, n2: number): number {
    
	return n1 + n2
}

// []  Used to specify the array type 
let a: number[]
 Equate to 
let a: Array<number>
a = [1,3,6,5,9]

//tuple Is a tuple （ts newly added ）, Tuples represent fixed length arrays 
let a: [string, number]
// Array a There are only two elements in it , The first is string type , The second is number type 
a = [1, '2']

//enum Is the enumeration （ts newly added ）
enum Gender{
    
	male,
	female
}

let a: {
    name: string, gender: Gender}
a = {
    name: ' Pig eight quit ', gender: Gender.male} 

// &  Indicates simultaneous 
let a: {
    name: string} & {
    age: number}
 Equate to 
let a: {
    name: string, age: number}
// object a There must be both name and age, And the type is the specified type 
a = {
    name: ' Pig eight quit ', age: 18}

// Alias for type  
type myType = 1 | 2 | 3 
let a: myType
let c: mType
a = 1, c = 3 
// a、c The value of is 1 or 2 or 3, Will do