Learning Advanced JavaScript (2008)(ejohn.org) |
Learning Advanced JavaScript (2008)(ejohn.org) |
[1]https://www.youtube.com/watch?v=Bv_5Zv5c-Ts
[2]https://www.youtube.com/watch?v=ejBkOjEG6F0
[3]https://www.udemy.com/understand-nodejs/?couponCode=LEARNNOD....
Disclaimer: Because it may sound like it, I'd like to clarify I have absolutely no affiliation with Tony or his courses. I just really really liked them.
Alicea has React course called 'React and Flux for Angular Developers'in Pluralsight if anyone is looking more of his courses.
[0] http://dmitrysoshnikov.com/ecmascript/javascript-the-core/
If you can work your way through this tutorial you'll gain a decent grasp of ES5 prototypes and functions.
[1]: http://ejohn.org/blog/secrets-of-the-javascript-ninja-releas...
https://www.amazon.ca/Secrets-JavaScript-Ninja-John-Resig/dp...
"Nature, in Code: Biology in JavaScript" -- Learn JavaScript programming by implementing key biology concepts in code, including natural selection, genetics and epidemics.
Instead of just learning programming principles outside of
any context, you will learn JavaScript programming by
implementing key biological concepts in code so they can
run in your browser.
https://www.edx.org/course/nature-code-biology-javascript-ep... [nikki ~]$ node
> const bind = (fn, obj, ...args1) => (...args2) => fn.call(obj, ...args1, ...args2)
undefined
> bind(console.log, console, 'a', 'b')('c', 'd')
a b c d
undefined
> // calls `fn` with `obj` as `this` and the remaining arguments prepended with given ones
I believe all of the old-style argument stuff with `arguments` is possible with `...`, not sure though, maybe some edge cases.Things like new on functions, context, how prototypes work, etc...
Now with ES6/7/Typescript coming along, you're going to have a new generation of JS programmers that won't even realize you can "new up" a function.
A good programmer can pick up javascript quickly. Other than syntactic and semantic warts, it is not a difficult language to learn.
I do not want to understand this absurdness. I want a comment that tells me what it does so I can rewrite it in a sane way.
Is that function that insane? I can understand it at a glance, and performance is high (it matters here). AS a JS programmer, just knowing that it is an implementation of bind() should be enough of a hint that it uses its first argument as context, the rest as a curry and the arguments of the newly generated function as additional arguments.
But one wouldn't encounter this code in an application; this is library code. It's so useful and common that it's part of the ES5 standard (yes, ES5, not ES6). It might be the bind method from Prototype.js, but it's also the .bind method that all ES5 JS functions have.
Anyway, the question is not whether or not you should/coudl write this. The question is whether or not it's a good goal to be able to read this.
IMO, anyone who cannot read this function, albeit slowly and carefully, isn't an intermediate JS programmer, much less an advanced one.
Which of the concepts in this chunk of code is foreign to you? Prototypes? this? Using Array.p.s.c() to turn array-like args into an actual Array? shift? returning a function that, when called, invokes another function on the concatenation of one set of args with another set of args? This is all easy-mode stuff, unless you're brand new to JS, or you haven't bothered learning it.
Separate the declaration to 3 lines because the 2nd and the 3rd declarations depend on each other. Keeping them on the same line makes the reader think this is a simply declarative code but in fact it's the opposite.
Avoid using the slice shift combo but use slice with a start of 1 plus direct index access to the arguments[0] to get the first argument. this way i'm not mutating the args array and that makes the code easier to follow.
Rename the object variable to '_this'. Giving the reader a hint as to what it is used for.
And of course if this is actually to be used in production I assume it will be wrapped inside a check to see if the bind function is already defined.
// The .bind method from Prototype.js
Function.prototype.bind = function(){
var fn = this,
args = Array.prototype.slice.call(arguments),
object = args.shift();
return function(){
return fn.apply(
object,
args.concat(Array.prototype.slice.call(arguments))
);
};
}Then don't read the ejohn? =)
(Me neither, fwiw. Would rather write a combined com/transpiler from sane to asm.js/wasm bypassing JS entirely. Not that I do, just that I'd rather.)
Speaking from my own experience, I didn't know about all these prototypes and important concepts for a long time and and did fine. I built tons of web apps without knowing these "advanced" features. It was only when I decided to learn the language seriously that I got acquainted with a lot of these features like the prototype concept, object constructors, etc.
If you can build pretty advanced production websites without knowing these features I would say these features are advanced. That said, it's a different story now because javascript is an important language. But my point is in 2008 it wasn't.
Also this guy created jQuery, if he says it's advanced, it probably was.
Yeah, by pretentious people who thought…
> most web programmers who only used to use javascript for displaying alerts and cute dynamic features.
… that. I wouldn’t call someone who only knows how to display an alert a “JavaScript programmer” or base what are considered advanced concepts off of them.
> Also this guy created jQuery, if he says it's advanced, it probably was.
jQuery is a pretty normal library that gained a lot of popularity. It’s not particularly advanced.
Now with ES6 (ES2015), ES2016, ES2017, etc... It's beginning to add a not-insignificant amount of features to the core language which at least to me has completely changed how I write it (for the better)
I actually started with Python and moved on to JavaScript for my work involving web development. Currently, I use both.
I'm generally comfortable with making CRUD apps employing OOP, using both Python classes and prototypal inheritance in JS. My issue is that I still don't have the experience to understand WHY people often lament the 'chaotic disaster' that is JS. I haven't had any issues yet...
I also just want to keep the momentum up and never stop learning.
I don't mean that to be rude. It's just...the bar is very low here.
Now I write mostly JavaScript (<3 TypeScript) because it's so easy and fast, but having traditional OOP principals in my head is very helpful.
You'll also find many more, much better examples for data structures and algorithms in Java or C#.
Perhaps you might try Lisp or scheme:
I think this is a poor recommendation regardless, because programming in JS really is more similar to modern C# than it is to Lisp or Scheme.
Also, Douglas Crockford is an asshat. How did he wind up an authority on anything?
My thinking goes: understanding classic OOP is helpful in learning JavaScript because the high level concepts are the same but in my opinion more obvious and easier to implement in Java/C#.
By more obvious, a Java/C# (+ others) program starts with a class and to add functionality you either have to add more methods to that class or implement another class. So to a new programmer "duh, everything is an object and objects are instances of a class".
It's kind of hard to convey the same idea to someone in JavaScript when {} is called an object, "xxx" is an object, and to compose a new class, you compose a new function.
However, to someone who already understands classes and objects, it's just a new/different way to create classes and objects.
I spent years programming C# before switching to JS, and it took me a long time to stop thinking in a object-oriented way and embrace the functional style that works best with JavaScript.
If you want to learn JS and be a good JS programmer, you are best learning JS, not some other language. That's basic common sense. A great place to start is with the "You Don't Know JS" book series, which are all available online, for free: https://github.com/getify/You-Dont-Know-JS.
This is just wrong on so many levels. I wish "we" would get over this meme that by picking up language X that is a paradigm shift from language Y, that you're going to be a better programmer in language Y. That's just nonsense.
The comment about "chaotic disaster zone" is just bitterness for the typical reasons of hatred for JavaScript.
https://developer.mozilla.org/en/docs/Web/JavaScript/Referen...
meanwhile, everyone else uses one of the sixteen competing implementations of something that was built-in to any real language starting in the 70s. that's not a mess at all.
I've only worked on one application written without any OO patterns, completely procedural, and it was a complete mess.
Adding or extending features caused cascading bugs. Eventually we had to rewrite the backend (PHP) into MVC to be productive. I quit because I dreaded the work. I didn't want to write another line.
I have been pretty interested in functional programming lately, or the functional paradigm everyone in JS is following nowadays, but haven't gotten the chance to take a deep dive yet.