In React, you typically do not target elements directly, and

modify them like you would when working with JavaScript and the DOM.

For example, JavaScript provides selector methods like get element by ID,

that return an element in the DOM.

Which you can then manipulate, get and set it's text content, and more.

To modify what a React component or

element displays on the screen, you use state and props.

You trigger a state change and re-render the component with new props.

And if it's a component with local state or

a controlled component, you'll re-render it with each update in state.

There may be times when you need a target and

modifying element outside of that typical data flow.

So React provides an escape hatch with refs.

Refs let you access and interact with DOM nodes or

React elements created in the render method.

They make it possible to let you do the more traditional DOM manipulation, and

they're commonly used to access form elements and get their values.

Earlier, you learned how to update the value of an input field using state,

by creating a controlled component or

a component with internally controlled state.

We had to write quite a bit of code just to update an access the text fields value.

For example, we created a value's state and

wrote a function to update the value state.

Then we wired the input field to the function using an onChange event.

For only one input field, writing this code is not a big deal.

And this is still the recommended React way to control form elements.

Especially if you need to validate user input in real time, or

filter results with every keystroke for example.

However, if you're building a form that does not require internal state,

you can make use of the ref attribute instead of writing an event handler for

every state update.

So let's create a ref that will access the player text field.

You create a ref using the React.createRef method, and

then you attach the ref to a react element via the ref attribute.

In the AdPlayerForm class, I'll create a ref named

playerInput with playerInput = React.createRef.

Then attach this ref to the text input in the render method,

by giving the input a ref attribute and

passing it the playerInput ref with this.playerInput.

This puts a reference to the input on the AddPlayerForm class.

When the input is rendered onto the page,

it returns the reference which you can access with this.playerInput.

For example, if I console.log this.playerInput,

it returns an object with current pointing to the input element.

In fact, it even selects and highlights the input in the browser.

So great, the ref is now referencing the input element, and

we can access it using its current property.

So in the handle submit function, instead of passing the value state to

the addPlayer callback I'll pass it the ref with this.playerInput.

And if the ref is a form element, you get the value of the ref with .current.value.

So now we can delete the state object,

because we're no longer using the value state.

That means we can also delete the handleValueChange function,

as well as the setState method inside handleSubmit.

And the onChange and value attributes from the input element.

All right, let's test it's in the browser to make sure that our

ad player functionality still works.

Type a name into the text field, submit it, and it works.

Now, the form no longer resets the text field after submitting a name,

this is a quick fix.

One way we can reset the form is by writing

e.currentTarget.reset in the handleSubmit function.

I'll submit another player, and the input once again resets on submit, good.

So as you can see, refs can provide an easier and

quicker way to get the value of an input field.

Now, when building forms,

when should you use a controlled component instead of creating refs, and vice versa?

Well, controled components have internal state and

require functions to update state.

They make it easier to modify or

validate user input or filter results based on user input in real time.

Control components with state call render on every keystroke,

where as in refs, render is only called once.

So whenever you're building a form that requires field inputs and

you don't need to keep track of every keystroke, you have the option to create

an uncontrolled component, and use refs to get the form values from the DOM.

Finally, refs are not limited to class components.

You can create and use refs inside a functional component.

In functions, you need to assign React.createRef in the ref name to

a variable, then reference that variable in the ref attribute.

I've posted a code snippet that shows the add player form component as a function

with refs, in the teacher's notes.

So, it's up to you to convert it from a class to a function.