Name	Name	Last commit message	Last commit date
parent directory ..
README.md	README.md

EarthOne React/JSX Style Guide

EarthOne's version of a mostly reasonable approach to React and JSX

Basic Rules
Class vs React.createClass
Naming
Declaration
Component Organization
Alignment
Quotes
Spacing
Props
Parentheses
Tags
Methods
Ordering
isMounted
Use CSS Modules

Basic Rules

Only include one React component per file.
Always use JSX syntax.
Do not use React.createElement unless you're initializing the app from a file that is not JSX.

Class vs `React.createClass`

Use class extends React.Component unless you have a very good reason to use mixins.

eslint rules: react/prefer-es6-class.

```javascript
// bad
const Listing = React.createClass({
  render() {
    return <div />;
  }
});

// good
class Listing extends React.Component {
  render() {
    return <div />;
  }
}
```

Naming

Extensions: Use .jsx extension for React components.
Filename: Use PascalCase for filenames. E.g., ReservationCard.jsx.
Reference Naming: Use PascalCase for React components and camelCase for their instances.

eslint rules: react/jsx-pascal-case.

```javascript
// bad
import reservationCard from './ReservationCard';

// good
import ReservationCard from './ReservationCard';

// bad
const ReservationItem = <ReservationCard />;

// good
const reservationItem = <ReservationCard />;
```

Component Naming: Use the filename as the component name. For example, ReservationCard.jsx should have a reference name of ReservationCard. However, for root components of a directory, use index.jsx as the filename and use the directory name as the component name:
```
// bad
import Footer from './Footer/Footer';

// bad
import Footer from './Footer/index';

// good
import Footer from './Footer';
```

Declaration

Do not use displayName for naming components. Instead, name the component by reference.

// bad
export default React.createClass({
  displayName: 'ReservationCard',
  // stuff goes here
});

// good
export default class ReservationCard extends React.Component {
}

Component Organization

class definition
constructor
- event handlers
'component' lifecycle events
getters
render
defaultProps
proptypes

class Person extends React.Component {
  constructor (props) {
    super(props);

    this.state = { smiling: false };

    this.handleClick = () => {
      this.setState({smiling: !this.state.smiling});
    };
  }

  componentWillMount () {
    // add event listeners (Flux Store, WebSocket, document, etc.)
  },

  componentDidMount () {
    // React.getDOMNode()
  },

  componentWillUnmount () {
    // remove event listeners (Flux Store, WebSocket, document, etc.)
  },

  get smilingMessage () {
    return (this.state.smiling) ? "is smiling" : "";
  }

  render () {
    return (
      <div onClick={this.handleClick}>
        {this.props.name} {this.smilingMessage}
      </div>
    );
  },
}

Person.defaultProps = {
  name: 'Guest'
};

Person.propTypes = {
  name: React.PropTypes.string
};

Alignment

Follow these alignment styles for JSX syntax

eslint rules: react/jsx-closing-bracket-location.

```javascript
// bad
<Foo superLongParam="bar"
     anotherSuperLongParam="baz" />

// good
<Foo
  superLongParam="bar"
  anotherSuperLongParam="baz"
/>

// if props fit in one line then keep it on the same line
<Foo bar="bar" />

// children get indented normally
<Foo
  superLongParam="bar"
  anotherSuperLongParam="baz"
>
  <Spazz />
</Foo>
```

Quotes

Always use double quotes (") for JSX attributes, but single quotes for all other JS.

Why? JSX attributes can't contain escaped quotes, so double quotes make conjunctions like "don't" easier to type. Regular HTML attributes also typically use double quotes instead of single, so JSX attributes mirror this convention.

eslint rules: jsx-quotes.

```javascript
// bad
<Foo bar='bar' />

// good
<Foo bar="bar" />

// bad
<Foo style={{ left: "20px" }} />

// good
<Foo style={{ left: '20px' }} />
```

Spacing

Always include a single space in your self-closing tag.

// bad
<Foo/>

// very bad
<Foo                 />

// bad
<Foo
 />

// good
<Foo />

Props

Always use camelCase for prop names.

// bad
<Foo
  UserName="hello"
  phone_number={12345678}
/>

// good
<Foo
  userName="hello"
  phoneNumber={12345678}
/>

Wrap props on newlines for 2 or more.

// bad
<Person
 firstName="Michael" />

// good
<Person firstName="Michael" />

// bad
<Person firstName="Michael" lastName="Chan" occupation="Designer" favoriteFood="Drunken Noodles" />

// good
<Person
 firstName="Michael"
 lastName="Chan"
 occupation="Designer"
 favoriteFood="Drunken Noodles" />

Omit the value of the prop when it is explicitly true.

eslint rules: react/jsx-boolean-value.

// bad
<Foo
  hidden={true}
/>

// good
<Foo
  hidden
/>

Parentheses

Wrap JSX tags in parentheses when they span more than one line.

eslint rules: react/wrap-multilines.

```javascript
// bad
render() {
  return <MyComponent className="long body" foo="bar">
           <MyChild />
         </MyComponent>;
}

// good
render() {
  return (
    <MyComponent className="long body" foo="bar">
      <MyChild />
    </MyComponent>
  );
}

// good, when single line
render() {
  const body = <div>hello</div>;
  return <MyComponent>{body}</MyComponent>;
}
```

Methods

Bind event handlers for the render method in the constructor.

Why? A bind call in a the render path creates a brand new function on every single render.

eslint rules: react/jsx-no-bind.

```javascript
// bad
class extends React.Component {
  onClickDiv() {
    // do stuff
  }

  render() {
    return <div onClick={this.onClickDiv.bind(this)} />
  }
}

// good
class extends React.Component {
  constructor(props) {
    super(props);

    this.onClickDiv = this.onClickDiv.bind(this);
  }

  onClickDiv() {
    // do stuff
  }

  render() {
    return <div onClick={this.onClickDiv} />
  }
}
```

Do not use underscore prefix for internal methods of a React component.

// bad
React.createClass({
  _onClickSubmit() {
    // do stuff
  },

  // other stuff
});

// good
class extends React.Component {
  onClickSubmit() {
    // do stuff
  }

  // other stuff
}

Ordering

Ordering for class extends React.Component:

constructor
optional static methods
getChildContext
componentWillMount
componentDidMount
componentWillReceiveProps
shouldComponentUpdate
componentWillUpdate
componentDidUpdate
componentWillUnmount
clickHandlers or eventHandlers like onClickSubmit() or onChangeDescription()
getter methods for render like getSelectReason() or getFooterContent()
Optional render methods like renderNavigation() or renderProfilePicture()
render

How to define propTypes, defaultProps, contextTypes, etc...

import React, { PropTypes } from 'react';

const propTypes = {
  id: PropTypes.number.isRequired,
  url: PropTypes.string.isRequired,
  text: PropTypes.string,
};

const defaultProps = {
  text: 'Hello World',
};

class Link extends React.Component {
  static methodsAreOk() {
    return true;
  }

  render() {
    return <a href={this.props.url} data-id={this.props.id}>{this.props.text}</a>
  }
}

Link.propTypes = propTypes;
Link.defaultProps = defaultProps;

export default Link;

Ordering for React.createClass:

displayName
propTypes
contextTypes
childContextTypes
mixins
statics
defaultProps
getDefaultProps
getInitialState
getChildContext
componentWillMount
componentDidMount
componentWillReceiveProps
shouldComponentUpdate
componentWillUpdate
componentDidUpdate
componentWillUnmount
clickHandlers or eventHandlers like onClickSubmit() or onChangeDescription()
getter methods for render like getSelectReason() or getFooterContent()
Optional render methods like renderNavigation() or renderProfilePicture()
render

eslint rules: react/sort-comp.

`isMounted`

Do not use isMounted.

Why? isMounted is an anti-pattern, is not available when using ES6 classes, and is on its way to being officially deprecated.

eslint rules: react/no-is-mounted.

Use CSS Modules

Use CSS Modules
This will allow using short CSS class names and at the same time avoid conflicts.
Keep CSS simple and declarative. Avoid loops, mixins etc.
Feel free to use variables in CSS via precss plugin for PostCSS
Prefer CSS class selectors instead of element and id selectors (see BEM)
Avoid nested CSS selectors (see BEM)
When in doubt, use .root { } class name for the root elements of your components

// Navigation.scss
@import '../variables.scss';

.root {
  width: 300px;
}

.items {
  margin: 0;
  padding: 0;
  list-style-type: none;
  text-align: center;
}

.item {
  display: inline-block;
  vertical-align: top;
}

.link {
  display: block;
  padding: 0 25px;
  outline: 0;
  border: 0;
  color: $default-color;
  text-decoration: none;
  line-height: 25px;
  transition: background-color .3s ease;

  &,
  .items:hover & {
    background: $default-bg-color;
  }

  .selected,
  .items:hover &:hover {
    background: $active-bg-color;
  }
}

⬆ back to top

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

react

react

README.md

EarthOne React/JSX Style Guide

Table of Contents

Basic Rules

Class vs `React.createClass`

Naming

Declaration

Component Organization

Alignment

Quotes

Spacing

Props

Parentheses

Tags

Methods

Ordering

`isMounted`

Use CSS Modules

Files

react

Directory actions

More options

Directory actions

More options

Latest commit

History

react

Folders and files

parent directory

README.md

EarthOne React/JSX Style Guide

Table of Contents

Basic Rules

Class vs React.createClass

Naming

Declaration

Component Organization

Alignment

Quotes

Spacing

Props

Parentheses

Tags

Methods

Ordering

isMounted

Use CSS Modules

Class vs `React.createClass`

`isMounted`