#setstate

[designcollection1208]

ReactJS State: SetState, Props and State

ReactJS is a popular JavaScript library used for building user interfaces. One of the most important aspects of ReactJS is the use of state and props to manage data and UI rendering.

ReactJS State: SetState, Props and State, ReactJS setState tutorial, Props vs State in ReactJS, ReactJS state management tutorial, Best practices for using setState in ReactJS, Understanding ReactJS component state, ReactJS setState example, ReactJS props tutorial, How to pass props in ReactJS, ReactJS state vs Redux state, setState not updating state in ReactJS

[winstonmhangoblog]

React state So far,we have learnt the basics of how to create a react project all the way to creating components.The main features and the very reason we opt for Javascript libraries and frameworks is to make sure our code is properly organised. React props and state are one way of organising data in a Javascript project using React js. In this slides set,we will look at what is state and how to use it. Enjoy the reading #react #javascriptlibrary #reactstate #setstate (at Lilongwe, Malawi) https://www.instagram.com/p/B-TlVYshpqz/?igshid=iyrxi2prhe3a

[tutorials-website]

Hooks in ReactJS | Tutorials Website

Hooks in Reactjs: Hooks are a new addition in React 16.8. They allow you to use React without classes. It means you can use state and other React features without writing a class.

[wheresmyesckey]

Dive into React codebase: Handling state changes

State. One of the most complicated concepts in React.js nomenclature. While some of us already got rid of it in our projects (Redux anyone?) by externalizing state, it is still widely used feature of React.js. While convenient, it can cause some issues. Robert Pankowecki, one of Rails meets React.js authors had the problem with validations when he started his journey with React. The story went like this: Validations seem to be quite easy to do, but there is a problem of vanilla form - first time user sees the input it should not get validated, even if it's invalid to have this input empty. This is definitely a stateful behaviour - so Robert concluded it'll be good to put his validation messages in state. So basically he just went and implemented the logic like this: ``` !javascript // ... changeTitle: function changeTitle (event) { this.setState({ title: event.target.value }); this.validateTitle(); }, validateTitle: function validateTitle () { if(this.title.length === 0) { this.setState({ titleError: "Title can't be blank" }); } }, // ... ``` Bam. This code doesn't work. Why is so? This is because setState works in an asynchronous way. That means after calling setState the this.state variable is not immediately changed. This is described in docs under "Notes" section: setState() does not immediately mutate this.state but creates a pending state transition. Accessing this.state after calling this method can potentially return the existing value. So it is rather a misunderstanding or lack of knowledge than something really weird. Robert could avoid his problem by reading the docs. But you can agree that it's a rather easy mistake to make for a beginner! This situation has triggered some interesting discussions internally in the team. What can you expect from setState? What guarantees you have? Why can you be sure that state will get updated correctly if you change the input and press "Submit" immediately? To understand what's going on and to make an interesting journey into React internals I've decided to trace what happens under the hood if you call setState. But first, let's solve the problem Robert had in an appropriate way.

The setState headache.

[wickedmuso]

I didn’t know...

I’ve been doing a lot of React in the past twelve months and have become reasonably comfortable with the component lifecycle and the async nature of thinking in React (especially when you combine it with the dynamic data from Meteor).

However (and I am not sure if this was how it was originally or not) I had been using setState with an object to update my state. I found the shallow copy mechanism also useful in other parts of my code (which is very easy to use with ES6 destructuring assignments instead of using Object.assign).

Now I discover that the RECOMMENDED way to use setState is with a function callback. This opens up a whole new world... [no - not the song from the Aladdin movie].

Given that setState is async (and can be batched) there didn’t appear to be a reliable way to sequence some other work (other than using componentDidUpdate/componentWillUpdate) that was based on changing the state. There are only certain places where you can update the state. But the callback approach solves that (especially when you want to get sequentially incrementing numbers or to do something else before the component updates). I am sure I even thought at one point: “The parameter to setState should be a function”.

On top of that, there is also a second callback that will called after your callback has been applied. While this is not recommended (over componentDidUpdate) it does provide another way to trigger other activity without directly polluting the component itself.

Both of these functions could be passed into the component as props - thereby completing isolating the state management from the component itself! [You’d really want to know what you were doing - but it is very powerful]

No practical examples in my own experience as yet but I’ll be keeping an eye open for where I might need to use it.  I know I have written code where I have delayed certain things that would depend on the state being updated (versus using componentDidUpdate).

Stay tuned.... if I find a good use-case, I’ll write it up.

[borislit]