In this section, we've got a collection of interesting many Web applications to build, the first one
that we're going to be building is just a regular joke that's going to get the current joke of the day,
making a collection to the end point, returning back an object that objects to contain the joke information.
And then we're taking that joke information and putting it on the page using JavaScript.
The next project that we're going to work on is going to be a practice to connect to fetch text files.
So we've got three different text files within an array.
So loading the content of any one of the text files and outputting it to the page.
So it's simple exercise where we've got multiple endpoints and the user can interact and select which
file they want to make the request to and which files they want to return back on the page.
So it's making a fetch request, returning back the content of the text file.
The next one is that we're making Fach request to GitHub.
So this allows us to search the ghetto repositories and also get a Zen response from GitHub.
So returning back the GitHub repository information.
So the URL, the ID and just some useful information.
And this is a really good API that you can connect to in order to practice and getting data from a very
deep API.
It's got a lot of object information, so selecting that object information and outputting it to the
page.
So that also includes linking it to where the you are out is.
The next one is going to be a word scramble game and we're actually going to be getting the data from
a Google sheet.
So loading the sheet by whatever the ID is of the sheet.
So this is the sheet here and dynamically loading whatever the ID is of the sheet.
We've got the sheet content shared, so it's looping through and getting the first row of content from
the first column of the sheet.
And if we update the sheet and we refresh the project load sheet data, now we've got the new content
included within the sheep list.
So there's Lowrance and that's been added as number 12 were also because we just want a simple word
list.
We're going to be splitting the words by spaces.
So if the words do have spaces in there, it's just going to be listed as a separate object.
So now we've got the newly updated content and that's been loaded into the sheet.
So once we've loaded the data that we want to use for this word scrambled game, it's going to take
that data list.
So the new word list is loaded.
We can hit start game and that's going to start the game where we need to select.
And guess what word is this one from the 14 words that we had with in the spreadsheet.
So a way to dynamically load and generate spreadsheet information.
And then this, again, is all coming from the spreadsheet content and dynamically can be updated so
that you update your spreadsheet content and that will update that content.
Coming up next is Dummy JSON Quiz.
So this is just a simple quiz and practice generating an object array.
So we've got a number of possible answers and we've got a question and that's up to the user to pick
which one is the right one.
We can select a dynamic number of questions if we want, and this just generates some random JSON data.
So it's a practice exercise for creating dummy data and it's relatively straightforward where we've
got the question.
And then one of these answers is right.
We select the right one.
We move on to the next question.
If we select the wrong one, we get the wrong message and we can go through the quiz.
And then at the end, we're going to also be tracking the score.
So it's moving through the questions of the quiz.
And then at the end, we're able to select and get the ultimate score and then we can refresh it and
rebuild the quiz.
And this is all dynamically generated so we can update and set how many JSON questions we want.
And it's also a good practice way of constructing JSON objects.
And then the last one is going to be a YouTube search.
So if we want to search YouTube for whatever term we want to search for, it's actually going to be
searching my channel for any related content.
So it returns back from the YouTube API.
We're going to be connecting to the YouTube API and returning back the snippet information of the available
video content.
And there's a lot of information contained within the API.
So also taking that information and putting it to the page, including getting the.
Thumbnail of the video, as well as getting the details, the title and also linking it to the video,
so all of that information being returned back from the YouTube API dynamically with the search and
all of the all of the lessons are going to start with the same basic code structure and then all of
the content is going to be dynamically generated within that output div.
So they're all going to have an input button and each one tag and a development and then the rest is
going to be done with JavaScript and this is going to be the same across all of them where we've got
the basic structure that we're starting with and then the content gets generated dynamically.
So when we hit start game it populates the content using JavaScript into the output element and runs
the game within the output element.
And also for this one, the same structure once again, where we have a very simple structure and this
is reconstructed with JavaScript to update it and to be able to accommodate building out the gameplay
that we've set out with an application.
So there's a lot of really good practice exercises in this lesson.
Source code, of course, is included and one of the best ways to learn is just to try it out.
The code for yourself.
If you have any questions or comments, I'm always happy to hear from you.
So let's get started coding.