Javascript examples with code pdf ( জাভাস্ক্রিপ্ট উদাহরণ সহকোড পিডিএফ )
YOU DON'T KNOW JAVASCRIPT 6 PDF BOOKS
You Don't Know JS: Async & Performance
 |
You Don't Know JS: Async & Performance
|
Table of Contents
·
Foreword
·
Preface
Chapter 1: Asynchrony: Now & Later
·
A Program In Chunks
·
Event Loop
·
Parallel Threading
·
Concurrency
·
Jobs
·
Statement Ordering
Chapter 2: Callbacks
·
Continuations
·
Sequential Brain
·
Trust Issues
·
Trying To Save Callbacks
Chapter 3: Promises
·
What is a Promise?
·
Thenable Duck-Typing
·
Promise Trust
·
Chain Flow
·
Error Handling
·
Promise Patterns
·
Promise API Recap
·
Promise Limitations
Chapter 4: Generators
·
Breaking Run-to-completion
·
2)Generator'ing Values
·
Iterating Generators Asynchronously
·
Generators + Promises
·
Generator Delegation
·
Generator Concurrency
·
Thunks
·
Pre-ES6
Generators
Chapter 5:Program Performance
·
Web Workers
·
Parallel JS
·
SIMD asm.js
Chapter 6: Benchmarking & Tuning
·
Benchmarking
·
Context Is King
·
jsPerf.com
·
Writing Good Tests
· Micro performance
·
Tail Call Optimization (TCO)
Appendix A: asynquence Library
Appendix B: Advanced Async Patterns
---------------------------------------------------------------------------
Jake Archibald
|
| You Don't Know JS: Async & Performance |
Developer Advocate at Google Chrome
Type of File :
PDF BOOK
Pages :
172
Size :
1.32 MB
---------------------------------------------------------------------------
You Don’t Know JS: ES6 and Beyond
 |
You Don’t Know JS: ES6 and Beyond
|
Table of Contents
1. ES? Now & Future
Versioning
Transpiling
Shims/Polyfills
Review
2. Syntax
Block-Scoped
Declarations
let Declarations
const Declarations
Spread / Rest
Default Parameter Values
Default Value Expressions
Destructuring
Object Property Assignment
Pattern
Not Just Declarations
Too Many, Too Few, Just Enough
Default Value Assignment
Nested Destructuring
Destructuring Parameters
Object Literal Extensions
Concise Properties
Concise Methods
Computed Property Names
Setting [[Prototype]]
Object super
Template Literals
Interpolated Expressions
Tagged Template Literals
Arrow Functions
Not Just Shorter Syntax, But
this
for..of Loops
Regular Expressions
Unicode Flag
Sticky Flag
Regular Expression flags
Number Literal Extensions
Unicode
Unicode-Aware String Operations
Character Positioning
Unicode Identifier Names
Symbols
Symbol Registry
Symbols as Object Properties
Review
3. Organization
Iterators
Interfaces
next() Iteration
Optional: return(..) and
throw(..)
Iterator Loop
Custom Iterators
Iterator Consumption
Generators
Syntax
Iterator Control
Early Completion
Error Handling
Transpiling a Generator
Generator Uses
Modules
The Old Way
Moving Forward
The New Way
Circular Module Dependency
Module Loading
Classes
class
extends and super
new.target
static
Review
4. Async Flow Control
Promises
Making And Using Promises
Thenables
Promise API
Generators + Promises
Review
5. Collections
Typed Arrays
Endianness
Multiple Views
Typed Array Constructors
Maps
Map Values
Map Keys
WeakMaps
Sets
Set Iterators
WeakSets
Review
6. API Additions
Array
Array.of(..) Static Function
Array.from(..) Static Function
Creating Arrays And Subtypes
copyWithin(..) Prototype
Method
fill(..) Prototype Method
find(..) Prototype Method
findIndex(..) Prototype Method
entries(), values(), keys()
Prototype Methods
Object
Math
Number
Static Properties
Number.isNaN(..) Static
Function
Number.isFinite(..) Static
Function
Integer-related Static
Functions
String
Unicode Functions
String.raw(..) Static Function
repeat(..) Prototype Function
String Inspection Functions
7. Meta Programming
Function Names
Inferences
Meta Properties
Well Known Symbols
Symbol.iterator
Symbol.toStringTag and
Symbol.hasInstance
Symbol.species
Symbol.toPrimitive
Regular Expression Symbols Symbol.isConcatSpreadable
Symbol.unscopables
Proxies
Proxy Limitations
Revocable Proxies
Using Proxies
Reflect API
Property Ordering
Feature Testing
FeatureTests.io
Tail Call Optimization (TCO)
Tail Call Rewrite
Non-TCO Optimizations
Meta?
Review
8. Beyond ES6
`async function`s
Caveats
Object.observe(..)
Custom Change Events
Ending Observation
Exponentiation Operator
Objects Properties and ...
Array#includes(..)
SIMD
---------------------------------------------------------------------------
 |
You Don’t Know JS: ES6 & Beyond
|
by Kyle Simpson
Copyright © FILL IN YEAR Getify
Solutions, Inc.. All rights reserved.
Type of File :
PDF BOOK
Pages :
228
Size :
5.78 MB
Scope and Closures
 |
| Scope and Closures |
§
Learn about scope, a set of rules to help javascript engines locate variables in your code
§
Go deeper into nested scope, a series of containers for variables and functions
§
Explore function- and block-baesed scope , “ hosting,”
and the patterns and benefits of scope-based hiding.
§
Discover how to use closuers for synchronous and
asynchronous tasks including the creation of JavaScript libaries.
Table of Contents
1 ) What Is Scope?
Compiler Theory
Understanding Scope
Nested Scope
Errors
2) Lexical Scope
Lex-time
Cheating Lexical
3. Function Versus Block Scope
Scope From Functions
Hiding in Plain Scope
Functions as Scopes
Blocks as Scopes
4. Hoisting
Chicken or the Egg?
The Compiler Strikes Again
Functions First
5. Scope Closure
Enlightenment
Nitty Gritty
Now I Can See
Loops and Closure
Modules
A. Dynamic Scope
B. Polyfilling Block Scope
C. Lexical this
D. Acknowledgments
---------------------------------------------------------------------------
Scope and Closures
 |
| Scope and Closures |
by Kyle Simpson
Copyright © 2014 Getify Solutions, Inc. All
rights reserved.
Type of File :
PDF BOOK
Pages :
98
Size :
6.1 MB
---------------------------------------------------------------------------
This & Object Prototypes
 |
this & Object Prototypes |
Like other books in the
You Don’t Know JS series, this & Object Prototypes dives into trickier
parts of the language that many JavaScript programmers simply avoid. Armed with
this knowledge, you can become a true JavaScript master.
WITH THIS BOOK YOU WILL:
■ Explore how the this binding points to
objects based on how the function is called
■ Look into the
nature of JS objects and why you’d need to point to them
■ Learn how developers use the mixin pattern to
fake classes in JS
■ Examine how JS’s prototype mechanism forms links between objects
■ Learn how to move from class/inheritance
design to behavior delegation
■ Understand how the OLOO (objects-linked-to-other-objects)
coding style naturally
implements behavior delegation
KYLE SIMPSON, an open-web
evangelist, is passionate about JavaScript, HTML5, real-time/peer-
to-peer
communications, and web performance. He’s an author, workshop trainer, tech
speaker, and
avid open source community member.
Ø Table of Contents
1. this or That?
Why this?
Confusions
What’s this?
2. this All Makes Sense Now!
Call-Site
Nothing but Rules
Everything in Order
Binding Exceptions
Lexical this
Review
3. Object
Syntax
Type
Contents
Iteration
Review
4. Mixing (Up) “Class” Objects
Class Theory
Class Mechanics
Class Inheritance
Mixins
5.
Prototypes
- [[Prototype]]
- “Class”
- (Prototypal) Inheritance
- Object Links
6.
Behavior Delegation
- Toward Delegation-Oriented Design
- Classes Versus Objects
- Simpler Design
- Nicer Syntax
- Introspection
- Review
A.
ES6 Class.
B. Acknowledgments
---------------------------------------------------------------------------
 |
this & Object Prototypes
|
by Kyle Simpson
Copyright © 2014
Getify Solutions, Inc. All rights reserved.
Type of File :
PDF BOOK
Pages :
173
Size :
3 MB
---------------------------------------------------------------------------
Types & Grammar
 |
Types & Grammar
|
No matter how much experience you have with JavaScript, odds are you
don’t fully understand the
language. As part of the You Don’t Know JS series,
this compact guide explores JavaScript types in
greater depth than previous
treatments by looking at type coercion problems, demonstrating why
types work,
and showing you how to take advantage of these features.
Like other books in this series, You Don’t Know JS: Types & Grammar dives
into trickier parts of the
language that many JavaScript programmers simply
avoid or assume don’t exist (like types). Armed
with this knowledge, you can
achieve true JavaScript mastery.
WITH THIS BOOK YOU WILL:
■ Get
acquainted with JavaScript’s
seven types: null, undefined, Boolean, number, string, object, and symbol
■ Understand
why JavaScript’s unique array,
string, and number characteristics may delight or confound you
■ Learn how natives provide object wrappers
around primitive values
■ Dive into the coercion controversy—and learn
why this feature is useful in many cases
■ Explore
various nuances in JavaScript syntax, involving statements, expressions, and
other features
KYLE SIMPSON is an Open Web evangelist who’s passionate about all things
JavaScript. He’s an
author, workshop trainer, tech speaker, and OSS
contributor/leader.
Table of Contents
1.
Types
- A Type by Any Other Name…
- Built-in Types
- Values as Types
2.
Values
- Arrays
- Strings
- Numbers
- Special Values
- Value Versus Reference
3.
Natives
- Internal [[Class]]
- Boxing Wrappers
- Unboxing
- Natives as Constructors
4.
Coercion
- Converting Values
- Abstract Value Operations
- Explicit Coercion
- Implicit Coercion
- Loose Equals Versus Strict Equals
- Abstract Relational Comparison
5.
Grammar
- Statements & Expressions
- Operator Precedence
- Automatic Semicolons
- Errors
- Function Arguments
- try..finally
- switch
A. Mixed Environment JavaScript
B. Acknowledgments
---------------------------------------------------------------------------
You Don’t Know JS: Types &
Grammar
 |
| Types & Grammar |
by Kyle Simpson
Copyright © 2015 Getify Solutions,
Inc. All rights reserved.
Type of File :
PDF BOOK
Pages :
195
Size :
3.78 MB
---------------------------------------------------------------------------
Up & Going
 |
| UP AND GOING JS |
It’s easy to learn parts of JavaScript, but much harder to learn it
completely—or even sufficiently —
whether you’re new to the language or have
used it for years. With the “You Don’t Know JS” book
series, you’ll get a more
complete understanding of JavaScript, including trickier parts of the
language
that many experienced JavaScript programmers simply avoid. The series’ first
book, Up &
Going , provides the necessary background for those of you with
limited programming experience.
By learning the basic building blocks of
programming, as well as JavaScript’s core mechanisms,
you’ll be prepared to
dive into the other, more in-depth books in the series—and be well on your way
toward true JavaScript.
With this book you will:
■ Learn the
essential programming building blocks, including operators, types, variables,
conditionals, loops, and functions
■ Become
familiar with JavaScript’s
core mechanisms, such as values, function closures, this , and prototypes
■ Get an overview of other books in the series—and learn why it’s
important to understand all parts of JavaScript
Kyle Simpson is an Open Web Evangelist from Austin, TX, who’s passionate
about all things
JavaScript. He’s an author, workshop trainer, tech speaker,
and OSS contributor/leader.
Ø Table of Contents
1. Into Programming
- Code
- Expressions
- Try It Yourself
- Operators
- Values & Types
- Code Comments
- Variables
- Blocks
- Conditionals
- Loops
- Functions
- Practice
- Review
- 2. Into JavaScript
- Values & Types
- Variables
- Conditionals
- Strict Mode
- Functions as Values
- this Identifier
- Prototypes
- Old & New
- Non-JavaScript
3.
Into YDKJS
- Scope & Closures
- this & Object Prototypes
- Types & Grammar
- Async & Performance
- ES6 & Beyond
A. Acknowledgments
---------------------------------------------------------------------------
|
| UP AND GOING JS |
by Kyle Simpson
Copyright © 2015
Getify Solutions. All rights reserved.
Type of File :
PDF BOOK
Pages :
87
Size :
3.15 MB
---------------------------------------------------------------------------
More JavaScript PDF BOOK
JavaScript :The Definitive Guide [SIXTH EDITION]
JavaScript Bible [Seventh Edition]
JavaScript CookBook
Posted by Imran Hossain
){kind=link}
Posts
Comments
0 Comments