A record is defined as a data structure that stores a related set of properties. A common example of that would be something like a table within a relational database. Now in JavaScript, it is common to store records as key value pairs within JavaScript objects, and TypeScript provides a utility type to annotate such objects intuitively called record. So let's take a look Here. We are using the built-in utility type called record to create an object such that given a string key, it'll give us a value object that has a member name of type string and role of type string.

We can create an object of type persons and then use it to store some people. For example, we are storing two people over here, one named John of role admin and one named Jane of role owner. Now, the value type is something that will be enforced whenever we try to store a new person. For example, if you try to store an object that does not contain the name property, we'll get an error from the type strip compiler. Now, even though this demonstrates some of the usefulness of the record utility, this is not something that you couldn't easily achieve with the existing index signatures feature of TypeScript. However, even in this particular case,

I find the record utility to be a bit more easier to read, however it provides additional features as well. So let's take a look. In addition to using primitive types such as string and number, you can use a union of literal types as well as keys for your record utility. For example, we can create a record called people with roles such that it only allows the two roles, which are admin and owner as the keys and the values of string arrays. An obvious example would be something like this object that contains the two keys and arrays containing the different users. Now, when we use a limited set of literals as keys

for the record, utility type TypeScript will also enforce that all of those keys are provided when we create the object and raise an error. If you forget some of them, enforcing this constraint means that we can access any of the records literals without having to worry about them being possibly undefined. This also means that we can use the record utility as a shorthand for creating some simple objects. For example, hey, we've defined the point at a type as something that can contains two members, X and Y, both of type number. And we can see that when we hover over this particular type.

And honestly in this particular case, I would much rather type the verbose version instead of using the record utility. But let's look at a use case where this is actually useful. We have a type called page in four that has two members id of type string and title of type string. And then we have a number of pages within our project. Now, a verbal way of defining those pages is to repeat the page info annotation for all of the pages that exist. That is home services about and contact. This is an excellent use case for using the record digital. Instead of having to define the page info annotation again

and again, we can simply specify that people have the keys home services about and contact, and they will all have the same type. And because we don't have to keep annotating Page info again and again, we can even not create that type and declare that in line as the value for the different records as well. So in this particular case, using the record utility saves us from having to create the page info type and then having to repeat ourself by using the same annotation again and again. Now finally, if you are interested in the internals of this record utility, it is nothing more than a maps type wrapper.

It takes a set of keys that must be valid indexes, takes a value type T, and then loops over all of the keys in K using a map type and maps them to the value T. That said, you don't need to look at the internals of the record type in order to use it effectively as long as you remember the key use cases that we have demonstrated in this lesson. And that's all for this lesson. Smash the like and subscribe for more quick recording tips like this. And if you're interested more in learning about map types, I have a lesson dedicated to that over here. Thanks for joining me and I will see you in the next one.