06.1 any — 伝播する

any は「何でも入る」ではなく「検査しない」

any を付けた値には、どんな操作をしてもエラーになりません。

const x: any = "文字列";

x.toFixed(2);          // エラーにならない（実行時に落ちる）
x.foo.bar.baz;         // エラーにならない（実行時に落ちる）
x();                   // エラーにならない（実行時に落ちる）

下流に広がる

問題は、any が伝染することです。

function parse(json: string): any {
	return JSON.parse(json);
}

const user = parse('{"name":"Alice"}');   // user は any
const name = user.name;                   // name も any
const upper = name.toUpperCase();          // upper も any
const len = upper.lenght;                  // 打ち間違いも通る（実行時 undefined）

暗黙の any

strict 型を書き忘れた引数は、暗黙に any になります。strict が有効ならエラーで教えてくれます。

function greet(name) {
	//         ~~~~
	// error TS7006: Parameter 'name' implicitly has an 'any' type.
	//
	// 訳: 引数 'name' は暗黙的に 'any' 型になっています。
	return "Hello, " + name;
}

03. tsconfig のとおり、TypeScript 7 では strict が既定で有効です。5 系から移行すると、このエラーが大量に出ることがあります。

any が要る場面はほとんどない

06.2 unknown — 安全な受け口

「何でも入るが、確かめるまで何もできない」

unknown は any と同じくどんな値でも代入できます。違うのは使うときに絞り込みを強制される点です。

const x: unknown = "文字列";

x.toUpperCase();
// ~
// error TS18046: 'x' is of type 'unknown'.
//
// 訳: 'x' は 'unknown' 型です。

if (typeof x === "string") {
	x.toUpperCase();      // ここでは string として扱える
}

外部から来る値は unknown で受ける

JSON.parse の戻り値は any です。受け口で unknown に変えると、検証を強制できます。

// unknown-parse.ts
function parseJson(text: string): unknown {
	return JSON.parse(text);
}

type User = { name: string; age: number };

function isUser(v: unknown): v is User {
	return (
		typeof v === "object" && v !== null &&
		typeof (v as Record<string, unknown>).name === "string" &&
		typeof (v as Record<string, unknown>).age === "number"
	);
}

const data = parseJson('{"name":"Alice","age":30}');

if (isUser(data)) {
	console.log(`${data.name} は ${data.age} 歳`);
} else {
	console.log("User の形ではありません");
}

console.log(isUser(parseJson('{"name":"Bob"}')));

$ npx tsx unknown-parse.ts
Alice は 30 歳
false

v is User という書き方は型ガード関数です。詳細は 08. 型の絞り込み で扱います。

06.3 as — 検査を黙らせる

as は変換ではない

as は型アサーションです。「この値はこの型だと思って扱え」とコンパイラに指示するだけで、値は何も変わりません。

const x: unknown = "文字列";
const n = x as number;        // 通る。何も起きない

console.log(n.toFixed(2));    // 実行時エラー: n.toFixed is not a function

as が嘘をつく瞬間

type User = { name: string; age: number };

const data = JSON.parse('{"name":"Alice"}') as User;

console.log(data.age.toFixed(0));
// 型の上では number なので通る
// 実行時: TypeError: Cannot read properties of undefined (reading 'toFixed')

外部から来た値に as を使うのが最も危険です。実際のデータが型と違っていても、誰も教えてくれません。

as を使ってよい場面

二段階の as は危険信号

const s = "文字列";
const n = s as unknown as number;      // 無関係な型にも変換できてしまう

as は近い型どうしでしか使えませんが、as unknown as を挟むと何にでも変換できます。この書き方が出てきたら、設計を見直す合図です。

satisfies — 型を確かめるが、型は変えない

as の代わりに使える演算子です。「この型を満たしているか確かめるが、推論された型はそのまま残す」という意味です。

type Config = Record<string, string | number>;

// as だと、推論された具体的な型が失われる
const a = { host: "localhost", port: 3000 } as Config;
// a.port の型は string | number

// satisfies なら、検査もされるし具体的な型も残る
const b = { host: "localhost", port: 3000 } satisfies Config;
// b.port の型は number

設定オブジェクトを書くときは satisfies が適しています。誤った値を検出しつつ、使う側では具体的な型を保てます。

06.4 ! — 非 null アサーション

「null ではない」と言い切る

function find(id: string): User | undefined { /* ... */ }

const user = find("1");
console.log(user.name);
//          ~~~~
// error TS18048: 'user' is possibly 'undefined'.

console.log(user!.name);     // ! を付けると通る（検査されない）

! は as の null 版です。実行時には何も起きません。間違っていれば TypeError になります。

使ってよい場面・いけない場面

! の代わりに例外を投げる

// assert.ts
function findUser(id: string): { name: string } | undefined {
	const db: Record<string, { name: string }> = { "1": { name: "Alice" } };
	return db[id];
}

// ! を使わず、見つからないことを明示的に扱う
function getUserOrThrow(id: string): { name: string } {
	const user = findUser(id);
	if (!user) {
		throw new Error(`ユーザーが見つかりません: ${id}`);
	}
	return user;      // ここでは undefined でないことが型でも分かる
}

console.log(getUserOrThrow("1").name);

try {
	getUserOrThrow("999");
} catch (e) {
	console.log((e as Error).message);
}

$ npx tsx assert.ts
Alice
ユーザーが見つかりません: 999