В TypeScript: в чем разница между `any` и `Object` и когда что использовать?

Ключевое различие: тип vs. отсутствие типа

Ваше замешательство абсолютно понятно. На первый взгляд any и Object действительно похожи, но они работают на совершенно разных уровнях системы типов TypeScript.

any — это не тип в классическом понимании. Это отключение проверки типов для данного значения. Когда вы пишете value: any, вы говорите компилятору: "Не проверяй это значение вообще, я знаю, что делаю". TypeScript полностью доверяет вам и позволяет делать с этим значением абсолютно всё: вызывать любые методы, обращаться к любым свойствам, присваивать чему угодно.

Object — это самый базовый тип в иерархии типов. Он означает "любой объект, но не примитив". В JavaScript примитивы (числа, строки, булевы значения, null, undefined, symbol, bigint) не являются объектами, хотя и ведут себя как объекты из-за автоупаковки. TypeScript строго следит за этим: Object не включает примитивы.

Проверим на практике:

let a: any = 42;
let b: Object = 42; // Ошибка? Нет, не ошибка!

// Странно, да? Всё дело в том, что TypeScript делает исключение для литералов.
// Но если вы попробуете передать число через переменную:
let num: number = 42;
let c: Object = num; // Тоже работает? Да, из-за автоупаковки.

// А вот это уже не сработает:
let d: Object = null; // Ошибка!
let e: Object = undefined; // Ошибка!

Почему вы не можете вызвать toFixed()?

Когда вы пишете value: Object, TypeScript знает только то, что value — это объект. Он не знает, что это число, строка или массив. Поэтому он разрешает вызывать только те методы и свойства, которые есть у самого типа Object (например, toString(), hasOwnProperty()).

Метод toFixed() — это метод прототипа Number, а не Object. Поэтому TypeScript справедливо блокирует такой вызов.

Когда использовать any, а когда Object?

Правило простое: никогда не используйте ни то, ни другое, если есть альтернатива. Оба типа — это костыли для особых случаев.

• any — используйте только когда:
  • Вы мигрируете код с JavaScript и пока не успели всё оттипизировать.
  • Вы работаете с динамическими данными, тип которых невозможно предсказать (например, ответ от внешнего API, который может быть чем угодно).
  • Вы намеренно хотите отключить проверку типов для небольшого участка кода (но лучше переписать это правильно).
• Object — практически никогда. Он слишком широкий и не несёт полезной информации. Если вам нужно "что-то с ключами", используйте Record<string, unknown> или { [key: string]: unknown }.

Правильное решение: дженерики и unknown

Для вашей задачи "функция, которая принимает что угодно и возвращает то же самое" идеально подходит дженерик:

function identity<T>(value: T): T {
    return value;
}

let num = identity(42); // num имеет тип number
num.toFixed(2); // Работает!

let str = identity("hello"); // str имеет тип string
str.toUpperCase(); // Работает!

TypeScript автоматически выводит тип T из переданного аргумента и возвращает его. Вы получаете полную безопасность типов.

Если же вам нужно хранить значение, тип которого вы не знаете, но при этом вы хотите проверять типы при использовании, используйте unknown:

function processUnknown(value: unknown): void {
    // value.toFixed(); // Ошибка! Нельзя вызывать
    if (typeof value === "number") {
        value.toFixed(2); // Теперь можно, после проверки
    }
}

unknown — это типобезопасная альтернатива any. Вы не можете ничего сделать с unknown, пока не проверите его тип. Это заставляет вас писать более надёжный код.

Итог:

• any — отключает проверку типов. Используйте в крайнем случае.
• Object — бесполезный тип, который не даёт нормально работать с данными.
• unknown — безопасная альтернатива для неизвестных типов.
• Дженерики — лучший способ сохранить тип при передаче через функцию.

// Плохо: теряем всю информацию
function processData(data: any) {
    return data.name; // Ошибка во время выполнения, если data не объект
}

// Тоже плохо: Object не даст даже проверить
function processData2(data: Object) {
    return data.name; // Ошибка компиляции, у Object нет name
}

function processDataSafe(data: unknown): string | null {
    if (data === null || data === undefined) {
        return null;
    }
    
    if (typeof data === "object" && data !== null) {
        // Теперь data — это объект, но всё ещё unknown
        // Нужна дополнительная проверка
        if ("name" in data) {
            return (data as { name: string }).name;
        }
    }
    
    return null;
}

// Или ещё лучше — с помощью дженерика и схемы валидации:
function processDataTyped<T>(data: unknown, validator: (d: unknown) => d is T): T | null {
    if (validator(data)) {
        return data; // TypeScript знает, что data — это T
    }
    return null;
}