React Basics - Beau teaches JavaScript

Creating Components and Managing State with React

When it comes to building complex applications with React, managing state is crucial. In this example, we'll explore how to create components that interact with each other and manage state effectively.

Initially, React was created without JavaScript classes. This meant that developers had to use the arrow function syntax to define functions within components, which could lead to issues with the `this` keyword binding. For instance, if you defined a function using an arrow function, it would not bind correctly when used inside another function. To illustrate this point, let's consider an example.

Suppose we have a list of items that we want to display and interact with on our application. We'll create a constructor that initializes the list and then use a `push` method to add new items to the list. When an item is clicked, it will be removed from the list. This process creates a dynamic component-based system where each item in the list serves as its own mini-component.

Here's how we can achieve this:

```jsx

constructor(props) {

super(props);

var thisList = [];

for (var i = 0; i < props.items.length; i++) {

thisList.push({

value: props.items[i].item,

onclick: this.add_item.bind(this)

});

}

return thisList;

}

add_item(item) {

item.value = "";

}

```

In the above code, we create a list of items (`thisList`) in the constructor. Each item is an object with `value` and `onclick` properties. The `onclick` property points to the `add_item` function, which is bound to the component using `bind(this)`. This ensures that `this` refers to the correct component when the `onclick` event is triggered.

However, this approach has a limitation - every time we render the list, we're creating a new copy of the list. This can lead to performance issues and unnecessary computations. To overcome this issue, React uses a concept called "memoization," where components only re-render if their props or state change.

In our case, we want to avoid creating a new copy of the list on every render. We can achieve this by using a technique called "rendering an empty array." When we click on an item, we create a new copy of the list and assign it back to the `list` prop of the component.

Here's how we can modify our code to achieve this:

```jsx

constructor(props) {

super(props);

this.state = {

items: props.items,

newList: []

};

}

add_item(item) {

var new_list = [...this.state.newList, item];

this.setState({new_list});

}

render() {

return (

    {this.state.items.map((item, index) => (

  • this.add_item(item)}>

    {item.value}

    • ))}

    {this.state.newList.map((item, index) => (

  • {item.value}

    • ))}

);

}

```

In the modified code, we create a `newList` prop in our component's state. When an item is clicked, we push it onto the end of `newList` and then update the component's state with `this.setState({newList})`. We also render the new items added to `newList` as separate list items.

To make this work seamlessly, we need to add a way for users to interact with our application without having to restart it. This is where the "Add Item" feature comes in. When users click on the button and enter their item name, we create an input field that updates its `value` property based on what's entered.

To achieve this, we can use HTML elements like `` and bind the state update using JavaScript functions. Here's how we can implement it:

```jsx

class ShoppingList extends React.Component {

constructor(props) {

super(props);

this.state = {

items: props.items,

newList: []

};

this.add_item = this.add_item.bind(this);

this.update_input = this.update_input.bind(this);

}

add_item(item) {

var new_list = [...this.state.newList, item];

this.setState({newList});

}

update_input(event) {

let inputId = `list-item`;

document.getElementById(inputId).value = event.target.value;

this.add_item({

value: event.target.value

});

}

render() {

return (

{this.state.newList.map((item, index) => (

  • {item.value}

    • ))}

    );

    }

    }

    ```

    In the above code, we create an `input` field with a unique ID for each item. When users enter their item name and click on the "Add Item" button, the input field's value is updated based on what's entered.

    We also render the items added to our list as separate `

  • ` elements, complete with a "Remove" button next to each one. When these buttons are clicked, they call the `add_item` function again, passing in the item object.

    To take it to the next level, we can create a form-like interface using HTML forms instead of individual input fields for each item. Here's how we can modify our code:

    ```jsx

    class ShoppingList extends React.Component {

    constructor(props) {

    super(props);

    this.state = {

    items: props.items,

    newList: []

    };

    this.add_item = this.add_item.bind(this);

    this.update_input = this.update_input.bind(this);

    }

    add_item(item) {

    var new_list = [...this.state.newList, item];

    this.setState({newList});

    }

    update_input(event) {

    let inputId = `list-item`;

    document.getElementById(inputId).value = event.target.value;

    this.add_item({

    value: event.target.value

    });

    }

    render() {

    return (

    {this.state.newList.map((item, index) => (

  • {item.value}

    • ))}

    );

    }

    }

    ```

    In the modified code, we create a single form with an input field and a "Add Item" button. When users click on the submit button or enter their item name and press Enter, the input field's value is updated based on what's entered.

    We also render the items added to our list as separate `

  • ` elements, complete with a "Remove" button next to each one. When these buttons are clicked, they call the `add_item` function again, passing in the item object.

    This approach allows us to create an interactive and dynamic shopping list interface using React components, where each item is its own mini-component that interacts seamlessly with other items.