Readonly

readonly

TypeScriptの型システムでは、インターフェース上の個々のプロパティをreadonlyとしてマークすることができます。これにより、関数的に作業することができます(予期しない変更は良くありません)。
1
function foo(config: {
2
readonly bar: number,
3
readonly bas: number
4
}) {
5
// ..
6
}
7
8
let config = { bar: 123, bas: 123 };
9
foo(config);
10
// You can be sure that `config` isn't changed 🌹
Copied!
もちろん interfacetypeの定義にreadonlyを使うこともできます:
1
type Foo = {
2
readonly bar: number;
3
readonly bas: number;
4
}
5
6
// Initialization is okay
7
let foo: Foo = { bar: 123, bas: 456 };
8
9
// Mutation is not
10
foo.bar = 456; // Error: Left-hand side of assignment expression cannot be a constant or a read-only property
Copied!
クラスプロパティをreadonlyとして宣言することもできます。次のように、宣言箇所またはコンストラクタで初期化することができます。
1
class Foo {
2
readonly bar = 1; // OK
3
readonly baz: string;
4
constructor() {
5
this.baz = "hello"; // OK
6
}
7
}
Copied!

Readonly

Readonly型はT型をとり、そのすべてのプロパティをreadonlyとマークします。以下にデモを示します:
1
type Foo = {
2
bar: number;
3
bas: number;
4
}
5
6
type FooReadonly = Readonly<Foo>;
7
8
let foo:Foo = {bar: 123, bas: 456};
9
let fooReadonly:FooReadonly = {bar: 123, bas: 456};
10
11
foo.bar = 456; // Okay
12
fooReadonly.bar = 456; // ERROR: bar is readonly
Copied!

さまざまな使用例

ReactJS

不変性(Immutabillity)を愛するライブラリの1つがReactJSです。たとえば、あなたのPropsStateには不変(immutable)であるとマークすることができます:
1
interface Props {
2
readonly foo: number;
3
}
4
interface State {
5
readonly bar: number;
6
}
7
export class Something extends React.Component<Props,State> {
8
someMethod() {
9
// You can rest assured no one is going to do
10
this.props.foo = 123; // ERROR: (props are immutable)
11
this.state.baz = 456; // ERROR: (one should use this.setState)
12
}
13
}
Copied!
しかし、Reactの型定義として、これらをreadonlyとしてマークする必要はありません。Reactは既に内部でそれを行っています。
1
export class Something extends React.Component<{ foo: number }, { baz: number }> {
2
// You can rest assured no one is going to do
3
someMethod() {
4
this.props.foo = 123; // ERROR: (props are immutable)
5
this.state.baz = 456; // ERROR: (one should use this.setState)
6
}
7
}
Copied!

シームレスな不変性(Seamless Immutable)

インデックスのシグネチャをreadonlyとしてマークすることもできます:
1
/**
2
* Declaration
3
*/
4
interface Foo {
5
readonly[x: number]: number;
6
}
7
8
/**
9
* Usage
10
*/
11
let foo: Foo = { 0: 123, 2: 345 };
12
console.log(foo[0]); // Okay (reading)
13
foo[0] = 456; // Error (mutating): Readonly
Copied!
ネイティブのJavaScript配列を不変的(immutable)な方法で使用したいと思うことは、素晴らしいことです。実際、ちょうどそのためにTypeScriptにはReadonlyArray<T>インターフェースが付属しています。
1
let foo: ReadonlyArray<number> = [1, 2, 3];
2
console.log(foo[0]); // Okay
3
foo.push(4); // Error: `push` does not exist on ReadonlyArray as it mutates the array
4
foo = foo.concat([4]); // Okay: create a copy
Copied!

自動推論

場合によっては、コンパイラは、特定の項目を読み込み専用に自動的に推論することができます。例えば、クラス内でgetterしか持たずsetterを持たないプロパティは、読み取り専用とみなされます。
1
class Person {
2
firstName: string = "John";
3
lastName: string = "Doe";
4
get fullName() {
5
return this.firstName + this.lastName;
6
}
7
}
8
9
const person = new Person();
10
console.log(person.fullName); // John Doe
11
person.fullName = "Dear Reader"; // Error! fullName is readonly
Copied!

constとの相違点

const
  1. 1.
    変数参照に利用するものである
  2. 2.
    他の値を再度割り当てることはできない
readonly
  1. 1.
    プロパティに利用するものである
  2. 2.
    エイリアシングによってプロパティが変更されることがありえる
説明のためのサンプル1:
1
const foo = 123; // variable reference
2
var bar: {
3
readonly bar: number; // for property
4
}
Copied!
説明のためのサンプル2:
1
let foo: {
2
readonly bar: number;
3
} = {
4
bar: 123
5
};
6
7
function iMutateFoo(foo: { bar: number }) {
8
foo.bar = 456;
9
}
10
11
iMutateFoo(foo); // The foo argument is aliased by the foo parameter
12
console.log(foo.bar); // 456!
Copied!
基本的に readonlyは、プロパティを私が変更することはできないことを保証しますが、(型互換性のための理由で)その保証を持たない人にそれを渡すと、変更できてしまいます。もちろん、iMutateFooが「foo.barに変更を加えない」と言っている場合、コンパイラは以下のように正しくエラーフラグを立てます:
1
interface Foo {
2
readonly bar: number;
3
}
4
let foo: Foo = {
5
bar: 123
6
};
7
8
function iTakeFoo(foo: Foo) {
9
foo.bar = 456; // Error! bar is readonly
10
}
11
12
iTakeFoo(foo); // The foo argument is aliased by the foo parameter
Copied!