TypeScript学习二（对象类型）

对象类型

object、Object和{}类型

• object
  object 类型用于表示所有的非原始类型，即我们不能把 number、string、boolean、symbol等 原始类型赋值给 object。在严格模式下，null 和 undefined 类型也不能赋给 object。

let obj: object;
obj = 1; // error
obj = "a"; // error
obj = true; // error
obj = null; // error
obj = undefined; // error
obj = {}; // 编译正确

• Object
  Object 代表所有拥有 toString、hasOwnProperty 方法的类型 所以所有原始类型、非原始类型都可以赋给 Object(严格模式下 null 和 undefined 不可以)

let Obj: Object;
Obj = 1; // error
Obj = "a"; // error
Obj = true; // error
Obj = null; // error
Obj = undefined; // error
Obj = {}; // 编译正确

• {}
  {} 空对象类型和大 Object 一样 也是表示原始类型和非原始类型的集合

类

在 TypeScript 中，通过 Class 关键字来定义一个类

class Person {
    name: string;
    age: number;
    constructor(name: string, age: number) {
      this.name = name;
      this.age = age;
    }
    say(): void {
      console.log(`My name is ${this.name} and I am ${this.age} years old.`);
    }
}

let p = new Person('ZhangSan',18)
p.say() //My name is ZhangSan and I am 18 years old.

函数

• 函数声明

function userInfo(name: string, age:number): string{
    return name + age
}
userInfo('张三',18)

• 函数表达式

const userInfo = function(name: string, age:number): string{
    return name + age
}
userInfo('张三',18)

• 接口定义函数

//定义参数 num 和 num2  ：后面定义返回值的类型
interface Add {
    (num1:  number, num2: number): number
}

const fn: Add = (num1: number, num2: number): number => {
    return num1 + num2
}
fn(5, 5)

interface User{
    name:string,
    age:number
}
function getUserInfo(user: User): User {
  return user
}

//重名interface  可以合并
interface A{name:string}
interface A{age:number}
var x:A={name:'xx',age:20}
//继承
interface A{
    name:string
}
interface B extends A{
    age:number
}
let obj:B = {
    age:18,
    name:"string"
}

//[propName: string] 任意属性  需要注意的是，一旦定义了任意属性，那么确定属性和可选属性的类型都必须是它的类型的子集：
//readonly 只读属性是不允许被赋值的只能读取
interface Person {
    b?: string,
    readonly a: string,
    [propName: string]: any;
    cb:()=>void
}
 
const person: Person = {
    a: "213",
    c: "123",
    cb:()=>{
        console.log(123)
    }
}

• 可选参数

//通过?表示该参数为可选参数
const fn = (name: string, age?:number): string => {
    return name + age
}
fn('张三')

• 默认参数

const fn = (name: string = "默认值"): string => {
    return name
}
fn()

• 剩余参数

const fn = (array:number[],...items:any[]):any[] => {
       console.log(array,items)
       return items
}
 
let a:number[] = [1,2,3]
 
fn(a,'4','5','6')

• 函数重载
  重载是方法名字相同，而参数不同，返回类型可以相同也可以不同。
  如果参数类型不同，则参数类型应设置为 any。
  参数数量不同你可以将不同的参数设置为可选。

function fn(params: number): void
 
function fn(params: string, params2: number): void
 
function fn(params: any, params2?: any): void {
    console.log(params,params2) 
}

fn(123) //123 undefined
fn('123',456) // '123' 456

注：函数重载真正执行的是同名函数最后定义的函数体 在最后一个函数体定义之前全都属于函数类型定义 不能写具体的函数实现方法 只能定义类型

数组

• 数组类型

var arr: number[] = [1, 2, 3]; //数字类型的数组
var arr2: string[] = ["1", "2"]; //字符串类型的数组
var arr3: any[] = [1, "2", true]; //任意类型的数组

• 数组泛型
  规则 Array<类型>

let arr:Array<number> = [1,2,3,4,5]

• 用接口表示数组
  一般用来描述类数组

interface NumberArray {
    [index: number]: number;
}
let fibonacci: NumberArray = [1, 1, 2, 3, 5];
//表示：只要索引的类型是数字时，那么值的类型必须是数字。

• 多维数组

let data:number[][] = [[1,2], [3,4]];

• arguments类数组

function Arr(...args:any): void {
    console.log(arguments)
    //错误的arguments 是类数组不能这样定义
    let arr:number[] = arguments
}
Arr(111, 222, 333)
 
 
 
function Arr(...args:any): void {
    console.log(arguments) 
    //ts内置对象IArguments 定义
    let arr:IArguments = arguments
}
Arr(111, 222, 333)
 
//其中 IArguments 是 TypeScript 中定义好了的类型，它实际上就是：
interface IArguments {
[index: number]: any;
length: number;
callee: Function;
}

• any在数组中的应用

let list: any[] = ['test', 1, [],{a:1}]