ts 中不允许变量同名
函数定义的两种方式
第一种：命名函数 = 声明式定义
function fn(){}
第二种：匿名函数
var fn = function(){}
function fn(x:string,y:string):string{ // x:string 这里指 变量x 的数据类型 y:string 这里是 变量y 的数据类型 ():string 这里指 函数return 的数据类型
return " hello world "
}
var fn=function(x:string,y:string):string{ // 与上面的解释一致
return "hello world"
}
约束函数
var sf:(x:string,y:string)=>string=function(a:string,b:string):string{
return "hello"
}
可选参数 ：使用 ？来实现可选参数的功能，可选参数一定要放后面
function fn(x:string,y?:string):string{
return "hello"
}
fn("hello","world") fn("hello") // 这两种写法都不会报错
默认参数：使用 = 给参数赋值
function fn(x:string,y:string="hello"):string{
return y;
}
fn("world") // = 给参数一个默认值
... 运算符：如果不确定传参的个数，我们可以用 ... 运算符来表示，且还会将元素转化成数组
function fn(...res):number{
console.log(res)
}
fn(12,24,36,48,60,72,84,96);
函数重载
在 js 里面不存在函数重载，但是有函数重写
函数重载的定义：函数名相同，跟据参数类型决定，使用哪个函数
函数重写：在 js 中，因为一旦函数名相同，后者会将前者覆盖
function fn(x){} // 像这里，我们没有指定数据类型，他会默认数据类型为 any （任何类型），但是 一般情况下 还是要加的
ts重载 案例：
定义两个函数的数据类型，没有实现他的功能
function fn(x:number):number;
function fn(x:string):string;
function fn(x):any{
return x
}
fn(12) / fn("hello") // 这个案例是一个简单的写法 主要是看实参传递什么样的格式，以便正常的返回什么样的数据类型
ts 函数重载：定义一个函数的数据类型，函数会进行重载
原生 js 伪实现一个重载的案例：
function fn(x){
if(typeof x == "string"){
console.log("string")
}
else if (typeof x == "number"){
console.log("number")
}
}
fn(12)
类
案例：
class Person{
name:string; // 定义属性
age:number;
constructor(name:string,age:number){ // 实例
this.name=name;
this.age=age;
}
run(){
console.log("hello world") // 这个是定义方法
}
}
var person = new Person("zhang",20);
定义类的注意事项
1. ts 定义类，首先如果有属性，一定要定义属性，指定数据类型，不加修饰符，默认是 public
2. ts 中，类没有原型概念
3. new 实例的时候，就是调用构造函数
4. 方法中的 this 指向实例对象
类的继承：关键字 extends super
案例：
class Animal{
name:string;
age:number;
constructor(name:string,age:number){
this.name=name;
this.age=age;
}
move(){
console.log(this.name);
}
}
class Dog extends Animal{
constructor(name:string,age:number){
super(name,age)
}
}
var shinubi = new Dog("史努比",7);
shinubi.move()
多态：对父类的方法重写，并且子类之间，这个方法 表现/功能 不一样，这就叫多态，都是为了 继承 用的
多态的另一种解释：父类定义一个方法，没有去实现，由子类去实现，并且表现不一样，就也叫多态
多态的目的：都是继承用的
案例：
class Person{
move(){}
}
class dog extends Person{
move(){}
}
class cat extends Person{
move(){}
}
这个是一个简单的多态的案例，就只是函数名一样，但功能及用法，完全不同
类中的修饰符：一种访问权限
public 公共的 当没有在属性和方法前面加修饰符，默认 public ，在任何地方都可以访问（类内，子类，类外）
protected 受保护的 子类，类内 可以访问，类外面不能访问
private 只有 类内 可以访问，子类及类外 不可以访问
static 静态属性，类上面的属性；
访问静态的属性 类 . 属性名
案例：
class Father{
name:string;
protected money:number;
private company:string="上市公司";
constructor(name:string,money:number){
this.name=name;
this.money=money;
console.log(this.company);
}
static query(){
console.log("我特别安静");
}
}
class Son extends Father{
constructor(name:string,money:number){
super(name,money);
}
}
var son = new Son("zhang",10);
console.dir(son);
console.dir(Father);
抽象类 abstract
1. 作为其他子类的基类使用
2. 抽象类不能被实例化
3. 使用 abstract 关键字，来定义抽象类和抽象方法
4. 抽象类中的抽象方法，不包含实现，在他的派生类（子类）实现
5. 派生类中的必须实现抽象类的抽象方法，普通方法可以不用重写，子类继承抽象类和类的继承用法一致，唯一区别就是抽象方法必须写
6. 实现抽象类的子类使用关键字 extends
对于抽象类的理解
抽象类：就是给子类指定一些约束条件，实现抽象类，子类的时候，必须包含抽象类的所有属性
案例：
abstract class Ed{
abstract name:string;
abstract move():any;
}
class Fd extends Ed{
name:string;
move(){
console.log("我们被迫的");
}
}
var sd = new Fd;
sd.move();
接口：interface
接口和抽象类都是对事物的一种约束，抽象类只能约束类，接口可以约束条件，很多接口就是指定的一种规范，就是要按照这个规则来
使用关键字 interface 来指定规范
1. 指定属性的接口
interface obj{ // obj 这个类上 规定了 name 属性 必须是字符串 age 属性 必须是 数字 ，且必须有 name 和 age 属性
name:string;
age:number
}
var fs:obj={name:"zhang",age:10};
console.log(fs) // 我们的 fs 就使用了obj 的规范
function fn(x:obj):void{ // 我们的函数使用这种规范
console.log(x)
}
fn({name:"lisi",age:20});
2. 实现函数类型的接口
interface fn{ // 规定函数规范
(x:string,y:string):string
}
var f:fn=function(a:string,b:string){ // f 使用这 fn 规范
return a+b
}
3. 可索引类型（数组 ，对象）
1. 数组
interface arrs{
[index:number]:string
}
var arr:arrs = ["zhang","lisi"];
console.log(arr);
2. 对象
interface objs{
[index:string]:string
}
var obj:objs = {name:"zhang",age:"12"};
4. 定义类的类型接口
1. 里面的方法不能实现
2. 使用关键字 implements 实现这个接口类
3. 在类中实现接口的办法
interface Animal{
name:string;
eat():void;
}
class Dog implements Animal{
name:string;
eat(){
console.log("我是被迫的")
}
}
var dog = new Dog;
dog.eat()
5. 接口继承
接口继承的方式 extends 的关键字
interface A{
color:string
}
interface B extends A{
name:string
}
var afg:b={ // 在这里知道，我们必须有 color 属性，还要由 name 属性才可以，
color:"red",
name:"zhang"
}
console.log(afg);