ts学习之基础知识1（ts种定义属性的写法，类型注解和类型推断，interface对象类型，ts里面关于类的使用，类的存取器）

ts种定义属性的写法

基本类型属性

let num: number = 11;
let str: string = '11';	

对象类型属性

let obj: {
      name: string } = {
      name: '张三' }

数组类型属性

let arr: number[] = [ 1,2 ]  //代表类型是数组，并且数组里面只能是数字

class类型属性

 class Person();  const obj:Person = new Person();  //代表函数对象
 class Person{
     
	age:number;
	constructor(){
     
		this.age = 18
	}
}

函数类型属性

const fn:() =>number = () =>{
      return 123; } //代表返回类型为数字的函数

类型注解和类型推断

（1）类型注解：
就是像上面这样，自己告诉ts使用什么类型，使用情况是ts无法推断出来的变量
（2）类型推断：
ts自动根据内容推断出是什么类型
（3）那什么时候使用类型注解呢

function fn( num1 , num2 ) {
      return num1+num2 }  let count =  fn( 1,2 ) 
//像上面代码是无法推断出num1和2的类型的，那么就需要做类型注解

像下面的代码：

function fn( num1: number , num2: number){
      return num1+num2 }  //这样就能检测到类型

（4）并且对于函数的类型注解，可以设置整体函数返回的值的类型

function fn( num1: number , num2: number): string {
      return num1+num2+'11' }  //表示返回的类型是字符串类型

（5）如果传进去函数的是一个对象作为参数呢

function fn( {
     num1 , num2} : {
      num1 : number, num2 : string } ): string {
      return num1+num2 }   //在函数内这样注解
fn ( {
      num1: 1, num2 : '123'}  //传值

（6）数组内有多种类型的注解方法：

let arr: (string | number)[] = ['1','2',3]  //这里是两种类型
let arr1: any[] = ['1',1,[],{
     }]  //代表所有类型都可以

（7）类型别名的用法，如下面代码：

let obj : objName = [ {
      'name': '11', 'age':18 }, {
     'name': '22', 'age': 20} ] ;  
type objName = {
      name:string,age:number }  //这里定义属性类型

（8）元组使用方法：

let arr:[ string, string, number ] = [ 'a', 'b',1 ];  //规定好每一项的类型
//二维数组
let arr1: [ string, string, number ][] = [ [ 'a','b',1 ],['a','b',1],['a','b',1] ]    

let arr:[ string , string, number, number ] = [ 'a', 'b',1 ];  //会报错  

interface对象类型

作用：定义 对象 的类型，其实就是校验工具，用法如下:
首先是interface接口的使用规范：
1、定义的对象第一字母大写
2、注意interface里面每一个属性定义类型时候用分号隔开
使用：

interface Person {
      name:string;sex:string }  //定义属性类型
let obj: Person = {
      name:'11', sex: '男' }  //基本使用方法

interface Person {
      name:string; sex:string; age?:number }    //?: 表示可有可无属性
let obj: Person = {
      name:'11', sex: '男' } // ?: 表示可有可无属性

interface Person {
      name:string; sex:string; [propName:string] : any; }    
let obj: Person = {
      name:'11', sex: '男', a:1, b:2, c:3}
//上面这段代码中[propName:string] : any  ，[propName:string]代表的是属性是字符串类型的属性，如abc ,属性值是任意类型

再比如：

interface Person {
      name:string; sex:string; [propName:string] : any; }    
let obj: Person = {
      name:'11', sex: '男', a:1, b:2, run(){
      return '11'}} //这里多了个方法，也可以的
//但是
//如果再定义个方法：
interface Person {
      name:string; sex:string; [propName:string] : any; run():number} //这里代表的是run方法返回的必须是数字类型  
 let obj: Person = {
      name:'11', sex: '男', a:1, b:2, run(){
      return '11'}}

再如：只读类型

interface Person {
      readonly name:string;sex:string }  //加一个readonly 就可以  
let obj: Person = {
      name:'11', sex: '男' } 

ts里面关于类的写法，它是综合了es6和es7

首先es6的写法：

class Person ({
      constructor(){
      this.name = '张三' } })   //类的内容必须放到constructor里面，然后使用this标注以下

然后es7写法：

calss Person ({
      name = '李四'  constructor(){
     } }) //不需要this，并且constructor可有可无

那上面如何使用上面这个类呢，只需要：

let obj = new Person()   //这样，之后就可以使用obj.name  得到张三

那如何实现类的继承呢，只需要这样

class Child extends Person {
       }  let obj = new Child 
// 这样就继承上面的parent类，出来了child类，它带有父类的所有属性，new下就可以用，并且遵循原型链

再如：如果想要再子类去拿父类的作为子类的东西，可以这样

class Child extends Person {
      run(){
      return super.run() } }  

ts里面关于类的使用

类的修饰符：
public : 表示定义的属性，只能再任何地方都能访问到
private: 表示定义属性或者方法只能再类的内部访问到
比如：再父类里面定义一个private name :string 如果使用的时候 比如拿来用： obj.name 就 会报错 比如继承给子类，子类拿来用 this.name 也会报错
protected: 类似private ，但这个可以再子类中使用 ，不会报错
然后正常使用类是如何使用的呢：

class Parent {
      name: string; constructor(){
      this.name = 'zhnagsan' } } 
class child extends Parent {
       }

其实可以简写：
比如：

class Parent {
      public name: string; constructor( name: string ){
      this.name = name } }

可以简写成：

class Parennt {
      constructor( public name: string ){
       } }  //这样子就代表定义了类型，并且省去了this.name = name 

然后继承的时候也可以使用，比如：

class child extends Parent{
      constructor( public age:number ){
      super( '张三' ) } }  //这里继承的时候，自己定义age属性，并且必须需要使用super()来拿到父级的东西

类的存取器

如果想要在类外部使用私有属性呢，就可以用到你类的存取器

class Parent {
       constructor(private _name: string) {
       }   //这里定义了一个类  注意，要使用name这个属性，就需要在这个属性面前加 下横线 
 get name(){
       return this._name  }      //读取私有属性
 set name(name){
         this._name = name  }    //赋值私有属性
}
//最后看：
let obj = new Parent('张三')   
obj.name = '李四'  //这里才可以赋值
console.log(obj.name);  //这里才可以读取

抽象类abstract

作用：就是定义抽象类和抽象方法，抽象是什么意思呢，就是比如定义一个dog类，一个cat类，然后再定义一个抽象类比如animal类，这个animal类就是用来定义前面两个类相同的属性，。抽象方法就是他们都会用到的方法，但是抽象类是不可以实例化，就是拿来用的

	//抽象类 
	abstract  class animal {
         //类似interface
	  age:number;
	  getType(){
     
	    return 'animal'
	  }
	  abstract call():string    
	}
	

	class Dog extends animal {
     
	  call(){
                          //定义了抽象类，就必须再子类中使用
	    return '汪汪'
	  }
	}

	class Cat extends animal {
     
	  call(){
     
 	   return '喵喵'
	  }
	}