Intro to Rxjs for Javascript Developers

Key Takeaways

girls and welcome to brainy visitor from I'm penis today we're gonna be giving a quick introduction into reactive extensions for JavaScript or what is basically called rxjs so rkx is basically a library for reactive programming pattern for working with synchronous and asynchronous code both of them on java scripts this is not only available on javascript though you can use it on any other programming language like C C++ Java Python many many other places that reactive programming paradigm or pattern can be applied very easily so the main uses for managing the state of data fetching or basically handling events on a system so for example you need to fetch for a sequence of data from your server API and you really just need to fetch one single piece of data you want a sequence of data that you want executed one after each others you basically as just few wants so from your server API you can just register an observable which you know something that can be observed and each time the piece of data gets resolved a notification is gonna be a minute or pushed to your observer and observer in this case is gonna be a simple callback that's a function callback that just takes an argument which is the piece of data is gonna be fetch it from the server api and once this DNS companion be fettered just gonna be like you know put it on the observer for you so this is how the paradigm works you know there's two a couple of things to be covered but this is simply what it's called the rxjs so as I've said the are reactive extension is not only available for JavaScript though you can use it for other programming languages so you want to check the main official website reactive annex the aisle for other platforms and available and development environments so the reactive extension for JavaScript in here why do you use rx chance so the main point of trying to use our in my opinion is you can run both synchronous and asynchronous code on the same machine or in the same context without having to create promises and you know two single functions for dealing with synchronous counters on and so forth using observable pattern or even subjects pattern throughout our fjs you can easily run both synchronous and asynchronous code overlap them without any problems or issues you can also do a tradable objects and promises can be also used with within our exchanges so you can easily move from your promises you can easily convert it into an observable and use it within the our exchange context or use it within the hour exchange pattern without rewriting the whole code or refactoring your code base and this is super super useful you could also emit multiple events over time and this is the main point what a lot of people love it and use it because it's actually a stream of data that's you know gets notification over time once this dream is still alive and listening for events and you can emit whatever kind of events but also there is a larger set of operators to work with like standard data times so yeah the opera music can help you a lot either for easily creating observables or observing observables or pretty much you can just do in middle operators for dealing or manipulating your data for the observables now let's just take a quick look of what an observable is well observable a lot of people when they hear this name they feel like a little bit overwhelmed they they don't understand remains well it's basically super super simple I just think mr. point in here so observe any object and we add up in changes and yeah that this is pretty much all the points it's just trying to say here now if we could take a look at the observer this paradigm or this diagram I got it from the main official webpage so the origins observer was just basically you can take it as a normal function or no objects since both of them you know have the same context on JavaScript so you can just tell it to observe an object and once any changes happens throughout the time to this particular object this observer was gonna emit event to the observer and the observers have said before is just like a callback so you can just imagine emitting event using the event imager on the noches events being much system so once over time in there you can just you can of course in my event bonds they can have the same shape or something but on the observable you can emit as many events as you want you can also have the complete in the air event if there is any problems and curious in here whenever you emit something the flip in this case represents our observable and throughout the time in here this is just the line that goes from the left of life represents the timeline of the application running so you can omit anything you can omit for example star and it goes right into and it goes to the observer and the other case so the some points you want to just not get of it so for some reason the observer Tammany's the abnormally with an error of course you're gonna get the arrows tattoos or if everything goes right and your observable gets emailed all the notification needed which is gonna complete and the dotted line in this case I'm gonna mean like the transformation has been successfully applied and you have completely or successfully finished doing the job of the observable so this is pretty much where it is you can just come in and see more about this on the official web page but you could just you know keep watching this we're gonna be looking on the code and see how things work so we'll just jump right into and get started with our exchange so this is the official web page for the reactive X and actually available for all platforms so you can select you know whatever programming language you want and you can use but for specifically using it with JavaScript so since we are actually having a JavaScript story in this case so you can just go to rxjs dev and you can find this in here you can even take a look on the get up depository well there's also a really cool API documentation is underneath in here if you want to check it them out but let's go to jump without further ado into our Carolyn here and we just simply start by taking a look of what durable and how we can work with it so no just just simply we need to install RF channels so we just open up the terminal and I'm gonna do NPM install rx chance and there's also extensions for oxygens but the main minimal in the bare components or the main components in here to install is actually the rxjs library so just do install our chance - save and you click it and it just gonna be installing it for you it's not that much of a huge you just have all the needed components for you to run RS chance on your application and here I mean usually know just to run this of course the browser does support that's on your problems but you're not further ado just use the nerdiest in here and you works with it pretty much fun just for the tutorials sake as I mean now let me just gonna do rxjs an important really quickly so I'm gonna do our exchange and important this using require now this ArcGIS is gonna import the global thing so all the functions classes objects and error types and everything is gonna be put inside of that so it's actually gonna play a role as a global variable to be honest I'm just gonna use this so firstly to create an observable wonders of thought before an observable it's just something that reacts over time whenever you give it you know like you telling to emitted events any missing events and you can just tell it for example to go in and watch a specific object like an array or something and you can use it throughout operators but it's not simply an decreed and observable so I'm gonna do the cost and I'm gonna do there's gonna be much observable so this is the bare minimal thing and I'm gonna do new onyx Janus dot observable the old pattern has a static function that pretty much allows you to create this boss the new pattern you need to initialize this using the constructor and the new keyword so pretty much just that's and here it takes a function so a function it takes a subscriber a subscriber is pretty much means is the observer so the guy or the object that is currently observing the current observable so you're just gonna pass objects so you can have control over and you can do whatever you want with it so I'm just gonna have the subscriber you can either call it subscriber or observer and it's the same thing it doesn't really that much of a mirror we got the SUBSCRIBE in here and throughout the SUBSCRIBE objects to try to type this what we can have you have a couple of things you've got the main thing is actually emitting with the next method so the next method what does it means an event or a push notification to the observer so the observer is gonna receive some kind of an event on his callback on the next callback of course are gonna be registering and you can emit how much every wants not only one not only to you can you know minutes as many as you want and you can finally complete it or you can just finish it with an error so seriously there's our next an error method and a complete method so here and complete either one of them has to happen it can't happen go through the same time for the next you can omit many next ones and omit many data to the observer and finally can finish it with an error if there's any errors happening only behind the observer only there kind of things you can just complete it successfully without any problems so here we can just gonna miss let's say hello and you can of course omit how many data as you want not you you're not actually controlled by anything because you might want to say as for example promises you only be able to omit one single thing once the promise is resolved and resolved with a single value or either rejected or an error and this is a completely difference this is what you mean by an observable so you can image many types of data and not only one single time so for example you give it like 15 or something you can give it a boolean an object that doesn't really matter and here like I can give it like an ID one and this is my object and finally as I've said you need to either finish it with a complaint or error I'm gonna just put a complete in here and means we have successfully completed the observer so this is how basically the observer works and this is a custom observer I'll pretty much of observable and this is how you could create it you can here not between this and this killed looking for example like yours to do and fetch data from the server API and you can do for example using it gets HTTP request you can go to the or URL it gets the data and once the data's gonna guess just gonna submit it next function and but then it's gonna be mutilated to the observer we easily now to this have created observer this is not gonna be running and they mostly cold as a cold observables so what I mean by cold it's just like simply they're not gonna be running until you subscribe to them and subscribing basically means you're gonna be observing them or registering an observer for a specific observable so this is pretty much ready means and here of cosmic observable I'm just gonna do such the SUBSCRIBE function or subscribed method since we are actually in an object context so we got to subscribe method and here it takes an observers pretty much see in here and there's actually a couple of two implementations all of them are deprecated is gonna be removed with the next versions while volume once is the last one where you can just provide a next callback and error callback and a complete callback so when you call next this callback is gonna be executed when you call it error in here inside of the implementation of the observable I'm gonna call it error this is the error is gonna be happen and when you call complete it's gonna be happening there and completed errors of sin they only happen one single time on the you know the running time or the timeline of the observable they can't run both multiple times the only one and once so call the next in here and it's gonna talk about we're gonna be emitted from here we're gonna receive it right over here so I can give my console dot long next and you can just put the value inside of here I can have the ear without any errors so I think I'm just gonna do console era and pretty much gonna have the air and finally what we can probably do is the complete the complete doesn't takes anything so I just put bass and you can do these I'm salsa but long completed successfully something and there you go so we came here after subscribing and after running the keratin just gonna save this just gonna point to Marconi for you so you configure see is next there's a hello and then you submits hello on the next floor back less 15 and there's pretty much the next and with an object I'm chief so I'll get it right over here and a finally need just like completes and it calls this callback which means complete it successfully so this is basically what observable is and how you can use it but if you don't call the subscribe right over here it's not gonna be running and it just like gonna be a cold observable so you need to first cool subscribe like attach an observer to it first so we can run otherwise it won't run in any way and it just like stays and implementation so this is what I mean by a cold observable in the context now about observables what you can do is pretty much you can dispose or like you say here the observer was gonna be running its gonna emit next function is gonna emits the other next function someone on so forth and then it gonna miss the complete function as furies in here there is only synchronous code so this executes before as you put it in here the you know the the order of the execution of the lines and functions in here they are the same execution here there's a means they are synchronous but how we can one asynchronous code so just by putting asynchronous carried in here like he puts a fetch API on the server or simply you can just do this by using the set timeout so you can use set timeouts and you can tell you after two seconds so the set timeout here who's gonna do which is gonna do subscriber and it's gonna cool annex so next so after two seconds and here we're gonna just be running this after two seconds you're gonna be run after two seconds but we need easier you're completement so before this gets running the complete is gonna be one in the actual observable it's gonna be stomping so you need to copy this and make sure like once you run the last execution of the next function you just like call the complete because call the compute will dispose the observable and you won't be able to pull next again that's why you mean you need to call this after calling the last next otherwise that's not gonna be executed whatsoever so I'm just gonna save this right here clear you see we get all of those and we get after two seconds then it can plane so pretty much we put the code right over here right in the middle but it is running asynchronously as you clearly see observables can also be running a synchronously with all your problems now there's all types of observables like subjects which is a special kind of observables in this subject what it means is actually but you can share the same behaviors what the difference main difference between an observable and a subjects they actually share the same behavior of emitting next function notifications and the complete in error status is but the only difference is that subjects can can be observables and observers at the same time and which means they can listen and react for emitted event values why they can also emit values on their own so that's our one subject video the other thing is that subjects are hot which means they can even run before subscribing to it so once you create the subjects it's just gonna be start running immediately without subscribing in here so as we've seen the observable is actually a cold thing so once you subscribe is gonna start running but on the other hand the subject only gets one in once you actually create and initialize this so this is gonna see subjects in here just gonna create a comment and putting right over here let me just get in Commons all this code in here so since we're just gonna be needing it anyway now for simply creating a subjects it super simple is not something really complicated it's just a special kind of gerbil so we gonna do cause I'm gonna do my sake Jackson here and I'm gonna create in you using our strands stop subjects so the subject in here takes nothing so it doesn't have the same context as put in on a subscriber in here and I put a call back and then you can define whatever you observably would be able to do now this one is actually can play both roles as I've said so you can play a role of an observable and you can also play a role of an observer so this is pretty much what a subject is and this is the difference between an observable and a subjects now we can do my subjects and it can emit an X function of course influency is a next available here you can stop emitting anything but let me just say like this value is first so for example before subjects one so the subjects even receive this because the subject is hot so once you create the instance in here and once you emit an event to it is you're gonna emits the event it doesn't really care if there's a subscriber or there is an observer listening to the subject or if it does not have that so in this case we don't have any subscribers this is not gonna be received whatsoever in this case we're just gonna try to do a subscribe function to it and for subscribe function I'm just gonna grab this I don't want to waste a little bit of time so I'm just gonna do my subjects subscribe to you're gonna have the next gonna completely successfully the same whenever you subscribe to it as I've said in this time it plays a role of unobservable and in this case it plays a role of an observer so you've got the point of trying to say in here and they're just kind of try to emit another one but after listening into it after subscribing to the observable that's my subject observed we're gonna just do this value gets and it's gonna try to control ants seriously we get this value gets received which is you know we submitted this for emitted this after subscribe you but we're not getting the one we are a meaning before subscribing that's why as I've said that subjects start running once they initialize them in here the immediately start running so once you push like a notification or omits in here a value it's gonna be like pushed it doesn't really care if there's a subscriber or not but on the other hand once you subscribe to not observable only then it's gonna be start running so you've seen if we just remove the subscribe from here like you know remove the SUBSCRIBE but we still initialize and create the instance pretty much of the observer in this case you just wanna be running anyway so we just like stays cold and you know stays underneath the hood is not gonna be running whatsoever so this is the main difference when I'm trying to say it right over here there's also all the types of subjects which allows you to pretty much manipulate specific data so there is actually the reply subjects in this reply subject what it does they actually can allow you to get the last minute value so once you just subscribe to it every single one every single observer that subscribe to my subjects will be able to get the last emitted value on the stream so the last immediate value in this case is will be this type of string so much we subscribe to it will be able to get this string then you can get this one of course but let's say you want to emit another one in this case and this is received and as I've sent the replies subjects only gets the last emitted value which is this one right before we subscribe and it push it and the SUBSCRIBE is gonna receive it throughout the the next Handler and we can just go and do it so here you see if you save it we've got this values first before subject runs they recall this received and we got also this guest received previously we've got all of them running because we are just pushing them before we subscribe i watch however then do a plant objects gonna be pushing right over here there's also other kind of things like the cave your objects so the behavior subjects and you can take a profit as a parameter as an additional to the reply object it's pretty much the same thing to apply subjects but here it can take an initial value to get a minute first so this initial value you can give it like nature or something something like this and you can start working with that but in this case you won't be getting it anywhere so you see we can this is received at the volume against receive we only get the last one received and we got this value gets received whatsoever so after we subscribe to it we gave the last immediate value because it's a behavior object and we get the one after we subscribe to it we're actually emitting pretty much and the replied subjects gonna get you all the values before subscribing is gonna be emitted for you right over when you subscribe Bonni other keys for the behavior subject you can specify let's specify an initial value in this case I'm just gonna move this the SUBSCRIBE so let me just go over this select it and move it right up there so we'll be able to get the initial value and all of the values in this case but I'm just gonna try to like comment this code so it won't run anyway so I'm just saving this we get initial because you know we're specifying this to be the initial value to get pushed to whatever observer gets subscribed first then we get the value gets received you can subscribe how much ever you know although subscribe handlers and stuff and they still cannot be worked the same way I'll say leaders in here and the other important parts of our chairs are the operators so arch is operators are like you know a bridge for creating and quickly create creating observables without you know having to deal with all this callback functions and stuff including them from the beginning you know you can just gonna use operators and they can do the job for you for example we've got an array so it's saying here in this case we got a Const my data and it's gonna have an array so God's first simple high many gods 15 then a gods in an ice cream or something in this I don't know something like this how many ridiculous and then I've got inside of your array and why you want you want to just like register an observable that distance for every single value or every single item on this array and pretty much images so to do so we can use the are exchange there's an operator called a from so the front operator takes any kind of a tradable object like an array or it can takes a promise or it can take like a generator function which is returning an iterator of course you can you can learn more about this on the MDM documentation why not boss the main part in here you can give it to my DNA he's gonna return to you as an observable so you can subscribe you can use the pipe method so the SUBSCRIBE became just go ahead and do the subscription in here I really quickly I'm just gonna copy but if this so three teachers gonna use subscription and it's gonna pretty much work fine so we can save this run it again as clearly we get high get 50 we get ice cream and so on and so forth that but by using the from an operator it takes this the other time the irradiated type it converts it for us into us variable then you can subscribe to anything you say easily now let's say we've got this array and we pretty much even we've got this DN a-- but what we want i want to just get rid of the ice cream at the end in here or i want to add like instead of like returning a single Ultima from this case we may return objects and stand so here where he comes the park method so the pod method retakes you can just panic through words the before run in subscribe of course you can manipulate the data in here and watch till you return the subscribes gonna like receive the new returning DN a-- from the pipe method what I mean by this you can also use all the operators in this Kings so for the pipe it takes pretty much a function and you can take you know the source observable and you can return the DN a-- but what I want is specifically I'm gonna use the map operator so the map operator I'm gonna get from the operators because I will be able to guess the arts Jan's from operator from from the exacts you know our exchange librarian here from the global variable because it's very important that's why it's been included there but to access all the available operators what you can do I'm gonna just use the destructor in here I'm gonna call it map and also naps you I'm gonna do is focused on operators so the operators folder has all the available operators for you so you can easily quickly use it the map operator what it does it takes like the value that you're gonna be receiving and once you return something you can return whatever so I'm gonna say V pretty much let's say data or item it's gonna be V and let's say exists sure so I want to return an object like this in this case of course I'm just gonna rock this using parentheses since this is a function and once we return this is this objects that we are returning for every single awesome on the lesson here on the array so this object is gonna be forwarded into the SUBSCRIBE and the V every single time is gonna equal this object so you can just going to do console what spheres difficult just take a look there's the item they exist on the e value so I've seen this I'm gonna against an object every single time like item hi exist true a 19-15 the same thing over and over again just by using this cool awesome operators you can do a plethora of things of course and you can you can do a plenty of things there's plenty of plenty of operators who keeps going to check out the documentation the other operator I really do like and really do enjoy working with is actually the arcs chance can can't operator and the time operator so let's say you've got observable payments timer one so the timer one in here what it does then use the oxygen as the timer method and this one is gonna create for me observable that's you know gets evaluated after a certain amount of time like you can imagine this as a sent timeouts body says returning an observable instead of a function so the timer here so I'm gonna say ever every a second are you gonna be just doing I'm gonna be piping it so then use the map I'm gonna do math to in every single time I'm gonna be mapping it to Han all right I'm gonna use another custom one in here so I'm gonna do time in to the time that you're in this key is gonna have two thousand means two seconds and I'm gonna have to blow so after Osaka is gonna be a minute Hong and after two seconds it's gonna be meeting hello I used this operator because in maps whatever value comes from here into hello so the final value is gonna be a from this observable it's gonna be hello and after just two seconds just gonna complete so it's emit only one single value to run this of course we need to subscribe to it so for subscribe anything just give ants here my chicken to subscribe I'm gonna use the concatenate function so instead of the front we're gonna do King cats and King cats takes as many operators as you want but it runs them on order so it runs the timer one in Muncie finishes it started the timer to and once it finishes and someone and so forth so it runs all the observer was given between parentheses in here in order one by one I'm gonna do time for one and of course time or two once it completes the timer 2 is gonna be running and so on and so forth so this is how we pay much worse and I can just go ahead and I'm piping in here so we're gonna get the same result nice pretty much we're doing so starting oh yes we get fighting high after a second after two seconds we get high - hello then it got exist - because we're using point so this pretty much it for arc suggests there's a plenty of things pretty popular is you can just come and check out the documentation I hope you really guys enjoyed the video tutorial as I did enjoy making it and think us watching I really hope you guys have enjoyed make sure to check how about and you know request any other video tutorials you would like in the comments below see you guys in the next video tutorial