Javascript Tutorial - Continuous Pagination

Woah there, what's this! A Javascript tutorial!? Yes, I know its been a while since a Javascript tutorial graced the pages of Switch On The Code - but what can I say? I kind of got bored with writing them. And so, after a few month hiatus (and a couple fresh ideas for tutorials), they are back.

So what is on the plate for today? Well, we are going to take a look at how to implement continuous pagination in javascript. What is continuous pagination, you ask? That's a very good question, and it's actually a little bit difficult to describe. Say you have a list with a large number of entries - much more than you would want to load and display at once. The general tactic would be to paginate them - display 10-20 at once, and then have the user click 'next' to see the next 20, and so on and so forth.

But if for the most part, the user is just quickly scanning through these entries, this can get annoying. The user has to click and wait for the next batch of entries to load every time that they are done with the current set. Continuous pagination gets rid of this problem. As the user approaches the end of the entries currently displayed, the next entries are requested asynchronously and appended to the end of the list displayed to the user. This way, the user never has to do anything directly to get the next entries - they are just always there waiting in the list when they are needed!

A great example of this behavior is on the site DZone (which, besides showing off the behavior I'm talking about, is a great developer resource - if you haven't been there, you should check it out).

But of course, we aren't here just to talk about someone else's implementation - we are here to write out own! Below, there is a small example that we are going to create today. As you scroll down to the bottom, it will go off, load more elements, and append them to the bottom.

Ok, now that you're done having fun scrolling, we can drop right into the code. First, the basic html structure:

Really not much there - and the element we care about at the moment is the inner div, the 'scrollContainer'. It is a normal div, except that we have attached the method OnDivScroll to the event onscroll. As you might expect, the onscroll event is fired whenever the div is scrolled. So let's take a look at this OnDivScroll method:

So first, we go and grab the scrollContainer element. Then we check the current scroll position against the total scrollable height of the element. The only oddity is that the property scrollTop gives the current scroll position in terms of the top of the element - which means that scrollTop can never be bigger than scrollHeight minus the actual height of the element. In this case, we are checking to see when scrollTop is within 800 pixels of scrollHeight. If it is, we are close enough to the bottom that we want to load more elements. This value of 800 is completely dependent on what you think feels right for your application - in this case, I just got the number by multiplying the actual height of the element by 2.

Once we know that we should load more elements, we grab ahold of the little loading div element. Then we check if it is currently being displayed or not. If it is being displayed, then we must have already dispatched a request for more elements in a previous OnDivScroll call. Otherwise, we display the loading div, and we call the function LoadMoreElements.

It is in this function that you would do an AJAX callback to request more elements from the server. Since this is just a little demo app (and I didn't want to write any server side code), we just simulate this action by using a setTimeout call. Why is this mostly equivalent to doing an actual callback? Well, an actual callback will take time, and occur asynchronously, and that is what the setTimout call here is doing for us.

So, after a bit of time, the server returns with some elements (or, in the case, the setTimeout executes our function):

In this case, again, since there is no actual server results, we are just generating new entries and adding them. Potentially, this callback would have an argument (the server response), and you would parse the response and add all the contained elements. Oh, and don't forget to set the loading div to be invisible again.

And there you go! That is all you need to do continuous pagination. Here is all the code together in a single block for your viewing pleasure:

If you would like, you can download a simple html file with this example here. As always, fee free to leave any questions or comments below.