设计哲学的根本差异

TypeScript：结构类型系统（Structural Typing）

// 关注的是形状，不是名称
interface Point {
  x: number;
  y: number;
}

class MyPoint {
  x: number;
  y: number;
  constructor(x: number, y: number) {
    this.x = x;
    this.y = y;
  }
}

const point: Point = new MyPoint(1, 2); // ✅ 可以赋值，因为形状匹配

C 语言：名义类型系统（Nominal Typing）

// 关注的是名称，不是结构
typedef struct {
    int x;
    int y;
} Point;

typedef struct {
    int x;
    int y;
} MyPoint;

Point p;
MyPoint mp = {1, 2};
p = mp; // ❌ 编译错误：incompatible types

类型声明方式对比

TypeScript：灵活的类型推导

// 类型推导
let name = "John";          // 自动推断为 string
let age = 30;               // 自动推断为 number
let numbers = [1, 2, 3];    // 自动推断为 number[]

// 类型注解
let score: number = 100;
let isActive: boolean = true;

C 语言：显式类型声明

// 必须显式声明类型
char name[] = "John";       // 字符数组
int age = 30;               // 整型
int numbers[] = {1, 2, 3};  // 整型数组

float score = 100.0;        // 浮点型
bool isActive = true;       // C99 引入的布尔类型

类型安全对比

TypeScript：编译时类型检查

// 编译时捕获错误
let count: number = 10;
count = "hello"; // ❌ 编译错误：Type 'string' is not assignable to type 'number'

function add(a: number, b: number): number {
    return a + b;
}
add("1", 2); // ❌ 编译错误：Argument of type 'string' is not assignable to parameter of type 'number'

C 语言：弱类型，运行时风险

// 编译通过，但运行时可能出错
int count = 10;
count = "hello"; // ❌ 编译警告，但可能通过（隐式转换）

int add(int a, int b) {
    return a + b;
}
add("1", 2); // ❌ 编译警告，但可能通过（字符'1'的ASCII码49 + 2 = 51）

高级类型特性对比

TypeScript：丰富的类型操作

// 联合类型
type Status = "success" | "error" | "pending";

// 泛型
interface Response<T> {
    data: T;
    status: number;
}

// 条件类型
type NonNullable<T> = T extends null | undefined ? never : T;

// 映射类型
type Readonly<T> = {
    readonly [P in keyof T]: T[P];
};

C 语言：基础类型系统

// 有限的类型组合
typedef union {
    int intValue;
    float floatValue;
    char charValue;
} Value; // 联合体，类似TS的联合类型但更底层

// 泛型？不存在的，只能用void指针
typedef struct {
    void* data;
    size_t size;
} GenericArray; // 类似泛型但类型不安全

// 宏模拟泛型（有限）
#define DEFINE_ARRAY(T) \
typedef struct { \
    T* data; \
    size_t size; \
} Array_##T

DEFINE_ARRAY(int);
DEFINE_ARRAY(float);

内存管理对比

TypeScript：自动内存管理

// 垃圾回收自动管理内存
let obj = { value: 42 };
obj = null; // 内存自动回收

C 语言：手动内存管理

// 必须手动分配和释放内存
int* numbers = (int*)malloc(10 * sizeof(int)); // 分配内存
if (numbers == NULL) {
    // 处理分配失败
}
// 使用内存...
free(numbers); // 必须手动释放
numbers = NULL; // 避免野指针

函数类型对比

TypeScript：函数是一等公民

// 函数类型
type MathOperation = (a: number, b: number) => number;

const add: MathOperation = (a, b) => a + b;
const multiply: MathOperation = (a, b) => a * b;

// 高阶函数
function calculate(op: MathOperation, x: number, y: number): number {
    return op(x, y);
}

C 语言：函数指针

// 函数指针
typedef int (*MathOperation)(int, int);

int add(int a, int b) {
    return a + b;
}

int multiply(int a, int b) {
    return a * b;
}

MathOperation op = add;
int result = op(2, 3); // 5

总结对比

特性	TypeScript	C 语言
类型系统	结构类型	名义类型
类型安全	强类型，编译时检查	弱类型，运行时风险
类型推导	强大的自动推导	基本无推导
泛型支持	原生支持	通过void指针或宏模拟
内存管理	自动垃圾回收	手动管理
高级特性	联合类型、条件类型等	有限的高级特性
函数类型	一等公民，丰富支持	函数指针
开发体验	开发友好，错误早发现	接近硬件，控制力强