Save Spectator Conditional with airSlate SignNow

Save spectator conditional

welcome back to their their very own it's coding below and nice trip types of Dave is the last part and we're gonna look into more advanced types like map types conditional types and in fair with these type annotations these evaporators and ones have you've learned previously you're going to be in a better position to write a more maintainable ties people as you can transform types think about that your other times that are already defined in your application when you're defining new types so let's get started rig the slide awesome so today we're going to talk about map types map types map ad types which is the last part of advanced types I want to touch with you in the series there's a personal side mapped types hmm so oftentimes when doing type script you will find yourself in the need of converting one type into another type making a transformation of types and this is where map types come in because they allow you a very nice way to achieve that conversion for instance here is nice used caves to use map times I will be we happen quite open so here we have a class person I had some properties I want that we've seen in the series before name string height number weight age and now you have one method that you want to use to abrade some of the fields of this class so it could be all of the fields or it could be some of the fields and we're gonna represent this with an interface right now called person options right and then we use a bead or a sign and we assign some of those properties to the instance of this class person this is one way in which we could achieve it with the person options interface that represents those params that we need to update and when we use it we can use it like this we say yay me no updates and I will send age 37 because was my birthday yesterday so I'm becoming older and I have more wrinkles so you can see that with donuts and all the the properties we can solve it and one and I will get h updated in that person so happens is that we there's even ways in which we can solve this right one way to solve this is to recreate this type person options from scratch using optional property so we more or less reproduce all the properties in person and we'll say name age height weight of the same times and then we say they're optional and that way we have a way to represent that they need a structure type to play the fields inside a person are you think about it this is not super maintainable right because we have two definitions we have the actual person class we has it's already typing itself has its properties and now we need to duplicate more or less the same types but just making them optional with a new interface and then what happens is that if you are some time and then what happens is that if I have some yeah hey and then what happens is that if at at some point in time in the future we update the interface of person now we have to go ahead and also update the interface of person options that we have just created so basically this creates more maintenance for us in the future because we have a new type that we need to maintain right so if we go back to this class person wouldn't be wouldn't it be nice if it was a way for us to transform the person type itself into like a version of person type that is that has all the properties optional and this is worth map types come in very handy so we're going to do a transformation of a type into another type like the partial type so here we have imagined a new type called partial that what it does is it uses generics and it says partial of T of person is the same type as person but now all the properties are optional and is how you write it as a map type so here we have this is the syntax I use for map types and we're using both generics so we saying partial o type we're saying partial of T so it could be applied to any type and then we're using this special keyword inning to traverse all the properties of the type T we're Masek making them optional let's break it down to each of a component parts of this map type so we can understand better how it works and I feel good look have a waiter have oh there's a pointer there and it's gonna stay there so yeah now the type are shown so basically we're saying creates a new type called partial and then is gonna be based on type D we're using generics here so it works with any type that we can imagine and now we say okay it's gonna have all the properties of P it's gonna have all the properties P of T so you don't have all the properties of that object but basically traversing of those properties and then we're applying an operator on them this question mark basically says that all these properties are now gonna be optional and then the return type or using an index X operator here we're saying that return type is going to be the same so we're extracting the type of property P in type T and then this is basically the whole explanation for this partial map type so if you think about this new operator in in the Union type if you break it down is basically it works like a loop so it allows you to go through all the properties of an object and then do different things to them and that's how we are mapping over an object we're mapping up through all these properties of an object and then if you be nice to and then it's nice to to pause a little bit and X minus and realize how we're using this map types resolved as part of very useful because they build on all the craters that we've seen thus far all those type of failures so we're saying that we're using generics at the top then we're seeing the map type with an in operator then we're seeing that index query operator key of that we saw earlier to extract the properties of an object as a union type then we're seeing how we're playing that operator at may emotional and then finally we have the index access operator again to access appropriate m to access a type properly in an object in a type to access that type of property in a type there's a lot of types and properties type system the type dimension can get complex ok and now let's look at different examples or there are some other useful examples of map types that we can't think of so in here we're combining or using a combining a map type with intersection operator and then we get we we have to transform a type and then we get to extend the type with new fields so here we have a partial type that in addition to that also adds a timestamp just like their proofs that we have before but now we're extending it using intersection operator to add a new field timestamp there the pink here we have another map type that instead of making properties optional they make it makes a nullable now you can see how the interesting part the the change applies to the return type so we're saying that unlevel type T and the level of T okay where this is an object that has the same properties as the object we're basing ourselves on and now the return type it can be to twofold it can be two different things either the type of the property itself in there you know object or no I'm using this in this case transforming that return time we're getting the ability to make an object notable here we have another example this is a read-only of T so this makes every property of an object read-only and then this is exactly or super similar to partial of T but now instead of you seen that question mark operator to make them optional now we're using read-only to make it read only if we want to make the reverse a writable of T so we do - read-only and that allows us to make all properties not read-only so all previous writable we have another type this is either even more complex because now we are using Q generic types of this object allows us what this new type allows us is to pick some of the properties only of a given type so create a new type by picking some of the properties of other type and this is how you would use it so we have this type age less person which is the result of applying this map type pick to the type person and send in a union type with all the friends that we want to get and if we read it slowly we say peak of T so it's about type T and K which accent K of T so K is a union type that can be one or more of the properties in type T and then you can see that instead of traversing like we did before we'll have a traversal key of G so we traverse all the properties of type T now we're traversing P&K it's okay it's only a subset of those properties and then the return type is the same we use it in the success to get the type of the property so if you think about it a nice way to think of map types is like in terms of function so there are like functions or work on types very similar to the map function that we have in ray prototype but instead of working on values equation types so it transforms types into other types and you can see them as transforming a collection of properties with some types into a collection of all the verbage with our types awesome so all of these map types are you've seen are so useful that they actually can built in in Thai scripts and I called utility types read-only of T part of T pick TFK there's a lot of these types are built in utility types that come ready to be used in Thai script and you can find great examples of how to use these different utility types right in the types of documentation so you go there you go to utility types and you will find all of them here with examples for you to use very useful now for the N we have conditional types and in fair and this one rap argue at advanced types in dye script conditional dye it's selling fur so conditional types let you choose between types based on our condition now you're gonna see how that works in an example because that's the best way to explain it and then in fare lets you infer generic types which you can then refer to in conditional types particularly in the true branch of the conditional type and again this is much easier to understand when you see an actual example of a map type using a conditional type so we're going to jump into that okay so let's imagine that we have some code and in the code you want to load that something happen and now we're using a logger to lock that information and what we're doing we're saying that okay we're logging that my dog it ate my mom and then we put a time same day dot now now we're writing some tests right we write in to test I want to assert that that method was called when we exercised some system under test and in order to do that we're gonna use a mocking framework and we're going to to record some expectations and I'm all can say respect that this method will be called block with this information and that's the scenario we're going to cover right now so this is how it looks the implementation for this mocking framework it has a way to even our arguments that we they're called argument matters and then when we start with doing with the good record expected behavior in our log in our mock so and it has the same API or a brace in your API I'm the real object so that longer dot log thus we're saying okay we're expecting that whenever we exercise the system under test we're gonna call the logger.log method with these argument my dog ate my mom and then because time Sam's aren't very reliable you don't want to tinker with the clock we say that we're going to ignore the second argument that important and then we test system under test and then we verify that the log was called and that's gonna pass or fail our test and this is a special method that is in in this mock class that's called power verify that verifies that the spectator was met that happened so now we have a mock that matches the mock type behavior but it patents all methods to allow for argument matters so this sounds a lot like a transformational types right so now when we want to or need to model this in the world of types let's see how we do it see how we represent it in the type dimension so this we're going to create a new arch a new math type because we're transforming an object a tight they want to mock into into a mocked version of the type and that's transformation therefore map types sounds like a good candidate for that so we create this new type mocked of T that represents a mock of type T it should be generated because you should work with any object now we're saying okay for every property P in type T we're gonna we're gonna do the following we're gonna say that and now it's when we use it on a user conditional type so we say if the type of that property or using index access so the type of property P in type T if that type of P extends this other type so basically what we're asking is is this type of function is the type of this property a function and then we're saying basically if it accepts and that's the type annotation for a function if not I infer for now or don't ignore it so we assume within fair even a fair are basically it's like we're saving those types in a variable so we're saying that basically saying oh this is a function and then by the way save the arguments in the type u and save the return type in i par and then we can refer to it in the next in the next part so I said okay if the type of that property is a function then return this type and that is you you're seen aware patch in both the arguments and the return-type work so we're saying okay so we for the type of this property if it is a function then we're gonna replace arguments for mock arguments of you which is gonna be another mob type and then the return type is also we're gonna touch it for Makar so basically we were replacing we're saying if it is a function then instead of using the former type now it's gonna have this patch type that basically makes it mockable or useful in in in tests and if it is not a function that we don't need to do anything so yes if it is just a property yes return the type of that property so basically it's traversing all the properties check in if it is a function if it is an action then we patch it if no the function then we just use a normal type and then in the end we use the intersection type operator to extend the macht of t them to extend them the original type with a bunch of methods that are only available in most like that tor verify for instance and then yet you saw how that is where infer comes in so we're saying you need using fair there so we can refer back to it here I'm saying whichever type is there now we're gonna actually patch it or extend it or transform it that's right word transformative over use map types so these here this part here is a conditional type this one we say if this type is a function then touch the function if it's not a function then it's a property that returns normal type so this is the conditional type and then just program please shine so the mod arguments of T this is also a map type but this is simple this is where you're saying go through all the properties in this type and then they can either be the regional type or it can be an argument matter and because they can be either of those then basically what we're doing is that we're allowing the consumer of the smoke to provide either the normal type or this argument matters like the ignore argument otherwise we wouldn't be able to do it because the function would expect normal types are not arguing matters that's it that's it format types conditional types an affair I know that this can be very confusing so don't be too hard on yourself if it sounds weird or it sounds confusing it's okay for you to go back where I started talking about mom types and going through it once more so it slowly sinks in and the next thing that you should do is to open that ask your playground and just play yourself with map types and try to create partial on your own try to try to create read only on your own try to experiment with different map types and conditional so you understand how it works and can internalize it but this is very hard to to understand because it's super as abstract we're normally super weary habituated very comfortable with values we just programming but then when you add a layer of types on top it can be quite confusing because it's so abstract everything is like one step away from the actual program is like it's like a different dimension the type dimension awesome so now we're gonna finish this talk with as const is i know where to put it so I put it in the end this is a nice thing to know that it exists it's a way to make objects immutable so it's something that you can apply in the world of types in that script to make objects immutable completely new level so here we have an object literal which is like obvious dummy object said it has a appropriate text value hello if you use s Const when you declare it in the end and it's only worked with object literals what you do is that you make all properties read so now these from the tax-free perspective this obviously this object is completely immutable you cannot change it the cool thing about this is that is deeply immutable so if you have a nested objects if you have an asset object with objects inside itself as cons applies to all the the objects and that's inside an object so this is we would call a deep immutable so this really useful to creating new objects use it in the codes where are my hands they're here like I'm a homeless homeless person person with no hands but they're here