学习 Typescript 的旅程

秋丽君_8552

发布时间：2024-11-08 12:55:57

389人浏览过

来源于dev.to

转载

学习 typescript 的旅程大家好，我最近开始了我的 typescript 之旅，并通过编程英雄的高级 web 开发课程取得了进步。我对 typescript 有一些基础知识，但没有深入探索。我的课程从深入研究 typescript 开始。一周过去了，我的学习有了很大的进步。以下是我所掌握的关键概念的简化概述。

typescript 就像 javascript，但具有超能力！

typescript 是 javascript 的超集，为该语言添加了可选的静态类型。这意味着您可以声明变量、函数参数和返回值的类型，这有助于在开发过程的早期发现潜在的错误。
使用 typescript 的好处

早期错误检测
提高代码可读性
增强代码可靠性
更好的代码完成和 intellisense
大型项目支持

原始和非原始数据类型

原始数据类型表示单个值并直接存储在内存中。以下是 typescript 中使用的一些原始数据类型

字符串
数字
布尔值
未定义
空

let name : string = "kishor";
let age : number = 27;
let isdeveloper: boolen = true;
let x : null = null;
let y: undefined = undefined;

正如您在示例中看到的，要为变量分配类型，您必须在定义变量名称和类型后使用冒号 ( :) 符号。

非原始数据类型，也称为引用类型，表示复杂的数据结构，并存储为对内存位置的引用。 typescript 支持以下非原始数据类型：

对象
数组
元组
功能

let person: {name: string, age : number} = {name: "kishor", age: 27}; //object
let numbers: number[] = [1,2,3,4];
let fruits: string[]= ["apple", "pineapple", "banana"];
let tuple: [string, number, boolean] = ["xyz", 123, true];
function greet(name: string) : any {
  return `hello ${name}`
}

类型别名

typescript 中的类型别名是一种为现有类型赋予新名称的方法。这可以使您的代码更具可读性和可维护性，尤其是在处理复杂类型时。

// defining a type alias for a person object
type person = {
  name: string;
  age: number;
};
// using the type alias
const person1: person = {
  name: "alice",
  age: 30
};

在此示例中，person 是一个类型别名，表示具有名称和年龄属性的对象。
typescript 中的并集和交集类型
联合类型表示可以是多种类型之一的值。它是使用 | 定义的运算符。
交叉类型将多种类型合并为一种类型。它是使用 & 运算符定义的。

type stringornumber = string | number; //union type
let value: stringornumber = "hello";
value = 42;
type person = {
    name: string;
    age: number;
};
type address = {
    street: string;
    city: string;
};
type personwithaddress = person & address;//intersection type
const personwithaddress: personwithaddress = {
    name: "alice",
    age: 30,
    street: "123 main st",
    city: "anytown"
};

从未、未知

never 类型表示从未出现过的值。
未知类型代表任何值。它比 any 类型更安全，因为在使用未知类型的值之前必须执行类型检查或断言。

function error(message: string): never {
    throw new error(message);
} //the return type is never because there is no data returned.
let value: unknown = "hello";
if (typeof value === "string") {
  let strlength: number = value.length;
}

类型断言

类型断言是一种告诉 typescript 编译器您比它更了解类型的方法。这是一种显式指定变量类型的方法

let value: unknown = "hello";
let strlength: number = (value as string).length;

类型保护装置

类型保护允许您根据某些条件缩小变量的类型范围。通过在访问变量的属性或方法之前检查变量的类型，您可以避免潜在的运行时错误。

运算符类型
实例操作符

//typeof
function printvalue(value: unknown) {
    if (typeof value === "string") {
        console.log(value.touppercase());
    } else if (typeof value === "number") {
        console.log(value.tofixed(2));   
    }
}
//instanceof
function printdate(date: unknown) {
    if (date instanceof date) {
        console.log(date.toisostring());
    }
}

typescript 中的接口

typescript 中的接口是用于创建具有特定属性的对象的蓝图。

interface person {
  firstname: string;
  lastname: string;
  age: number;
}
const person1: person = {
  firstname: "alice",
  lastname: "johnson",
  age: 30
};

在此示例中，person 接口定义了 person 对象必须具有firstname、lastname 和age 属性。创建 person1 对象时

typescript 中的泛型

泛型是 typescript 中的一项强大功能，它允许您创建可以处理不同数据类型的可重用组件。

Add Typescript Best Practices

在 CLAUDE.md 中配置 TypeScript 最佳实践和代码风格规则

下载

function identity<t>(arg: t): t {
  return arg;
}
identity<string>(string);

在此示例中，t 是类型参数。它代表任何类型的占位符。当你调用恒等函数时，你可以传递任何类型的参数，函数将返回相同的类型。

typescript 中的约束

在 typescript 中，泛型约束允许您对可以作为参数传递给泛型函数或用作泛型类或接口中的类型参数的类型应用限制。

interface person {
    name: string;
    age: number;
}
function identity<t extends person>(arg: t): t {
  return arg;
}
const result  = identity<person>({
    name: "aa";
    age: 12;
});

这里使用extends关键字来约束数据

操作员的钥匙

typescript 中的 keyof 运算符用于获取对象类型的所有属性名称的联合类型。这在使用泛型类型和映射类型时特别有用。

interface person {
  name: string;
  age: number;
}
type personkeys = keyof person; // type: "name" | "age"

实用程序类型

pick<t、k>：从 t 中选择特定属性

type person = {
  name: string;
  age: number;
  email: string;
}
//pick<t,k>
type name = pick<person, "name">;
type nameage = pick<person, "name" | "age">

omit<t、k>：省略 t 中的特定属性

type person = {
  name: string;
  age: number;
  email: string;
}
//omit<t,k>
type email= omit<person, "name" | "age">;

partial<t>：使 t 的所有属性可选。

interface person {
    name: string;
    age: number;
}
type partialperson = partial<person>; // { name?: string; age?: number; }

其他人喜欢，
必填<t>
只读<t>
记录<k、t>

typescript 中的类

在 typescript 中，类是使用 class 关键字定义的。

class person {
    firstname: string;
    lastname: string;

    constructor(firstname: string, lastname: string) {
        this.firstname = firstname;
        this.lastname = lastname;   

    }

    greet() {
        console.log("hello, my name is " + this.firstname + " " + this.lastname);   

    }
}

typescript 中的访问修饰符

public 类成员的默认可见性是public。公共成员可以在任何地方访问
受保护的成员仅对声明它们的类的子类可见。
私人成员只能在班级内访问。

typescript 中的静态成员

typescript 中的静态成员是属于类本身的成员（属性和方法），而不是属于类的各个实例。

class myclass {
    static staticproperty: string = "static property";

    static staticmethod() {
        console.log("static method");
    }
}

在 typescript 中实现

在 typescript 中，接口定义了要实现的类的契约。实现接口的类必须具有接口中声明的所有属性和方法。使用了implements关键字

interface Shape {
    area(): number;
}

class Circle implements Shape {
    radius: number;

    constructor(radius: number) {
        this.radius = radius;
    }

    area():   
 number {
        return Math.PI * this.radius * this.radius;   

    }
}