TypeScript 语言基础

变量声明

let value:string ="hello,world!"

//let :关键字,代表变量,与它相对的关键字是const 代表常量
//value :变量名,用户自定义
// string :变量的数据类型
//  "hello,world!" :变量value 的初始化值

常用数据类型

let value:string ="hello,world!"
// string 字符串,可以用单引号或双引号

let value:number =20
//number 数值, 整数,浮点数都行
//十进制(22)，十六进制(0x22)，八进制(012),二进制(0b11)都行

let value:boolean =ture
//boolean 布尔类型


let x: [string, number]=['hello', 10];
//元组类型允许表示一个已知元素数量和类型的数组，
//各元素的类型不必相同。 

let value:any ="jack"
value =18
// any 不确定什么类型，可以是任何类型


enum Color {Red, Green, Blue};      //枚举
let c: Color = Color.Green;      //枚举变量 c
//enum类型是对JavaScript标准数据类型的一个补充，
//使用枚举类型可以为一组数值赋予友好的名字。


let notSure: unknown = 4;
notSure = 'maybe a string instead';
notSure = false;
//不希望类型检查器对这些值进行检查而是直接让它们通过
//编译阶段的检查。那么我们可以使用unknown类型来标记这些变量


let u: undefined = undefined;
let n: null = null;
//TypeScript里，undefined和null两者各自有自己的类型
//分别叫做undefined和null。


let value:number|string|boolean ='jack'
value=30
// union 联合类型，可以是多个指定类型中的一种

let p={name:'jack',age:25}
// 定义对象，不用写具体类型

p.name   //调用对象中的成员----方法一
p['age']  //调用对象中的成员----方法二

console.log("age: "+p.age)   //向控制台输出内容"age: 25"


let values:number[] =[12,34]
let ages:Array<string> =["jack",'rose']
//定义数组的两种方法,元素可以是其他任意类型
console.log(ages[1])
//访问数组ages

条件控制

if-else

let value:number =15
if(value>0)
{
   console.log(value+"是正数")
}
else if(value===0)     //"==="该运算符是比较运算符，
                       //也可以用"==",后者在比较时需要判断 
                       //双方数据类型是否一致,而前者则不需要。
{
   console.log(value+"是负数")
}
else
{
   console.log(value+"是0")
}

在TypeScript中,空字符串,数字0,null,undefined都被认为是false,其他值则为true。

switch

与C语言switch用法类似。

let grade: string='A'
switch(grade)
{
  case 'A' :
  {
      console.log("优秀")
      break;
  }
  case 'B' :
  {
      console.log("良好")
      break;
  }
  case 'C' :
  {
      console.log("合格")
      break;
  }
  default :
  {
      console.log("非法输入")
      break;
  }
}

循环迭代

for与while

与C++语法类似。

//普通for
for(let i=0;i<10;i++)
{
     console.log("第"+i+"次")
}

//普通while
let i=0;
while(i<10)
{
   console.log("第"+i+"次")
   i++
}

//迭代器iterator
//当一个对象实现了Symbol.iterator属性时，我们认为它是可迭代的。
//一些内置的类型如Array，Map，Set，String，
//Int32Array，Uint32Array等都具有可迭代性。

let values:string[] =["jake","rose"]
for(const i in values)  //for in 迭代器,获得数组各个元素的下标
{
   console.log(i+":"+values[i])
}

for(const value of values)  //for of 迭代器,
                           //直接获得数组各个元素
{
   console.log(value)
}

函数

普通函数

形式: function 函数名(参数1名:参数1类型,参数2名:参数2类型):函数返回值类型

//函数定义
function  say666(name:string):number
{
 console.log(name+" say 666")
 return 6
}

//匿名函数
let myAdd = function (x: number, y: number): number
{
        return x + y;
};

//函数调用
let result=say666("jack")   //已经默认result是number类型的了

箭头函数(普通函数的简写)

let result=(name:string) =>{
console.log(name+" say 666")
}
result("jack")     //箭头函数的调用

可选参数,默认参数,剩余参数

//可选参数,在参数名后面添加?,表示该参数是可选的
function  say666(name?:string):void
{
//判断name 是否有值,若无值,则给个默认值
 name=name? name : "陌生人"  //三目运算符
 console.log(name+" say 666")
}

//函数的调用,两者都可以
say666("rose")
say666()

//剩余参数会被当做个数不限的可选参数,可以一个都没有，
//同样也可以有任意个。 可以使用省略号（ ...）进行定义：

function getEmployeeName(firstName: string, 
...restOfName: string[])      //...restOfName 叫剩余参数
{
  return firstName + ' ' + restOfName.join(' ');
}

let employeeName = getEmployeeName('Joseph', 'Samuel', 
'Lucas', 'MacKinzie');

function  say666(name:string="陌生人"):void    //默认参数
{
 console.log(name+" say 666")
}

//函数的调用,两者都可以
say666("rose")
say666()

类和接口

TypeScript中,类和接口中声明和定义的方法都不用添加关键字function

接口(抽象父类)与类

接口(interface): 用于声明函数

类(class): 用于实现接口---即实现函数定义

接口与类的关系可以看作父类(抽象父类)与子类的关系,接口类似C++中的纯虚函数

//定义枚举
enum Msg{
 Hi="Hi"
 HELLO ="hello"
}

//定义一个接口,里面是抽象方法声明(函数声明)
interface A{
    say(msg::Msg):void    //参数是一个枚举类型的
}

//实现接口
class B implements A{
    say(msg::Msg):void{
        console.log(msg+",I am B")
    }
}

//初始化对象
let a:A= new B()    //这里是父类(A)变量接收了子类(B)的对象
                    //也可以是子类(B)变量接收子类(B)对象
                    //类多态的体现
                    
a.say(Msg.Hi)     //调用方法，传递枚举参数

类的继承

//定义矩形类
class Rectangle
{
   //成员变量，不需要let关键字
   private  width: number
   private  length: number
   private  tap: string
   
   //构造函数，constructor是关键字
   constructor(width:number,length:number,tap:string)
   {
       this.width = width
       this.length = length
       this.tap=tap
   }
   
   //成员方法
   public area(): number
   {
       return this.width * this.length
   }
   
public getTap(): string 
{
    return  `this tap is  ${this.tap}`;  
}


//定义正方形类
class Square extends Rectangle   //继承父类Rectangle
{
    constructor(side: number,tap:string)
    {
        //调用父类构造
        super(side,side,tap)
    }
}

let s:Square = new Square(20,"世界")
console.log("正方形面积是"+s.area())

模块开发

当应用复杂时，我们可以将通用功能抽取到单独的ts文件(TypeScript文件),每个文件都是一个模块(model)。模块可以相互加载，提高代码复用性。

//使用export将代码导出，方便其他人使用
export class Rectangle
{
   //成员变量，不需要let关键字
   private  width: number
   private  length: number
   
   //构造函数，constructor是关键字
   constructor(width::number,length::number)
   {
       this.width = width
       this.length = length
   }
   
   //成员方法
   public area(): number
   {
       return this.width * this.length
   }
}

//使用export将代码导出，方便其他人使用
export function  say666(name:string="陌生人"):void  
{
   console.log(name+" say 666")
}

import{Rectangle,say666} from  文件所在路径
//导入模块代码  Rectangle和say666