Arrow is a JavaScript library that allows for asynchronous functions called arrows. Arrows take input and produce output asynchronously. Using arrows provides benefits like implicit returns, automatic binding of 'this' to surrounding context, and shorter syntax. Arrows handle promises, events, and the event loop. They solve issues with callbacks and callback hell. The event loop processes callbacks asynchronously by placing them in a queue to be executed. This allows JavaScript to remain single-threaded.

1. In Commercial
Web
Applications
Submitted By:
Anirudh Gangwar
Information Technology
1404313010
Submitted To:
Prof. A.K. Solanki
Head of Department
1

2. Content
 What is Arrow?
 What are the benefits of using Arrow?
 Characteristic of Arrow.
 Facts on Arrow.
 Difference between traditional approach and by using Arrow.
 Promises, Event Programming and Event loop.
 Architecture of Event loop.
 Comparison between this and Lexical : this keyword.
 Conclusion
2

3. What is arrow ?
An arrow is a function that takes some input and
produces some output, possibly asynchronously.
It is a JavaScript library.
Syntax for Arrow function:-
function() replaced with “ => ”
3

4. What are the benefits of using
Arrow?
4
 Arrows is a new syntax for functions, which brings several
benefits:
 Arrow syntax automatically binds this to the
surrounding code’s context.
 The syntax allows an implicit return when there is no
body block, resulting in shorter and simpler code in
some cases.
 Last but not least, => is shorter and simpler than
function, although stylistic issues are often subjective.

5. Characteristics of Arrow.
5

6. Facts on ARROW ?
 Implicit return.
 this binding.
 Arrow subsume the sequencing and
error handing features of Promises.
 It also provide a means for cancelling
and repeated computation.
 Its solution to the problem of callbacks.
6

7. Difference in traditional approach
and with Arrow
7
/*traditiona
l
approach*/

8. New approach with Arrow
8

9. Promises and Event programming &
Event loop.
9
Promises are a way of dealing with asynchronous
code. Code using promises can make asynchronous
code easier to compose, and can also avoid the
common issue of “callback hell”.
A promise can only succeed or fail once. It cannot
succeed or fail twice, neither can it switch from success
to failure or vice versa.
There are three states of promise:
1. Pending 2. Fulfilled 3. Rejected

10. Constructing a promise
10
new promise (function(function resolve, function reject) resolver)
-> promise
Example:-
let promiseToCleanTheRoom = new Promise(function(resolve, reject) {
//cleaning room
Let isclean = true;
If(isclean){
Resolve(‘clean’) }
Else { reject();
} });
promiseToCleanTheRoom.then(function(fromResolve) { console.log(room is
+’fromResolve’); });

11. Event programming & Event Loop
11

12. EVENT LOOP
12

13. Architecture Of Event Loop
13

14. Comparison b/w this, bind this &
Lexical this.
 THIS KEYWORD :-
 this can be used to refer current class instance
variable.
 this() can be used to invoke current class constructor.
 this can be passed as an argument in the method call.
 this can be used to invoke current class method
(implicitly).
14

15.  When ‘this’ lost there context to parent function then we
declare a variable ( var x = this; ) and
after by using this variable we increase the
context of ‘this’ keyword throughout the parent
function to nested functions.
Ex:-
var usebind= { di=1;
var z= function( ){
console.log(this.di);
setTimeOut(function(console.log(that.di)){ }); .bind(this); }
15
Bind(this)

16. Lexical this
JavaScript has lexical scoping with function scope. In
other words, even though JavaScript looks like it
should have block scope because it uses curly braces {
}, a new scope is created only when you create a new
function.
function FooCtrl (FooService) {
this.foo = 'Hello';
FooService .doSomething((response) => this.foo =
response); }
16

17. Error handling
 Error handling mainly handled by promises in this
technology.
 Arrow library which is widely used now this time
it is composed of error handling tools.
There are also other basic libraries which are
useful in handling the error which occurred
exceptionally.
17

18. CONCLUSION
At the end we could conclude that, In future
we could easily integrate ARROW with real
world. And it will very helpful in designing and
and handling the exceptional error of web
applications.
18
Conclusion

19. References
[1] E. Fritz, T. Zhao, Type inference of asynchronous arrows in
JavaScript, Reactive and Event-based Languages & Systems
(2015).
[2] Y. P. Khoo, M. Hicks, J. S. Foster, V. Sazawal, Directing JavaScript
with arrows, in: Proceedings of the 5th Symposium on Dynamic
Languages, DLS ’09, ACM, New York, NY, USA, 2009, pp. 49–58.
[3] K. Gallaba, A. Mesbah, I. Beschastnikh, Don’t call us, we’ll call
you: Characterizing callbacks in javascript, in: Empirical Software
Engineering and Measurement (ESEM), 2015 ACM/IEEE
International Symposium on, IEEE, 2015.
19

20. ANY QUESTIONS??
20

21. THANK YOU.
21