React - The Complete Guide 2025 (incl. Next.js, Redux)

AllGoodTutorials
39 followers
27 Video Views·Oct 31, 2025
Dive in and learn React.js from scratch! Learn React, Hooks, Redux, React Router, Next.js, Best Practices and way more!
Unlock 1 Month of FREE Premium Access to Our Best Courses! 🎓✨
Sign up today and elevate your skills: https://allgoodtutorials.com/supporters/pricing 🚀
(ONLY GOOD FOR THE FIRST 50 PEOPLE TO PARTICIPATE)
Learn to Code For FREE and Get Your Dream Developer Job: https://www.allgoodtutorials.com
*****************************************
Connect with me:
◾ Whatsapp: +212637648713
◾ Gmail: [email protected]
// Social Links //
Website: https://www.allgoodtutorials.com
Telegram: https://t.me/AllGoodTutorials
Hi and welcome to this course. My name
is Maxmillian Schwartzmull and I will be
your instructor in this course where I
will teach you React from the ground up
step by step and in great depth. In this
first course section here, I'll get you
started with this course and get some
organizational things out of the way
which you should know about React and
this course. And thereafter, after an
optional JavaScript refresher section
which you can take if it's been some
time since you last worked with
JavaScript, we're going to dive right in
and explore React in great detail. And
speaking of that, let's start with the
most important question. What exactly is
React?
So what is React and why exactly would
you use it? Well, if we visit the
official web page react.dev,
we get an answer. It's a library for web
and native user interfaces. So put in
other words, React is a library for
building user interfaces. That's what
React is all about. And as it turns out,
it's a JavaScript library for building
user interfaces. But that of course
still doesn't answer the other question.
Why would you use it? And the answer can
be found if you visit a web page that
uses React like for example Netflix. As
you navigate around on such a website,
you'll see that all these transitions
are super smooth, pretty much instant,
and you never have this effect where you
seem to load a new page. So, where you
seem to wait for a new page to be sent
back by the server. To some extent, it
therefore feels like a mobile app
because in mobile apps, getting instant
feedback and having smooth transitions
is pretty much the standard. And it's
libraries like React that help us build
such user experiences, such user
interfaces for the web as well. Because
React, since it's a JavaScript library,
uses JavaScript in the browser to update
the page and the user interface. we see
on that page without reloading the page.
JavaScript can do that because
JavaScript in the end runs kind of in
the background of a website and
JavaScript is able to read and
manipulate the web page after it was
loaded. So JavaScript can for example
make sure that as I click on the movies
tab, it fetches the movies data behind
the scenes in the background without
reloading or leaving the page. And it
then updates what I see on the screen
with that movies data leading to that
smooth transition between those pages.
But wait a second, since this is all
JavaScript in the end, why do we need
this React library for JavaScript?
Because as you will see in the next
lecture where I'll compare using just
JavaScript to using libraries like
React, working with just JavaScript of
course is an option, but it isn't a
great one. It's cumbersome. It means
more work for you. it can be more
errorprone and especially if you're
building more complex user interfaces
and more complex applications like this
Netflix web app then using just vanilla
JavaScript so without any library like
react would just be a huge pain and
wouldn't be a very realistic option to
be honest
so I told you that often using just
JavaScript isn't a great option and that
instead using libraries like React is
better because React offers a simpler
mental model and provides an easier way
of building complex web applications and
web user interfaces. But of course, you
don't have to believe me. That's why I
prepared two basic web applications, two
basic demo websites which essentially
have the same content, some tabs you can
click to change the content below these
tabs. But I built this application with
React and also with just JavaScript so
that we can compare these web
applications. Now I built these web
applications here with help of code
sandbox which is a in browser
cloud-based code editor and development
environment which allows you to for
example work on react projects without
installing any software or tools or
anything at all on your local system and
which therefore provides you with an
easy way of getting started with React.
And therefore attached to this lecture
you find links to these two demo
websites and you can therefore use your
browser to play around with them,
explore them and change the code in any
way you want. In case the vanilla
JavaScript version shouldn't load
correctly and the content below the
first tab might be missing, simply click
this refresh icon here and it should
reload and display this content. Now in
the vanilla JavaScript version, we got
two important files. We got the index
html file which in the end contains the
HTML elements that are responsible for
displaying the majority of this page.
And we got the index.js file which is
responsible for getting hold of these
buttons for adding click listeners to
these buttons and for then updating the
UI as these buttons are clicked and
these click listeners are triggered. Now
for this course I do assume that you do
have basic JavaScript and knowledge and
therefore I won't explain this
JavaScript code in depth here. Instead
you can simply pause the video and go
through the code on your own with help
of those links that are attached to this
lecture. And if you're struggling to
understand this code, I strongly
recommend that you do pick up some basic
JavaScript resource in addition to this
course and that you take a look at the
next course section where I give you a
JavaScript refresher. In the end, in
this code, as mentioned, I'm setting up
these click listeners and we're
executing this function here whenever a
button is clicked. And then in this
function, I'm in the end ensuring that
the clicked button receives the active
CSS class by clearing that class from
all buttons and then adding it to the
button that was clicked, which is this
event target of that click event. And
I'm displaying the content below the
button by loading the content from this
content array, which is an array that
contains more arrays inside of it.
And that selected content is then passed
to a display content function where I in
the end create a string that contains a
bunch of li elements as text. I create
an unordered list element. I clear the
tab content element below the buttons so
that then to that list I can add that
list content string as inner HTML. And I
then append that list that contains that
list content to that tab content. And
that's how this content ends up on the
screen as I switch tabs.
That's what I'm doing here in
JavaScript. And this, of course, is a
fairly trivial app here, as you can
tell. But still, nonetheless, it does
take quite some code to make this app
work this way. And of course, there
would be alternative ways of writing
this code, but I chose an approach that
hopefully is also pretty easy to
understand and follow along. Now if we
take a look at the React app, we have
the same behavior, but the code is very
different. If we take a look at this
folder, we also find an index html file
in the public folder, but this index
html file is pretty empty in the end.
Its body section only contains one div
in the end with an id of root. But this
div has no content because indeed here
in a React app, React is responsible for
rendering the entire user interface. And
it's this index.js file where the React
journey starts, so to say. Now, you will
of course learn all about React and how
it works and what this index.js file
does later in the course. So at the
moment you absolutely will not
understand everything here and that's
totally fine because this is just a
first demo to show you the difference
between React and JavaScript not to
teach you all about React in this one
single lecture. Now nonetheless you
should know that in that index.js file
we in the end select this div with an ID
root. So this div here is selected and
React takes over that div and starts
controlling the div and its content.
It's then the app.js file that contains
the important code so to say. In there
we have a function called app. And in
this function there is something strange
because we got a bunch of HTML code in
there. And that is definitely not a
default JavaScript feature because by
default if you start adding HTML code to
a JavaScript file you'll get an error.
This by default is not supported.
Now it does work in the React project
because of how this overall project is
set up behind the scenes. And later in
the course, you will also learn how to
set up such a react project locally on
your system. Here in code sandbox, it's
already set up such that it works. But
then once it is set up correctly, it's
one of the key features of React that
you can blend HTML and JavaScript code.
And if you then take a look at this HTML
code, you'll see that in here in this
app.js file, we in the end got all the
HTML code with this header and these
buttons and this unordered list that we
before found in this index html file
when working with vanilla JavaScript.
Now, it's all in that one single
JavaScript file. But what you'll also
notice is that all these JavaScript
instructions that we had in the vanilla
version are missing in the React
version. Instead, in that app.js file,
we just got that HTML code. And then in
that HTML code, we got some dynamic
elements, some dynamic pieces of code
blended into the HTML code. Now again
you'll learn all about writing such
react code later but what this code here
in the end does is it defines different
states you could say of the different
HTML elements. For example that this
button here should have an active CSS
class added to it if this active content
index thing here to which I'll get back
in a second is equal to zero. So if this
condition is met otherwise an empty
class. So no CSS class will be added.
And we have similar conditions for the
other buttons
down here where I'm outputting the
actual tab content. I have my unordered
list here as HTML in JavaScript. And
then there we got more dynamic content
where in the end we're loading such a
nested array from that content array
depending on which button was clicked.
So depending on this active content
index thing here and then all these
items in that nested array. So all these
string items here are in the end
converted to list items. Something that
also doesn't work in vanilla JavaScript
but works in React. And this is how all
these list items are in the end added to
this unordered list here. Now this
active content index thing is kind of
like a variable. It's created and
controlled with a react feature called
use state. And this in the end creates a
dynamic react managed variable you could
say that can be updated with help of
this set active content index function
here which for example gets used for
these click listeners which are also
directly added to the buttons right
inside that HTML code here. And then
it's this active content index variable
that changes and influences how the
current UI looks like because React
basically watches this variable. And
whenever it does change, it takes a look
at your HTML code here, checks all these
conditions and executes all that code
and sees if that code now should lead to
a different UI than what was rendered
before. And if a different UI is needed,
React goes ahead and updates the UI. It
does all these things automatically for
you. Because when working with React,
you in the end write declarative code,
which means you define the target UI
state or states, not the steps needed to
get there, and React will figure out how
to get there and perform the necessary
steps. So when writing React code,
you're writing code in a declarative
way. And that's a key thing to
understand and keep in mind because
that's how React works in the end. On
the other hand, when writing vanilla
JavaScript code, you're writing
imperative code, not declarative code,
which simply means you're not defining
the goal, but instead the steps needed
to get there. And as you can see in this
example, that's of course way more
cumbersome and difficult. Because even
though this here is a very basic and
simple example, we do have to find a lot
of steps to get the desired behavior and
it's easy to forget a step or introduce
some error along the way. Updating this
code and handling a fourth button also
could become unnecessarily complex. So
here we got these step-by-step
instructions and therefore this
imperative approach. In React instead,
it's all pretty lean. It's less code
that needs to be written and React takes
care of updating the UI. React uses
JavaScript under the hood to update the
UI and we instead just define our
conditions, our target states and when
these states should change and React
will take care of the rest.
So, now that we know why we might want
to use React instead of just JavaScript,
and before we start diving deeply into
React and we'll learn it from the ground
up, I already want to make sure that we
get our hands dirty and that we actually
start working on our first React app,
even though we don't really know a lot
about React yet. But from what we've
seen thus far, we might be able to solve
the following tasks. And it all starts
with a new updated demo app. And for
that, attached to this lecture, you find
another link leading to another React
web app on code sandbox. And of course,
it's pretty much the same app as before,
but I actually updated this content
array here. And I added a new fourth
nested array in that content array. And
that fourth array inside of this content
array will become important for this
exercise. which is why you should follow
that link you find attached to this
lecture because in this updated app the
goal now is to add a fourth button with
any text of your choice doesn't really
matter but when this fourth button is
clicked the content for this button so
this fourth entry in this content array
should be loaded and displayed on the
screen now implementing this of course
will be challenging because you don't
really know React yet despite the last
lecture
But definitely feel free to pause the
video at this point and try solving
these tasks on your own before then
after a short pause, we'll solve it
together. If you can't solve it, by the
way, no worries. We're just getting
started and you haven't learned React
yet. So that's absolutely fine. But
still, you might want to give it a try.
So did you succeed? Let's try it
together. For this, of course, it's
important that you're using this updated
version which you find attached where
you do have this extra entry in this
array. And then with that, we can go
down to the buttons and add another
button here to this menu. And for that,
I'll just copy one of the existing
buttons and paste it in here. Maybe at
the end of the menu, but the exact
position doesn't matter.
And I'll give it a text of React
versusJS. though that text of course is
up to you.
Now we got this button here. If I now
click this button, I actually get a
strange behavior though because now the
third and the fourth button seem to be
active simultaneously and I do load the
content of this third button. Now we do
get this behavior here because of course
I copied this third button and I kept
all the logic that was on this button.
But now we need to adjust this logic on
this new fourth button. For example,
here for this click listener in this
function that's executed when that click
occurs, we should set the active content
index to three to select the fourth item
in this content array because as you
know in JavaScript arrays start with the
index zero. So that in the end will make
sure that we for example down here will
use the fourth item in this array by
using the index three.
Here in this condition we also should
compare the active content index to
three. Therefore to make sure that this
button here only receives the active
class if the content index is three. And
that actually is all. Then if you save
that maybe reload here though it
shouldn't be required. You should be
able to now select this button and see
the content for this button and have
only that button being active. So now
all the buttons work as intended. This
fourth button included and therefore we
got our hands dirty. We wrote our first
lines of React code and we solved these
tasks here. And of course, as mentioned
before, if you were not able to do this
on your own, that is absolutely fine and
absolutely to be expected because you
haven't even learned React yet. I
haven't taught you React yet. I just
showed you one basic first example and
we're going to learn React from the
ground up in this course, of course. So,
no worries if you were not able to do
this on your own yet.
So with all that, you now got started
with React and you learned why you might
want to use React and what its core
philosophy is in the end. This
declarative approach. Now I want to
briefly introduce you to this course and
explain what you can expect from this
course. And as you can tell by taking a
look at the course curriculum, it's of
course a huge course packed with
content. And you can think of the
content in this course as two main
packages, you could say, because we'll
start by setting a solid foundation.
And the next core sections, the first
couple of core sections will all be
about introducing you to these
fundamental React concepts you must know
like components, JSX, props, state,
events, styling components, hooks,
debugging, and much more. You will learn
all these things over the next sections
and you will therefore have a solid
React foundation once you finished those
sections.
Thereafter, we'll dive into many
advanced concepts which you also must
know as a React developer. We'll dive
into concepts called refs, portals, how
to handle side effects and what side
effects are into advanced hooks and what
hooks are, custom hooks, HTTP, Redux,
routing, index.js, JS authentication and
much more. This course is huge and the
course curriculum of course allows you
to dive into the content you're most
interested in. Though I will say that
the different course sections of course
build up on each other. So I do
recommend that you simply complete the
course lecture by lecture, section by
section. Now, in addition to all the
video lectures in this course, you'll
also find plenty of quizzes, coding
exercises, assignments, and demo
projects in this course, allowing you to
practice what you learned. And I of
course recommend that you do use these
practice opportunities because only
practice makes perfect. And therefore,
if you do go through the video lectures
and all the course sections and you do
dive into all the quizzes and exercises
and so on, you'll be a React developer
by the end of this course.
Now, this course is packed with content,
but this course also comes with two
optional paths you can take. The main
path you can take is the standard path,
which is the path I recommend for most
students. For this path, you simply
continue. You start in lecture one and
section one, and you go through the
entire course, lecture by lecture,
section by section, in the order you
find in the curriculum. This way, you'll
learn all about React in great detail,
step by step, in the right order. But if
you're in a hurry or if you already know
React and you just want a refresher, you
could also consider finishing section
one and then jumping right ahead to
section 30. Attached to this lecture,
you also find a link that will directly
take you to that section if you want to
follow that fast track path because this
course section will then give you just
the React essentials. less deep dives,
less advanced concepts, less examples,
but you'll get those essentials. And
therefore, if you don't have that much
time or you don't want to go through the
entire course, this fast track path and
this dedicated section is for you. By
the way, this React summary section will
also be interesting for you if you did
complete the standard path because if
you completed that path and you then
want to revisit the core React concepts,
you can also use this React summary
section.
Now, obviously this course has a lot of
content, but I want to make sure that
you also get the most out of this
content. And of course, since this is a
videobased course, this all starts with
watching the videos, but watch them at
your pace. Use the video player controls
to slow me down if I'm going too fast or
speed me up if I'm going too slow. Also,
take advantage of the fact that this is
a ondemand video course. Watch the
videos whenever you have time for them.
There is no time pressure on you. In
addition, feel free to repeat videos or
even entire sections if certain concepts
aren't clear immediately. Pause the
videos from time to time and try out
things on your own because that is how
you will get the most of this
video-based course. And that's in
general a recommendation I have for you.
Code along and practice what you
learned. Also, practice what you learned
in your own projects. There are plenty
of demo projects and examples in this
course. But you of course absolutely
should also come up with your own basic
example projects and try building those
with React with the React knowledge you
gain in this course because only
practice makes perfect. Now, this course
also comes with some course resources,
namely the slides which you can download
and various code snapshots which you can
use to compare your code to mine in case
you're getting stuck at some point. And
attached to this lecture, you'll find a
link to GitHub which I'm using as a code
repository for those code snapshots and
materials. And you'll find instructions
on how to use this repository and how to
get to the code snapshots on that page.
In the end, it comes down to selecting
different branches for different course
sections. And then in the different
branches, once you selected them, you'll
find the slides for that branch and also
the code snapshots for that branch.
That's how this works. In addition, as
you complete this course, at the end of
every course section, you'll find a
module resources lecture which will
provide a direct link to the resources
of the section you just completed. Now,
last but not least, you're also not
alone. This course comes with a Q&A
section where you can ask questions, but
where you should also try answering the
questions of other students. Because by
helping others with their problems, you
will learn even more because you're
forced to think about a certain problem
and come up with a solution. And even if
your solution should turn out to be
wrong, you'll learn even more from the
feedback you'll get there. So asking and
answering in the Q&A section is a great
way of sharing knowledge and finding
help. In addition, this course also
comes with access to our Discord
community to which you find a link in
the lecture after this lecture and you
can then also join this community
totally for free to find fellow
developers and learn and grow together.
A couple of lectures ago, we saw our
first React project in action, and we
actually already worked on that first
project. Now, as you might imagine,
we're going to work on many React
projects throughout this course. And of
course, those projects in order to work
on them first must be created. Now, I
will say that whenever we're starting a
new project in this course, I will
provide a starting snapshot to you.
You'll find it attached to the lecture
where the project is created and I will
also let you know that attached you find
such a starting snapshot. So you will be
able to use these starting snapshots to
get working React projects. Nonetheless,
as a React developer, you should of
course also know how you can create
React projects on your own. And when it
comes to that, you basically have two
main options. You can either create
projects locally on your system so that
all the project files are created on
your hard drive and any software needed
to run that project is installed on your
system. And therefore, of course, you
also must install any tools or packages
that are required to run a project and
you must have all these project files on
your system. Or alternatively you can go
for a browserbased a remote react
project solution in the end for example
with help of services like code sandbox
which is the service I also used earlier
in this section for this first react
project I showed you.
When using such a remote solution, such
a browserbased React project, you don't
need to install anything on your local
system and you don't need to create any
files on your local system. Instead, all
the React project files as well as any
extra tools that might be required
behind the scenes will be provided and
hosted by that remote project provider.
So, by code sandbox for example. And
when it comes to these project snapshots
you find attached to the course, I will
also always offer you both options. A
zip file which you can download as a
local React project or a code sandbox
link that will take you directly to a
React project running on code sandbox.
So running in the browser with which you
can get started without installing
anything on your system. Therefore, the
great advantage of such a browserbased
React project is, of course, that it's
super fast to get started with it. The
advantage of a local setup is that you
have more configuration options. You can
use exactly the code editor you want to
use with exactly the settings and
extensions you might want to use. And I,
for example, prefer local React projects
because I want that full control over
them. In addition, when it comes to
recording a course like this, recording
those videos simply is easier with a
local setup where I can arrange
everything exactly as I want it to be
arranged. But for following along, such
a browserbased setup can definitely be a
great alternative. There though you have
to live with the general layout and
configuration options that are given to
you and you have less control over the
project setup and configuration. Now in
the next lecture I will show you how you
can create a brand new React project
locally on your system and therefore you
can of course skip this lecture if you
don't want to do that. In the lecture
thereafter I will do the same for the
browserbased alternative. So for
creating a project with code sandbox
now using a browserbased react project
has certain advantages. For example,
it's instantly available but it also has
disadvantages. For example, you only
have limited control over the general
layout of that browser editor. And you
can also only configure the things this
browserbased editor allows you to
configure. If you want full control, you
need a local React project. And as
mentioned before already, whenever we
start a new React project in this
course, you'll find a starting snapshot
attached to the lecture where we create
that project.
It'll typically be such a zip file which
you can simply download onto your system
and extract. And then in there, you'll
find a React project with which you can
work. Now, in order to run this React
project and for example start a
development server which allows you to
preview the React app whilst you're
working on it, you will need to install
NodeJS though. So, you need to install
this extra software onto your system.
And you can simply visit nodejs.org
to download NodeJS from there. You can
either use the latest or the LTS
version. That shouldn't matter. You can
download it from there. It is available
for all operating systems and it will
automatically pick the right installer
for your operating system. And once you
did download and install NodeJS by
simply walking through the installer
this page gives you, you'll be able to
start such an attached project snapshot.
For that, you should open the downloaded
project snapshot in your favorite code
editor. For example, in Visual Studio
Code, which is an amazing free-touse
code editor that is available for all
operating systems, you can simply
download and install it on your system
to open React projects with it. And
inside of Visual Studio Code, you can
then browse these code files. And you
can also tweak Visual Studio Code
exactly to your liking by going to the
settings there and for example choosing
a color theme by tweaking the keyboard
shortcuts and the general settings. You
can also change the appearance of Visual
Studio Code under view and for example
make sure that you have a status bar at
the bottom or you maybe don't have it.
So that's what I mean. you have full
control over how it looks and behaves
and definitely take some time to play
around with Visual Studio Code to
configure it in exactly the way you want
it to configure. Now, two things I would
recommend that you tweak about Visual
Studio Code locally on your system is
for one that you go to the keyboard
shortcuts and then there you should
search for the format document shortcut
and make sure you bind this command to a
convenient shortcut because whenever you
press that shortcut then it will
automatically format your code making it
more readable which is super convenient.
In addition, and kind of related to
that, you should also go to the
extensions area of Visual Studio Code
because this code editor allows you to
install third-party extensions. And
there you can of course install any
extensions you want, but I do recommend
that you install the prettier extension,
which helps this code formatting command
in the end because this extension and
this command will make your life as a
React developer a bit easier. Now, if
you want to run such a downloaded
project snapshot, you'll have to open a
new terminal in Visual Studio Code,
which simply opens your default system
terminal or command prompt just
integrated into Visual Studio Code here
and already navigated into this project
folder. And then as a first step, you'll
have to run npm install, a command which
will only work if you did install
NodeJS.
because this npm command is part of
NodeJS.
Now when you run npm install, it will go
ahead and install any extra dependencies
and packages that are required by this
project in order to run correctly. For
example, it will download and install
the React library into this project.
Those dependencies are not part of the
attachment because they are pretty big
and they would unnecessarily bloat the
zip files.
Now you only need to run npm install
once after you downloaded such a
project. Thereafter you just need to run
npm start to start this development
server which allows you to preview the
react application.
For that you then just have to visit the
address that is shown here. And there
you should then see the sections
starting project.
Now, what's really nice about this
development server is that as long as
it's up and running, whenever you change
anything in your code and you save that
file, it will automatically update the
website and reflect your changes there.
So, you should keep this process up and
running as long as you're working on
your code. And whenever you're done for
the day, you can simply quit it by
pressing Ctrl C. You can then, of
course, always restart it with npm start
if you want to continue working.
So that's how you can use those project
snapshots which you find attached to the
course. But of course sometimes you also
want to create a brand new React
project. And for that you can for
example use a tool called create react
app which you should find if you search
for a create react project. On the
official website of that tool you get
instructions on which command to run to
create a new React project. And as you
can see, it's just one simple command
you have to run. This command must be
executed in your system terminal or
command prompt. And there you should
first navigate into the folder where you
want to create your React project with
help of the cd command. And once you are
in the place where your project should
be created, you can paste in this
command and then give this project any
name of your choice like for example
react complete guide. And once you hit
enter, it will go ahead and create a new
folder with that name and create a React
project inside of that folder.
Now, important for this command to
succeed, you also must have NodeJS
installed on your system. Now, you can
then also open such a project with
Visual Studio Code, and you'll find
basically the same folder structure as I
have it in the code snapshots I'm
providing to you. Now in this project
here, you don't need to run npm install
because that was already done as part of
this npx create react app process.
Instead, you can right away run npm
start to start the development server.
And then once you visit this address,
you should see a react project that
looks something like this.
Now to conclude this lecture I also want
to note that you could alternatively
also use a tool called vit to create
react projects and if you search for vit
create react project you'll find the
official documentation which then also
lets you know which steps to follow to
create a react project with v. In the
end it's up to you which tool you want
to use. They all give you React projects
and the React code you'll write will be
the same either way. But with that, you
now also know how you can create a React
project locally on your system and you
therefore can go with whichever approach
you personally prefer.
Now, as mentioned in the last lecture,
throughout this course, I will typically
provide starting snapshots to you. So if
you want to follow along with code
sandbox, you would simply use the code
sandbox starting project link and you
get a preconfigured React project with
which you can get started right away.
But of course, you should also know how
you can create a brand new project with
code sandbox. And it is actually super
simple. You just have to type react new
in your browser address bar and hit
enter. and it will immediately take you
to code sandbox and open up a new react
project for you there. So with that you
then therefore also got a almost
instantly available react project in
which you can work. Now in this code
sandbox editor, you'll find the files
area here to the left with all your code
files. And you can also create new files
and folders with help of these buttons
here, including nested files and
folders. If you use these buttons on
existing folders,
you can install dependencies down there.
something you won't have to do initially
in the first couple of course sections
but later in the course you will for
example have to install the React Router
DOM package and when using code sandbox
you would do this here in this
dependencies area by entering the
package name and picking it from the
drop-down but again that's not something
you'll need in the first course
sections.
Then of course you got your code editor
for the selected file in the middle here
and a live preview of your React
application on the right here. So this
is your React website based on your
React code here running in this right
area of the code sandbox editor. You can
of course resize those windows and you
can also dive into the code sandbox
settings by clicking on this menu icon
here and then going to file preferences.
And then you have some general code
editor settings and some code sandbox
specific settings.
Simply take a look through these
settings and make sure you configure
them in exactly the way you want to
configure things. You will have less
options available than in a local setup,
but you can tweak quite a lot of things.
Now, in addition, when you are on code
sandbox here, you also might want to
consider creating an account because
that will then allow you to run more
code sandboxes.
And that's how you can follow along in
your browser without installing anything
on your system.
