数据类型
/**
* 数据类型
*/
let s: string;
let n: number;
let b: boolean;
// 数组
let arr1: string[] = ['a', 'b', 'c'];
let arr2: Array<number> = [1, 2, 3, 4, 5];
let tuple: [string, number] = ['a', 1]; // 元祖
let arr3: (string|number)[] = ['a', 1];
let anyList: any[] = ['a', 1, true];
// 枚举
enum Directions{
left=2,
right,
top,
bottom
}
console.log(Directions.top);
console.log(Directions[2]);
// 对象
interface LabelledValue {
label: string;
}
function printLabel(labelledObj: LabelledValue) {
console.log(labelledObj.label);
}
let myObj = {size: 10, label: "Size 10 Object"};
printLabel(myObj);
// 函数
interface SearchFunc{
(source: string, subString: string): boolean
}
let mySearch: SearchFunc;
mySearch = function(source:string, subString: string): boolean{
let result = source.search(subString);
return result>-1;
}
// 其它方式
interface Person {
age:number
}
interface Musician extends Person {
instrument:string
}
var drummer = <Musician>{};
函数:
function add(x: number, y: number): number{
return x+y;
}
let myAdd = function(x: number, y: number): number{
return x+y;
}
// 函数的完整类型
let myAdd_: (baseValue: number, increment: number) => number = function(x: number, y: number): number{
return x+y;
}
类
class Person{
name: string; // 属性必须赋值或者在构造函数中初始化
age: number;
constructor(name: string, age: number){
this.name = name;
this.age = age;
}
// 方法必须实现
getName(): string{
return this.name;
}
}
抽象类:
abstract class Animal{
abstract type: string; // 抽象属性只需定义,无需实现(赋值或者在构造函数中初始化)
name: string; // 普通属性定义同一般类
constructor(name: string){
this.name = name;
}
abstract getType(): string; // 抽象方法只需定义,无需实现
getName(): string{ // 普通方法定义同一般类
return this.name;
}
getTheType(): string{
return this.type; // 普通方法中可以包含抽象属性
}
}
class Dog extends Animal{
type: string; // 类中必须实现所继承的抽象类中的属性
constructor(name: string, type: string){
super(name);
this.type = type;
}
// 类中必须实现所继承的抽象类中的方法
getType(): string{
return this.type;
}
}
接口
// 属性接口
interface LabelledValue {
label: string;
}
function printLabel(labelledObj: LabelledValue) {
console.log(labelledObj.label);
}
let myObj = {size: 10, label: "Size 10 Object"};
printLabel(myObj);
// 函数接口
interface SearchFunc{
(source: string, subString: string): boolean
}
let mySearch: SearchFunc;
mySearch = function(source:string, subString: string): boolean{
let result = source.search(subString);
return result>-1;
}
// 可索引类型接口
interface StringArray{
[index: number]: string;
}
let myArray: StringArray = ["Bob", "Fred"];
let myStr: string = myArray[0];
// 类接口
interface Girl{
// 接口中的属性和方法只需定义,无需实现
name: string;
age: number;
loveYou():void;
}
class GrilFirend implements Girl{
// 接口中的属性和方法必须实现
name: string;
age: number;
constructor(name: string, age: number){
this.name = name;
this.age = age;
}
loveYou():void{
console.log("Her name is " + this.name + ", her age is " + this.age);
}
}
let gf = new GrilFirend("Linda", 28);
gf.loveYou();
泛型
注意,无法创建泛型枚举和泛型命名空间。
类有两部分:静态部分和实例部分。 泛型类指的是实例部分的类型,所以类的静态属性不能使用这个泛型类型。
// 泛型函数
function showData<T>(person: T): T{
return person;
}
showData<string>('Lucy');
// 泛型类型1
interface GenericIdentityFn {
<T>(arg: T): T;
}
function identity<T>(arg: T): T {
return arg;
}
let myIdentity: GenericIdentityFn = identity;
// 泛型类型2
interface GenericIdentityFn<T> {
(arg: T): T;
}
function identity<T>(arg: T): T {
return arg;
}
let myIdentity: GenericIdentityFn<number> = identity;
// 泛型类
// 类有两部分:静态部分和实例部分。 泛型类指的是实例部分的类型,所以类的静态属性不能使用这个泛型类型。
class GenericNumber<T> {
zeroValue: T;
add: (x: T, y: T) => T;
}
let myGenericNumber = new GenericNumber<number>();
myGenericNumber.zeroValue = 0;
myGenericNumber.add = function(x, y) { return x + y; };