<p>When working with Javascript applications chances are you sometimes use console.log() when debugging your application. It is fast way to view data in the console and get an idea how your application is working. Most often the data is some kind of an object or array. When logging these to console you don't always see all the data and have to click the object open quite a bit and you end up something like this:</p>
<p><img src="./images/consolelog24.png" alt="Console log"></p>
<p>This is a bit nasty since you have to click open the object to see what's inside. A better way to log your objects and arrays is to use <strong>console.table()</strong>.</p>
<p>console.table() takes an object or array as parameter and prints a very nice table of the data. This is what the previous example looks like with console.table():</p>
<p><img src="./images/consoletable24.png" alt="Console table"></p>
<p>Hope this helps you at least a bit with your debugging efforts!</p>
<p>So whip out your dev tools and give it a try yourself or play with it in <a href="/blog/online-code-editor-every-web-developer-should-know-about/">codesandbox</a> by clicking below!</p>
<p><a href="https://codesandbox.io/s/mq88yrql98?expanddevtools=1&#x26;module=%2Fsrc%2Findex.js"><img src="https://codesandbox.io/static/img/play-codesandbox.svg" alt="Edit console.table() demo"></a></p>
<p>If you have questions or something to add, feel free leave a comment below!</p>



When working with Javascript applications chances are you sometimes use console.log() when debugging your application. It is fast way to view data in the console and get an idea how your application is working. Most often the data is some kind of an object or array. When logging these to console you don't always see all the data and have to click the object open quite a bit and you end up something like this:

![Console log](/blog-posts/introducing-console-table/images/consolelog24.png)

This is a bit nasty since you have to click open the object to see what's inside. A better way to log your objects and arrays is to use **console.table()**.

console.table() takes an object or array as parameter and prints a very nice table of the data. This is what the previous example looks like with console.table():

![Console table](/blog-posts/introducing-console-table/images/consoletable24.png)

Hope this helps you at least a bit with your debugging efforts!

So whip out your dev tools and give it a try yourself or play with it in [codesandbox](/blog/online-code-editor-every-web-developer-should-know-about/) by clicking below!

[![Edit console.table() demo](https://codesandbox.io/static/img/play-codesandbox.svg)](https://codesandbox.io/s/mq88yrql98?expanddevtools=1&module=%2Fsrc%2Findex.js)

If you have questions or something to add, feel free leave a comment below!


When debugging Javascript applications chances are you sometimes use console.log(). There is a better way tho...

Introducing console.table()

<p><img src="./images/open-office-headphones.jpg" alt="Noise cancelling headphones in use"></p>
<p>Most of the time coding requires undivided concentration on the task at hand. So do you know the feeling when you are working on something that requires your full attention. Then something happens around you, phone rings or people start a conversation, and this breaks your concentration.</p>
<p>That used to happen to me a lot. That is before I discovered noise cancelling headphones.</p>
<p>Before my discovery I had always used some normal headphones. Whenever I bought new pair, I would try to find one that cancels the outside noise by being tightly set around my ears. And of course the sound needed to be good too and they needed to fit my head well so that they could be worn several hours.</p>
<p>Then I learned that there is this thing called noise cancelling headphones. I know (now), they have been around quite some time but this was new to me.</p>
<p>I went to a store and tried out a pair of <a href="https://amzn.to/2OhFAjG">Bose's QuietComfort 35 (Series I)</a>. I was sold instantaneously. I was thinking "I need these!". Only thing slowing me from rushing to the cashiers with the headphones was the 400€ price tag. That was a lot more than I was used to pay for a pair of headphones. But because the sound was good, they fit well to my head and most importantly they literally canceled out every other noise from the store, I was convinced that they would be a good investment.</p>
<p>I am happy to say that they were!</p>
<h2>Life ANCH (After Noise Cancelling Headphones)</h2>
<p>I do most of my programming in an open office or places that are crowded and tend to have quite a bit background noise or people having conversations. With my old headphones I could always hear some of the background noise or a conversation that other people were having near me. With my Boses, once I place them on my ears and put on the music, every other sound disappears and I am able to concentrate on my coding without being disturbed by my surroundings.</p>
<p>I have used my noise cancelling headphones for two years soon. Has it been worth the money? Definitely.</p>
<p>I am able to concentrate on my work better and much easily and I have experienced improvements in productivity since I'm being distracted less by my surroundings. One thing is for sure, I won't be buying any other than noise cancelling headphones in the future either.</p>
<p><img src="./images/tume_coding-819x1024.jpg" alt="My headphones in action"></p>
<h2>Conclusion</h2>
<p>If you are working in open office or crowded place I strongly recommend getting a pair of noise cancelling headphones for yourself if you have a chance. At least go to a store and try them out so you see how well they can work.</p>
<p>I have only used the <a href="https://amzn.to/2OhFAjG">Bose QuietComfort 35 (Series I)</a> model but I'm sure there are many other good ones too. Just keep in mind that some very cheap models might not work as well as some more expensive ones. If you choose to go with Bose you might want to check out the <a href="https://amzn.to/2LVdxJW">Series II of the QuietComfort 35</a>. It is a newer version of the ones that I have.</p>
<p>That's it folks! If you have something to add, please be sure to leave a comment below! I would be happy to hear from you!</p>



![Noise cancelling headphones in use](/blog-posts/noise-cancelling-headphones-should-you-buy-them/images/open-office-headphones.jpg)

Most of the time coding requires undivided concentration on the task at hand. So do you know the feeling when you are working on something that requires your full attention. Then something happens around you, phone rings or people start a conversation, and this breaks your concentration.

That used to happen to me a lot. That is before I discovered noise cancelling headphones.

Before my discovery I had always used some normal headphones. Whenever I bought new pair, I would try to find one that cancels the outside noise by being tightly set around my ears. And of course the sound needed to be good too and they needed to fit my head well so that they could be worn several hours.

Then I learned that there is this thing called noise cancelling headphones. I know (now), they have been around quite some time but this was new to me.

I went to a store and tried out a pair of [Bose's QuietComfort 35 (Series I)](https://amzn.to/2OhFAjG). I was sold instantaneously. I was thinking "I need these!". Only thing slowing me from rushing to the cashiers with the headphones was the 400€ price tag. That was a lot more than I was used to pay for a pair of headphones. But because the sound was good, they fit well to my head and most importantly they literally canceled out every other noise from the store, I was convinced that they would be a good investment.

I am happy to say that they were!

## Life ANCH (After Noise Cancelling Headphones)

I do most of my programming in an open office or places that are crowded and tend to have quite a bit background noise or people having conversations. With my old headphones I could always hear some of the background noise or a conversation that other people were having near me. With my Boses, once I place them on my ears and put on the music, every other sound disappears and I am able to concentrate on my coding without being disturbed by my surroundings.

I have used my noise cancelling headphones for two years soon. Has it been worth the money? Definitely.

I am able to concentrate on my work better and much easily and I have experienced improvements in productivity since I'm being distracted less by my surroundings. One thing is for sure, I won't be buying any other than noise cancelling headphones in the future either.

![My headphones in action](/blog-posts/noise-cancelling-headphones-should-you-buy-them/images/tume_coding-819x1024.jpg)

## Conclusion

If you are working in open office or crowded place I strongly recommend getting a pair of noise cancelling headphones for yourself if you have a chance. At least go to a store and try them out so you see how well they can work.

I have only used the [Bose QuietComfort 35 (Series I)](https://amzn.to/2OhFAjG) model but I'm sure there are many other good ones too. Just keep in mind that some very cheap models might not work as well as some more expensive ones. If you choose to go with Bose you might want to check out the [Series II of the QuietComfort 35](https://amzn.to/2LVdxJW). It is a newer version of the ones that I have.

That's it folks! If you have something to add, please be sure to leave a comment below! I would be happy to hear from you!


Do you know the feeling when you are working on something that requires your full attention. Then something happens around you, phone ringing or people starting a conversation, and this breaks your concentration. That was common for me up until about 18 months ago. That's when I discovered noise cancelling headphones.

Noise cancelling headphones - Should you buy them?

<p><a href="https://draftjs.org/">Draft.js</a> is an open source library for handling rich text editing with React.</p>
<p>Draft.js handles the storing of the editor state (e.g. text, transformations and undo/redo stack) by storing everything into an EditorState object. It is a complete snapshot of the editor state.</p>
<p>EditorState object itself maintains the undo/redo stack of the editor. This stack is comprised of ContentState objects.</p>
<p>ContentState object represents the contents of the editor (e.g. text, entity ranges and inline styles) and selection states before and after rendering the contents.</p>
<p><em>Entity ranges is something we won't be touching on this post but if you wish you can read more about them from the <a href="https://draftjs.org/docs/advanced-topics-entities">documentation</a>.</em></p>
<p>I believe that best way to learn is just start doing so let's dive in and create a basic editor component.</p>
<p><em>I just published a class where I teach more about Draft.js. Best part is that you can get it for free! <a href="/blog/rich-text-editing-in-react-with-draft-js-course/">Read more</a>.</em></p>
<h3>Basic Draft.js editor usage</h3>
<p>We are going to make a React component with a Draft.js editor that has basic bold, underline and italic rich text editing functions. I am going to use <a href="/blog/online-code-editor-every-web-developer-should-know-about/">codesandbox.io</a> for this example. You can find the finished sandbox for this tutorial <a href="https://codesandbox.io/s/1z4vl0wz13?module=%2Fsrc%2FMyEditor.js">here</a>. Go ahead and fork it so you can make changes, follow along and play around with it.</p>
<p>First off we need to add Draft.js to our project. In codesandbox you can do this by opening the "File editor" tab from the left and under "Dependencies" click "Add dependency" and search for draft-js.</p>
<p><img src="./images/codesandbox-draft-js-dependency-1024x733.png" alt=""></p>
<p>Now let's add a new file <code>MyEditor.js</code> which will hold our editor component.</p>
<p>In the <code>MyEditor.js</code> file let's type in the following:</p>
<pre><code class="language-jsx">import React, { Component } from "react";
import { Editor, EditorState } from "draft-js";

const wrapperStyle = {
  border: "1px solid gray", // add some border
  width: "400px", // set fixed width
  margin: "auto", // aligns the component in the middle
  textAlign: "left", // start the text from left hand side
};

class MyEditor extends Component {
  constructor(props) {
    super(props);
    this.state = { editorState: EditorState.createEmpty() };
    this.onChange = (editorState) => this.setState({ editorState });
  }

  render() {
    return (
      &#x3C;div>
        &#x3C;div style={wrapperStyle}>
          &#x3C;Editor
            editorState={this.state.editorState}
            onChange={this.onChange}
          />
        &#x3C;/div>
      &#x3C;/div>
    );
  }
}

export default MyEditor;
</code></pre>
<p>This will render an instance of Draft.js editor and add some styling for the wrapping div. As you can see we are importing <code>Editor</code> and <code>EditorState</code> from the draft-js library. <code>Editor</code> is the actual component for the editor and <code>EditorState</code> is a top-level state object for the editor.</p>
<p>In the constructor we want to define a state for the component. We will store the state of the editor in an <code>editorState</code> variable. We initialize it with <code>EditorState.createEmpty()</code> because it must be a valid <code>EditorState</code> object and <code>EditorState.createEmpty()</code> returns a new <code>EditorState</code> object with an empty <code>ContentState</code> and default configuration.</p>
<p>Because the editor will be a controlled component, we need to define <code>onChange</code> function for it. We define it in the constructor and in it, we will update the component's state with new <code>editorState</code> object.</p>
<p>In the component's render method we render the <code>Editor</code> component with <code>editorState</code> and <code>onChange</code> props. The editor should now look like this.</p>
<p><img src="./images/editor1-hello-codepulse.jpg" alt="The editor"></p>
<p>We now have a working editor component but we don't yet have any rich text editing functionality in it. So let's add the <strong>bold</strong>, <em>italic</em> and underline commands to our editor.</p>
<p>Here is the updated code for the <code>MyEditor.js</code> component that includes the functionality for bold, italic and underline features. The changes are highlighted.</p>
<pre><code class="language-jsx">import React, { Component } from "react";
import { Editor, EditorState, RichUtils } from "draft-js";

const wrapperStyle = {
  border: "1px solid gray", // add some border
  width: "400px", // set fixed width
  margin: "auto", // aligns the component in the middle
  textAlign: "left", // start the text from left hand side
};

class MyEditor extends Component {
  constructor(props) {
    super(props);
    this.state = { editorState: EditorState.createEmpty() };
    this.onChange = (editorState) => this.setState({ editorState });
    this.handleKeyCommand = this.handleKeyCommand.bind(this);
  }

  handleKeyCommand(command) {
    const { editorState } = this.state;
    const newState = RichUtils.handleKeyCommand(editorState, command);
    if (newState) {
      this.onChange(newState);
      return true;
    }
    return false;
  }

  render() {
    return (
      &#x3C;div>
        &#x3C;button onClick={() => this.handleKeyCommand("bold")}>Bold&#x3C;/button>
        &#x3C;button onClick={() => this.handleKeyCommand("italic")}>Italic&#x3C;/button>
        &#x3C;button onClick={() => this.handleKeyCommand("underline")}>
          Underline
        &#x3C;/button>

        &#x3C;div style={wrapperStyle}>
          &#x3C;Editor
            editorState={this.state.editorState}
            onChange={this.onChange}
            handleKeyCommand={this.handleKeyCommand}
          />
        &#x3C;/div>
      &#x3C;/div>
    );
  }
}

export default MyEditor;
</code></pre>
<p>So first we import <code>RichUtils</code> module from the draft-js library. It contains a set of utility functions for rich text editing.</p>
<p>We pass <code>handleKeyCommand</code> prop for the <code>Editor</code>. This will allow us to handle the key commands.</p>
<p>In the <code>handleKeyCommand</code> method, we use <code>RichUtils.handleKeyCommand</code> function to apply the given command for the current <code>editorState</code>. The command is a string e.g. "bold", "italic" or "underline". The <code>RichUtils.handleKeyCommand</code> function will take care of applying the given style to the <code>editorState</code>. Note that in order for "<code>this</code>" to work inside <code>handleKeyCommand</code> method, we need to add the following line to the constructor:</p>
<p>this.handleKeyCommand = this.handleKeyCommand.bind(this);</p>
<p>We also need to return true / false from the <code>handleKeyCommand</code> method so that the editor knows if the command was handled or not.</p>
<p>Finally we add three buttons in the render method that when clicked, call the <code>handleKeyCommand</code> method with appropriate command. Note that the commands must be lowercase.</p>
<p><img src="./images/editor2-hello-codepulse.jpg" alt=""></p>
<p>That's it! Now we can highlight text and use either the buttons or the keyboard shortcuts (ctrl/cmd+B, ctrl/cmd+I, ctrl/cmd+U) to apply styles to the text in the editor.</p>
<h3>Conclusion</h3>
<p>We went over how to create a component that handles rich text editing using Draft.js. As we saw, adding rich text editing to React component is not that complicated. Hopefully this tutorial helped you in getting started with Draft.js. If you have any questions or comments be sure to drop them into the comment section! All comments are appreciated!</p>
<h3>Want to know more?</h3>
<p>I have also written about <a href="/blog/how-to-display-draft-js-content-as-html/">How to display Draft.js content as HTML</a> and <a href="/blog/how-to-store-draft-js-content/">How to store Draft.js content</a>. So be sure to check those out too!</p>



[Draft.js](https://draftjs.org/) is an open source library for handling rich text editing with React.

Draft.js handles the storing of the editor state (e.g. text, transformations and undo/redo stack) by storing everything into an EditorState object. It is a complete snapshot of the editor state.

EditorState object itself maintains the undo/redo stack of the editor. This stack is comprised of ContentState objects.

ContentState object represents the contents of the editor (e.g. text, entity ranges and inline styles) and selection states before and after rendering the contents.

_Entity ranges is something we won't be touching on this post but if you wish you can read more about them from the [documentation](https://draftjs.org/docs/advanced-topics-entities)._

I believe that best way to learn is just start doing so let's dive in and create a basic editor component.

_I just published a class where I teach more about Draft.js. Best part is that you can get it for free! [Read more](/blog/rich-text-editing-in-react-with-draft-js-course/)._

### Basic Draft.js editor usage

We are going to make a React component with a Draft.js editor that has basic bold, underline and italic rich text editing functions. I am going to use [codesandbox.io](/blog/online-code-editor-every-web-developer-should-know-about/) for this example. You can find the finished sandbox for this tutorial [here](https://codesandbox.io/s/1z4vl0wz13?module=%2Fsrc%2FMyEditor.js). Go ahead and fork it so you can make changes, follow along and play around with it.

First off we need to add Draft.js to our project. In codesandbox you can do this by opening the "File editor" tab from the left and under "Dependencies" click "Add dependency" and search for draft-js.

![](/blog-posts/getting-started-with-draft-js/images/codesandbox-draft-js-dependency-1024x733.png)

Now let's add a new file `MyEditor.js` which will hold our editor component.

In the `MyEditor.js` file let's type in the following:

```jsx
import React, { Component } from "react";
import { Editor, EditorState } from "draft-js";

const wrapperStyle = {
  border: "1px solid gray", // add some border
  width: "400px", // set fixed width
  margin: "auto", // aligns the component in the middle
  textAlign: "left", // start the text from left hand side
};

class MyEditor extends Component {
  constructor(props) {
    super(props);
    this.state = { editorState: EditorState.createEmpty() };
    this.onChange = (editorState) => this.setState({ editorState });
  }

  render() {
    return (
      <div>
        <div style={wrapperStyle}>
          <Editor
            editorState={this.state.editorState}
            onChange={this.onChange}
          />
        </div>
      </div>
    );
  }
}

export default MyEditor;
```

This will render an instance of Draft.js editor and add some styling for the wrapping div. As you can see we are importing `Editor` and `EditorState` from the draft-js library. `Editor` is the actual component for the editor and `EditorState` is a top-level state object for the editor.

In the constructor we want to define a state for the component. We will store the state of the editor in an `editorState` variable. We initialize it with `EditorState.createEmpty()` because it must be a valid `EditorState` object and `EditorState.createEmpty()` returns a new `EditorState` object with an empty `ContentState` and default configuration.

Because the editor will be a controlled component, we need to define `onChange` function for it. We define it in the constructor and in it, we will update the component's state with new `editorState` object.

In the component's render method we render the `Editor` component with `editorState` and `onChange` props. The editor should now look like this.

![The editor](/blog-posts/getting-started-with-draft-js/images/editor1-hello-codepulse.jpg)

We now have a working editor component but we don't yet have any rich text editing functionality in it. So let's add the **bold**, _italic_ and underline commands to our editor.

Here is the updated code for the `MyEditor.js` component that includes the functionality for bold, italic and underline features. The changes are highlighted.

```jsx
import React, { Component } from "react";
import { Editor, EditorState, RichUtils } from "draft-js";

const wrapperStyle = {
  border: "1px solid gray", // add some border
  width: "400px", // set fixed width
  margin: "auto", // aligns the component in the middle
  textAlign: "left", // start the text from left hand side
};

class MyEditor extends Component {
  constructor(props) {
    super(props);
    this.state = { editorState: EditorState.createEmpty() };
    this.onChange = (editorState) => this.setState({ editorState });
    this.handleKeyCommand = this.handleKeyCommand.bind(this);
  }

  handleKeyCommand(command) {
    const { editorState } = this.state;
    const newState = RichUtils.handleKeyCommand(editorState, command);
    if (newState) {
      this.onChange(newState);
      return true;
    }
    return false;
  }

  render() {
    return (
      <div>
        <button onClick={() => this.handleKeyCommand("bold")}>Bold</button>
        <button onClick={() => this.handleKeyCommand("italic")}>Italic</button>
        <button onClick={() => this.handleKeyCommand("underline")}>
          Underline
        </button>

        <div style={wrapperStyle}>
          <Editor
            editorState={this.state.editorState}
            onChange={this.onChange}
            handleKeyCommand={this.handleKeyCommand}
          />
        </div>
      </div>
    );
  }
}

export default MyEditor;
```

So first we import `RichUtils` module from the draft-js library. It contains a set of utility functions for rich text editing.

We pass `handleKeyCommand` prop for the `Editor`. This will allow us to handle the key commands.

In the `handleKeyCommand` method, we use `RichUtils.handleKeyCommand` function to apply the given command for the current `editorState`. The command is a string e.g. "bold", "italic" or "underline". The `RichUtils.handleKeyCommand` function will take care of applying the given style to the `editorState`. Note that in order for "`this`" to work inside `handleKeyCommand` method, we need to add the following line to the constructor:

this.handleKeyCommand = this.handleKeyCommand.bind(this);

We also need to return true / false from the `handleKeyCommand` method so that the editor knows if the command was handled or not.

Finally we add three buttons in the render method that when clicked, call the `handleKeyCommand` method with appropriate command. Note that the commands must be lowercase.

![](/blog-posts/getting-started-with-draft-js/images/editor2-hello-codepulse.jpg)

That's it! Now we can highlight text and use either the buttons or the keyboard shortcuts (ctrl/cmd+B, ctrl/cmd+I, ctrl/cmd+U) to apply styles to the text in the editor.

### Conclusion

We went over how to create a component that handles rich text editing using Draft.js. As we saw, adding rich text editing to React component is not that complicated. Hopefully this tutorial helped you in getting started with Draft.js. If you have any questions or comments be sure to drop them into the comment section! All comments are appreciated!

### Want to know more?

I have also written about [How to display Draft.js content as HTML](/blog/how-to-display-draft-js-content-as-html/) and [How to store Draft.js content](/blog/how-to-store-draft-js-content/). So be sure to check those out too!


Getting started with Draft.js can be a bit confusing. In this post we will cover how to get started by creating an Editor component capeable for RTE.