Могут ли interface расширять друг друга в TypeScript?

Interface наследование (extends) в TypeScript

Да, interfaces обязательно могут расширять друг друга. Это один из основных механизмов типизации в TypeScript. Вот подробный анализ.

1. Базовое наследование

// Базовый interface
interface Animal {
  name: string;
  age: number;
}

// Расширение interface
interface Dog extends Animal {
  breed: string;
  bark(): void;
}

// Dog имеет все свойства Animal + свои
const dog: Dog = {
  name: 'Buddy',
  age: 5,
  breed: 'Golden Retriever',
  bark() { console.log('Woof!'); }
};

2. Множественное наследование

// TypeScript позволяет наследоваться от нескольких interfaces
interface Named {
  name: string;
}

interface Aged {
  age: number;
}

interface Person extends Named, Aged {
  email: string;
}

const person: Person = {
  name: 'John',
  age: 30,
  email: 'john@example.com'
};

3. Цепочка наследования

interface Base {
  id: number;
}

interface Extended extends Base {
  name: string;
}

interface VeryExtended extends Extended {
  description: string;
}

const obj: VeryExtended = {
  id: 1,
  name: 'Test',
  description: 'Long description'
};

4. Переопределение свойств

interface Animal {
  name: string;
  move(): void;
}

interface Fish extends Animal {
  // Переопределяем move с более специфичным типом
  move(): string;  // или может быть более узкий тип
}

// ❌ Нельзя расширить тип (только сузить)
interface Bird extends Animal {
  move(): string;  // OK, более специфичный тип
}

5. Конфликты свойств

// Если интерфейсы имеют одинаковые свойства
interface A {
  value: string;
}

interface B {
  value: number;
}

// ❌ Ошибка: conflicting property types
interface C extends A, B {  // Ошибка! string и number конфликтуют
  // ...
}

// ✅ Решение: явно переопределить
interface C extends A {
  value: string;  // явно выбираем A
}

6. Использование intersection types

type A = { x: string };
type B = { y: number };

// Intersection типы (похоже на extends, но не совсем)
type AB = A & B;  // { x: string; y: number }

const obj: AB = { x: 'hello', y: 42 };

7. Interface vs Type

// Interfaces могут расширять друг друга
interface Animal {
  name: string;
}

interface Dog extends Animal {
  bark(): void;
}

// Types могут использовать intersection
type Animal2 = {
  name: string;
};

type Dog2 = Animal2 & {
  bark(): void;
};

// Также type может расширять interface
type Cat = Animal & { meow(): void };

// И interface может расширять type (с ограничениями)
// interface Bird extends Animal2 { }  // Иногда работает, иногда нет

8. Generic interfaces

interface Container<T> {
  value: T;
  get(): T;
}

interface NumberContainer extends Container<number> {
  increment(): void;
}

const nc: NumberContainer = {
  value: 10,
  get() { return this.value; },
  increment() { this.value++; }
};

9. Практический пример: архитектура

// Base интерфейс для всех сущностей
interface Entity {
  id: string;
  createdAt: Date;
  updatedAt: Date;
}

// Интерфейс для сущностей с владельцем
interface OwnedEntity extends Entity {
  ownerId: string;
}

// Интерфейс для сущностей, которые можно опубликовать
interface Publishable {
  published: boolean;
  publishedAt?: Date;
}

// Конкретная сущность
interface BlogPost extends OwnedEntity, Publishable {
  title: string;
  content: string;
  tags: string[];
}

// Использование
const post: BlogPost = {
  id: '123',
  createdAt: new Date(),
  updatedAt: new Date(),
  ownerId: 'user-1',
  published: true,
  publishedAt: new Date(),
  title: 'My Post',
  content: 'Content here',
  tags: ['typescript', 'interfaces']
};

10. Readonly и другие модификаторы

interface Base {
  readonly id: string;
  name: string;
}

interface Extended extends Base {
  // id остается readonly
  // можем сделать name тоже readonly
  readonly name: string;
}

interface BadExtended extends Base {
  // ❌ Ошибка: нельзя убрать readonly
  // name: string;  // Ошибка!
}

11. Method overloading

interface Animal {
  move(): void;
}

interface Dog extends Animal {
  move(speed: number): void;  // Overload method
  move(speed?: number): void {
    if (speed) {
      console.log(\`Moving at \${speed} km/h\`);
    } else {
      console.log('Moving');
    }
  }
}

12. Практический pattern: Repository

// Базовый интерфейс для всех репозиториев
interface Repository<T> {
  create(item: T): Promise<T>;
  findById(id: string): Promise<T | null>;
  update(id: string, item: Partial<T>): Promise<T>;
  delete(id: string): Promise<void>;
  findAll(): Promise<T[]>;
}

// Интерфейс сущности
interface User {
  id: string;
  name: string;
  email: string;
}

// Специализированный репозиторий
interface UserRepository extends Repository<User> {
  findByEmail(email: string): Promise<User | null>;
  findActive(): Promise<User[]>;
}

// Реализация
class UserRepositoryImpl implements UserRepository {
  async create(user: User): Promise<User> { /* ... */ }
  async findById(id: string): Promise<User | null> { /* ... */ }
  async update(id: string, user: Partial<User>): Promise<User> { /* ... */ }
  async delete(id: string): Promise<void> { /* ... */ }
  async findAll(): Promise<User[]> { /* ... */ }
  async findByEmail(email: string): Promise<User | null> { /* ... */ }
  async findActive(): Promise<User[]> { /* ... */ }
}

13. Conditional types (advanced)

// Зависимость на основе типа
interface HasId {
  id: number;
}

interface Extended<T extends HasId> {
  item: T;
  getKey(): T extends { id: infer ID } ? ID : never;
}

const ex: Extended<{ id: string; name: string }> = {
  item: { id: 'abc', name: 'Test' },
  getKey() { return this.item.id; }
};

Best Practices

1. Используй наследование для переиспользования

// ✅ Хорошо
interface Base {
  id: string;
}

interface User extends Base {
  name: string;
}

// ❌ Плохо
interface User {
  id: string;
  name: string;
}

interface Post {
  id: string;
  title: string;
}

2. Не переусложняй цепочки

// ❌ Слишком глубоко
interface A extends B extends C extends D extends E { }

// ✅ Лучше
interface Combined extends B, C, D, E { }

3. Используй meaningful имена

// ✅ Ясно что это расширение
interface UserWithProfile extends User { }

// ❌ Неясно
interface UserExt { }

На production

В моих проектах я часто использую паттерн:

// Базовая сущность
interface BaseEntity {
  id: string;
  createdAt: Date;
  updatedAt: Date;
  deletedAt?: Date;
}

// Интерфейсы для разных операций
interface CreateUserInput {
  name: string;
  email: string;
  password: string;
}

interface UpdateUserInput extends Partial<CreateUserInput> { }

interface UserModel extends BaseEntity {
  name: string;
  email: string;
  passwordHash: string;
  isActive: boolean;
}

// Использование в services
class UserService {
  async create(input: CreateUserInput): Promise<UserModel> { }
  async update(id: string, input: UpdateUserInput): Promise<UserModel> { }
  async findById(id: string): Promise<UserModel | null> { }
}

Да, interfaces обязательно могут расширять друг друга, и это один из самых мощных механизмов создания гибкой и переиспользуемой типизации в TypeScript.