最終投稿日：2026年1月26日
| ・public | ・・・ | どこからでもアクセス可能（デフォルト） |
| ・private | ・・・ | クラス内部でのみアクセス可能 |
| ・protected | ・・・ | クラス内部および継承したクラスからアクセス可能 |
| ・readonly | ・・・ | プロパティ専用となり、宣言時および、コンストラクタでのみ初期化が可能です |
class User {
public foo?: string;
public hoge!: string;
private age: number = 0;
constructor(_hoge: string, _age: number) {
this.hoge = _hoge;
this.age = _age;
}
get getAge(): number {
return this.age;
}
set setAge(_age: number) {
this.age = _age;
}
}
let my = new User('ほげ', 5); // クラスの初期化
my.setAge = 6; // 年齢変更
console.log(my.getAge); // 5
class User {
constructor(public hoge: string, private age: number) {}
}
class User {
public hoge: string = '';
private age: number = 0;
constructor(_hoge: string, _age: number) {
this.hoge = _hoge;
this.age = _age;
}
}
クラス型について、TypeScriptではクラスを全てのプロパティを含むオブジェクト型として扱います。
つまり、クラス名『Hoge』がプロパティ「name」のみを保持している構造の場合、以下は同じ型として扱われます。
class Hoge {
constructor(public name: string) {}
}
let foo = new Hoge('ふ～');
let bar = {name: 'ばぁ'};
function getFuga(obj: Hoge): string{
return obj.name;
}
console.log(getFuga(foo));
console.log(getFuga(bar));
親のメソッドをオーバーライドした際、親を呼び出す方法も『super()』を使えます（メソッドの最初に記述する事）
class MathUtil {
static PI: number = 3.14;
static circleArea(radius: number): number {
return this.PI * radius * radius;
}
}
console.log(MathUtil.PI); // 3.14
console.log(MathUtil.circleArea(50)); // 7850
class Hoge {
constructor(){}
// オーバーロードの定義
showVal(var1: string, var2: number): string;
showVal(var1: string, var2: string): string;
showVal(var1: number, var2: string): string;
// メイン関数
public showVal(var1: number | string, var2: number | string) {
return var1.toString() + var2.toString();
}
}
let hoge = new Hoge();
console.log(hoge.showVal('ほげ','ふ～'));
console.log(hoge.showVal('ほげ',5));
console.log(hoge.showVal(3,'ほげ'));
ジェネリック型は、型をパラメーター化（抽象化）することができます
type User<T> = {name: string, age: T};
let hoge: User<number> = {name: 'ほげ', age: 10}; // コンパイルが通る
let foo: User<number> = {name: 'ほげ', age: '十歳'}; // NG
let bar: User<string> = {name: 'ほげ', age: '十歳'}; // コンパイルが通る
class Hoge<T> {
private name: string = 'ほげ';
private age: T;
constructor(_age: T){
this.age = _age;
}
getShow(): any {
return this.age;
}
}
let hoge = new Hoge<number>(5);
let foo = new Hoge<string>('十二歳');
const showTextAge = (age: string): string => {
return age
}
const showIndexAge = (age: number): number => {
return age
}
// 上記２つの関数は、ほぼ同じ内容です。
// ↓ ジェネリック型 を利用して共通化
const hoge = <T>(arg: T): T => {
return arg;
}
console.log(showTextAge('10歳'));
console.log(showIndexAge(10));
console.log(hoge<string>('10歳'));
console.log(hoge<number>(10));
foo?: stringは、省略可能な変数の場合はこちらを使用します。
hoge!: stringの意味は、変数を初期化していなくてもエラーにならない様にする宣言です。
※ ただしプロパティを利用する前に値が必ず割り当てることを断言する意味でもあります
故に以下２つの内容は同じ意味となります。