[MUSIC PLAYING]
BRIAN YU: OK, welcome back everyone to CS50 Beyond.
We continue where we left off this morning.
This morning we introduced React, a JavaScript-based framework
to allow us to quickly and easily build user
interfaces via declarative programming, describing
what it is that we want the page to look like in terms
of various different components.
Then putting those components together to be
able to create an application that's interactive.
In order to update the application, we didn't
need to do what we did before in the world of imperative
programming of saying, go to this part of the page
and insert certain components or other HTML elements
inside this section of the page.
We would just update our data, update the state of our components
in order to say this value of the state should take on this new value.
And React would take care of the process of updating the user
interface to reflect whatever it is was contained inside of our state.
So we're going to pick up where we left off,
continuing in with the morning project.
So there are a number of different ways to solve
the problem in this morning's project.
I'll show you a couple of them now just to give you
a sense for the different approaches, the way
that you can use React to implement some of these features.
And then I'll introduce what the afternoon project will be.
And the main focus of the afternoon lecture
is just going to be thinking in React, thinking
about what components we need, what state we need,
how we might set up an application.
And then we'll actually go ahead and try and implement the afternoon project.
So let's go ahead and get started with the to-do list application, where
we left it off this morning.
So as of earlier this morning, we had a to-do list application
that had a list of tasks, whereby I could type in a task, task one,
and I click Add task.
And that allows Add tasks to show up in this list.
But of course, task one is still listed here in the input field.
How do I get rid of task one from the input field?
Going back to this morning, how would I remove task one from the input field
when I click Add task, clearing out that field?
Which function needs the change?
Yeah?
AUDIENCE: Send the value of input to empty string.
BRIAN YU: Good, set the value of input to empty string.
And where should I do that, in which function?
AUDIENCE: In add task?
BRIAN YU: Great, in add task.
So when I add a new task, I want to do two things.
In addition to taking my tasks array and updating it, filling it
in with the new thing, I also want to say, all right
whatever the value of the input field was before, just
go ahead and set that equal to the empty string, because I
want to clear out the input field as soon as I click the Add task button.
So I'll go ahead and refresh this, try this out.
I type in task one, click Add task.
And all right, great, the task shows up and this field clears itself out.
The other thing that we ask you to do this morning
was show a count of how many tasks are currently in the task list.
And someone else tell me how you did that.
What did you change and what code did you have to write?
I know many of you did this.
So how did you do it?
Show how many tasks I currently have.
Yeah?
AUDIENCE: Use .length.
BRIAN YU: Yeah, if you have an array in JavaScript, and you use .length,
you can get at the length of the array, the number of elements in the array.
And so if I wanted to display the number of tasks that I currently have,
I could just say number of tasks.
And then using curly braces, again, to mean plug-in some JavaScript value
here, where are my tasks stored?
What would I type?
In the state?
OK, this .state.tasks.
And then .length to get at, OK, here is the number of tasks that I actually
have as of this moment inside of my application state.
So I refresh that.
And now I see, OK, tasks, number of tasks is zero.
But as soon as I add a first task here and click Add task,
multiple things happen.
The list updates.
We also see that this clears out and number of tasks
updates to reflect the length of that array.
Questions about any of that?
All right, so the challenging piece of this, of the morning project
was really the deletion of tasks.
How do you take a task in this list of tasks
and delete it so we no longer have it?
And so let's take a look at how we implemented that.
We'll scroll up to the top.
For every list item, when we map over all of our tasks, right now
we just have a list item that lists the name of the task just like this.
If I wanted to do more than that, well, I could just add to this list item.
In addition to just having a task, I'll also have a button, for example.
And that button we'll just call delete.
And let's leave it at that for now, just putting a button there.
Right now the button doesn't do anything.
But let's at least see it so we can visually
see what that button looks like on the to-do page.
We'll refresh the page.
OK, number of tasks is zero.
And I could say, OK, task one for example, add the task there.
And all right, great, we see the Delete button.
We also see task 1 show up next to it.
They're a little bit close together.
So you might try and modify some of the spacing of things,
the margin around the button, for instance,
in order to give yourself more space if you wanted to.
But of course right now, even if I have multiple tasks, I can click Delete
and the delete buttons aren't doing anything just yet.
So how do we actually delete a task?
Well, we probably want some function that's
going to take care of deleting a task.
And so one way to do this might be to say, all right, delete task.
And I saw people approach this in a couple different ways.
So I'll show you both ways that you could
have tried to approach this problem.
One way would have been to say, all right, delete task.
Well, this is a function that's going to take
some argument, some like index for which task
it is that I actually want to delete.
And the logic there would be, well, all right,
when I click on the button, button on-click.
Let me go ahead and delete that specific task corresponding
to index I, which is the index I'm currently on.
So you might have tried to write something like this .deletetask.
And then in parentheses, you might have thought all right,
let me put in the variable I there.
Now, this doesn't quite work.
Does anyone know why this doesn't quite work?
It's a little bit subtle.
Yeah?
Exactly.
This on-click attribute should take as its argument a function.
And the idea is that that function will not
be called upon until we actually click on the button.
But right now what we're passing into on-click
is the result of calling a function.
The fact that you see parentheses after this function
means that we're actually calling the delete task function, which
is not what we want to do.
What we want to do is we want to pass the function
into the on-click attribute, but not actually call
the function until we click on it.
So a couple ways to potentially handle that, the simplest way might
have been just to wrap this whole thing inside of a function, where, oops,
undo that.
What did I just do?
Delete task takes an index.
I think I accidentally deleted that.
And instead of saying on-click equals this .deletetaskI.
We can wrap this entire thing in a function
as simply as adding an extra set of parentheses and an arrow.
Remember, that arrow syntax creates a function.
And so we've created a function that doesn't take any arguments,
but that when it's run, will actually perform the deletion of the task.
So this is one way to do things.
And so now what exactly does the delete task function need to do?
Well, it needs to remove the task at this particular index.
So I'm going to say this .setstate.
And the new state is going to be a function of the old state.
I'm going to take the old state, modify it by removing the task,
and then returning the new state.
So this is going to be a function that takes the old state.
And then what do we need to do?
Well, the first thing we need to do is get a copy of that list of tasks.
Because I can't modify the state itself, as we mentioned before,
you should never modify the state directly and react.
So I'm going to create a variable called Tasks.
And that's just going to be equal to this .state.tasks filled into a brand
new array.
So I create a copy of that list, save it inside of a variable called tasks.
And then I want to remove whatever is at index I.
And so as we've decided this morning, the way we would do
that is by saying tasks.spliceindex1.
In other words, saying remove whatever is at index--index.
And how many things should I remove?
1.
Now, the return value of splice is going to be the array that was removed,
that was spliced out of the tasks array.
But tasks itself, as a variable, is going
to be the original array with whatever we wanted to remove removed.
So there's a slight nuance there that I saw a couple people
struggle with a little bit.
Just know that what splice of returns is different than what
the actual value of the tasks variable is.
And now that I've spliced out whatever was an index,
I can now use this variable tasks to be the new list that has the thing
index--index removed from it.
And so this is a function.
So the last thing I need to do now is return something.
And I'm going to return, all right, what should the new tasks be?
It should be just this variable called tasks.
And so this is a slightly more complicated set state function.
In particular, it's more complicated because it's
really more of a full fledged function where
I'm defining variables, and manipulating those variables,
and returning some value.
Their add task meanwhile, was a much simpler function,
whereby I could just say I didn't need to create any new variables.
All I needed to do was say we start with this state
and we're just going to immediately return
this object that represents the changes that we're going to make to the state.
And so I'd just take a look at Add task and Delete task,
and see if you can get an understanding for the differences between the two.
All we need to do in Add task is add to this tasks array.
But in Delete task, we really need a little bit of extra logic
to copy the array, remove something from the array,
and then return what the new object should be.
Questions about anything so far?
This was one way to implement things from this morning.
Yeah?
AUDIENCE: [INAUDIBLE]
BRIAN YU: If you're getting an error about-- so
I would first check to make sure that your curly braces in parentheses
match the curly braces in parentheses that I have here.
You might be using the keyword in a place in your code
that you're not allowed to use it.
But if you're still getting that error after that,
it's probably some syntax thing that we can
take a look during the project time.
Yeah?
AUDIENCE: Why wouldn't we use this .setstate for delete task?
BRIAN YU: We are using this .setstate for delete task.
Yeah?
AUDIENCE: [INAUDIBLE]
BRIAN YU: In the Add task function--
so this is a little bit of a nuance of the way
that arrow functions in JavaScript work--
if all we're doing in a function is taking some input
and immediately returning its output without anything else,
I can just say state as the input, arrow,
and then immediately give whatever the thing I'm returning
is, which is this JavaScript object.
And so if that's all the function is doing,
there's no additional logic, no loops, no variables, or anything like that,
then you don't need to explicitly say return.
Whereas in Delete task, the function is a little more complicated.
I need variables.
I need to manipulate those variables.
And so at the end of that, I do need to explicitly say return something.
Yeah?
AUDIENCE: What is .something, [INAUDIBLE]..
BRIAN YU: This is because I'm calling this .setstate.
And the function that I'm passing into this .setstate is this entire thing.
This function.
And so this function, what it's returning ultimately
is a new set of tasks that is going to become the new state.
Yeah?
AUDIENCE: Shouldn't this be just state, not .state?
BRIAN YU: Oh, you're right, this should just be state, not this .state.
Thank you.
That's a good catch.
Yeah?
AUDIENCE: If you put the variable conts task outside of this .setstate,
will that work?
BRIAN YU: If you put conts task outside of this .setstate and you do something
like this .state.tasks here, this will work in this example,
but it suffers from the potential for the race conditions that we talked
about earlier where if we're basing the new state of the old state,
we should really be using the state input to the set state function.
So in this example, it will work fine both ways.
But good design habit to get into the habit of doing things this way.
Other things?
I think there are other questions.
Yeah?
AUDIENCE: I think we probably have [INAUDIBLE]..
BRIAN YU: Yep.
AUDIENCE: So we decided to practice using [INAUDIBLE]..
BRIAN YU: Right, we're wrapping this delete task inside of a function
so the delete task isn't run until we actually call this function.
And this is a common way in programming to delay
the evaluation of some expression is just to wrap the whole thing
inside of a function.
And only when you call that function will the value actually be evaluated.
So this will work.
This actually is a little bit inefficient in the sense
that every time I generate a button, it's
going to regenerate one of these new functions.
And so I'll show you another way of doing the exact same thing.
Totally fine to do this, but if you're looking for really trying to optimize
your react code, I'll show you one other method of achieving the same goal,
where instead of wrapping this whole thing in a function,
I can just use this .delete task.
Again, I'm not calling the function just yet.
Delete task is going to be called eventually.
But this time delete task is not going to take an index as its argument.
But instead, what I'm going to do is I'm going to associate
some data with this button.
In the same way that in JavaScript before we could attach data attributes
to HTML elements, we can do the same thing here,
because this is just JavaScript, where I can say buttondata-index is going
to be equal to I. Remember, data attributes
are a way of adding information data that we
care about to our HTML elements.
And here I'm just adding I as the data attribute of this particular button.
So now when someone clicks on delete task,
this delete task is going to take an event as an argument,
because we're going to need access to the event.
Because if we try and get at the event.target,
that's going to give us the button, the button that we clicked on.
And if we access the data set for that button, the data attributes of it,
and get at the index of that dataset, what that's going to do
is it's going to give us access to the index of the button.
It's going to take that button, get at its data properties,
and get at the field called data-index.
And that will give us access to whatever the index of this particular row
happens to be.
And so this will behave the same way, where I can say task one and task 2.
And if I delete task two, all right, great, I'm left with just task one.
And the number of tasks decreases from two to one as well,
because React is dynamically going to update the DOM with any changes
as a result of changing the state of my components.
So two different ways of achieving the same thing.
I'm just showing you both, because they're
both the types of things that you might see in the world of programming
in React.
Questions about anything?
Yeah?
AUDIENCE: If we do it this, it's like a data attribute.
For the index we use just value.
Does that work for you?
BRIAN YU: Yeah, you can use other attributes as well
and access as attributes, and that would probably work.
Yep?
AUDIENCE: [INAUDIBLE]
BRIAN YU: So again, delete task, just to review,
is getting the index from the data attribute of the button.
Then updating the state.
And to update the state, we take the original tasks,
splice out whatever was at index I, and then return the new tasks.
And a small bit of JavaScript shorthand, which you don't need to know,
but might be useful sometimes, is if ever you have a situation where the key
of a JavaScript object has the same name as the value,
you actually don't need to say tasks:task.
If you just say tasks, that will implicitly just mean the key in a value
have the same name.
And so this is just a little bit of shorthand for doing the same thing.
But no need to worry about that if you don't want to.
Yeah?
AUDIENCE: Are you worried about this being inside set state?
Is it better to be outside?
BRIAN YU: This, it doesn't matter whether this
is inside or outside of set state, because it's not
dependent upon the state variable.
So you could calculate the index wherever.
So long as you have access to the same event,
the data index value is always going to be the same.
So it doesn't matter if it's inside or outside of the function.
Other things?
Yeah?
AUDIENCE: [INAUDIBLE]
BRIAN YU: Yeah so these events you can think of as the same sorts of events we
were dealing with in JavaScript before, where when I say button on-clicked
equals this .addtask task for instance, then the event that is happening is
the click event.
And the target of the click event is the button
that I actually use to do the clicking.
And so the way this works in the case of delete task is that when I call this
.delete task, it's going to be provided with the click event,
the fact that I clicked on a button.
And if I access event.target, that's going to give me which button
I actually clicked on to do the deleting.
So if I have 10 buttons, each of which has a different data-index property,
then if I go to event.target and look at what data-index is,
I'll know which button I clicked on and so
I'll know which task I should remove from my list of tasks.
Yeah?
AUDIENCE: So [INAUDIBLE],, but basically what I did is after delete task,
hit the button I, I used the index for I.
And then down at the function delete task, I used [INAUDIBLE]..
BRIAN YU: Yeah, so I showed two possible ways of doing it.
And so one way is to do it the way that you're describing it.
Yep.
Yeah?
AUDIENCE: Can you explain why the code is [INAUDIBLE]..
BRIAN YU: So we only need event as an input to the delete task
function because we need to use event to access the target, namely the button
that we clicked on, because we need the button to get
at the data attributes of the button.
In the first method that we used, we didn't
need to access any data attributes.
So it didn't actually matter to have access
to the button that was clicked on, because delete task was already
being provided with the index.
So we didn't need to access the event.
Other things?
Yeah?
AUDIENCE: Why is this way more efficient?
BRIAN YU: This way is slightly more efficient because in the other way when
we created a new function for each of the on-clicks where we did curly braces
arrow, this .deletetaskI, that would be a situation where every time
it's creating a new button, it's creating a brand new function in order
to put in on-click.
Whereas here, I'm just using the same this .delete task function.
And so it's just a slight efficiency benefit
that's really not a big deal here.
Though in larger applications, you might imagine
it could start to become a big deal.
In this case, it's probably fine just to avoid over optimizing.
And either way is OK.
All right, so really the best way to get good at React
is to start writing applications in React.
And we'll do some of these together.
And so that's what the goal of today and tomorrow is going to be.
React is a new way of thinking about writing programs.
It's a new way of working with programs, and thinking
about state and applications, and how to modify the user interface.
And so we'll go through a couple now slightly larger projects
that will step through the beginning parts together
to give you a sense for the types of things that you can do with React
and how to think about designing an application in React.
And so the application we're going to build now
is going to be a similar analog to the quiz application we had before.
We're to create a flash card application.
And so the flash card application is ultimately
going to look something like this.
When it's done, it's going to have a couple different modes.
It will have a card Editor.
And a card Editor basically allows me to input terms and definitions
into the cards.
So maybe I want to create addition flash cards, for example,
to help me practice for the addition game that we did earlier this morning.
So I do a front side and a backside.
A front and a back for the card.
Press Add card.
And all right, that adds to this list of cards.
I can add other front and back and more as well.
If I wanted to delete a card, I can delete a card too.
And then if I want to, once I'm satisfied with editing these cards,
I can switch to the card Viewer.
And the card Viewer is going to show me a card.
If I click on it, it'll flip it over so I can see the back.
If I click on it again, it will flip back to the front.
And I can click on New card to get me a new card.
Get me the next card in the list.
When I click on that, it'll flip over, show me
the back of the card, so on and so forth.
I can switch back to the Editor.
I can switch back to the Viewer.
So this is the application we're going to build.
And it seems a little bit complicated.
But let's try and break it down into components.
And what's the first thing that you might notice?
What is this interface at least remind you
of in terms of things we may have done today?
Yeah, it reminds you very much, hopefully,
of the tasks management application that we did this morning of just
creating a to do list of tasks.
This is effectively exactly the same thing,
except instead of a task just having one field for the task,
the task has a front and it has a back.
It's two input fields instead of one.
So this interface is probably largely going
to resemble what it is that you did earlier this morning.
We just now need to add a Viewer to it as well to be able to view those cards
and flip the cards over from front to back.
So questions about the goal-- what we're trying
to achieve in writing this application?
All right, let's go ahead and dive right in and actually start
working on the application.
So we'll go ahead and create a new file.
We'll call it flashcards.html.
And I'll go ahead and start with just going ahead and copying
the to-do app just so we get the basic structure of it.
But I'm going to completely empty out what's inside of class at, at least
for now.
We'll give it a title of flashcards.
And all right, let's actually think for a moment.
If I say term and definition, what are the different components
that I might divide my application into?
Process to different components of the application?
There are at least two big components of the application,
distinct parts of the application that behave differently.
The Viewer and the Editor.
Great, I have this Editor right here that is a place where I can edit tasks,
add tasks to them.
And I also have some Viewer that lets me view all of the cards
that I currently have inside of my flash card table.
And so those are probably at least two different components
that are going to behave differently.
So one thing I might do right away is say, all right, I'm
going to have a class called card Editor that is going to be a component.
And for now, let's go ahead and render that just by returning a div that says
this is the Editor.
So all right, I have a class called card Editor.
And all the card Editor is going to do is say this is the Editor, at least
for now.
In addition to that, I probably also want
a class called card Viewer that going to extend React.component.
And we're going to render it by returning for now this is the Viewer.
So all right, we have two classes, card Editor and card Viewer.
And right now they just say this is the Editor, this is the Viewer.
And I can test this, make sure it works by inside of my app.
In order to render the app, let's for now just
return a card Editor and a card Viewer.
We'll load both components into the application, one on top of the other,
just to see how this looks.
I'll go ahead and open up flashcards.html.
And all right, great, this is what I see.
I see the card Editor that just says this is the Editor.
And I see the card Viewer that just says this is the Viewer.
But of course I don't want to display both the Editor and the Viewer
at the same time.
So let's step by step start building up this application.
What is a piece of state that I need inside of my application?
Yeah?
AUDIENCE: Whether you're on Editor or Viewer?
BRIAN YU: Exactly, whether I'm on the Editor
or whether I'm currently on the Viewer.
So it's some notion of, like, what the current mode of the application is.
And so I could implement this by saying, all right,
let's create a constructor that takes props, super props just
to make sure that the component gets its props correctly.
And let's give some state to this application.
We care about knowing whether or not we're in the--
so we could do this state in a number of ways.
We could say, all right, let's add a mode property to the state
where the mode could start out being Editor, for example.
And then mode could be any number of different things.
But right now there are only two different modes.
So I'll just say Editor is true.
We'll have a piece of the state called Editor.
By default, it is true.
So by default, I'll see the Editor.
And if ever the value changes, I'll show something else.
And so, OK, what do I do now?
Well, inside the Render function, we'll say something like if this
.state.editor, implicitly if this .state.editor is true,
then what do I want to do?
Well, I want to return a card Editor.
And otherwise else, I want to return a card Viewer.
And I go ahead and delete this unnecessary return here at the bottom.
So here is the render code for my app.
I'm basically checking whether this .state.editor,
should the state of my application be showing the Editor or not showing
the Editor?
If I am supposed to show the Editor, then
go ahead and return the card Editor.
Otherwise, go ahead and return the card Viewer.
So if I load the page now, refresh flashcards.html,
I just see this is the Editor and I have no way of accessing the Viewer.
I only see the Editor.
Questions about anything?
BRIAN YU: All right, so let's take the next step.
I can have the Editor.
And now I want some way of flipping back and forth between Editor and Viewer,
between Editor and Viewer, going back and forth between these two components.
And so I probably need some way inside of my app
to change the value of this Editor piece of state.
I want some function that is going to change whether Editor is true or false.
So I'll go ahead and add a new function.
And the new function, we'll call it switch mode.
Switch mode is going to be a function that
takes me from Editor mode to Viewer mode, and from Viewer mode
to Editor mode.
So it's going to be a function.
In order to do that switch, I need to set the state to something.
So I'm going to start with some starting state.
And what is the new state?
What goes in here to switch the mode of my application?
Yeah?
AUDIENCE: [INAUDIBLE].
BRIAN YU: Yes, so we have inside of this .state a notion of where we are.
If Editor is true, we should be on the Editor.
If Editor is false, we should be on the Viewer.
So yes, good, we need that.
And, yes?
AUDIENCE: Editor, [INAUDIBLE].
BRIAN YU: Yeah, exactly.
Editor, we're going to change the value of Editor
to exclamation point for not state.editor.
So whatever the value of state.editor was before,
let's take whatever is not that, so if it was true, it's now false.
It was false, it will now be true.
And that will be the new value of Editor, for example.
So all right, now what I need is I would like some way for maybe the Editor
to have a button and the Viewer to have a button that
will result in switching the mode of the application, for example.
And so how do I go about doing that?
Well, there are a of ways to do it.
I could put the button directly in the app right
here and just have a button at the bottom that's going
to say, like, switch mode or something.
Another way to do it would be inside of card Editor for instance,
let's go ahead and add maybe a horizontal row.
HR just creates a horizontal row, a line, across the page effectively,
and a button that says go to Viewer.
And in the Viewer, go ahead and create a horizontal row and a button that says
go to Editor.
So OK, I have the task Editor that has a button that says go to the task Viewer.
And I have the Viewer that has a button that says go to the Editor.
If I refresh the page, it says this is the Editor
and there's a button that says go to Viewer.
Of course if I click on that, nothing happens.
Nothing happens because I haven't specified
what should happen when I click on this Go to Viewer button.
What I would like to happen, if I click on the Go to Viewer button in the card
Editor component, is that it calls the switch mode method of my app component.
But there is a slight problem, what's the problem?
Why can't I just say switch mode?
Yeah?
AUDIENCE: They're in different classes.
BRIAN YU: They're in different classes.
Exactly.
Switch mode is a method inside of the app component,
but I want to be able to call it from the card Editor component.
They're in different components, but I want
the card Editor to still be able to call a function inside of the app.
So how would I do that?
Any thoughts on how I might solve that problem?
The function is inside of the app and I would
like to give it to the card Editor.
In other words, pass information about that function or pass the function
itself to the card Editor so the card Editor can use it.
Thoughts on how to solve that problem?
We saw the solution this morning.
Yeah?
AUDIENCE: Could you have it extend the app?
BRIAN YU: Could you have it extend the app?
Yes, you could.
Generally, React doesn't recommend that you have different classes extending
other classes, because generally the classes want
to do pretty distinct things.
But that could be one solution to the problem.
Yeah?
AUDIENCE: You can use a property.
BRIAN YU: You can use a prop.
Great.
And that's going to be the solution we're going to use.
We learned already that if I want to pass information into the card Editor,
I can add props to the card Editor.
I can say, all right, give the card Editor a switch mode property that is
equal to this .switchmode.
Remember, I'm inside of the app component right now.
And when I load my card Editor component,
I would like to provide it with a property called switch mode.
And that is equal to the this .switchmode function.
I'm passing this function into the card Editor component
so that the card Editor component can use that function.
It can be helpful here to think about the hierarchical structure
of the application.
We have the app, which is the big container, inside of which
is the card Editor.
And the app is going to give the card Editor this, this.switchmode function
so that the card Editor can now use that function.
Yeah?
AUDIENCE: Let's say you have a function that every single last [INAUDIBLE]
would use.
If you could find that function, [INAUDIBLE]..
BRIAN YU: That's a good question about if you
had a lot of components that were all trying to take advantage of functions
that are modifying the state, with just React,
you'd have to do something along these lines.
Although, there are other libraries.
In particularly, a library called Redux, which is quite popular,
which helped to make that process easier and can have some useful abstractions
for simplifying that process.
We're not going to get our chance to talk about it this week.
It's a little beyond on the scope of the class.
But Redux is what you should look into if that's something
that you're trying to do.
So OK, I provided the switch mode property into the card Editor.
And now inside of card Editor, what should button on-click do?
What is the function that I need to call when the button is clicked?
AUDIENCE: This .prop.
BRIAN YU: This .props.switchmode.
Great.
I want to access the switch mode function,
and the switch mode function was provided
as one of the props of this card Viewer component.
So when I click on the button, it should call this .props.switchmode.
I'll go ahead and refresh the page.
It says this is the Editor.
I click on and go to the Viewer, and, uh-oh, something went wrong.
Why did that not work?
This .props.switchmode.
AUDIENCE: [INAUDIBLE]
BRIAN YU: What did I not do?
I didn't edit-- oh, I edited the Viewer class.
Yes, thank you.
I'll go ahead and make the same change to the Editor class button.
When you click on it, unclick this .props.switchmode.
Thank you for that.
OK, now if I refresh the page it says this is the Editor.
If I click on Go to Viewer, it switches.
Now I'm on the Viewer, I click go to Editor
and why did that one not work now?
Oh, why did that one not work?
Why did card Viewer not work?
Anyone know?
AUDIENCE: [INAUDIBLE].
BRIAN YU: It has this .prop.switchmode.
But what did I forget?
AUDIENCE: [INAUDIBLE].
BRIAN YU: I need to give it the prop.
Exactly.
So I have card Viewer, but I didn't provide it with a switch mode prop.
And so I need to say card Viewer and switch mode prop is going to be equal
to this .switchmode for example.
So now I have the Editor.
I can switch to the Viewer and hopefully I can switch back to the Editor.
You can go back and forth between the two just
by changing the state of the application.
Questions about anything so far?
All right, so let's go ahead and try and build out this Editor.
We'll try and build the Editor together.
And then I'll leave most of the Viewer to you
to try and figure out if you'd like to.
So inside of our application, we currently
have some state that indicates whether we're on the Editor mode
or on the Viewer mode.
We're also going to need some state about, like,
what the current cards inside of my collection of flash are.
Like, what are the cards, what's on the front, what's on the back of them.
And an interesting question comes about of where should that state live,
should that state be inside of app, should it be inside of card Viewer,
or should it be inside of card Editor?
Each is a component, each can have its own state, which component should
maintain the list of all of the cards?
What do we think?
Yeah?
AUDIENCE: [INAUDIBLE] Editor.
BRIAN YU: Yeah, exactly.
We want the state about all the cards to be accessible to both
the Editor and the Viewer.
So it probably makes sense to put the state
about what all the cards are inside of the app,
give the state access to cards, which by default will just be an empty list.
That way we can provide that information to both the Editor and the Viewer,
and both can have access to that same state.
And this is an idea you'll commonly see in React called Lifting State Up
that you might think, OK, the card Editor needs to have access
to state about all of the cards.
But if we lift the state up out of the card Editor and into the application,
then anything the application uses, any of its components
can have access to that same piece of state.
Questions about that?
All right, let's go ahead and try and build the card Editor now.
So importantly, when I have the card Editor,
the card Editor needs to know what the cards are.
So I'm going to go ahead and provide the card Editor
with an additional property.
And that property is just going to be called cards, I suppose.
And cards should be equal to what value?
AUDIENCE: This .state.cards.
BRIAN YU: This .state.cards.
Great.
This is inside of my app component, and so when I have the card Editor,
I want to provide it with cards, and its value should be this .state.cards.
You'll notice this line is starting to get a little bit long.
So it's often common in React paradigms to see each
prop to be on a new line of its own.
And so you'll often see something that looks a little something like this,
where I'll return card Editor.
Cards is equal to this .state.cards.
And I'll also give it access to switch mode.
And I'll do the same for card Viewer, give it access to cards in this
.state.cards, give it access to switch mode for the card Viewer.
They both need access to that same information.
So now let's go ahead and build our card Editor.
Right now all it does is just say this is the Editor.
Let's add some HTML to it.
At this point, I can just write HTML and declaratively describe
what it is that I want the Editor to look like.
Well, it should be in H2, maybe, that says card Editor.
You can make it in H1 also, make it a little bit smaller.
And underneath the card Editor, I want there to be a table.
A table where I have rows and columns, a way
to show the front and the back of each card,
and then a button to delete each card.
So underneath this, I'll say table.
The table is going to have a table head and a table body,
either just HTML just to make it easy to separate the heading of the table
from the body of the table.
And the heading of the table is going to have a table row, just
a row along the top of the table.
And that row is going to have three columns.
The first column will be, OK, this is the front of the card,
this is the back of the card, and here's a button
to delete this particular card.
So I have a row at the top of the table, front, back, delete.
And inside the body of the table, here is now where all of the rows
are going to go.
And oftentimes an easy way of just doing this is by declaring a variable
and then we can go back and actually declare it.
I'll just say curly braces rows, meaning the rows of the table
are going to go here.
Now, rows is a variable I haven't yet actually defined.
And so I can define a variable up at the top of the render function.
I can define a variable called rows, which
is going to be equal to, all right, well how am I going to get all the rows?
Well, this is going to look very similar to how
we got that unordered list of items inside of our task list.
What I'm going to say is, where are the cards stored,
this .state or this .props?
Props.
Great.
Why props?
Why are the cards in the props?
Yeah?
AUDIENCE: [INAUDIBLE].
BRIAN YU: Yeah, so in app when we were creating the card Editor,
we passed in cards as one of the properties of the card Editor.
And so now in order to access those cards, we can say this .props.cards.
And then I want to again map over each of these cards,
doing something with each card, in particular,
creating a table row for each one of them.
So I'll say map and we'll go map over every card,
and also give it an index variable I so we have access to which card
it actually is.
And we're going to go ahead and return a table row.
Each card is going to correspond to a single table row.
We'll give that table row a key, because React
likes to have anything that's iterated over a key that is unique.
And we'll give it three cells inside of that row, a front, a back,
and a Delete button.
For the first cell, we'll say card.front.
We'll make each one an object.
Right now we haven't actually seen how we create a new card yet,
but this is how we would print them out for instance.
Then we'll have another one that says card.back.
And then we'll have another one that's just a button that says delete.
So OK, I've defined rows, which is going to be taking all of the cards
and mapping over them, looping over all of the cards.
And for each card, creating a new row.
That row has three columns, one column to represent the front of the card, one
column to represent the back of the card,
and one column to be a button that I can click on to delete the card.
Very similar again to the task management
example from earlier this morning.
So hopefully you can see the parallels that are there as well.
Take a look at the example from this morning at the map
that we were doing over the list of tasks.
And you'll see a lot of similar code that's being used here,
a lot of similar ideas in React.
To test this out, rather than starting cards off with an empty thing,
I can just for the sake of example give it, OK, front is going to be test front
and back is going to be test back.
And we'll go ahead and add a second one, front equals test 2 front,
back is test 2 back.
Just giving it some default state that I'll delete eventually,
but that'll be useful for now until I have the ability
to add cards to be able to see what are the cards
that I currently have inside of my application.
If we open up flashcards.html, all right, great,
we see now that we have a card Editor and we have
three columns, front, back, and delete.
The Delete button doesn't do anything yet.
But at least now I can see the contents of my Editor.
What questions do you have so far with what we've done just now?
We just created an Editor where we can see the contents of whatever
flash cards we currently have.
I'm going to add some CSS code just to make this look a little bit nicer.
If we go up to the top of our HTML page, this is very similar to CSS code
I've added before.
So we'll go through it a little bit quickly.
But feel free to stop and I'll post this code once we move into project time
if you want to take a closer look at it.
But basically tables, and table data cells, and table heading cells,
I should probably change the headings to table headings.
I'll actually do that now.
The headings should probably be th instead of td.
Effectively, this isn't changing a whole lot.
But it helps to make sure that HTML knows that these
are in fact headings for the tables.
So the table, table data cells, and table headings,
those will have a border that is a one pixel solid block border for example.
And so, OK, what does that look like?
All right, we have a one pixel solid black border around each of the cells.
I don't like the fact that there is two lines between a lot of the information.
And so in order to collapse that inside of table,
we can use the border collapse is collapsed CSS property.
That'll basically take all of the neighboring sections of the border
and just collapse them down.
And now this feels a little bit cramped.
So I'd like to add a little bit more space
in between these various different elements.
So for table data cells and table headings cells,
let me add 10 pixels of padding on the inside of each of those cells.
And that will be space on the interior of the border such
that when I refresh the page now, all right, this looks a little bit better,
at least a little more aesthetically pleasing.
And you should feel welcome to mess with the CSS all you want.
You can add colors, change the border if you would like to.
You can center the table if that looks better for you.
So feel free to make any changes to the style and the aesthetics of the code,
and also the functionality of the code if you choose to do so.
Questions about anything thus far?
All right, so we have this table.
And now in addition to having a table, I also
need some way of adding a new card.
So I'll go ahead and say line break here.
And I'll have an input whose name is going to be front
and that'll be it for now.
And an input whose name is going to be back,
and actually I'll give each of them a placeholder at least.
I'll call it front of card and place holder back of card.
So we have two input fields now.
And I'll have a button that says Add card.
So I have two input fields, one called front, one card called back.
And a button that's going to add a new card to this list of cards.
Press Refresh.
Some error somewhere.
I executed closing tag for input.
Oh, I need a flash to close these input tags.
All right, now I have a card Editor.
It's got a table.
And I also have a place where I can type in the name of the front of the card,
then whatever goes on the back of the card.
And then a button to actually add that card to this table.
So now what state do I need to keep about the card Editor?
What can change about the card Editor?
Similar in spirit to what we had with the to-do list,
what are two pieces of state that I need?
Yeah?
AUDIENCE: The input.
BRIAN YU: The input.
Yeah, what it is that I'm typing into the front field,
and what it is that I'm typing into the backfield,
that all needs to be state inside of my card Editor.
So I'll go ahead and create a constructor
that takes in some properties.
And I'll set the initial value of this .state equal to, all right, well,
the front of the card by default is just going to be empty.
And the back of the card is by default also just going to be empty.
And that's going to be the value of this .state.
If I scroll down to these two input fields,
this is the input field where I type in what goes on the front of the card.
This is the input field where I type in what goes on the back of the card.
The value of this input field is going to be this .state.front,
whatever it was on the front of the state.
And the value for the back, this .state.back.
I'm basically doing the same thing I did with all the input fields
before, just giving them a value so that I can later refer back to them.
Both of them need an on change property for what happens when I actually start
typing something into this input field.
And I'll just say this .handlechange as the name of the function for when I
actually start typing something into the front field or into the backfield.
For the back one, I'll do the same thing, onchange=this.handlechange.
And now let's write the handle change function
for what should happen when I start typing something into the input field.
And let me do that underneath at the end of the render function.
Handle change is going to be a function that takes its event.
And handle change is going to need to modify the state of the application.
And if I wanted to change the front of the value front inside of the state,
I could say this .state front is equal to event.target.value.
And that would change the front value.
And if I wanted to change what was on the back of the card,
I would have to do this .state back equals something else.
And so this is a little bit problematic, because I'm using this .handlechange
for both front and back.
I'm using the same event handler, this .handlechange for both of them.
And so I need some way of differentiating between these two event
handlers or saying, if I type something into the front input field,
then I want to change the value of this .state.front.
And if I type something into the back input field,
then I want to change this .state.back.
And so taking a look at these input fields,
is there any property that would be helpful for doing that?
Take a look on 63 and 64, any attribute these elements
have that would be useful.
Yeah?
AUDIENCE: You could somehow put the name [INAUDIBLE]..
BRIAN YU: Yeah, exactly.
I could somehow take advantage of the fact
that the name attribute of this input field is front
and the name attribute of this input field is back.
And I would like to if the name is front, set the state for front
to be event.target.value.
And if it's back, then set it to the back value.
And so JavaScript has some special syntax for doing this.
It's not something you've likely seen before.
But if I in brackets say [event.target.name],
well that's going to say whatever the value of event.target.name is,
let's go ahead and use that as the key.
And then event.target.value is going to go ahead and be the value.
So I can use a single handler to be able to handle
changing both the front and the back value of the state.
So something you might see from time to time,
this is common when you have multiple different input fields.
And rather than create a handle change front function and a handle
change back function, which would just be repetitive,
you can just have a single function that takes care of all of that.
Yeah?
AUDIENCE: [INAUDIBLE].
BRIAN YU: Yeah, so I could add logic.
I could equivalently do this by doing ifevent.target.name=front,
then do something, and else do something else, and that would work too.
And again in React as with almost any programming project,
there are many ways of achieving the same things.
So pick the thing that makes the most sense to you
is often the best piece of advice.
So all right, I have a card Editor now where
I can type something into the front of the card and something else
into the back of the card.
And clicking Add card right now does nothing.
So let me go ahead and write a function that is going to add a new card.
Now to add a new card, do I need to modify the state of card Editor, card
Viewer, or app?
Again, I have three components.
Which state do I need to modify to add a new card?
App state, right.
Because app, that class, is the one that actually
has cards inside the state of the application.
So we're going to need to add a Add card method to this application.
And the Add card method, we'll have it take two arguments.
We can choose what the arguments are.
But it's probably going to make sense for the Add card method
to take an argument for the front and an argument for the back.
And then do something with those two values.
So to add a card with a front equal to front and a back equal to back,
I can do this .setstate.
I want to update the state of my application.
And I want to set cards equal to, well, I
want all the existing cards plus my new card.
So I'll say ...state.cards to say fill in all of the existing cards
into the array.
And now I'd like to add my new card to this array
as well, where the front is going to be equal to front,
and the back is going to be equal to back.
So I'm updating the state, saying take the old state,
go ahead and fill in all of those cards, and then just tack
on to the end of the array a new object where the front of the card
is this variable front, and the back of this card is this variable back.
Yeah?
AUDIENCE: [INAUDIBLE].
BRIAN YU: Yeah, excellent point.
So I mentioned this a moment ago of JavaScript object shorthand,
because front's key and front's value are the same name,
they're both called front and back, they're both called the same thing,
this happens often enough in JavaScript that there's shorthand for it.
I can just say, front, back and it's just
going to assume the keys and values have the same name.
And so this will do exactly the same thing.
But yeah, that's the shorthand I can use.
Yeah?
AUDIENCE: Can you repeat [INAUDIBLE].
I'm a little bit confused with event.
Why does switch mode not take an event, if it also [INAUDIBLE]??
BRIAN YU: So why does switch mode not take an event.
Switch mode could take an argument called event.
JavaScript option has functions that have
these optional arguments that if you wanted to take an event argument,
it can.
But switch mode doesn't need to access the event.
Because the only thing the switch mode function needs to do
is take, whether it's on the Editor and the Viewer,
and switch it to the other Viewer, the other component that I have.
And so nothing about the event actually matters for the logic
of the switch mode function.
Whereas by contrast, handle change actually does care about the event.
The event of me changing the input field is important for two reasons.
One, I care about the event, because I care about the name of the input field
that I was typing something into.
Was I typing something into the front field or the backfield?
And depending on that, I want slightly different logic.
And it also matters because I care about what is it that I actually typed in.
Because what it is that I typed in should be the new value of either front
or back in the state.
So if you need to access the event for some reason,
usually to get at event.target, the thing that's triggering the event,
then you'll need the event parameter in the function.
But if you don't need the event, then it doesn't matter whether you include it
or not.
And so generally speaking, we won't include it.
Yeah?
AUDIENCE: For all the examples you've been doing [INAUDIBLE]
Is there a reason we're doing that instead of on the bottom click
maybe change the state of the [INAUDIBLE]..
BRIAN YU: So when the button is clicked, we
want to be able to just look at the state of the application
to be able to know what is the front value and what if the back value.
And so generally in React, any time something
changes in the user interface, that should be represented
by some underlying change in state.
In other words, if you know the state of the application,
what the value of this .state is for all of your components,
I should be able to tell you exactly what the page is going to look like.
And so that's just sort of part of the React paradigm.
Yeah?
AUDIENCE: [INAUDIBLE].
BRIAN YU: It depends on what you try to do with properties that you
don't provide in.
So if you try to use a property that you don't provide and just,
like, paste it into the HTML content somewhere inside your render function,
odds are it will work but just nothing will show up there.
But if you try and do any logic with it, like, if you try and call
or pass it in as arguments to functions or perform operations with it
and they don't exist, then you could start to get errors.
So you do want to be a little bit careful about that.
Other things?
OK, so we have this Add card function.
And in particular, this Add card function
is a function that our card Editor needs to have access to.
And so I'll go ahead and add to this card Editor.
The card Editor knows how to switch modes.
But the card Editor also needs to know how to add a card.
So Add card will be equal to this .addcard.
And now inside of our card Editor, when you click on the button, on-click,
I'll call this .addcard.
So this is a different Add card function.
But what needs to happen when I add a card in a Viewer?
Well, two things need to happen.
One is I need to actually call the Add card function in my props.
This .props.addcard, passing in whatever was in the front input field
and whatever was in the back input field.
And that information is stored in this .state.front and this .state.back.
And then what else should I do from a user experience perspective
if I type in something into the front input field, type in something
into the back, and click Add card?
AUDIENCE: Clear out the states.
BRIAN YU: Clear out the state's.
Clear out the input field so that we say this .setstate.
Front is going to be empty.
Back is going to be empty.
And so we're saying clear out those input
fields so that we can start fresh.
Go ahead and refresh the page.
Front of the card, it will be test three front.
Back of the card, test three back.
I'll go ahead and click Add card.
And all right, great, we got a new card in this list of cards.
And the input fields cleared themselves out.
At this point, I'm going to go back and delete these sample cards
that we had just for testing purposes.
We'll go back to just starting with an empty list.
And now I can begin to add whatever flashcards I want.
I can say, OK, 1 plus 1, plus 2.
We can do as many of these as you want to.
But of course, the Delete button doesn't yet work.
We can create all the cards, but we can't yet delete a card.
And so to do that, it's going to be basically
the exact same thing as what we just did for adding
a card, but the analog for deleting, as we did with the tasks example.
So inside of the app, we had a function called Add
card, which took care of adding a card.
But our app is also going to need to know how to delete a card.
And to delete a card, we're going to delete a card based on its index.
And this code should look very familiar to the code we
did when we were doing task management.
We're going to say, all right, this .setstate.
It's going to take the original state.
And let's go ahead and say, all right, the cards,
let's make a copy of state.cards.
And let's go ahead and splice out of the cards
remove something from the cards array at index.
Remove one thing and go ahead and return cards
is equal to whatever the value of cards is.
So what's happening here?
When I delete a card, at this particular index, I'm saying,
OK, make a copy of state.cards, store it in this variable called cards,
remove what was ever at this index, remove
one element using the splice method.
And then I'm returning the new state, update the value of cards in the state
to be equal to this variable cards.
And as we've seen a couple of times now, because these things have
the same name, you could even simplify this to just return cards.
And we'll implicitly assume that they have the same name.
So now I have this delete card method in my app
that operates in order to delete a card.
This is also a function that card Editor needs to have access to.
So we'll say delete card equals this .deletecard.
And we'll go ahead and now go to the card Editor.
And we'll do the same thing we did before, this button will
give a data index property of--
I'm sorry, not the Add card button.
The Delete button-- yeah, here's the Delete button--
will give it a data/index property of, all right,
what is the index of which element to delete if I try and delete this card?
It'll be I for example.
And then when I click on it, we're going to call the this .deletecard method.
Same as the example from earlier this morning.
And now when I delete a card, that's going
to be a function that takes the event as input.
And why do we need the event?
Well, because event.target.dataset.index.
In other words, take the click event, get out
its target, the button that I clicked on, get at its data
attributes, and specifically, get at the data-index attribute of the button
then I clicked on.
This is the index of the card I want to delete.
And so to actually do the deletion, I'll say this .props.deletecard.
I'm deleting whatever was at that index.
So I have a delete card function inside of the card Editor
that calls the delete card function that was provided to me as one of the props.
And the only difference is this function, delete card,
is going to take care of providing to the apps delete card
the index that I actually want to delete.
Yeah?
AUDIENCE: [INAUDIBLE].
BRIAN YU: Repeat that?
AUDIENCE: [INAUDIBLE].
BRIAN YU: We don't need to wrap it because we're not actually calling this
.deletecard.
I'm not saying this .deletecardI, which you could do.
I'm just saying this .deletecard.
And so that is a function that we'll run when the button is clicked.
And so there's no need to wrap that inside of an outer function.
Yeah?
AUDIENCE: Why can you find delete card twice separately
rather than just call the card function that's
defined in the app and [INAUDIBLE]
BRIAN YU: So you could do it that way.
You could wrap this in a function and say, this .props.deletecardI.
And that would work just fine.
Basically, having a function that when you call it
is going to go to props.deletecard and delete that element.
But I'm putting it separately for the efficiency reason
that I described before of not regenerating these functions over
and over.
Let's check to make sure this actually works.
So let's do test, test.
Another one, another one.
If I delete a card, all right, it gets removed.
If I I delete another card, we're able to add and delete cards
from the card Editor.
Questions about anything?
Yeah?
AUDIENCE: [INAUDIBLE].
BRIAN YU: Good question.
So the delete card function inside of the app class
is a delete card function that just takes an index and removes
whatever card is at that index.
And I had another function in card Editor
that I could have given a different name.
But it's deleting a card, so I decided to give it the same name.
And all this function is doing is it is calling the original function,
passing in which card to actually delete.
You could conceive of other models where you consolidate these
into one function.
I separated into two for the sake of separating
the behavior of deleting a card at a particular index
and responding to the fact that you clicked on a button that is supposed
to do the deleting of the card.
Though if you'd like to practice, it would be an interesting exercise
to consolidate this to just a single function.
And you can try doing it that way.
All right, so now we have the ability to edit cards.
And all that remains is this card Viewer.
And so we have this, this is the Viewer page where in theory you'd
be able to view whatever contents of the cards that you have,
because card Viewer is going to provide this cards argument that
is going to contain all of the cards in the current state.
Questions?
OK, so there's a lot of code here, a lot of interacting and moving pieces.
We have an app that is this big component that
contains within it two smaller components, a card Editor and a card
Viewer.
And there's a lot of interaction between these components.
The app is providing props to the card Editor,
providing information about the cards, providing event handlers
for what to do in order to add a card or remove a card.
And in response, the card Editor is calling a lot of those functions
that it was provided in order to say, OK, update the application state,
update the cards or change the mode from the Editor to the Viewer,
or vise versa.
So I definitely encourage you to take a look at this example--
I'll post it online in just a moment--
and try and tease it apart.
Try and figure out how it's working.
In fact, potentially try and add new features to it if you'd like.
And the main project of this afternoon is going to be to extend on this.
The first step is going to be understand the code that exists there.
But then let's think about trying to add some more possibilities.
So adding flash cards is a feature that we already have.
Displaying the flash cards in a table, the second thing
here is a feature that we already have.
And it's these last two bits that are worth trying to implement here.
Try and implement the card Viewer, some way of viewing the flash cards.
And at first, just see if you can get one flash
card to display the front of card number one, for example.
And then see if you can add some notion of,
all right, when you click on something, have an on-click handler
that flips the card over.
In other words, goes from storing the front to the back.
And you might think about the kind of state that you want to store that.
You probably want something inside your application state that's
keeping track of are you on the front of the card
or are you on the back of the card?
And when you click on the card, you just need
to flip that state around going from front to back.
In much the same way that we went from Editor to Viewer,
when you clicked on a button, you can go from front to back of the card
by clicking on the card.
You can display one card, and show the card, and flip it over to the back.
Consider a button that moves you on to the next flash cards.
So you're on card number one, you press a button,
it takes you to card number two.
And that's very similar in spirit to just this idea
of thinking about what you need to store inside of your application state.
In addition to having information about are you on the front of the card
or the back of the card, you probably also want some information
about which card are you currently on?
Some notion inside the state of I am currently
on card zero, or card one, or card two, whereby you can change that state value
in order to show a different card.
So go ahead and give that a shot.
If you manage to finish that, there are certainly
other features you can consider.
I listed a couple here.
Consider a button that will shuffle the cards and put them in a random order,
for instance.
Or marking cards as learned or not, the one you might see on a quiz app
like Quizlet, for example.
And so plenty of room to explore here as well.
Feel free to continue working on the to-do list application
if you'd like to.
The staff will be around to certainly help you up until 5:00.
And tomorrow, we're going to spend even more time on React.
So if this all seems new and unfamiliar to you,
know that tomorrow we'll be spending more time on the exact same topic
so that we can help you become familiar with it,
help you get used to the different way of thinking with regards to React.
And so all that and more with CS50 Beyond.
So we'll go ahead and turn to our afternoon project now.
Feel free to stick around here in the auditorium.
And come and find the staff if you need help with anything.