I'm already develop a timer on which we can enter a name and time in seconds to start the timer.
I want now to create a button and if I click, it display another timer with name, and time in seconds.
I don't know how I can do this...
Here is the timer with the inputs... https://jsfiddle.net/q806zeps/37/
I think if I can duplicate this ReactDOM.render(<App/>, document.getElementById('timer')); but I thonk it's not possible ?
Thanks
Please have a look at this code, hope it solves your problem.
class App extends React.Component {
constructor(props){
super(props)
this.state = {
counter : 1
}
}
//add timer code by oneshubh
addTimer(){
this.setState({counter: this.state.counter+1})
}
render(){
var timerDom = [];
for(var i = 0;i<this.state.counter;i++){
timerDom.push(<Wrapper />)
}
return (
<div>
{timerDom}
<button onClick={()=>this.addTimer()} >add timer</button>
</div>);
}
}
You can use an array on the state of Wrapper to track the individual timers within your application.
state: {
timers: []
}
Clicking the button, adds an object into your state with your current keys.
{
libelle: 'Input name',
seconds: 10
}
Iterate over this array to render you Minuteur components by passing the correct index.
Here is an updated fork of your fiddle. Creating timers using an array
Related
The story is this: just learning react, doing a to-do-list app, have the following structure of my app:
function Task
class Tasks
class ToDoList
Function Task:
function Task(props){
const [close, setClose] = useState(false);
const [task, setTask] = useState(props.toDo);
let animation = "task";
console.log("[TASK] ", task)
if (close){
setTimeout(() => {props.onRemoveClick()}, 500);
}
close ? animation += " remove_task" : animation += " add_task";
return(
<div className={animation} key={props.id}>
<input
className="task_text"
value={task}
/>
<div className="delete_task" onClick={() => {setClose(true);}}></div>
</div>
)
}
Class Tasks:
class Tasks extends React.Component{
renderTask(task, id){
return <Task
task = {task}
id = {id}
onRemoveClick = {() => this.props.onRemoveClick(id)}
/>
}
render(){
const tasks = this.props.tasks.map((step, move) => {
console.log("[TASKS] ", step)
return(
this.renderTask(step, move)
)
})
return (
<div className="tasks">{tasks}</div>
)
}
}
Class ToDoLlist:
class ToDoList extends React.Component{
constructor(props){
super(props);
this.state = {
tasks : []
}
}
removeTask(id){
const tasks = this.state.tasks;
tasks.splice(id, 1)
this.setState({tasks : tasks})
}
render(){
return(
<div className="ToDoList_box">
<Tasks
tasks = {this.state.tasks}
onRemoveClick = {(id) => this.removeTask(id)}
/>
</div>
)
}
}
the application is a rectangle, one large rectangle, in which other rectangles with tasks are added (at the same time they are added by slide animation, for this I use the .add_task css class)
to delete tasks, I placed a corresponding button next to each task, and in order for the tasks to disappear animatedly, similarly to the appearance, I came up with such logic, the user clicks on the delete button, the setClose hook is called (which is false by default) and updated to true, at the beginning the class contains a check, the close values, in accordance with which, the onRemoveClick prop is called, and the removal animation is assigned...
as a result of all this long history, I get absolutely not the result that I would like, the Tasks class passes the correct values, but the Task function displays completely different from what is passed to it (I think this is due to the fact that I prematurely update one of tasks, changing its state, maybe it somehow affects, but I don’t know there)...
I hope someone has the strength to read all this, and perhaps understand me ..
I also attached two screenshots from the browser above, where the first after adding 5 tasks, and the second after deleting the 3rd task:
adding 5 tasks
deleting the 3rd task,
I am working on a React application where I am trying to render text on the screen when a button is clicked. I have defined a function onButtonClick which gets triggered whenever the button is clicked. However, the HTML that I am returning from the function is not rendered on the screen. I am in the learning stages of React so please excuse me if the question seems silly.
class App extends Component {
constructor() {
super();
this.state = {
blockno:0
}
}
OnButtonClick = () => {
this.setState({blockno: this.state.blockno + 1})
return(
<div>
<h3>Some text</h3>
</div>
);
}
render() {
return(
<div>
<Button onButtonClick={this.OnButtonClick}/>
</div>
);
}
}
The value is being returned, but the framework/browser/etc. has no reason to do anything with that value.
Try thinking about this a different way, a "more React way". You don't want to return the value to be rendered, you want to update state. Something like this:
constructor() {
super();
this.state = {
blockno:0,
showDiv: false // <-- note the new property in state
}
}
OnButtonClick = () => {
this.setState({blockno: this.state.blockno + 1, showDiv: true})
}
Now you're not returning anything, but rather updating the state of the component. Then in your render method you conditionally render the UI based on the current state:
render() {
return(
<div>
<Button onButtonClick={this.OnButtonClick}/>
{
this.state.showDiv
?
<div>
<h3>Some text</h3>
</div>
: ''
}
</div>
);
}
The click handler doesn't modify the page, it just modifies the state of the component you're writing. The render method is responsible for rendering the UI based on that state. Any time state changes, render will be called again to re-render the output.
(Note: It's not 100% clear if this is exactly the functionality you're looking for in the UI, since it's not really clear what you're trying to build. But the point here is to illustrate how to update state and render output in React. Your logic can be tweaked as needed from there.)
You have to make a render based on your state. Please check the tutorial at the react docs to learn more about how React works. It's really good
Here is a version of your code that works. Hope it helps
class App extends Component {
constructor() {
super();
this.state = {
blockno: 0
};
}
OnButtonClick = () => {
//updates the states
this.setState({ blockno: this.state.blockno + 1 });
};
//remember: every time there is an update to the state the render functions re-runs
render() {
//variable holding the blocks in an array
let blocks = []
//if blockno is greater than 0, it checks everytime that there is a state change
if (this.state.blockno > 0) {
//for every block added
for (let index = 0; index < this.state.blockno; index++) {
//We`re going to add to the array of blocks a new div with the block number
blocks.push(
<div>
<h3>My block number is {index}</h3>
</div>
);
}
}
return (
<div>
<div>
{/**button that updates the state on every click */}
<button onClick={this.OnButtonClick}>
Click me to add a new div!
</button>
</div>
{/**This render the blocks variable that holds the divs */}
{blocks}
</div>
);
}
}
What I see is that you are trying to build a counter. The value that you're returning from the click handler function can't be rendered, instead you need to manage it in the render function as follow:
class App extends Component {
constructor() {
super();
this.state = {
blockno: 0
}
}
OnButtonClick = () => {
this.setState(prevState => ({ blockno: prevState.blockno + 1 }));
}
render() {
return(
<div>
{this.state.blockno > 0 && <div>some text {this.state.blockno}</div>}
<Button onButtonClick={this.OnButtonClick} />
</div>
);
}
}
Also note that the setState method is asynchronous, please read the documentation https://reactjs.org/docs/react-component.html#setstate
I am very new to React ,trying to develop a Quiz with questions,I have Quiz component which recieve array which is Json with the questions. This is the Quiz class :
class Quiz extends Component {
constructor(props){
super(props);
this.state={
questions: this.props.jsonArray,
score: 0,
currentQuest: 0,
guessedAnswer:'',
};
this.handleSubmit = this.handleSubmit.bind(this);
this.handleChange= this.handleChange.bind(this);
}
handleSubmit(event){
console.log("In parent submited");
let correct_answer= this.state.questions[this.state.currentQuest].correct_answer;
console.log("Correct answer is " + correct_answer);
if(this.state.guessedAnswer===correct_answer){
console.log('Correct answer');
this.setState({score : this.state.score + 1});
}
console.log('Your score is ' + this.state.score);
this.setState({currentQuest : this.state.currentQuest + 1});
console.log("Current question is " + this.state.currentQuest);
}
handleChange(val){
this.setState({guessedAnswer: val});
}
render(){
return(
<div>
{this.state.currentQuest< this.state.questions.length ? <QuestComp question={this.state.questions[this.state.currentQuest]} onChangeValue={this.handleChange} onFormSubmit={this.handleSubmit}/> :null}
</div>
);
}
}
It calls the Question component with parameter ,the current question ,here is the Question component :
class QuestComp extends Component{
constructor(props){
super(props);
this.state={
question: this.props.question,
rerender: false
}
console.log('In constructor in question');
}
updateAnswer=(e)=>{
console.log('changed ' + e.target.value);
this.props.onChangeValue(e.target.value);
}
submitForm=(e)=>{
e.preventDefault();
this.setState({question : this.props.question});
this.props.onFormSubmit(e);
}
render(){
console.log("Rerender child" + this.props.question.question);
let incorrect_answers=[];
for(let i=0;i<this.state.question.incorrect_answers.length;i++){
incorrect_answers.push(this.state.question.incorrect_answers[i]);
}
let randNum=Math.round(Math.random()* (incorrect_answers.length-1));
let correct_answer=this.state.question.correct_answer;
incorrect_answers.splice(randNum,0,correct_answer);
return(
<form onSubmit={this.submitForm}>
<h2><p>{this.state.question.category}:</p></h2>
<h3><p>The question is {this.state.question.question}</p></h3>
{incorrect_answers.map((answer,i) => <div key={i}><input name="somename" onChange={this.updateAnswer} type="radio" key={i} value={answer} />{answer} </div>)}
<input type="submit" className="btn btn-success" value="Submit"/>
</form>
);
}
}
The idea is simple everytime a user submit the form I increment the currentQuestion state and pass the next question to QuestComp to display it ,the problem is the first time I have to click the submit button actually 2 times to go to the next question ,it just not render it and when i put console.log in the QuestComp render method to see what question it recieved ,actually it is the right one ,it just dont display it I dont know why ,so the first time I have to press 2 times the submit button to go to the next question ,after that it is working fine ,one press and renders the next question ,any idea why ?
The main problem is related to the question state in QuestComp is out of sync with the question props passed from Quiz.
Just use the props passed from Quiz directly instead of setting the props to the state in QuizComp. Setting props to state like this is an anti-pattern and error prone.
So to solve this, just replace all your this.state.question in QuestComp with this.props.question.
setState is asynchronous and it takes some time to complete. Your this.props.onFormSubmit(e); triggers right after and doesn't wait for it to end.
Try using it this way:
this.setState({question : this.props.question},
() => this.props.onFormSubmit(e);
);
It should trigger after setState end and make your stuff work.
When you click submit for the first time you run this.setState({ question: this.props.question }); with this.state.questions[this.state.currentQuest].
The current value of currentQuest is 0 so it shows your question with index = 0 again. handleSubmit increases it to 1 right after so every next go is good.
You need to increase that number before.
I am starting my adventure with React so it is a hard time for me, however I prepared such pen for you to test. Here is a portion of code:
class App extends React.Component {
constructor() {
super();
this.state = {
settings: true,
next: false,
};
}
toggler(abc) {
console.log(">>", abc)
this.setState({
next: !this.state.next
/* {abc}: this.state.{abc} */
})
console.log(this.state.next)
}
render() {
return (
<div className="kalreg">
<MyButton name='settings' isActive={this.state.settings} type="settings" toggle={this.toggler.bind(this)}/>
<MyButton name='settings2' isActive={this.state.settings} type="settings" toggle={this.toggler.bind(this)}/>
<MyButton name='next' isActive={this.state.next} type="next" toggle={this.toggler.bind(this)}/>
</div>)
}
}
class MyButton extends React.Component {
constructor(props) {
super(props);
}
onChangeName(){
console.log(this.props.type)
if ( this.props.isActive ) { console.log("this one is active"); } else { console.log("ouch! it is not active, ignoring!"); return;}
this.props.toggle(this.props.type);
}
render () {
if ( this.props.isActive ) {
return ( <div className="button notVisible" onClick={this.onChangeName.bind(this)}>{this.props.name}</div>)
} else {
return ( <div className="button visible" onClick={this.onChangeName.bind(this)}>{this.props.name}</div>)
}
}
}
ReactDOM.render(<App />, document.getElementById("app"));
What I am trying to achieve is that when i press one of "settings" buttons (yellow) the "next" button becomes unclickable (green). There is a toggle function that every time I click settings button it turns on and off "next" button.
It works quite good, however it is just a draft of bigger project and i want to automate it a little bit.
As you can see I create my <MyButton> with both "isActive" and "type" props. But isActive holds what's inside this.state.settings while type is "settings". Instead of using two variables it would be great to pass only type of button to its component and component, depending on its type would check its parent's this.state.{type}. I used {type} because i would like to check it dynamically. Is that possible?
If so - how to do it?
My first attempt is to pass type from <MyButton> to <App> via toggler function. I named the variable "abc". I commented the way I wanted to do it because it doesn't work:
{abc}: !this.state.{abc}
Any idea to solve this problem would be more than appreciated.
Kalreg.
It is somewhat unclear what you are trying to achieve here. If you want to wire the state dynamically based on type, as you wrote in code: {abc}: !this.state.{abc} each button would toggle itself, not the next button. In this case your syntax is a little incorrect, it will work if you write it like:
[abc]: !this.state[abc]
However as I said, in your example, this makes the settings button change the state for this.state.settings disabling itself instead of the next button.
Another note would be, that if it is not necessary for the MyButton component to know its own type for other reasons, it is unnecessary to pass it as a prop and than make the component pass it back as an argument (this.props.toggle(this.props.type);). You can simply define the toggle function in the parent as:
toggle={() => this.toggler("settings")}
without passing type as a prop.
So basically we want to have the settings and settings2 buttons, and when we click on them, they toggle the state of the next button by making it un-clickable (green).
So if that is our goal, then
we don't need an isActive prop for the settings button. (Because it's always going to be active no matter what)
We also don't need to have a toggle prop on the Next button. (Because clicking the next button isn't supposed to toggle anything)
Instead of having two variables in the state why not just have one and then use that to determine the isActive prop of the next button?
The component would look like this:
constructor() {
super();
this.state = {
nextIsActive: false,
};
}
toggler() {
this.setState({
nextIsActive: !this.state.nextIsActive
})
console.log(this.state);
}
render() {
const {nextIsActive} = this.state
return (
<div className="kalreg">
<MyButton name='settings' isActive={true} type="settings" toggle={this.toggler.bind(this)}/>
<MyButton name='settings2' isActive={true} type="settings" toggle={this.toggler.bind(this)}/>
<MyButton name='next' isActive={nextIsActive}/>
</div>
)
}
That way you don't have to have 2 state properties that you have to dynamically update because it adds more complexity to your application.
You can see the finished product here: Codepen
I'm attempting to do an animation with React and CSS classes. I have created a live demo, if you visit it and click the Start button you will see the text fade in and up one by one. This is the desired animation that I am after.
However, there seems to be issues of consistency when you hit Start multiple times and I cannot pinpoint why.
The Issue: Below is a recording of the issue, you can see the number 1 is not behaving as expected.
live demo
The process: Clicking Start will cancel any previous requestAnimationFrame' and will reset the state to it's initial form. It then calls the showSegments() function with a clean state that has no classNames attached to it.
This function then maps through the state adding a isActive to each segment in the state. We then render out the dom with a map and apply the new state.
This should create a smooth segmented animation as each class gets dropped one by one. However when i test this in Chrome (Version 56.0.2924.87 (64-bit)) and also on iOS, it is very inconsistent, sometimes it works perfectly, other times the first DOM element won't animate, it will just stay in up and visible it's completed transitioned state with "isActive".
I tried to replicate this issue in safari but it worked perfectly fine, I'm quite new to react so i am not sure if this is the best way to go about things, hopefully someone can offer some insight as to why this is behaving quite erratic!
/* MotionText.js */
import React, { Component } from 'react';
import shortid from 'shortid';
class MotionText extends Component {
constructor(props) {
super(props);
this.showSegments = this.showSegments.bind(this);
this.handleClickStart = this.handleClickStart.bind(this);
this.handleClickStop = this.handleClickStop.bind(this);
this.initialState = () => { return {
curIndex: 0,
textSegments: [
...'123456789123456789123456789123456789'
].map(segment => ({
segment,
id: shortid.generate(),
className: null
}))
}};
this.state = this.initialState();
}
handleClickStop() {
cancelAnimationFrame(this.rafId);
}
handleClickStart(){
cancelAnimationFrame(this.rafId);
this.setState(this.initialState(), () => {
this.rafId = requestAnimationFrame(this.showSegments);
});
}
showSegments() {
this.rafId = requestAnimationFrame(this.showSegments);
const newState = Object.assign({}, this.state);
newState.textSegments[this.state.curIndex].className = 'isActive';
this.setState(
{
...newState,
curIndex: this.state.curIndex + 1
},
() => {
if (this.state.curIndex >= this.state.textSegments.length) {
cancelAnimationFrame(this.rafId);
}
}
);
}
render(){
const innerTree = this.state.textSegments.map((obj, key) => (
<span key={obj.id} className={obj.className}>{obj.segment}</span>
));
return (
<div>
<button onClick={this.handleClickStart}>Start</button>
<button onClick={this.handleClickStop}>Stop</button>
<hr />
<div className="MotionText">{innerTree}..</div>
</div>
)
}
}
export default MotionText;
Thank you for your time, If there any questions please ask
WebpackBin Demo
Changing the method to something like this works
render(){
let d = new Date();
const innerTree = this.state.textSegments.map((obj, key) => (
<span key={d.getMilliseconds() + obj.id} className={obj.className}>{obj.segment}</span>
));
return (
<div>
<button onClick={this.handleClickStart}>Start</button>
<button onClick={this.handleClickStop}>Stop</button>
<hr />
<div className="MotionText">{innerTree}..</div>
</div>
)
}
How this helps is that, the key becomes different than previously assigned key to first span being rendered. Any way by which you can make the key different than previous will help you have this animation. Otherwise React will not render it again and hence you will never see this in animation.