Today I Learned

A Hashrocket project

113 posts about #javascript

Custom loaders for webpack

Perhaps there is a transformation you’d like to perform on your javascript files that is unique to your project. Perphaps replacing the word dumb with smart is a requirement but you don’t have control over the actual files and can’t make that change to the source files themseles.

In this situation, you can use a custom loader.

module.exports = {
  module: {
    rules: [
        test: /\.js$/,
        loader: './smart-loader',

The loader itself (smart-loader.js) would look something like this.

module.exports = function(source) {
  return source.replace('dumb', 'smart');

Exclude files from webpack transformation

Sometimes you want every file that has the .dumb extension to be transformed by the dumb-loader except for one particularly dumb file that should remain as is, as a lesson for to all the other dumb files. Just use the handy exclude configuration on modules.rules.loader to make sure that file doesn’t get transformed.

module.exports = {
  module: {
    rules: [
        test: /\.dumb$/,
        loader: 'dumb-loader',
        exclude: /really\.dumb/

Now that really dumb file won’t get transformed by the dumb loader.

Cascading function calls

Cascading function calls can be useful for building up properties on an object. We can simply return this at the end of each cascading function so that we always end up with the object when we’re done.

Example - building a flash message after an ajax request in rails:

        method: 'DELETE',
        url: url,
        contentType: 'application/json',
        error: function(status, data, jqxhr){
          var message = JSON.parse(status.responseText).error;
          var flash = new FlashBuilder('div');

            .append('.flash-messages', '#some_container');
function FlashBuilder(el){
  this.element = $('<' + el + '>');

  this.text = function(text){
    return this;

  this.addClass = function(klass){
    return this;

  this.append = function(target, container){
    } else {

    return this;
} vs this in delegated events

When attaching click handlers to elements, I used to think I could use interchangeably with this. That is not true when we use event delegation.

Given the following JS:

    $('body').on('click', "[id^=delete_thing]", function(e){
      // do stuff

And the following HTML:

<a href="javascript:void(0)" id="delete_thing_184">
      <img  src="/assets/ui/icon_delete.png">
      <strong> Delete Thing </strong>

When we click this link, we’re actually clicking either the <strong> or the <img>. When the event e is passed to the callback, is the element we actually clicked, and this is the element the click event bubbled up to, so use this instead of

Expand Emojis With The Spread Operator

There are a number of emojis that are not stand-alone unicode characters, but instead are a combination of two or more other emojis. The two main places this happens is with family emojis and emojis using non-simpsons skin tones.

You can use JavaScript’s spread operator to expand these emojis to see what their base components are. Here is a screenshot of a few that I expanded from Chrome’s dev tools.


Respect Do Not Track 👁‍🗨

Before I put google analytics, adwords, or other third party scripts on my sites I can respect the DNT headers a user has set. Here’s how I can do it with Google Analytics:

  if (window.navigator.doNotTrack !== '1') {
    (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),

    ga('create', 'UA-xxxxxxx-5', 'auto');
    ga('send', 'pageview');

In the above snippet I check if the user has enabled DNT. If they haven’t set the header or they have turned it off the script will run. Checking for window.navigator.doNotTrack !== '1' ensures that the user purposely set the header.

Name that anonymous function

I use anonymous functions in javascript a whole bunch but anonymous functions don’t get a name:

> a = function() {}

Its helpful to have a name for the function when you’re debugging and need to determine the caller of a function or if you want to determine which function has been passed in as an argument.

It’s easy to name anonymous functions:

> a = function myName() {}

But weirdly, javascript doesn’t know about a function named myName so you’re not polluting the namespace:

> myName()
ReferenceError: myName is not defined

Date javascript

Date javascript function on chrome is weird:

new Date('2016-10-3')
Mon Oct 03 2016 00:00:00 GMT-0400 (EDT)
new Date('2016-10-10')
Sun Oct 09 2016 20:00:00 GMT-0400 (EDT)

Why? Anyway, this is my “alternative” approach for that:

new Date('2016-10-10 0:0')
Mon Oct 10 2016 00:00:00 GMT-0400 (EDT)
new Date('2016-10-3 0:0')
Mon Oct 03 2016 00:00:00 GMT-0400 (EDT)

Print call stack on Javascript

If you want to print the javascript call stack you can use:

console.log(new Error().stack);

Here it is an example:

function firstFunction() {
function secondFunction() {
function thridFunction() {
    console.log(new Error().stack);

//=> Error
//    at thridFunction (<anonymous>:2:17)
//    at secondFunction (<anonymous>:5:5)
//    at firstFunction (<anonymous>:8:5)
//    at <anonymous>:10:1

h/t @rondale_sc

Does CoffeeScript has a ternary operator?

Javascript has a ternary operator condition ? expr1 : expr2 like:

var x = true;
x ? 'yes' : 'no'
//=> "yes"
x = false;
x ? 'yes' : 'no'
//=> "no"

What about CoffeeScript?
x ? 'yes' : 'no'

will be compiled to the following:

if (typeof x !== 'undefined' && x !== null) {
} else {
  ({ 'yes': 'no' });

Why? Because of The Existential Operator

So there is no ternary operator on CoffeeScript. The best you can do is to have an one-line if-else statement:

if x then 'yes' else 'no'

h/t @mwoods79

Timing Processes

If you want to time a process, you can use the console.time() and console.timeEnd() utilities specified by the console Web API. Invoking console.time() with a label starts a named timer. You can then run the process you want to time. Then invoke console.timeEnd() with the same label to terminate the timer and see how long the process took.

> sorting: 0.278ms

console.time('console logging');
console.log('logging to the console');
console.timeEnd('console logging');
> logging to the console
> console logging: 0.311ms

console.time('adding'); 1 + 1; console.timeEnd('adding');
> adding: 0.006ms

These functions are implemented in most modern browsers.

See the docs for more details.

Better Module Imports With Webpack Aliases

Depending on how your JavaScript project is structured, you can end up with import statements that look like this:

import SomeComponent from 'app/assets/javascripts/components/SomeComponent.jsx';

or this:

import SomeComponent from '../components/SomeComponent.jsx';

The first is simply too long and the second is both ugly and brittle to changes in file location. This can all be resolved with a Webpack alias.

// webpack.config.js
resolve: {
  alias: {
    components: "app/assets/javascripts/components",

Webpack will use this alias when resolving module imports like the following updated example:

import SomeComponent from 'components/SomeComponent.jsx';

See the resolve.alias section of the Webpack docs for more details.

h/t Vidal Ekechukwu

JavaScript Implied Global

Here is a common Ruby technique:

$ me = myself = 'rubyist'
$ me # => 'rubyist'
$ myself # => 'rubyist'

Let’s try something similar in JavaScript.

var func = function() {
  var me = myself = 'rubyist';

This declares two local variables, me and myself, set to 'rubyist', right? As I learned today, no.

Variables in JavaScript are implied to be global. We must declare them as local with the var keyword. Thus, this function assigns, from right to left, myself as a global variable (because it isn’t scoped on its own with var), then me as a local variable. Check it out:

$ func()
=> undefined
$ me
=> Uncaught ReferenceError: me is not defined
$ myself

Define each variable explicitly and keep your global scope clean.

Variable Hoisting in JavaScript

I while back I wrote about variable hoisting in Ruby. This is when the value of a variable is ‘hoisted’ to the top of its scope with value nil, rather than left undefined, even if that variable is protected from ever being declared by (for example) an always-false conditional.

Today I learned that JavaScript shares this behavior.

Here’s an example. Let’s declare two global variables:

$ validGlobal = 'we need this';
=> "we need this"
$ questionableGlobal = 'aggressively scoped';
=> "aggressively scoped"

Then, make a function that declares a local variable with the same name as one of our globals:

$ var example = function() {

  var questionableGlobal = 'uh oh';


=> "we need this"
=> undefined
=> "uh oh"

validGlobal logs its global value, as expected. But because questionableGlobal is also declared as a local variable in this scope, when we try to log it before that declaration occurs, it returns undefined, rather than the global value. This is to protect us from raising a ReferenceErrorquestionableGlobal has been ‘hoisted’ like a pirate flag.

This is a noteworthy feature of both Ruby and JavaScript.

Running ES6 Specs With Mocha

If your JavaScript specs contain ES6 syntax, Mocha, by default, will not be able to interpret and run them. In order to run them with Mocha, you will need to tell Mocha to use something like Babel to compile them. The --compile flag can be used to point Mocha to the babel-core/register package.

$ mocha --compilers js:babel-core/register path/to/specs/*.spec.js

If you already have a test command specified in your package.json file, you can update it with the --compile portion of the above command.

This all assumes you’ve already setup your project with Babel and Babel presets.


Numbers Are Empty

The lodash project comes with a ton of handy JavaScript utilities including the _.isEmpty() function. This is great for checking if Arrays, Objects, and Strings are empty. The following is how this function is defined in the docs:

Checks if value is an empty collection or object. A value is considered empty if it’s an arguments object, array, string, or jQuery-like collection with a length of 0 or has no own enumerable properties.

Having not examined this definition too closely and because I primarily write Rails code from day to day, I conflated _.isEmpty() with the #blank? method provided by Rails’ ActiveSupport. This holds true for the most part, but quickly defies expectations when it comes to numbers.

> _.isEmpty(1)
// true

Debugging With Full Source Maps From Webpack

After Webpack runs your JavaScript through various loaders, it no longer looks like the code you were writing in your editor. This can make debugging difficult when you inspect the source of an error in the browser’s devtools. Fortunately, Webpack makes it easy to enhance debugging with full source maps of your code. Just add the following option to your Webpack config:

  devtool: "source-map",

This will generate a full source map with a filename that is something like

Note: this will slow down the webpack build process a bit.

Read more about the devtool configuration and all the possible options in the Webpack docs.

Accessing Arguments To A Function

The arguments object is available within any JavaScript function. It is an array-like object with all of the arguments to the function. Even if not all of the arguments are referenced in the function signature, they can still be accessed via the arguments object.

function argTest(one) {

// 1
// [1]
// undefined

argTest(1, 'two', true);
// 1
// [1,'two',true]
// 'two'

See the Arguments object docs on MDN for more details.

h/t Dorian Karter

Initialize Objects With Shorthand Property Names

If I have some variables:

const one = 1,
  two = 2,
  three = 3;

and I’d like to initialize an object with them, I’ll generally do something like the following:

const obj1 = {
  one: one,
  two: two,
  three: three
// Object { one: 1, two: 2, three: 3 }

That seems pretty standard, but with ES6 comes a feature called shorthand property names which makes that look verbose and redundant. If you already have properly named variables, they can be used as a short hand for both the key name and variable value:

const obj2 = {
// Object { one: 1, two: 2, three: 3 }

See the MDN Docs for Object Initializer for more details.

Immutable Remove With The Spread Operator

ES6 introduces the spread operator which allows you to expand arrays in place for function calls, array composition, array destructuring, etc. One thing the spread operator allows you to concisely do with array composition is perform immutable operations on arrays. For instance, to remove an item from an array by index, you can throw together the following function.

const remove = (items,index) => {
  return [...items.slice(0,index),

const list = [1,2,3,4,5];
remove(list, 2);
// [1,2,3,4]
// [1,2,3,4,5]

It only took a couple lines of code and immutability is baked in.

There may be a couple edge cases that are not handled in this solution (e.g. remove(list, -1)), but you get the general idea.

Sample from an array in JavaScript

There’s no equivalent to Ruby’s array.sample, so here’s this:

Array.prototype.sample = function() {
  return this[Math.floor(Math.random() * this.length)];

I recently needed to pop a random item out of an array, changing the array in the process. That’s just the above plus a splice:

Array.prototype.randomSample = function() {
  return this.splice(Math.floor(Math.random() * this.length), 1);

(You don’t have to put them on the Array prototype, I’m just being cute here)

Enable ES7 Transforms With react-rails

The react-rails gem adds JSX and ES6 transforms to the asset pipeline. By using .js.jsx and .es6.jsx extensions with relevant files, the asset pipeline will know to make the appropriate transformation when compiling application assets. ES7 transforms are not enabled by default, but can be configured. Add the following to the config/application.js file to allow ES7’s class properties syntax:

config.react.jsx_transform_options = {
  optional: ["es7.classProperties"]

h/t Mike Chau

Transforming ES6 and JSX with Babel 6

With Babel 5, transforming ES6 and JSX into ES5 code was accomplished by including the babel-loader. This would be configured in webpack.config.js with something like the following:

module: {
  loaders: [
      test: /\.jsx?$/,
      exclude: /node_modules/,
      loader: 'babel-loader',

Now, with Babel 6, the different parts of the loader have been broken out into separate plugins. These plugins need to be installed

$ npm install babel-preset-es2015 babel-preset-react --save-dev

and then included as presets

module: {
  loaders: [
      test: /\.jsx?$/,
      exclude: /node_modules/,
      loader: 'babel-loader',
      query: {
        presets: ['es2015', 'react']

Alternatively, the presets can be specified in the project’s .babelrc file.


Splat Arguments To A Function

Often times you have a function that takes a certain set of arguments. Like the following adder function:

var adder = function(a,b,c) {
  return a + b + c;

But you are left trying to pass in arguments as an array (e.g. [1,2,3]). You want to be able to splat the array of arguments so that it matches the function declaration. This can be done by using apply.

> adder.apply(undefined, [1,2,3])

Chrome DevTools navigation and editing tools

If you ever worked with editors such as Atom/Sublime Text you will appreciate the following: Chrome DevTools now sports fuzzy finders for your script/stylesheet files and for methods within them.

To get started open dev tools and hit Cmd+p start typing a filename or part of a filename: cmd-p

Then to jump to a specific method hit Cmd+Shift+P and start typing a method name: cmd-shift-p

If you are a big fan of multiple cursors, you’ll be happy to learn that those are now available within chrome developer tools:

cmd-d [while the cursor is on a word hit Cmd+d to duplicate the cursor to the next match]

holding alt [holding alt and dragging down will allow you to edit a vertical line]

To search all files (scripts/html markup) hit Cmd+Option+f: cmd-alt-f

Change the source in dev tools and hit Cmd+s the updated code will be run the next time it is called. DevTools will indicate it has a modified version by changing the background color to bright orange: change in memory

Avoid mutating array when sorting

I just ran into a hard to track down bug with code that amounted to this.

> a = [6,5,4,3,2,1]
[ 6, 5, 4, 3, 2, 1 ]
> { console.log(x); a.sort()})

Why is the second number 2 and not 5? Oh, because I was sorting the array. In my program I needed to gather some information about the collection as a whole and the sort statement was buried 2 function calls down, and didn’t realize the collection was being mutated while it was being iterated.

To avoid this, a best practice might be to copy the array before sorting it, two examples of that would be:




Same number of characters; choose your favorite.

Examine all jQuery events for namespace

In a big system you can lose track of all the events that might be registered with jQuery. An easy way to see them all is:

$._data(window, 'events')

jQuery allows namespacing events as well. This can look like:

$(myElement).on('click.nsMyElement', function() { console.log('click'})

And check it out you can see that through data

$._data(myElement, 'events')['click'][0]['namespace']
> nsMyElement

Best practice for event binding in JavaScript

When binding an event to a DOM element you often need a way to update your event in runtime. This presents a challenge because setting the new event will not override the existing one but instead create an additional event. In that case you need to namespace (jQuery terminology) your event which will allow you to replace it.


$(window).on('scroll', function () { console.log('A') });

// Scroll output: 
// => A
// => A

$(window).on('scroll', function () { console.log('B') });

// Scroll output: 
// => A
// => B
// => A
// => B


$(window).off('scroll.myPlugin').on('scroll.myPlugin', function () { console.log('A') });
$(window).off('scroll.myPlugin').on('scroll.myPlugin', function () { console.log('B') });

// Scroll output: 
// => B
// => B

Vanilla JS - when using the addEventListener use named functions (instead of anonymous..). It may be a good idea to keep an array of your event handlers in your object tree.


var scrollHandler = function() { console.log('A') };
var scrollHandler2 = function() { console.log('B') };
window.addEventListener('scroll', scrollHandler);
window.removeEventListener('scroll', scrollHandler);
window.addEventListener('scroll', scrollHandler2);

// Scroll output: 
// => B
// => B

This is especially important when writing your own libraries to avoid collisions with user events.

Synchronous XHR is deprecated

Sometimes before I’ve figured out the right pattern for my app I use the synchronous xhr to get some naive green for my tests.

  var isAsync = false
  var xhr = new XMLHttpRequest()'post', '/things.json', isAsync)
  xhr.send(JSON.stringify({things: things}))

But this time I got a nice deprecation notice at the console.

Synchronous XMLHttpRequest on the main thread is deprecated because of its detrimental effects to the end user's experience. For more help, check

And low and behold has a deprecation notice

An ES6 javascript array of numbers

If you want an array of numbers in ruby, you might do something like (0..127).to_a. Concise! I don’t really know how to do this in javascript but es6 has a couple of methods to help with a clever solution.

Array(100) gives you an array with 100 elements, all undefined.

array.keys() gives you an es6 iterator that will iterate through all the keys of the array, which happen to be 0 - 99.

Array.from() will turn an iterator into an Array!

So in just 3 weird steps you can get an array full of numbers.


Hopefully someone knows an easier way :).

Build URLs with Window Location

Want to build URLs with JavaScript? Try thewindow.location object.

This came from a React.js project we’re working on. It uses ES6 template string interpolation, which isn’t necessary but definitely is nice:


Which becomes:


Render 64-bit integers as strings in JSON

When rendering a server-side object containing 64-bit integers, precision can be lost if it is rendered as a number. For example, if a JSON document contains the number 9219976635399687875, JavaScript will parse it as 9219976635399688000. This is caused by JavaScript only having floating point numbers. To ensure very large numbers are not rounded, render the value out as a string, e.g. “9219976635399687875”.

V8 Optimizations

V8 will not define variables that would normally be within JS function scope until they’re actually called.

test('visiting /foo/bar', function(assert){
  var foo = server.create('foo');
  var bar = server.create('bar');

      var someProp = foo.callProperty;

When the console opens, foo will be in scope, while bar will be undefined

Get first value from javascript Map

Map is a new key/value data structure in es6 (and its available in your chrome browser RIGHT NOW). But getting values out of a Map without using a key is complicated a little by having to go through a javascript iterator.

> m = new Map([[1,"a"],[2,"b"]])
Map {1 => "a", 2 => "b"}
> m.values()[0]
> m.values()
MapIterator {"a", "b"}

Its all good though, the next() function of a fresh iterator will always return the first value. Well, not really the first value but a value wrapped in an object with two values, the value you are looking for represented by “value” and “done” which tells you whether the iterator has run out of elements or not.

> m = new Map([[1,"a"],[2,"b"]])
Map {1 => "a", 2 => "b"}
> m.values().next().value

Javascript closures bind to the variable

If you’re a clever kind of javascript dev you create functions with variables from outside the function definition.

var i = 5;
function printSomething() {console.log(i);}
> 5

But you should watch yourself when using a closure within a loop.

> fns = []
> for(var i = 0; i < 3; i++) {fns.push(function () {console.log(i); })};
> fns[0]();
> fns[1]();
> fns[2]();

Yikes! The closure references the variable as it is now, not the variable as it was. You should only reference the variable if you don’t expect it to change (or if you want it to change).

> fns = []
> function createFn(i) { return function() { console.log(i); };}
> for (var i = 0; i < 3; i++) {fns.push(createFn(i))};
> fns[0]();
> fns[1]();
> fns[2]();

Pause Ember acceptance tests

While your acceptance tests are running you can use pauseTest() to pause the test suite and interact with your app. NOTE: this does not halt execution like debugger, it only pauses the test suite.

test("my acceptance test", function(assert) {
  pauseTest();  // returns a promise that will never resolve
    // make assertions

Javascript keys are only strings!

You can use squares to access or set a value in an object, but that key is just getting converted to a string. And you can’t loop through the keys and expect the keys to be objects… they’re strings!

> a = {1: "x"}
{ '1': 'x' }
> a[/x/] = "y"
> a[1]
> a[/x/]
> a['1']
> a['/x/']
> for (var i in a) { console.log(i === 1); console.log(i === /x/) }