对象类型
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}]