Oh My Js The Best Javascript Articles Azat Mardan download
Oh My Js The Best Javascript Articles Azat Mardan download
Mardan download
https://ebookbell.com/product/oh-my-js-the-best-javascript-
articles-azat-mardan-4739586
Oh My God What Happened And What Should I Do English Version This Book
Is For Everyone Who Wants To Move Into The Digital Era Of Awesomeness
Abraham
https://ebookbell.com/product/oh-my-god-what-happened-and-what-should-
i-do-english-version-this-book-is-for-everyone-who-wants-to-move-into-
the-digital-era-of-awesomeness-abraham-22104574
https://ebookbell.com/product/oh-my-gouache-zoe-ingram-27935768
https://ebookbell.com/product/oh-my-cookbook-best-chicken-
recipes-50-delicious-and-easy-poultry-dishes-b-robinson-43143188
https://ebookbell.com/product/oh-my-goth-gena-showalter-43185010
Oh My Stars Lorna Landvik
https://ebookbell.com/product/oh-my-stars-lorna-landvik-46326402
https://ebookbell.com/product/oh-my-mother-a-memoir-in-nine-
adventures-connie-wang-50091400
https://ebookbell.com/product/oh-my-god-what-a-complete-aisling-emer-
mclysaght-sarah-breen-51876428
https://ebookbell.com/product/oh-my-gosh-i-love-your-shoes-a-decade-
of-headturning-heels-sophia-webster-52791706
https://ebookbell.com/product/oh-my-gods-alexandra-sheppard-34135900
Oh My JS
The Best JavaScript Articles
Azat Mardan
This book is for sale at http://leanpub.com/ohmyjs
This is a Leanpub book. Leanpub empowers authors and publishers with the Lean Publishing
process. Lean Publishing is the act of publishing an in-progress ebook using lightweight tools and
many iterations to get reader feedback, pivot until you have the right book and build traction once
you do.
JavaScript Fundamentals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
The World’s Most Misunderstood Programming Language . . . . . . . . . . . . . . . . . . 1
Understanding JavaScript Function Invocation and “this” . . . . . . . . . . . . . . . . . . 4
Code Conventions for the JavaScript Programming Language . . . . . . . . . . . . . . . . 9
Semicolons in JavaScript are optional . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
Tools . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
10 Must Have JavaScript Tools For Developers . . . . . . . . . . . . . . . . . . . . . . . . 66
Useful Node.js Tools, Tutorials And Resources . . . . . . . . . . . . . . . . . . . . . . . . 76
Control the Complexity of Your JavaScript Functions with JSHint . . . . . . . . . . . . . . 83
Testing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
Leaner, Meaner, Faster Animations with requestAnimationFrame . . . . . . . . . . . . . . 87
Node.js . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
Understanding event loops and writing great code for Node.js . . . . . . . . . . . . . . . . 98
Callback Hell . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
Understanding Express.js . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
Original Article
http://javascript.crockford.com/javascript.html
Douglas Crockford, crockford.com
http://crockford.com
JavaScript¹, aka Mocha, aka LiveScript, aka JScript, aka ECMAScript, is one of the world’s most
popular programming languages. Virtually every personal computer in the world has at least one
JavaScript interpreter installed on it and in active use. JavaScript’s popularity is due entirely to its
role as the scripting language of the WWW.
Despite its popularity, few know that JavaScript is a very nice dynamic object-oriented general-
purpose programming language. How can this be a secret? Why is this language so misunderstood?
The Name
The Java- prefix suggests that JavaScript is somehow related to Java, that it is a subset or less
capable version of Java. It seems that the name was intentionally selected to create confusion, and
from confusion comes misunderstanding. JavaScript is not interpreted Java. Java is interpreted Java.
JavaScript is a different language.
JavaScript has a syntactic similarity to Java, much as Java has to C. But it is no more a subset of Java
than Java is a subset of C. It is better than Java in the applications that Java (fka Oak) was originally
intended for.
JavaScript was not developed at Sun Microsystems, the home of Java. JavaScript was developed at
Netscape. It was originally called LiveScript, but that name wasn’t confusing enough.
The -Script suffix suggests that it is not a real programming language, that a scripting language
is less than a programming language. But it is really a matter of specialization. Compared to C,
JavaScript trades performance for expressive power and dynamism.
¹http://javascript.crockford.com/
JavaScript Fundamentals 2
Typecasting
JavaScript was designed to run in Netscape Navigator. Its success there led to it becoming standard
equipment in virtually all web browsers. This has resulted in typecasting. JavaScript is the George
Reeves³ of programming languages. JavaScript is well suited to a large class of non-Web-related
applications
Moving Target
The first versions of JavaScript were quite weak. They lacked exception handling, inner functions,
and inheritance. In its present form, it is now a complete object-oriented programming language.
But many opinions of the language are based on its immature forms.
The ECMA committee that has stewardship over the language is developing extensions which, while
well intentioned, will aggravate one of the language’s biggest problems: There are already too many
versions. This creates confusion.
Design Errors
No programming language is perfect. JavaScript has its share of design errors, such as the
overloading of + to mean both addition and concatenation with type coercion, and the error-
prone with statement should be avoided. The reserved word policies are much too strict. Semicolon
insertion was a huge mistake, as was the notation for literal regular expressions. These mistakes
have led to programming errors, and called the design of the language as a whole into question.
Fortunately, many of these problems can be mitigated with a good lint⁴ program.
The design of the language on the whole is quite sound. Surprisingly, the ECMAScript committee
does not appear to be interested in correcting these problems. Perhaps they are more interested in
making new ones.
²http://javascript.crockford.com/little.html
³http://www.amazon.com/exec/obidos/ASIN/B000KWZ7JC/wrrrldwideweb
⁴http://www.jslint.com/
JavaScript Fundamentals 3
Lousy Implementations
Some of the earlier implementations of JavaScript were quite buggy. This reflected badly on
the language. Compounding that, those implementations were embedded in horribly buggy web
browsers.
Bad Books
Nearly all of the books about JavaScript are quite awful. They contain errors, poor examples, and
promote bad practices. Important features of the language are often explained poorly, or left out
entirely. I have reviewed dozens of JavaScript books, andI can only recommend one: JavaScript:
The Definitive Guide (5th Edition)⁵ by David Flanagan. (Attention authors: If you have written a
good one, please send me a review copy.)
Substandard Standard
The official specification for the language⁶ is published by ECMA⁷. The specification is of extremely
poor quality. It is difficult to read and very difficult to understand. This has been a contributor to the
Bad Book problem because authors have been unable to use the standard document to improve their
own understanding of the language. ECMA and the TC39 committee should be deeply embarrassed.
Amateurs
Most of the people writing in JavaScript are not programmers. They lack the training and discipline
to write good programs. JavaScript has so much expressive power that they are able to do useful
things in it, anyway. This has given JavaScript a reputation of being strictly for the amateurs, that
it is not suitable for professional programming. This is simply not the case.
Object-Oriented
Is JavaScript object-oriented? It has objects which can contain data and methods that act upon that
data. Objects can contain other objects. It does not have classes, but it does have constructors which
do what classes do, including acting as containers for class variables and methods. It does not have
class-oriented inheritance, but it does have prototype-oriented inheritance.
The two main ways of building up object systems are by inheritance (is-a) and by aggregation (has-
a). JavaScript does both, but its dynamic nature allows it to excel at aggregation.
Some argue that JavaScript is not truly object oriented because it does not provide information
hiding. That is, objects cannot have private variables and private methods: All members are public.
⁵http://www.amazon.com/exec/obidos/ASIN/0596101996/wrrrldwideweb
⁶http://www.ecma-international.org/publications/standards/Ecma-262.htm
⁷http://www.ecma-international.org/
JavaScript Fundamentals 4
But it turns out that JavaScript objects can have private variables and private methods. (Click
here now to find out how.)⁸ Of course, few understand this because JavaScript is the world’s most
misunderstood programming language.
Some argue that JavaScript is not truly object oriented because it does not provide inheritance. But
it turns out that JavaScript supports not only classical inheritance, but other code reuse patterns as
well.⁹
Copyright 2001 Douglas Crockford.¹⁰ All Rights Reserved Wrrrldwide.¹¹
Original Article
http://yehudakatz.com/2011/08/11/understanding-javascript-function-invocation-and-this
Yehuda Katz, yehudakatz.com
.
Over the years, I’ve seen a lot of confusion about JavaScript function invocation. In particular, a lot
of people have complained that the semantics of this in function invocations is confusing.
In my opinion, a lot of this confusion is cleared up by understanding the core function invocation
primitive, and then looking at all other ways of invoking a function as sugar on top of that primitive.
In fact, this is exactly how the ECMAScript spec thinks about it. In some areas, this post is a
simplification of the spec, but the basic idea is the same.
For example:
⁸http://www.crockford.com/javascript/private.html
⁹http://javascript.crockford.com/inheritance.html
¹⁰mailto:douglas@crockford.com
¹¹http://www.crockford.com/
JavaScript Fundamentals 5
1 function hello(thing) {
2 console.log(this + " says hello " + thing);
3 }
4
5 hello.call("Yehuda", "world") //=> Yehuda says hello world
As you can see, we invoked the hello method with this set to "Yehuda" and a single argument
"world". This is the core primitive of JavaScript function invocation. You can think of all other
function calls as desugaring to this primitive. (to “desugar” is to take a convenient syntax and
describe it in terms of a more basic core primitive).
[1] In the ES5 spec¹², the call method is described in terms of another, more low level primitive, but
it’s a very thin wrapper on top of that primitive, so I’m simplifying a bit here. See the end of this post
for more information.
1 function hello(thing) {
2 console.log("Hello " + thing);
3 }
4
5 // this:
6 hello("world")
7
8 // desugars to:
9 hello.call(window, "world");
This behavior has changed in ECMAScript 5 only when using strict mode[2]:
1 // this:
2 hello("world")
3
4 // desugars to:
5 hello.call(undefined, "world");
¹²http://es5.github.com/#x15.3.4.4
JavaScript Fundamentals 6
The short version is: a function invocation like fn(...args) is the same as fn.call(window
[ES5-strict: undefined], ...args).
Note that this is also true about functions declared inline: (function() {})() is the same as
(function() {}).call(window [ES5-strict: undefined).
[2] Actually, I lied a bit. The ECMAScript 5 spec says that undefined is (almost) always passed, but
that the function being called should change its thisValue to the global object when not in strict
mode. This allows strict mode callers to avoid breaking existing non-strict-mode libraries.
Member Functions
The next very common way to invoke a method is as a member of an object (person.hello()). In
this case, the invocation desugars:
1 var person = {
2 name: "Brendan Eich",
3 hello: function(thing) {
4 console.log(this + " says hello " + thing);
5 }
6 }
7
8 // this:
9 person.hello("world")
10
11 // desugars to this:
12 person.hello.call(person, "world");
Note that it doesn’t matter how the hello method becomes attached to the object in this form.
Remember that we previously defined hello as a standalone function. Let’s see what happens if we
attach is to the object dynamically:
1 function hello(thing) {
2 console.log(this + " says hello " + thing);
3 }
4
5 person = { name: "Brendan Eich" }
6 person.hello = hello;
7
8 person.hello("world") // still desugars to person.hello.call(person, "world")
9
10 hello("world") // "[object DOMWindow]world"
Notice that the function doesn’t have a persistent notion of its ‘this’. It is always set at call time
based upon the way it was invoked by its caller.
JavaScript Fundamentals 7
Using Function.prototype.bind
Because it can sometimes be convenient to have a reference to a function with a persistent this
value, people have historically used a simple closure trick to convert a function into one with an
unchanging this:
1 var person = {
2 name: "Brendan Eich",
3 hello: function(thing) {
4 console.log(this.name + " says hello " + thing);
5 }
6 }
7
8 var boundHello = function(thing) { return person.hello.call(person, thing); }
9
10 boundHello("world");
Even though our boundHello call still desugars to boundHello.call(window, "world"), we turn
right around and use our primitive call method to change the this value back to what we want it
to be.
We can make this trick general-purpose with a few tweaks:
In order to understand this, you just need two more pieces of information. First, arguments is an
Array-like object that represents all of the arguments passed into a function. Second, the apply
method works exactly like the call primitive, except that it takes an Array-like object instead of
listing the arguments out one at a time.
Our bind method simply returns a new function. When it is invoked, our new function simply
invokes the original function that was passed in, setting the original value as this. It also passes
through the arguments.
Because this was a somewhat common idiom, ES5 introduced a new method bind on all Function
objects that implements this behavior:
Another Random Document on
Scribd Without Any Related Topics
The Project Gutenberg eBook of The Other
World; or, Glimpses of the Supernatural (Vol. 1
of 2)
This ebook is for the use of anyone anywhere in the United States
and most other parts of the world at no cost and with almost no
restrictions whatsoever. You may copy it, give it away or re-use it
under the terms of the Project Gutenberg License included with this
ebook or online at www.gutenberg.org. If you are not located in the
United States, you will have to check the laws of the country where
you are located before using this eBook.
Language: English
EDITED BY
THE REV. FREDERICK GEORGE LEE, D.C.L.
Vicar of All Saints’, Lambeth.
Chapter I.
Chapter II.
The Miraculous in Church History 21
Chapter III.
Spiritual Powers and Properties of the Church.—Sacraments.—
Sacramentals.—Exorcism 51
Chapter IV.
Witchcraft and Necromancy 149
Chapter V.
Dreams, Omens, Warnings, Presentiments, and Second Sight 207
MATERIALISM OF THE PRESENT
AGE.
Chapter I.
INTRODUCTORY.—MATERIALISM OF THE PRESENT AGE.
ebookbell.com