It’s official! We’re getting a new function syntax! The TC39 group (the panel charged with delivering ES 6) has reached consensus on an abbreviated syntax for JavaScript function expressions. Its popularly known as thefat arrow syntax, and is based on a similar construct found in CoffeeScript.

Make no mistake, I’m delighted that we will finally have an alternative to the unnecessary clunkiness and verbosity of the present grammar, but I can’t shake a nagging feeling that this proposal (in its current form) is flawed to the extent that it might actually make new developers more confused than they already were. I’ll run through the key features of this new construct, then explain my concerns and how they might be mitigated.

Continue reading“JavaScript Fat City”→

Most built-in JavaScript types are constructors whose prototypes contain the methods and other properties that define their default behavior:

//(results will vary by browser)Object.getOwnPropertyNames(Function.prototype)//["bind", "arguments", "toString", "length", "call", "name", "apply", "caller", "constructor"]

You can’t delete or replace a native prototype, but you can edit the values of its properties, or create new ones:

//create a new array method that removes a memberArray.prototype.remove = function(member) {  var index = this.indexOf(member);  if (index > -1) {    this.splice(index, 1);  }  return this;}['poppy', 'sesame', 'plain'].remove('poppy'); //["sesame", "plain"]['ant', 'bee', 'fly'].remove('spider'); //["ant", "bee", "fly"]

Et voila! Our code gets a useful array extension for free. However if you brag about doing this in production code, expect to get pummeled by a wave of fierce disapproval. Some of it carries weight. Let’s sift the danger from the dogma and try to reach an honest conclusion:

Continue reading“Extending JavaScript Natives”→

Working with JavaScript’stypeof operator is a bit like operating a clapped-out old car (or an early model Dell Inspiron). It gets the job done (mostly) and you learn to work around the quirks – but you probably aspire to something better.

In this article I’ll give a brief overview oftypeof before introducing a tiny new function which is a fully-loaded, more reliable alternative that works directly with the language internals.
Continue reading“Fixing the JavaScript typeof operator”→

Here’s a tiny util that you can save as a bookmarklet and use to crawl the JavaScript object model of any web site. Waldo (thanks to@shinypb for the name!) lets you find and inspect instances by name, type or value, and it can be easily customized to add additional tests. It runs in the console on Chrome, Firefox, Safari and IE>8. It's sourced ongithub. Feel free to fork it if you want to add more search methods or a spiffy UI.

(Update: Check outthis alternate version by@jdalton)

Continue reading“Waldo: Search the JavaScript Object Model in under 1 KB”→

(Russian,Japanese)

In this article I’ll explore JavaScript mixins in detail, and introduce a less conventional, but to my mind more natural mixin strategy that I hope you’ll find useful. I’ll finish up with aprofiler matrix summarizing the performance impact of each technique. [A big Thank You to the brilliant@kitcambridge for reviewing and improving the code on which this blog is based!]
Continue reading“A fresh look at JavaScript Mixins”→

The fifth edition of the ECMAScript specification introduced Strict Mode. Strict Mode imposes a layer of constraint on JavaScript – intended to protect you from the more perilous aspects of the language.

While researching this article I wrote 38 tests covering all the Strict Mode rules as defined in theES5 specification. You can see how your favorite browser shapes up byclicking here.

The code for each test is reproduced at the end of the article as an aid to understanding the specification. You can also run the tests manually by copying and pasting the source into the console. The full source code is onmy github repo.

Firefox 4 and IE10 (preview 1) already fully support Strict Mode, and Chrome 12 is nearly there. Strict Mode is here to stay – let’s dive in…
Continue reading“JavaScript Strict Mode”→

(на русском,日本)
 
Let’s begin with a funny tweet:

The ‘c’ at the end is for the lowly comma operator. Last in the line of operator precedence and rarely documented, the comma operator hides its light under a bushel. It may not be a JavaScript heavy-hitter but I like it anyway. Its simple, elegant and you should make it your friend. So, here we go – more than you’ll ever need to know about JavaScript’s bashful hero:
Continue reading“The JavaScript Comma Operator”→

In JavaScript, enumeration across regular (non-Array) Objects is often more painful than it should be. Arrays are merrily dispatched throughfor andwhile loops using all manner ofcrazy, fun techniques; Objects are forever at the mercy of the pedestrian, one directionalfor-in loop, without which we can’t even learn the names and length of its own property set. Arrays have access to a plethora of elegant higher order functions (forEach,map,filter etc.); Objects don’t. Until now, that is.
Continue reading“Rethinking JavaScript Object Enumeration”→