基础用法

  • 变量命名

    1. // let name: type = ""
    2. let userName: string = 'Cherish'

  • 静态类型

类型一旦定义后就不能够改变

  1. let userName: string = 'Cherish'
  2. // userName 被定义为 string，后续给userName赋值时，只能赋值为 string 类型
  • 自定义静态类型
    1. // 定义Coder 静态类型
    2. interface Coder {
    3.   name: string,
    4. age: number
    5. }
    6. // 使用Coder 自定义类型
    7. const Cherish: Coder = {
    8.   name: 'Cherish',
    9. age: 26
    10. }

    基础静态类型

    1. let name:type = xxx

对象静态类型

  1. // 对象字面量形势
  2. const Coder:{
  3.   name: string,
  4.   age: number
  5. } = { 
  6.   name: 'Cherish',
  7.   age: 26
  8. }
  10. // 数组形式: name: type [] = []
  11. const Coder:string [] = ['Jobs', 'BillGates', 'Cherish']
  12. const CoderAge: number [] = [1, 2, 3]
  13. // 数组中可以包含多种类型时，可以这样写
  14. const Coder: (number|string|Oject) [] = [1, '2', {name: '3'}]
  16. // 类形式
  17. class Person {
  19. }
  20. const Coder:Person = new Person()
  22. // 函数形式
  23. // Coding的类型必须是一个函数，并且有返回值，需要返回 string
  24. const Coding: () => string = () => {
  25.     return 'Coding java'
  26. }

类型注解（type annotation）

  1. 定义静态类型后，鼠标放在变量上，会有类型提示，这就是类型注解
  2. 冒号+类型  :type

类型推断（type interface）

  1. ts能推断出来的数据类型，叫类型推断，这样的数据，不用添加类型注解

函数参数注解和返回类型注解

  1. // 1.有返回值，返回值类型定义在参数后
  2. function getSum (x: number, y: number): number {
  3.     return x + y
  4. }
  5. // 2.无返回值，返回值类型定义为void
  6. function sayHello (): void {
  7.     console.log()
  8. }
  10. //3.函数代码永远不能执行完，比如 return 语句后有代码， 抛出异常后面有代码, 或者死循环
  11. // 此时类型用 never
  12. function errorFunction ()： never {
  13.     throw new Error ()
  14.   console.log('error！')
  15. }
  17. // 4.参数是一个对象，如何确定参数里的元素的类型
  18. function getSelfIntroduction ({name, age}: {name: string, age: number}): string {
  19.     return 'My name is' + name + 'I am' + age + 'years old'
  20. } 
  22. const selfIntroduction = getSelfIntroduction({name: 'Cherish', age: 26})

类型别名

  1. // 类型别名
  2. type Coder = { name: string, age: number }
  3. const CoderArray: { name: string, age: number }[] = [{
  4.   name: 'Jobs',
  5.   age: 26
  6. }, {
  7.   name: 'Gates',
  8.   age: 28
  9. }]
  10. // 等价于
  11. const CoderArray: Coder[] = [{
  12.   name: 'Jobs',
  13.   age: 26
  14. }, {
  15.   name: 'Gates',
  16.   age: 28
  17. }]
  18. // 相当于先定义好对象的类型
  19. // 类型别名的效果和定义类的效果是一致的
  20. class Code = {
  21.   name: string, 
  22.   age: number
  23. }
  24. const CoderArray: Coder[] = [{
  25.   name: 'Jobs',
  26.   age: 26
  27. }, {
  28.   name: 'Gates',
  29.   age: 28
  30. }]