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!
もちろん interfaceとtypeの定義に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です。たとえば、あなたのPropsとStateには不変(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.変数参照に利用するものである
2.他の値を再度割り当てることはできない
readonly
1.プロパティに利用するものである
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!

前

リテラル型

次

ジェネリック型

最終更新 2yr ago

リンクのコピー