In Typescript 4.3, typescript introduced the const
assertions. const
assertions are used to tell the Typescript compiler one of the following:
Object properties are Readonly
When you cast an object as const, the properties are marked as read-only and cannot be modified. Let's take the following variable person
with name and age in it.
const person = {
name: "John Doe",
age: 25,
};
Its types are inferred as string
and number
as expected:
But if we assert it as const
, the inferred types for the person object are marked as read-only and cannot be modified.
const person = {
name: "John Doe",
age: 25,
} as const;
If we tried to update the age
field, we would get the following error: Cannot assign to 'age' because it is a read-only property
Arrays become Readonly Tuples
In my last article, we looked into tuples, which you can learn more about here. const
assertions on an array allow us to mark an array as read-only Tuple i.e. content of the array in each position becomes a literal type that cannot be modified.
Let's take the following variable personNameAge
, a normal array with the name at the first position and age at the second position:
const personNameAge = ["john doe", 25]
Typescript will infer this as an array of strings or numbers i.e. (string | number)[]
:
But, if we used as const
assertions, this becomes restricted to a readonly Tuple, with "john doe" in the first position and "25" in the second position:
And its values cannot be modified:
A variable value should be treated as Literal Type
Literal types allow us to define types that are more specific, instead of something that is generalized like string or number. For example:
type Switch: "On" | "Off";
const
assertions allows us to mark a variable value as a literal type. For instance, if we had a variable onSwitch
and assigned the value on
, normally typescript will infer the type of the variable as a string:
But, if we used const
assertions, it will be inferred as a literal type of On
:
And cannot accept any other variable apart from On
:
One thing to keep in mind is that const
assertions can only be applied to simple expressions. So you can not do something like this:
function switchValue(input: boolean) {
let onSwitch = (input ? "On" : "Off") as const; // Won't work
return onSwitch;
}
The above will throw an error: A 'const' assertions can only be applied to references to enum members, or string, number, boolean, array, or object literals.
To solve the above issue, we need to apply const
assertions on each output value of our ternary operator:
function switchValue(input: boolean) {
let onSwitch = input ? "On" as const : "Off" as ;
return onSwitch;
}
And the type of onSwitch
variable get inferred to a literal type union On
| Off
:
Conclusion
In this article, we looked at const
assertions and how we can use it within our code. We learned that we can use it to mark an object field as read-only, create a read-only Tuple, and mark a variable's value as a Literal type instead of widening it to its based type i.e. string, number, etc.
Thank you for reading this article, if you are interested in more typescript content, check out my previous articles here, follow me on Twitter and LinkedIn. And you can also join my new community on Twitter for all Typescript developers, where we can learn, share and connect with each other.
Top comments (0)