Version 18 (modified by BJ Burg, 9 years ago) (diff)

update arrow function guidance

These are JavaScript coding styles used in the Source/WebInspectorUI/UserInterface folder.

(Note: Few if any of these guidelines are checked by check-webkit-style. There's a tracking bug for that:

Tokens, spacing, indentation, syntax

  • No trailing whitespace
  • Indent with 4 spaces
  • The opening bracket '{' after a named, non-inlined function goes on the next line. Anywhere else, the opening bracket '{' stays on the same line.
  • Style for object literals is: {key1: value1, key2: value2}. When key and variable names coincide, use the syntax {expression} rather than {expression: expression}.
  • Add new lines before and after different tasks performed in the same function.
  • Else-blocks should share a line with leading } or }).
  • Long promise chains should place .then() blocks on a new line.
  • Calling a constructor with no arguments should have no parenthesis '()'. eg. var map = new Map;
  • Put anonymous functions inline if they are not used as a subroutine.
  • Use arrow functions when possible, unless it makes code less readable. See below for examples.

Naming things

  • Avoid using the "on" prefix where possible. The _onFoo methods can just be _foo or _handleFoo.
  • New class names should use the name of the base class as a suffix. (ex: TimelinesContentView < ContentView). Exceptions: classes extending WebInspector.Object (unless they are a represented object), and deep hierarchies such as DebuggerSidebarPanel < NavigationSidebarPanel < SidebarPanel < Object.
  • Spell out identifier instead of id if not doing so would result in a name ending with capitalized Id. For example, just is fine, but this.breakpointId should be this.breakpointIdentifier.
  • An object's events live on the Event property of the constructor. Event names are properties on the Event object, and property values duplicate the event name, but are lowercased, hyphenated, and prefixed with the constructor name. See the skeleton example below.

API preferences

  • Use `Map` and `Set` collections instead of plain objects if the key values are unknown or not monotonic (i.e., frequently added then removed).
  • Use `hsla()' over hex or RGB colors in CSS.
  • Use for..of syntax when performing actions on each element. Use forEach when chaining methods in a functional style. Use a classical for loop when doing index math.
  • When using forEach or map, supply the this-object as the optional second parameter rather than binding it.
  • In promise chains, use arrow functions for lexical this, rather than assigning const instance = this;' or .binding every function's this`-argument.
  • Use destructuring assignment when digging values out of a JSON object or "args" object.
  • Use default parameters when it makes sense.
  • Use super to make calls to base class (possibly overridden) methods.

Layering and abstractions

  • Firewall the protocol inside the Manager classes. JSON objects received from the protocol are called "payload" in the code. The payload is usually deconstructed at the Managers level and passes down as smart objects inheriting from WebInspector.Object.
  • Avoid accessing *View classes from *Manager or *Object classes. This is a layering violation that prevents writing tests for models.
  • Avoid storing DOM elements in *Manager or *Object classes. (see above.)
  • In the backend, avoid using Inspector TypeBuilders outside of InspectorAgent classes. We want to isolate protocol considerations from other functionality in JavaScriptCore and WebCore.

Understanding and Using Promises

What's so great about Promises? The point of promises is to give us back functional composition and error bubbling in the async world. They do this by saying that your functions should return a promise, which can do one of two things:

  1. Become fulfilled by a value
  2. Become rejected with an Error instance or by throwing an exception

A promise that is eiher fulfilled or rejected is said to be settled. A promise that has not settled is said to be pending.

And, if you have a correctly implemented then() function, then fulfillment and rejection will compose just like their synchronous counterparts, with fulfillments flowing up a compositional chain, but being interrupted at any time by a rejection that is only handled by someone who declares they are ready to handle it.

Promise Gotchas

(Summarized from Blog and The Art of Code Blog)

  • Don't nest promises to perform multiple async operations; instead, chain them or use Promise.all().
  • Beware of storing or returning promise values that are not from the end of a chain. Each .then() returns a new promise value, so return the last promise.
  • Use Promise.all() with map() to process an array of asynchronous work in parallel. Use Promise.all() with reduce() to sequence an array asynchronous work.
  • If a result may be a promise or an actual value, wrap the value in a promise, e.g., Promise.resolve(val)
  • Use .catch() at the end of a chain to perform error handling. Most promise chains should have a catch block to avoid dropping errors.
  • To reject a promise, throw an Error instance or call the reject callback with an Error instance.
  • A .catch() block is considered resolved if it does not re-throw an Error instance. Re-throw if you want to log an error message and allow other parts of a chain (i.e, an API client) to handle an error condition.
  • Don't directly pass a promise's resolve function to Object.addEventListener, as it will leak the promise if the event never fires. Instead, use a single-fire WebInspector.EventListener object defined outside of the promise chain and connect it inside a .then() body. Inside the .catch block, disconnect the EventListener if necessary.
  • For APIs that return promises, document what the fulfilled value will be, if any. Example: createSession() // --> (sessionId)

Arrow Functions

Arrow functions simplify a common use of anonymous functions by providing a shorter syntax, lexical binding of this and arguments, and implicit return. While this new syntax enables new levels of terse code, we must take care to keep our code readable.

Implicit return

Arrow functions with one expression have an implicit return. All of these are equivalent (modulo this binding, arguments, constructor usage, etc.):

1   let foo = val => val;
2   let foo = (val) => val
3   let foo = (val) => val;
4   let foo = (val) => { return value++; }
5   let foo = function doStuff(val) { return value++; }

Never use option (1), because it is a special case that only applies when the function has one argument, reducing predictability.

In cases where the return value is used and the expression is a constant ("foo"), a variable (foo), or a member (, use option (2). Never use braces though, because implicit return only works if there are no braces around the single expression.

In cases where the expression computes a value (a + 42) or performs a side effect (++a), prefer option (4). In some sense, curly braces are a signpost to the effect of "careful, we do actual work here".


setTimeout(() => { testRunner.notifyDone(); }, 0)


setTimeout(() => { testRunner.notifyDone() }, 0); // return value not implicitly returned
setTimeout(() => testRunner.notifyDone(), 0); // implicit return value not used

When not to arrow

When assigning a function to a subclass prototype (in the old way of setting up classes), always use the normal function syntax, to avoid breaking subclasses who use a different 'this' binding. Note that arrow functions are NOT acceptable for assigning functions to singleton objects like WebInspector, since the captured lexical this is typically the global object.


Base.prototype.compute = function(a, b, c) { ... }
Foo.prototype.compute = function(a, b, c) {, a, b, c); }

WebInspector.UIString = function(format, args) { ... }


Base.prototype.compute = (a, b, c) => { ... }
Foo.prototype.compute = (a, b, c) => {, a, b, c); }

WebInspector.UIString = (format, args) => { ... } // this will be window.

Also use the normal function syntax when naming an anonymous function improves readability of the code. In this case, use Function.prototype.bind or assign the arrow function into a local variable first.


    .then(function resolved(value) { ... },
        function rejected(value) { ... });


    .then((value) => { ... },
        (value) => { ... })

Bugs and Gotchas

  • <> Currently, arrow functions will always capture lexical this, even if the arrow function does not actually use this. The behavior causes TDZ error if such an arrow function is used in a constructor before calling super().
  • Only basic functionality is implemented. Lexical binding of arguments, super,, and toString are unimplemented.

The feature tracking bug tree is here: <>

New class skeleton

New Inspector object classes use ES6 class syntax and should have the following format:

WebInspector.NewObjectType = class NewObjectType extends WebInspector.Object
       console.assert(param instanceof WebInspector.ExpectedType);
       this._propertyName = param;

    // Static

    static computeBestWidth(things)
        return 3.14159;

    // Public

    get propertyName()
        return this._propertyName;

    set propertyName(value)
        this._propertyName = value;

    publicMethod: function()
        /* public methods called outside the class */

    // Protected

    handleEvent: function(event)
        /* delegate methods, event handlers, and overrides. */

    // Private

    _privateMethod: function()
        /* private methods are underscore prefixed */

WebInspector.NewObjectType.Event = {
    PropertyWasChanged: "new-object-type-property-was-changed"