Что такое рефлексия в TypeScript?

Что такое рефлексия (Reflection) в TypeScript?

Рефлексия в программировании — это способность программы исследовать и модифицировать свою собственную структуру во время выполнения. В контексте TypeScript, строго говоря, полноценной рефлексии, как в Java или C#, не существует из-за природы компиляции в JavaScript. Однако есть несколько техник и возможностей, которые позволяют достигать аналогичных результатов, и они часто объединяются под термином "рефлексия в TypeScript".

Ключевой момент: TypeScript компилируется в "чистый" JavaScript, а система типов полностью стирается (type erasure) во время компиляции. Поэтому информация о типах (интерфейсы, обобщенные параметры) недоступна в рантайме. Вся рефлексия работает либо с данными JavaScript, либо требует дополнительных инструментов.

Основные подходы к рефлексии в TypeScript

1. Интроспекция (Introspection) в Runtime (нативное для JS)

Это исследование структуры объектов и их свойств во время выполнения с помощью стандартных JavaScript-методов.

class User {
    constructor(public name: string, public age: number) {}
    
    greet() {
        return `Hello, I'm ${this.name}`;
    }
}

const user = new User('Alice', 30);

// Проверка наличия свойства
console.log('name' in user); // true

// Получение списка всех собственных свойств
console.log(Object.getOwnPropertyNames(user)); // ['name', 'age']

// Получение списка всех методов через прототип
console.log(Object.getOwnPropertyNames(User.prototype)); // ['constructor', 'greet']

// Проверка типа конструктора
console.log(user.constructor === User); // true

2. Метаданные через декораторы и reflect-metadata

Наиболее мощный подход, приближенный к классической рефлексии. Требует:

• Включения опции "emitDecoratorMetadata": true в tsconfig.json
• Установки пакета reflect-metadata
• Использования декораторов

import 'reflect-metadata';

function LogType(target: any, propertyKey: string) {
    // Сохранение типа свойства в метаданные
    const type = Reflect.getMetadata('design:type', target, propertyKey);
    console.log(`Property ${propertyKey} has type: ${type.name}`);
}

class Product {
    @LogType
    public title: string;
    
    @LogType
    public price: number;
    
    constructor(title: string, price: number) {
        this.title = title;
        this.price = price;
    }
}

// В runtime теперь можно получать информацию о типах
const product = new Product('Book', 20);
const typeOfTitle = Reflect.getMetadata('design:type', product, 'title');
console.log(typeOfTitle); // [Function: String]

3. Создание и модификация объектов динамически

// Динамическое создание экземпляра класса
const className = 'User';
const classMap = { User };

if (classMap[className]) {
    const instance = new classMap[className]('Bob', 25);
    console.log(instance.greet()); // Hello, I'm Bob
}

// Динамический вызов методов
const methodName = 'greet';
if (typeof user[methodName] === 'function') {
    console.log(user[methodName]()); // Hello, I'm Alice
}

Практические применения рефлексии в TypeScript

• Валидация данных: Проверка типов и структуры объектов в runtime.
• Сериализация/десериализация: Преобразование объектов в JSON и обратно с сохранением типов.
• Внедрение зависимостей (DI): Автоматическое разрешение и инъекция зависимостей, как в Angular или TypeDI.
• ORM-системы: Маппинг классов на таблицы базы данных с анализом типов свойств.
• API-клиенты: Автоматическая генерация запросов на основе декораторов.

Ограничения и важные замечания

• Стирание типов: Получить информацию об интерфейсах или обобщенных типах в чистом виде невозможно.
• Требует настройки: Работа с метаданными через reflect-metadata требует дополнительной конфигурации.
• Производительность: Интенсивное использование рефлексии может влиять на производительность.
• Безопасность: Динамическое выполнение кода требует осторожности для избежания инъекций.

Сравнение подходов

Пример комплексного использования

import 'reflect-metadata';

// Декоратор для автоматической валидации
function Validate() {
    return function(target: any, propertyKey: string) {
        const type = Reflect.getMetadata('design:type', target, propertyKey);
        const key = `validator_${propertyKey}`;
        
        Reflect.defineMetadata(key, {
            type: type.name,
            validate: (value: any) => {
                if (type === String) return typeof value === 'string';
                if (type === Number) return typeof value === 'number' && !isNaN(value);
                return value instanceof type;
            }
        }, target, propertyKey);
    };
}

class Person {
    @Validate()
    name: string;
    
    @Validate()
    age: number;
    
    constructor(name: string, age: number) {
        this.name = name;
        this.age = age;
    }
}

// Валидатор на основе метаданных
function validateInstance(obj: any): boolean {
    for (const key of Object.keys(obj)) {
        const meta = Reflect.getMetadata(`validator_${key}`, obj, key);
        if (meta && !meta.validate(obj[key])) {
            console.error(`Validation failed for ${key}: expected ${meta.type}`);
            return false;
        }
    }
    return true;
}

const person = new Person('John', 30);
console.log(validateInstance(person)); // true

Таким образом, хотя TypeScript не предоставляет полноценной рефлексии "из коробки", комбинация декораторов, библиотеки reflect-metadata и стандартных JavaScript-методов позволяет реализовать мощные паттерны, близкие к классической рефлексии, что особенно востребовано в крупных фреймворках и сложных приложениях.