11.1函数，类

any任何类型编译阶段不报错

类型断言

类型断言只能够「欺骗」TypeScript 编译器，无法避免运行时的错误。

语法: 值 as 类型 或者 <类型>值

断言的类型必须在联合类型中存在

let someValue: any = "this is a string";
let strLength: number = (someValue as string).length;

let someValue: any = "this is a string";
let strLength: number = (<string>someValue).length;

函数：

返回值和参数都给类型，返回值的类型也可自动推出

两种方式为函数定义类型

声明式：只有一种

function add(x: number, y: number): number {
    return x + y;
}

定义式:只要是引用的方式都是

let myAdd = function(x: number, y: number): number { return x + y; };

参数定义后不能传多传少，

区分数组与元祖

//函数有2个参数 是number  和数组(任意数据)  返回值是元祖:2个数据第一个必须是number 第二个必须是数组

function fm(arg1:number,arg2:any[]):[number,any[]]{
   
   return [arg1*arg1,[10,"hello",arg2]]
}

never：永不结束的数据类型

抛出错误，死循环

可选参数：？

interface Params{
    params:object
}
//可选参数
function Myaxiosget(arg1:string,arg2?:Params){}

默认参数：=   给了默认值 这个参数就是可选参数

function fn(arg1:number,agr2:string="test"):void{  //void  空
    console.log(arg1,agr2)
}
fn(100,"hello")
fn(200)    //200 test    因为test为默认参数

参数位置：

1.可选参数放必填参数后面

2.可选参数不传值可用undefined表示（补值）

3.默认参数可放必填参数前面

function  fn(arg1:number,arg2?:boolean,arg3?:string){}
fn(100,undefined,"hello")

bug: 不传值就是用默认的,传值就需要传一个undefined进来使用

剩余参数

...rest

function fn(arg1:number,arg2:string,...rest):void{
    console.log(arg1,arg2,rest)
}

函数类型

定义式比声明式作用更广

参数和返回值来对函数进行分类

（参数1：类型，参数2：类型，...）=>返回值类型

参数名可变

let fn:(arg1:number,arg2:number,arg3:boolean)=>[number,number,boolean];

fn=function(arg1:number,arg3:number,arg2:boolean):[number,number,boolean]{
    return [arg1+100,arg3,arg2]
}

接口

interface MyTool{
    (number):number
}

let fn:MyTool;
fn=(arg:number):number=>{
    return arg*100
}
// fn=(arg:number):string=>"hello"    //报错

interface MyTool{
    ():number
}
interface MyTool2{
   (fn:(arg:number)=>MyTool,fm:number):(arg:number)=>MyTool
}

let fg:MyTool2;
fg=(arg1:(arg:number)=>MyTool,arg2:number):(number)=>MyTool=>{
     //(arg:number)=>MyTool
    return function(a:number):MyTool{return ():number=>100}
}

类：

将数据（属性）以及这些数据上的操作（方法）封装在一起

类和对象是面向对象编程技术中的最基本的概念。

类与对象的关系

1. 类是对象的抽象，而对象是类的具体实例，是通过new classname产生的。

2. 类是抽象的，不占用内存，而对象是具体的，占用存储空间。

3. 类是用于创建对象的蓝图（规划，抽象）。

1.面向对象（OOP）的三大特性：封装、继承、多态；

  封装（Encapsulation）：将对数据的操作细节隐藏起来，只暴露对外的接口。外界调用端不需要（也不可能）知道细节，就能通过对外提供的接口来访问该对象，同时也保证了外界无法任意更改对象内部的数据；

继承（Inheritance）：子类继承父类，子类除了拥有父类的所有特性外，还有一些更具体的特性；

多态（Polymorphism）：由继承而产生了相关的不同的类，对同一个方法可以有不同的响应。比如 Cat 和 Dog 都继承自 Animal，但是分别实现了自己的 eat 方法；

2.存取器（getter & setter） 的作用：用以改变属性的读取和赋值行为；

3.修饰符（Modifiers）：修饰符是一些关键字，用于限定成员或类型的性质。比如 public 表示公有属性或方法；

4.抽象类（Abstract Class）：抽象类是供其他类继承的基类，抽象类不允许被实例化。抽象类中的抽象方法必须在子类中被实现；

5.接口（Interfaces）：不同类之间公有的属性或方法，可以抽象成一个接口。接口可以被类实现（implements）。一个类只能继承自另一个类，但是可以实现多个接口；

字段和属性的区别

 constructor(){ }如果写了就是调用自己写的 不写会有一个默认的空的constructor调用

new  创建对象的时候  会自动去调用构造函数

//类属性的声明

class Person{
    //类为未来创建的对象声明属性
    birth:string;
    name:string;
    money:number=100; //类为未来创建的对象声明属性 而且初始化  
    m1 = (a:number, b:number)=>{    //字段
		console.log("m1")
	  }
    color:string;   
    say(){};
    makemoney(){}
    tool(arg:number):number{return 100}
    constructor(arg1:string,arg2?:number){
        this.birth="默认值" //为已经创建对象初始化属性值,属性值是直接生成的数据
        this.name=arg1//为已经创建对象初始化属性值,属性值是创建对象时传入的数据
        // this.money=100
        // this.color="red"//初始化
        arg2&&(this.money=arg2)
    }
}

let p1=new Person("张三")
p1.birth="1995-02-03"//为对象更新属性
p1.color="red"//js中可以为对象添加新成员  TS只能在类内部提前声明
console.log(p1,p1.birth)