TypeScript-数据类型

//number类型
let a:number=1;
console.log(a);

//string类型
let b:string='hello';
console.log(b);

//boolean类型
let c:boolean=false;
console.log(c);

//字面量:其本身，限制变量的值就是该字面量的值,像本例子中d变量的类型是 ‘hello’和'ts'，它只能兼容
//字面量值为 ‘hello’和'ts' 的变量，也只能接受 ‘hello’和'ts' 作为赋值数据。并且对于字面量来说，
//它接受string,number,boolean单独用或者是混合用。
let d:"hello"|'ts';
// d="hello"
// console.log(d);//hello
// d='ts'
// console.log(d);//ts
d="hello"
d='ts'
console.log(d+' '+d)//'ts' 'ts'

let e:'aa'|1
e='aa'
console.log(e)//'aa'
e=1;
console.log(e)//1

//any类型，表示任意类型,像let f:any;叫做显示any；let f叫做隐式any.
let f:any=1;
console.log(f)//1
f='ffff'
console.log(f)//'ffff'

//unknown类型，表示未知类型，定义一个变量为unknown类型，则可以给这个变量赋任何
//值，听起来这和any好像差不多，它们两个的区别是：
//any类型的变量可以赋值给任何类型的变量并且不会报错，如下：
let str:string;
str=f;
//但是对于unknown类型的变量就不能随便赋值给其他变量了，如下：
let g:unknown='hello';
// str=g;//Type 'unknown' is not assignable to type 'string'.
//可以说unknown是一个类型安全的any
//回到本例，如果我非要将unknown类型的值赋给string类型的变量，该怎么做？答：使用类型断言 ①变量 as 类型 ②<类型>变量
str=g as string;
str=<string>g;

//void类型，一般用在函数中，以函数为例，表示函数没有返回值，return null | undefined | ;结果一样。
function fn():void{

}

//never类型，一般用在报异常函数中，以报异常函数为例，只要执行这个函数，就会报异常，然后函数结束执行，永远不会返回
//结果.
function fn1(): never {
throw new Error('error');
}

//object类型,ts中的对象，在声明变量为一个对象类型时，可以怎么做：let obj:{},使用{}用来指定对象中可以包含哪些属性
//语法：{属性名：属性值，属性名：属性值},在使用{}来声明变量后，给变量赋值时，也要赋相同的属性名的值，数量也要一样，
//不能多不能少，，否则会报错。
let obj:{name:string,age:number};
obj={name:'lio',age:21}
//如果这样声明了，但是赋值的时候不想写age了，又不想报错，那么可以这样，在声明的时候给那个不想赋的属性名后面加上？
//表示这个属性可有可没有。
let obj1:{name:string,age?:number};
obj1={name:'lio'}
//假设有这样一个需求，要求对象obj2中必须有name属性，其他的属性都是可有可没有的，可以这样实现：
let obj2:{name:string,[propName:string]:any};
obj2={name:'iop',aa:'wqw'}
//对于function，要求声明函数时表明函数的参数类型，参数个数，返回类型，可以这样写设置函数结构的类型声明，语法
//(形参：类型，形参：类型，...)：
let fn3:(a:number,b:number)=>number;
fn3=function (n1,n2){
    return n1+n2;
}

//array类型，声明一个string|number|..类型的数组，可以①：
let arr:string[];
arr=['aa','bb','cc'];
console.log(arr);//[ 'aa', 'bb', 'cc' ]
//②：
let arr1:Array<string>;
arr1=['aa','bb','cc'];
console.log(arr1);//[ 'aa', 'bb', 'cc' ]


//tuple类型，元祖就是固定长度的数组,语法：[类型，类型,...]
let tup:[string,string];
tup=['aa','bb'];
console.log(tup);//[ 'aa', 'bb' ]

//enum类型，枚举，
enum Gender{
    Male=0,
    Female=1
}
let people:{name:string,grnder:Gender};
people={
    name:'llo',
    grnder:Gender.Male
}

//类型别名
type mytype=1 | 2 | 3 | 4;
let k:1|2|3|4;
let k1:mytype;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

编译后的1.js:

//number类型
var a = 1;
console.log(a);
//string类型
var b = 'hello';
console.log(b);
//boolean类型
var c = false;
console.log(c);
//字面量:其本身，限制变量的值就是该字面量的值,像本例子中d变量的类型是 ‘hello’和'ts'，它只能兼容
//字面量值为 ‘hello’和'ts' 的变量，也只能接受 ‘hello’和'ts' 作为赋值数据。并且对于字面量来说，
//它接受string,number,boolean单独用或者是混合用。
var d;
// d="hello"
// console.log(d);//hello
// d='ts'
// console.log(d);//ts
d = "hello";
d = 'ts';
console.log(d + ' ' + d); //'ts' 'ts'
var e;
e = 'aa';
console.log(e); //'aa'
e = 1;
console.log(e); //1
//any类型，表示任意类型,像let f:any;叫做显示any；let f叫做隐式any.
var f = 1;
console.log(f); //1
f = 'ffff';
console.log(f); //'ffff'
//unknown类型，表示未知类型，定义一个变量为unknown类型，则可以给这个变量赋任何
//值，听起来这和any好像差不多，它们两个的区别是：
//any类型的变量可以赋值给任何类型的变量并且不会报错，如下：
var str;
str = f;
//但是对于unknown类型的变量就不能随便赋值给其他变量了，如下：
var g = 'hello';
// str=g;//Type 'unknown' is not assignable to type 'string'.
//可以说unknown是一个类型安全的any
//回到本例，如果我非要将unknown类型的值赋给string类型的变量，该怎么做？答：使用类型断言 ①变量 as 类型 ②<类型>变量
str = g;
str = g;
//void类型，一般用在函数中，以函数为例，表示函数没有返回值，return null | undefined | ;结果一样。
function fn() {
}
//never类型，一般用在报异常函数中，以报异常函数为例，只要执行这个函数，就会报异常，然后函数结束执行，永远不会返回
//结果.
function fn1() {
    throw new Error('error');
}

//object类型,ts中的对象，在声明变量为一个对象类型时，可以怎么做：let obj:{},使用{}用来指定对象中可以包含哪些属性
//语法：{属性名：属性值，属性名：属性值},在使用{}来声明变量后，给变量赋值时，也要赋相同的属性名的值，数量也要一样，
//不能多不能少，，否则会报错。
var obj;
obj = { name: 'lio', age: 21 };
//如果这样声明了，但是赋值的时候不想写age了，又不想报错，那么可以这样，在声明的时候给那个不想赋的属性名后面加上？
//表示这个属性可有可没有。
var obj1;
obj1 = { name: 'lio' };
//假设有这样一个需求，要求对象obj2中必须有name属性，其他的属性都是可有可没有的，可以这样实现：
var obj2;
obj2 = { name: 'iop', aa: 'wqw' };
//对于function，要求声明函数时表明函数的参数类型，参数个数，返回类型，可以这样写设置函数结构的类型声明，语法
//(形参：类型，形参：类型，...)：
var fn3;
fn3 = function (n1, n2) {
    return n1 + n2;
};
//array类型，声明一个string|number|..类型的数组，可以①：
var arr;
arr = ['aa', 'bb', 'cc'];
console.log(arr); //[ 'aa', 'bb', 'cc' ]
//②：
var arr1;
arr1 = ['aa', 'bb', 'cc'];
console.log(arr1); //[ 'aa', 'bb', 'cc' ]
//tuple类型，元祖就是固定长度的数组,语法：[类型，类型,...]
var tup;
tup = ['aa', 'bb'];
console.log(tup);
//enum类型，枚举，
var Gender;
(function (Gender) {
    Gender[Gender["Male"] = 0] = "Male";
    Gender[Gender["Female"] = 1] = "Female";
})(Gender || (Gender = {}));
var people;
people = {
    name: 'llo',
    grnder: Gender.Male
};
var k;
var k1;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94