jQuery offers many methods that can help you easily manipulate the DOM.

Manipulating DOM elements can include adjusting an element's visibility

as we've already seen with the hide method, as well as adding, deleting, or

modifying the contents or attributes of an element and changing an element's styling.

One area where jQuery really shines is animation.

There are several built-in methods that allow you to use fun animations when you

add, remove, or reveal elements on a webpage.

There's fadeIn and Out which changes the opacity over time.

You can literally see through the element as it disappears or comes into view.

slideDown() and slideUp() reveal an element with a sliding motion.

There's even a method called delay() which lets you add a delay between two

animations.

For our first jQuery project,

we'll use a few of these methods to build a simple blog previewer

with a flash message that appears when the PREVIEW button is pressed.

We won't actually be building a functioning blog.

That would require back end programming, a database to store blog entries, and

a lot of complex functionality like user accounts

that are beyond the scope of this course.

Our project will simply allow the user to preview what their blog entry will look

like and let them know the changes have been saved.

Think of it as a prototype or

demonstration of a feature you'd add to a larger, more complex project.

In this video,

we'll create a flash message to learn about animation methods in more detail and

see how they can be used together to create some pretty cool effects.

A flash message is designed to show a temporary message like a warning,

confirmation, or alert to a user.

Since the message is only a temporary notification,

we wanna show it when the page loads then hide it after a few seconds delay.

Later, we'll program the message so

that it only displays once a user clicks this PREVIEW button.

But for now, the message and animation will show each time the page is refreshed.

Firstly, open up the workspace with this video to follow along with me.

If you'd rather work with your own text editor, you can download the files for

this course below.

Here we have got an index.html file, an app.js file, and

a CSS folder, which we won't be doing anything with but

it's providing some styles to make the blog previewer page look nice.

I've already included the file you'll need to use jQuery as well.

Once again,

I will show you how you can add jQuery to your own projects later on in this course.

Go ahead and go to app.js because we're all ready to start coding.

If we look at the index.html file,

we can see there’s a div at the top with an ID of flash message.

In app.js, we’ll use the ID selector to select the flash message element.

Be sure to include the hash symbol as we’re selecting an ID this time.

Let's make the message fade into view.

That means that first we need to hide the message when the page loads.

Let's save and refresh the preview to make sure it's hidden, it is, great.

Then we'll use a jQuery animation effect to fade it into view.

Let's try the fadeIn animation.

So let's save and preview the page.

As you can see, the message fades in quite quickly, only 400 milliseconds.

That's because all jQuery animations last for 400 milliseconds by default.

However, you can alter the time by passing in a value to the jQuery animation method.

To make the fade effect more obvious,

let's fade the message in over two seconds.

To do that, we'll pass 2,000 to the fadeIn method.

There are 1,000 milliseconds in each second.

So 2,000 milliseconds is two seconds.

Let's save and refresh the preview.

And the message is now appearing more slowly.

Two seconds seems a bit too slow.

Let's change it to 1,000 milliseconds, or one second.

And that's better.

Now we wanna make the flash message disappear.

Let's use the slideUp method for that.

Save the file and refresh the preview.

We'll see the message appear and disappear.

It's a nice animiation but

we aren't really allowing the user enough time to read the message.

We need to delay the animiation.

jQuery has a delay method that waits a given amount of time and

then moves up to the next animation.

I'm going to sandwich in a delay call between fadeIn and slideUp.

Let's give the user three seconds to read the message and

then slide the message out of view.

Save and preview.

The message fades in, we wait three seconds, and it disappears, awesome.

Instead of fadeIn,

let's use slideDown as that animation is complementary to the slide up animation.

Save and preview.

And that's looking pretty good.

We can get the same effect in even less code, jQuery let's you string or

chain together methods on the same element.

In other words, you can chain all the methods together like this.

Writing the code like this is more readable and

saves us from having to select the flash message div over and over again.

We can see that we select the flash message, hide it immediately,

then reveal the message with a slideDown,

wait three seconds, and then slide the message back up.

How does this work?

Most jQuery methods return the same element each time they're called.

So when the hide method is called on the flash message, jQuery hides the element,

then returns a reference to that element.

So calling slideDown next applies that animation to the message element as well.

You can think of it a bit like a factory line.

jQuery grabs the element from the page and

passes it down the line where each method does something to it.

Chaining is a nice feature of jQuery that makes your code easier to read and

write but it can also get out of hand and lead to long lines of code.

If a line of jQuery is getting too long,

you can add a new line at every method like this.

Indenting the method under the element you're performing actions on

helps with readability as well.

Feel free to play around with this and experiment with different animations and

delay times and see what fun animation sequences you can come up with.

As you just saw it, jQuery has some really nice animation methods that can add

a little flair to the user experience of your pages.

In a short amount of time and

with a relatively small amount of code, we performed a complex animation sequence.

You also saw how to write more concise code with method chaining.

You may now be starting to understand why jQuery's motto is write less, do more.