基础知识

1、特点

var
- 作用域
- 重复声明
let
- 块级作用域
- 在同一个块中不能重复声明
const
- 声明同时必须赋值
- 一旦声明不可改变（对象可以修改）
- 块级作用域
//强类型语言 声明变量要指明其类型
var str:string  = "hello world"

2、数据类型

//number,string,boolean
var num:number= 10;
var str:string = "hello world";
var b:boolean = true

//Array
var arr:string [] = ['html','css','javascript']
var all:number [] = [ 1,2,3]
// object
var obj:object = {
    name:"lisi",
    age:14
}

//声明一个数组,里面的元素是object
var list:object [] = [{name:"cheng",age:20},{name:"zhang",age:19}]

2-1 枚举类型

// 枚举
enum Status {
    success=200,
    fail=404,
    serverError=500
}
var s:Status = Status.success;
console.log(s);

2-2 any

// 指明数据类型为any后就不会类型检查了,数据可以改变成任意类型
var data:any = [1,2,3];
data = 'hello world';
data = 1442;
console.log(data);

2-3 void 没有返回值

function go():void{
    console.log("hello world")
}
go()
function test():number{
    console.log("a");
    return 10;
}

2-4 null和undefined

var n:null;
n = 20; //报错,因为变量已经声明为null,不能改变为其他类型
var s:null|number;
s = 30;

2-5泛型(任意，类型检查)

// 通俗理解:泛型就是解决类,接口,方法的复用性。以及对不特定数据类型的支持。
// function getData(value:any){
//     console.log(value)
// }
// 局限性 只能传入特定的类型
// any放弃了类型检查
// 既然有类型检查,又想传想传什么就传什么
// 任意类型:  任意,类型检查
function getData<T>(value:T){
    console.log(value)
}
getData<string>("hello")
getData<number>(113);

class Person<T>{
    print(msg:T){
        console.log(msg)
    }
}
class Student{
    name:string;
    age:number;
    constructor(name:string,age:number){
        this.name = name;
        this.age = age;
    }
}
var p = new Student("cheng",20);
var son = new Person<string>();
son.print("hello")
var li = new Person<Student>();
li.print(p);

3、函数

3-1带参数的函数

function fn(name:string,age:number):number{
    console.log(name,age)
    return 10;
}
fn("cheng",10)

3-2 函数的默认参数

function fn(name:string,age:number=20):number{
    console.log(name,age)
    return 10;
}
fn("cheng")

3-3 函数的可选参数

//设置可选参数之后,调用函数的时候,这个参数是可传可不传的
function fn(name:string,age?:number):number{
    console.log(name,age)
    return 10;
}
fn("cheng")

4、class

// private  私有的 作用范围只能类中
// public   共有的  其他类也可以访问
//不写变量修饰符  默认就是共有的
//person.ts
class Person {
    //类的一个属性
    name:string;
    age:number;
    constructor(name:string,age:number){
        this.name = name;
        this.age = age;
    }
    getName():void{
        console.log(this.name)
    }
}
export default Person;
import Person from './person'
// 继承 子类继承父类,子类的构造函数中第一行一定要加super
// 子类中调用父类的方法,this,super都可以调用
class Student extends Person {
    skill:string;
    constructor(name:string,age:number,skill:string){
        super(name,age);
        this.skill = skill;
    }
}
var s:Student = new Student("zhang",20,"lol");
console.log(s);
s.getName()

装饰器

// 装饰器  在不修改类的前提下对类的拓展
function addName(target:any){
    target.prototype.name = "cheng"
}
@addName
class Person{
    getData(){
        console.log("hello world")
    }
}
var p:any= new Person();
console.log(p.name);

5、接口

// 接口  在面向对象的编程中,接口一中规范。定义了行为的规范,在程序设计中，接口起来了限制和规范的作用
interface Animal {
    eat():any;
    run():any;
}
// 实现一个接口必须对里面的方法重写
class Dog  implements Animal {
    eat():void{
        console.log("吃骨头")
    }
    run():void{
        console.log("狗刨")
    }
}