text
stringlengths 1
81
| start
float64 0
10.1k
| duration
float64 0
24.9
|
|---|---|---|
out the information for each slide.
| 1,578.93
| 4.96
|
And so now let's go ahead
and implement that slideshow.
| 1,583.89
| 3.652
|
And so in order to do
that, we might have
| 1,587.542
| 1.708
|
something like where we have a
slide, which might take an array,
| 1,589.25
| 10.52
|
or it might take an object.
| 1,599.77
| 1.26
|
Let's call it a slide.
| 1,601.03
| 2.916
|
And what will it return?
| 1,603.946
| 2.454
|
Well, it should return a div.
| 1,606.4
| 3.597
|
Maybe inside it we have that H1.
| 1,609.997
| 1.333
|
Then maybe we have that unordered list.
| 1,615.16
| 1.64
|
And then go ahead and close that div.
| 1,619.359
| 1.541
|
So what goes in the H1 here?
| 1,626.26
| 2.37
|
Well, maybe we should
have that slide's title.
| 1,628.63
| 5.31
|
And what about generating those bullets?
| 1,633.94
| 2.1
|
Well, like we did in
the previous example,
| 1,636.04
| 1.75
|
we might want to do the
slide.bullets and map [? overflows ?]
| 1,637.79
| 4.01
|
to create those list items.
| 1,641.8
| 2.16
|
So for each bullet, just go
ahead and create a list item
| 1,643.96
| 6.196
|
where you have that bullet.
| 1,650.156
| 1.124
|
And so now we declared
exactly what a slide is.
| 1,657.25
| 2.48
|
Well, a slide takes in
an object representing
| 1,659.73
| 2.79
|
the slide in the same shape
of the object up here.
| 1,662.52
| 6.03
|
And then it just returns the same
HTML that we had in the other example.
| 1,668.55
| 3.81
|
It's a div that wraps
in H1, where we stick
| 1,672.36
| 2.04
|
in the title, an unordered
list that has some list
| 1,674.4
| 3.06
|
items that represent those bullets.
| 1,677.46
| 2.409
|
And now how might we
create that slideshow?
| 1,679.869
| 1.791
|
Well, maybe we just do for
each slot in the slides,
| 1,688.45
| 7.08
|
maybe we have an outer-wrapping
div that maps through the slides.
| 1,695.53
| 7.44
|
And for each slide, we actually
just use the slide down there.
| 1,705.79
| 5.23
|
So now we're going to get ahead
and use React and generate
| 1,724.29
| 5.36
|
basically the same HTML as
we had in the previous one.
| 1,729.65
| 3.12
|
But now say we wanted to change
the styling of the title.
| 1,732.77
| 3.33
|
How would we do that?
| 1,736.1
| 1.48
|
Well, that's just right here.
| 1,737.58
| 2.33
|
What about if we wanted to
change the structure of how
| 1,739.91
| 2.25
|
we created those bullets?
| 1,742.16
| 2.64
|
In the previous example, if we wanted
to wrap the list items in a div,
| 1,744.8
| 3.469
|
it would be many, many lines of code.
| 1,748.269
| 1.541
|
But here, it's just
you stick a div here,
| 1,749.81
| 2.79
|
because this is basically an
abstract component that says,
| 1,752.6
| 3.18
|
if we wanted to create a slide,
here's exactly how we do it.
| 1,755.78
| 2.52
|
Just make sure to pass me a
slide of the correct shape.
| 1,758.3
| 4.2
|
And so the React paradigm is
to take a very complex problem
| 1,762.5
| 3.3
|
and break it down into
small chunks like this
| 1,765.8
| 2.28
|
that each solve a discrete
problem in that UI.
| 1,768.08
| 4.29
|
Any questions so far?
| 1,772.37
| 1.23
|
Cool.
| 1,781.3
| 0.8
|
So another great thing is
that React is very performant.
| 1,782.1
| 3.29
|
We just write what we
want, and React will
| 1,785.39
| 1.75
|
do the hard work of
playing with the DOM,
| 1,787.14
| 2.67
|
or changing things so
that what we have written
| 1,789.81
| 3.33
|
matches with what we
have showing on the page.
| 1,793.14
| 3.34
|
And so the way it does this is through
an algorithm called reconciliation.
| 1,796.48
| 7.1
|
And this is the process by which
React syncs any changes in app state
| 1,803.58
| 3.06
|
to the DOM.
| 1,806.64
| 1.92
|
So what's great about
React is that it actually
| 1,808.56
| 2.64
|
maintains what's called a virtual DOM.
| 1,811.2
| 2.67
|
And so the slow thing
about playing with the DOM
| 1,813.87
| 3.3
|
is that anytime you destroy elements
or create new elements, that
| 1,817.17
| 3.45
|
takes a relatively long amount of time.
| 1,820.62
| 3.33
|
And so the way that React
says, maybe we should do this
| 1,823.95
| 3.36
|
better by rather than
changing stuff in the DOM
| 1,827.31
| 2.779
|
every time we want to change something,
what if we just stored everything
| 1,830.089
| 3.041
|
in memory?
| 1,833.13
| 1.009
|
And then with any
changes, we can just say,
| 1,834.139
| 1.791
|
hey, how does this differ
from what's shown on the page?
| 1,835.93
| 2.53
|
And only change what's necessary.
| 1,838.46
| 2.03
|
And so that's what's done in
the reconciliation process.
| 1,840.49
| 3.03
|
So first, anytime your
data changes, React
| 1,843.52
| 3.11
|
will reconstruct that virtual DOM.
| 1,846.63
| 3.12
|
Then it will diff that DOM against
what's actually there in the real DOM.
| 1,849.75
| 6.12
|
And it'll make only the
changes that are needed.
| 1,855.87
| 2.784
|
Of course, there is an asterisk
that goes along with that,
| 1,858.654
| 2.416
|
but in your mental model,
you can just think of it
| 1,861.07
| 2.083
|
as React will just only make
the changes as necessary.
| 1,863.153
| 5.377
|
So how the heck do we write React?
| 1,868.53
| 3
|
Well, there's this
thing called JSX, which
| 1,871.53
| 2.46
|
is short for JavaScript and XML, which
is basically just an XML-like syntax
| 1,873.99
| 4.44
|
extension of JavaScript.
| 1,878.43
| 2.349
|
It's great because it just
transpiles directly to JavaScript.
| 1,880.779
| 2.541
|
So as we talked about
in an earlier lecture,
| 1,883.32
| 2.7
|
the paradigm now is to rather than just
writing JavaScript by hand, using ES5
| 1,886.02
| 4.26
|
directly, we can write
in these other languages
| 1,890.28
| 2.31
|
that just transpile back to JavaScript.
| 1,892.59
| 2.64
|
So JSX is an extension to that
JavaScript syntax, which will just
| 1,895.23
| 3.63
|
compile back down into JavaScript.
| 1,898.86
| 2.7
|
And so tags defined in JSX, XML looks
exactly like HTML with the tags.
| 1,904.99
| 6.06
|
Lowercase tags are treated
as HTML or SVG tags,
| 1,911.05
| 3.69
|
whereas things uppercase are
treated as our custom components.
| 1,914.74
| 4.136
|
And what the heck is a component?
| 1,918.876
| 1.374
|
Well, a component is just a function,
a function that returns a node.
| 1,920.25
| 3.387
|
What's a node?
| 1,923.637
| 0.583
|
It's something that React can render.
| 1,924.22
| 2.04
|
For example, like a div or a
span or a string or a number.
| 1,926.26
| 3.99
|
And components will receive
an object of properties
| 1,933.31
| 3.51
|
that are passed to this element.
| 1,936.82
| 2.25
|
So going back to the example
that we were doing before,
| 1,939.07
| 3.15
|
see how one, we declared a
const called slide down here.
| 1,942.22
| 5.24
|
And notice how I
uppercased that S. That was
| 1,947.46
| 2.35
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.