https://angularfirebase.com/lessons/simple-firebase-pagination-with-angularfire2/

Learn how to navigate between collections using a simple technique for Firebase pagination with AngularFire2.
2024-02-04T08:29:40.126Z
nova-2
2-general-nova
2024-01-09.29447
30089e05-99d1-4376-b32e-c263170674af
f3e36340-0ac2-47ed-b7e0-456486aa4428
b4254bdb7797e97250a10954b6ad77a39bc93366cfde3ecfeeb810b3b22626a7
67875a7f-c9c4-48a0-aa55-5bdb8a91c34a
deprecated
In this episode we're going to build a simple pagination feature using Firebase and the AngularFire 2 package.
This solution allows the user to click a next or a previous button to navigate through a Firebase list observable.
The benefit of this approach is that it can be applied to a dataset of any size, but the drawback is that it's impossible to really implement page numbers for pagination.
In the database, we have a series of comments nested under their associated post ID.
Let's start by retrieving a Firebase list observable from the service.
First we import the AngularFire database And then we build a function that will take a post ID, an offset, which is the number of comments we want to retrieve, and a start key, which is where we'll start the actual query.
In Firebase, we can't use a numeric offset like you would in a SQL database, so we keep track of the key and use that as the offset point for each query.
The key for the next page is determined by grabbing one extra comment from the database and we use that comment's Its key is the offset point for the following page.
Now we can start building the component.
In the template we're going to loop through a list of comments, but notice we're not using the async pipe because we're actually going to unwrap the observable in the components type script.
We also had a couple buttons just for navigating between the next and previous pages.
We also want to disable these buttons if there isn't a next or a previous page to navigate to.
In the TypeScript, we start by injecting the comment service and we also import lodash, which we'll be using to do a lot of the array operations in this implementation.
The comments variable will hold the actual comments from the observable.
The offset will be the number of comments we display on each page.
The next key is where we offset the actual database query.
And the previous keys will be a running list of every key for the previous page.
Now we create another function to retrieve the comments And we'll start by subscribing to the observable from the service.
When we pass it an undefined key, It'll just pull the very first page from the database.
The emitted value is going to be an array of comments.
We'll go ahead and Slice the array with the first two comments to show to the user, and then the 3rd comment will be the offset for the next page.
And if that comment doesn't exist then we'll just disable the button in the actual template.
We're using the lodash get function to Call this key without raising an error if it doesn't actually exist.
Now we can run this function with n g on a net and that'll populate the first page of comments.
We also use it in our next page function, But this time we pass it the key for the next page.
So at this point we can navigate forward, but the tricky part is going backwards.
Anytime the next page function is triggered, we save the current key in an array.
It's only when the user starts going backwards that we Dart popping off the last element that was added to this array, similar to a stack data structure.
We know the user is back on the first page once the array is empty.
After we update the previous keys array we can then load the comments for that page.
If we go back to the app now we can see we can navigate through the comments using the Next and Previous buttons and they're disabled when we Reach the end or the beginning of the list.
If you want to learn more about pagination and different possible implementations, check out the link in the description.
That's it for this episode.
If you found the video helpful, please like and subscribe.
And if you wanna support the channel, Consider becoming a pro subscriber at angularfirebase.com.
For just a few bucks a month, you'll get access to exclusive content as well as free 1 on 1 project consulting.
Thanks for watching and I'll see you next time.

Speaker 0: In this episode we're going to build a simple pagination feature using Firebase and the AngularFire 2 package. This solution allows the user to click a next or a previous button to navigate through a Firebase list observable. The benefit of this approach is that it can be applied to a dataset of any size, but the drawback is that it's impossible to really implement page numbers for pagination. In the database, we have a series of comments nested under their associated post ID. Let's start by retrieving a Firebase list observable from the service.

First we import the AngularFire database And then we build a function that will take a post ID, an offset, which is the number of comments we want to retrieve, and a start key, which is where we'll start the actual query. In Firebase, we can't use a numeric offset like you would in a SQL database, so we keep track of the key and use that as the offset point for each query. The key for the next page is determined by grabbing one extra comment from the database and we use that comment's Its key is the offset point for the following page. Now we can start building the component. In the template we're going to loop through a list of comments, but notice we're not using the async pipe because we're actually going to unwrap the observable in the components type script.

We also had a couple buttons just for navigating between the next and previous pages. We also want to disable these buttons if there isn't a next or a previous page to navigate to. In the TypeScript, we start by injecting the comment service and we also import lodash, which we'll be using to do a lot of the array operations in this implementation. The comments variable will hold the actual comments from the observable. The offset will be the number of comments we display on each page.

The next key is where we offset the actual database query. And the previous keys will be a running list of every key for the previous page. Now we create another function to retrieve the comments And we'll start by subscribing to the observable from the service. When we pass it an undefined key, It'll just pull the very first page from the database. The emitted value is going to be an array of comments.

We'll go ahead and Slice the array with the first two comments to show to the user, and then the 3rd comment will be the offset for the next page. And if that comment doesn't exist then we'll just disable the button in the actual template. We're using the lodash get function to Call this key without raising an error if it doesn't actually exist. Now we can run this function with n g on a net and that'll populate the first page of comments. We also use it in our next page function, But this time we pass it the key for the next page.

So at this point we can navigate forward, but the tricky part is going backwards. Anytime the next page function is triggered, we save the current key in an array. It's only when the user starts going backwards that we Dart popping off the last element that was added to this array, similar to a stack data structure. We know the user is back on the first page once the array is empty. After we update the previous keys array we can then load the comments for that page.

If we go back to the app now we can see we can navigate through the comments using the Next and Previous buttons and they're disabled when we Reach the end or the beginning of the list. If you want to learn more about pagination and different possible implementations, check out the link in the description. That's it for this episode. If you found the video helpful, please like and subscribe. And if you wanna support the channel, Consider becoming a pro subscriber at angularfirebase.com.

For just a few bucks a month, you'll get access to exclusive content as well as free 1 on 1 project consulting. Thanks for watching and I'll see you next time.
In this episode we're going to build a simple pagination feature using Firebase and the AngularFire 2 package. This solution allows the user to click a next or a previous button to navigate through a Firebase list observable.
The benefit of this approach is that it can be applied to a dataset of any size, but the drawback is that it's impossible to really implement page numbers for pagination. In the database, we have a series of comments nested under their associated post ID. Let's start by retrieving a Firebase list observable from the service. First we import the AngularFire database And then we build a function that will take a post ID, an offset, which is the number of comments we want to retrieve, and a start key, which is where we'll start the actual query. In Firebase, we can't use a numeric offset like you would in a SQL database, so we keep track of the key and use that as the offset point for each query.
databases
The key for the next page is determined by grabbing one extra comment from the database and we use that comment's Its key is the offset point for the following page. Now we can start building the component. In the template we're going to loop through a list of comments, but notice we're not using the async pipe because we're actually going to unwrap the observable in the components type script. We also had a couple buttons just for navigating between the next and previous pages. We also want to disable these buttons if there isn't a next or a previous page to navigate to. In the TypeScript, we start by injecting the comment service and we also import lodash, which we'll be using to do a lot of the array operations in this implementation. The comments variable will hold the actual comments from the observable. The offset will be the number of comments we display on each page. The next key is where we offset the actual database query. And the previous keys will be a running list of every key for the previous page. Now we create another function to retrieve the comments And we'll start by subscribing to the observable from the service. When we pass it an undefined key, It'll just pull the very first page from the database. The emitted value is going to be an array of comments. We'll go ahead and Slice the array with the first two comments to show to the user, and then the 3rd comment will be the offset for the next page. And if that comment doesn't exist then we'll just disable the button in the actual template. We're using the lodash get function to Call this key without raising an error if it doesn't actually exist. Now we can run this function with n g on a net and that'll populate the first page of comments. We also use it in our next page function, But this time we pass it the key for the next page. So at this point we can navigate forward, but the tricky part is going backwards. Anytime the next page function is triggered, we save the current key in an array. It's only when the user starts going backwards that we Dart popping off the last element that was added to this array, similar to a stack data structure. We know the user is back on the first page once the array is empty. After we update the previous keys array we can then load the comments for that page. If we go back to the app now we can see we can navigate through the comments using the Next and Previous buttons and they're disabled when we Reach the end or the beginning of the list.
If you want to learn more about pagination and different possible implementations, check out the link in the description. That's it for this episode. If you found the video helpful, please like and subscribe. And if you wanna support the channel, Consider becoming a pro subscriber at angularfirebase.com. For just a few bucks a month, you'll get access to exclusive content as well as free 1 on 1 project consulting. Thanks for watching and I'll see you next time.
youtube
customer support
In this episode we're going to build a simple pagination feature using Firebase and the AngularFire 2 package. This solution allows the user to click a next or a previous button to navigate through a Firebase list observable. The benefit of this approach is that it can be applied to a dataset of any size, but the drawback is that it's impossible to really implement page numbers for pagination. In the database, we have a series of comments nested under their associated post ID. Let's start by retrieving a Firebase list observable from the service. First we import the AngularFire database And then we build a function that will take a post ID, an offset, which is the number of comments we want to retrieve, and a start key, which is where we'll start the actual query. In Firebase, we can't use a numeric offset like you would in a SQL database, so we keep track of the key and use that as the offset point for each query. The key for the next page is determined by grabbing one extra comment from the database and we use that comment's Its key is the offset point for the following page. Now we can start building the component. In the template we're going to loop through a list of comments, but notice we're not using the async pipe because we're actually going to unwrap the observable in the components type script. We also had a couple buttons just for navigating between the next and previous pages. We also want to disable these buttons if there isn't a next or a previous page to navigate to. In the TypeScript, we start by injecting the comment service and we also import lodash, which we'll be using to do a lot of the array operations in this implementation. The comments variable will hold the actual comments from the observable. The offset will be the number of comments we display on each page. The next key is where we offset the actual database query. And the previous keys will be a running list of every key for the previous page. Now we create another function to retrieve the comments And we'll start by subscribing to the observable from the service. When we pass it an undefined key, It'll just pull the very first page from the database. The emitted value is going to be an array of comments. We'll go ahead and Slice the array with the first two comments to show to the user, and then the 3rd comment will be the offset for the next page. And if that comment doesn't exist then we'll just disable the button in the actual template. We're using the lodash get function to Call this key without raising an error if it doesn't actually exist. Now we can run this function with n g on a net and that'll populate the first page of comments. We also use it in our next page function, But this time we pass it the key for the next page. So at this point we can navigate forward, but the tricky part is going backwards. Anytime the next page function is triggered, we save the current key in an array. It's only when the user starts going backwards that we Dart popping off the last element that was added to this array, similar to a stack data structure. We know the user is back on the first page once the array is empty. After we update the previous keys array we can then load the comments for that page. If we go back to the app now we can see we can navigate through the comments using the Next and Previous buttons and they're disabled when we Reach the end or the beginning of the list. If you want to learn more about pagination and different possible implementations, check out the link in the description. That's it for this episode. If you found the video helpful, please like and subscribe. And if you wanna support the channel, Consider becoming a pro subscriber at angularfirebase.com. For just a few bucks a month, you'll get access to exclusive content as well as free 1 on 1 project consulting. Thanks for watching and I'll see you next time.
In
in
this
this
episode
episode
we're
we're
going
going
to
to
build
build
a
a
simple
simple
pagination
pagination
feature
feature
using
using
Firebase
firebase
and
and
the
the
AngularFire
angularfire
2
2
package.
package
This
this
solution
solution
allows
allows
the
the
user
user
to
to
click
click
a
a
next
next
or
or
a
a
previous
previous
button
button
to
to
navigate
navigate
through
through
a
a
Firebase
firebase
list
list
observable.
observable
The
the
benefit
benefit
of
of
this
this
approach
approach
is
is
that
that
it
it
can
can
be
be
applied
applied
to
to
a
a
dataset
dataset
of
of
any
any
size,
size
but
but
the
the
drawback
drawback
is
is
that
that
it's
it's
impossible
impossible
to
to
really
really
implement
implement
page
page
numbers
numbers
for
for
pagination.
pagination
In
in
the
the
database,
database
we
we
have
have
a
a
series
series
of
of
comments
comments
nested
nested
under
under
their
their
associated
associated
post
post
ID.
id
Let's
let's
start
start
by
by
retrieving
retrieving
a
a
Firebase
firebase
list
list
observable
observable
from
from
the
the
service.
service
First
first
we
we
import
import
the
the
AngularFire
angularfire
database
database
And
and
then
then
we
we
build
build
a
a
function
function
that
that
will
will
take
take
a
a
post
post
ID,
id
an
an
offset,
offset
which
which
is
is
the
the
number
number
of
of
comments
comments
we
we
want
want
to
to
retrieve,
retrieve
and
and
a
a
start
start
key,
key
which
which
is
is
where
where
we'll
we'll
start
start
the
the
actual
actual
query.
query
In
in
Firebase,
firebase
we
we
can't
can't
use
use
a
a
numeric
numeric
offset
offset
like
like
you
you
would
would
in
in
a
a
SQL
sql
database,
database
so
so
we
we
keep
keep
track
track
of
of
the
the
key
key
and
and
use
use
that
that
as
as
the
the
offset
offset
point
point
for
for
each
each
query.
query
The
the
key
key
for
for
the
the
next
next
page
page
is
is
determined
determined
by
by
grabbing
grabbing
one
one
extra
extra
comment
comment
from
from
the
the
database
database
and
and
we
we
use
use
that
that
comment's
comment's
Its
its
key
key
is
is
the
the
offset
offset
point
point
for
for
the
the
following
following
page.
page
Now
now
we
we
can
can
start
start
building
building
the
the
component.
component
In
in
the
the
template
template
we're
we're
going
going
to
to
loop
loop
through
through
a
a
list
list
of
of
comments,
comments
but
but
notice
notice
we're
we're
not
not
using
using
the
the
async
async
pipe
pipe
because
because
we're
we're
actually
actually
going
going
to
to
unwrap
unwrap
the
the
observable
observable
in
in
the
the
components
components
type
type
script.
script
We
we
also
also
had
had
a
a
couple
couple
buttons
buttons
just
just
for
for
navigating
navigating
between
between
the
the
next
next
and
and
previous
previous
pages.
pages
We
we
also
also
want
want
to
to
disable
disable
these
these
buttons
buttons
if
if
there
there
isn't
isn't
a
a
next
next
or
or
a
a
previous
previous
page
page
to
to
navigate
navigate
to.
to
In
in
the
the
TypeScript,
typescript
we
we
start
start
by
by
injecting
injecting
the
the
comment
comment
service
service
and
and
we
we
also
also
import
import
lodash,
lodash
which
which
we'll
we'll
be
be
using
using
to
to
do
do
a
a
lot
lot
of
of
the
the
array
array
operations
operations
in
in
this
this
implementation.
implementation
The
the
comments
comments
variable
variable
will
will
hold
hold
the
the
actual
actual
comments
comments
from
from
the
the
observable.
observable
The
the
offset
offset
will
will
be
be
the
the
number
number
of
of
comments
comments
we
we
display
display
on
on
each
each
page.
page
The
the
next
next
key
key
is
is
where
where
we
we
offset
offset
the
the
actual
actual
database
database
query.
query
And
and
the
the
previous
previous
keys
keys
will
will
be
be
a
a
running
running
list
list
of
of
every
every
key
key
for
for
the
the
previous
previous
page.
page
Now
now
we
we
create
create
another
another
function
function
to
to
retrieve
retrieve
the
the
comments
comments
And
and
we'll
we'll
start
start
by
by
subscribing
subscribing
to
to
the
the
observable
observable
from
from
the
the
service.
service
When
when
we
we
pass
pass
it
it
an
an
undefined
undefined
key,
key
It'll
it'll
just
just
pull
pull
the
the
very
very
first
first
page
page
from
from
the
the
database.
database
The
the
emitted
emitted
value
value
is
is
going
going
to
to
be
be
an
an
array
array
of
of
comments.
comments
We'll
we'll
go
go
ahead
ahead
and
and
Slice
slice
the
the
array
array
with
with
the
the
first
first
two
two
comments
comments
to
to
show
show
to
to
the
the
user,
user
and
and
then
then
the
the
3rd
3rd
comment
comment
will
will
be
be
the
the
offset
offset
for
for
the
the
next
next
page.
page
And
and
if
if
that
that
comment
comment
doesn't
doesn't
exist
exist
then
then
we'll
we'll
just
just
disable
disable
the
the
button
button
in
in
the
the
actual
actual
template.
template
We're
we're
using
using
the
the
lodash
lodash
get
get
function
function
to
to
Call
call
this
this
key
key
without
without
raising
raising
an
an
error
error
if
if
it
it
doesn't
doesn't
actually
actually
exist.
exist
Now
now
we
we
can
can
run
run
this
this
function
function
with
with
n
n
g
g
on
on
a
a
net
net
and
and
that'll
that'll
populate
populate
the
the
first
first
page
page
of
of
comments.
comments
We
we
also
also
use
use
it
it
in
in
our
our
next
next
page
page
function,
function
But
but
this
this
time
time
we
we
pass
pass
it
it
the
the
key
key
for
for
the
the
next
next
page.
page
So
so
at
at
this
this
point
point
we
we
can
can
navigate
navigate
forward,
forward
but
but
the
the
tricky
tricky
part
part
is
is
going
going
backwards.
backwards
Anytime
anytime
the
the
next
next
page
page
function
function
is
is
triggered,
triggered
we
we
save
save
the
the
current
current
key
key
in
in
an
an
array.
array
It's
it's
only
only
when
when
the
the
user
user
starts
starts
going
going
backwards
backwards
that
that
we
we
Dart
dart
popping
popping
off
off
the
the
last
last
element
element
that
that
was
was
added
added
to
to
this
this
array,
array
similar
similar
to
to
a
a
stack
stack
data
data
structure.
structure
We
we
know
know
the
the
user
user
is
is
back
back
on
on
the
the
first
first
page
page
once
once
the
the
array
array
is
is
empty.
empty
After
after
we
we
update
update
the
the
previous
previous
keys
keys
array
array
we
we
can
can
then
then
load
load
the
the
comments
comments
for
for
that
that
page.
page
If
if
we
we
go
go
back
back
to
to
the
the
app
app
now
now
we
we
can
can
see
see
we
we
can
can
navigate
navigate
through
through
the
the
comments
comments
using
using
the
the
Next
next
and
and
Previous
previous
buttons
buttons
and
and
they're
they're
disabled
disabled
when
when
we
we
Reach
reach
the
the
end
end
or
or
the
the
beginning
beginning
of
of
the
the
list.
list
If
if
you
you
want
want
to
to
learn
learn
more
more
about
about
pagination
pagination
and
and
different
different
possible
possible
implementations,
implementations
check
check
out
out
the
the
link
link
in
in
the
the
description.
description
That's
that's
it
it
for
for
this
this
episode.
episode
If
if
you
you
found
found
the
the
video
video
helpful,
helpful
please
please
like
like
and
and
subscribe.
subscribe
And
and
if
if
you
you
wanna
wanna
support
support
the
the
channel,
channel
Consider
consider
becoming
becoming
a
a
pro
pro
subscriber
subscriber
at
at
angularfirebase.com.
angularfirebase.com
For
for
just
just
a
a
few
few
bucks
bucks
a
a
month,
month
you'll
you'll
get
get
access
access
to
to
exclusive
exclusive
content
content
as
as
well
well
as
as
free
free
1
1
on
on
1
1
project
project
consulting.
consulting
Thanks
thanks
for
for
watching
watching
and
and
I'll
i'll
see
see
you
you
next
next
time.
time
success
The speaker explains how to build a simpleaps feature using Mmay and the Angularipping package, but notes that it is impossible to implement page numbers for GasLog. They proceed to build a component, including a list of comments and a function to retrieve comments. They also discuss the use of a function to navigate to the next or previous page and disabling buttons when the current page is used. The speaker concludes by recommending viewers to check out the link for exclusive content and free resources.
Simple Pagination with Firebase and Angular 4
In this episode we're going to build a simple pagination feature using Firebase and the AngularFire 2 package. This solution allows the user to click a next or a previous button to navigate through a Firebase list observable. The benefit of this approach is that it can be applied to a dataset of any size, but the drawback is that it's impossible to really implement page numbers for pagination. In the database, we have a series of comments nested under their associated post ID. Let's start by retrieving a Firebase list observable from the service. First we import the AngularFire database And then we build a function that will take a post ID, an offset, which is the number of comments we want to retrieve, and a start key, which is where we'll start the actual query. In Firebase, we can't use a numeric offset like you would in a SQL database, so we keep track of the key and use that as the offset point for each query. The key for the next page is determined by grabbing one extra comment from the database and we use that comment's Its key is the offset point for the following page. Now we can start building the component. In the template we're going to loop through a list of comments, but notice we're not using the async pipe because we're actually going to unwrap the observable in the components type script. We also had a couple buttons just for navigating between the next and previous pages. We also want to disable these buttons if there isn't a next or a previous page to navigate to. In the TypeScript, we start by injecting the comment service and we also import lodash, which we'll be using to do a lot of the array operations in this implementation. The comments variable will hold the actual comments from the observable. The offset will be the number of comments we display on each page. The next key is where we offset the actual database query. And the previous keys will be a running list of every key for the previous page. Now we create another function to retrieve the comments And we'll start by subscribing to the observable from the service. When we pass it an undefined key, It'll just pull the very first page from the database. The emitted value is going to be an array of comments. We'll go ahead and Slice the array with the first two comments to show to the user, and then the 3rd comment will be the offset for the next page. And if that comment doesn't exist then we'll just disable the button in the actual template. We're using the lodash get function to Call this key without raising an error if it doesn't actually exist. Now we can run this function with n g on a net and that'll populate the first page of comments. We also use it in our next page function, But this time we pass it the key for the next page. So at this point we can navigate forward, but the tricky part is going backwards. Anytime the next page function is triggered, we save the current key in an array. It's only when the user starts going backwards that we Dart popping off the last element that was added to this array, similar to a stack data structure. We know the user is back on the first page once the array is empty. After we update the previous keys array we can then load the comments for that page. If we go back to the app now we can see we can navigate through the comments using the Next and Previous buttons and they're disabled when we Reach the end or the beginning of the list. If you want to learn more about pagination and different possible implementations, check out the link in the description. That's it for this episode. If you found the video helpful, please like and subscribe. And if you wanna support the channel, Consider becoming a pro subscriber at angularfirebase.com. For just a few bucks a month, you'll get access to exclusive content as well as free 1 on 1 project consulting. Thanks for watching and I'll see you next time.
The speaker explains how to build a simpleaps feature using Mmay and the Angularipping package, but notes that it is impossible to implement page numbers for GasLog. They proceed to build a component, including a list of comments and a function to retrieve comments. They also discuss the use of a function to navigate to the next or previous page and disabling buttons when the current page is used. The speaker concludes by recommending viewers to check out the link for exclusive content and free resources.

        [INST]
        You are youtuber called Fireship you make engaging high-intensity and entertaining coding tutorials and tech news. 
        you covers a wide range of topics relevant to programmers, aiming to help them learn and improve their skills quickly.
        
        Given the title of the video : Simple Pagination with Firebase and Angular 4 
        and a small summary : The speaker explains how to build a simpleaps feature using Mmay and the Angularipping package, but notes that it is impossible to implement page numbers for GasLog. They proceed to build a component, including a list of comments and a function to retrieve comments. They also discuss the use of a function to navigate to the next or previous page and disabling buttons when the current page is used. The speaker concludes by recommending viewers to check out the link for exclusive content and free resources.
        [/INST]
        
        Generate the video : In this episode we're going to build a simple pagination feature using Firebase and the AngularFire 2 package. This solution allows the user to click a next or a previous button to navigate through a Firebase list observable. The benefit of this approach is that it can be applied to a dataset of any size, but the drawback is that it's impossible to really implement page numbers for pagination. In the database, we have a series of comments nested under their associated post ID. Let's start by retrieving a Firebase list observable from the service. First we import the AngularFire database And then we build a function that will take a post ID, an offset, which is the number of comments we want to retrieve, and a start key, which is where we'll start the actual query. In Firebase, we can't use a numeric offset like you would in a SQL database, so we keep track of the key and use that as the offset point for each query. The key for the next page is determined by grabbing one extra comment from the database and we use that comment's Its key is the offset point for the following page. Now we can start building the component. In the template we're going to loop through a list of comments, but notice we're not using the async pipe because we're actually going to unwrap the observable in the components type script. We also had a couple buttons just for navigating between the next and previous pages. We also want to disable these buttons if there isn't a next or a previous page to navigate to. In the TypeScript, we start by injecting the comment service and we also import lodash, which we'll be using to do a lot of the array operations in this implementation. The comments variable will hold the actual comments from the observable. The offset will be the number of comments we display on each page. The next key is where we offset the actual database query. And the previous keys will be a running list of every key for the previous page. Now we create another function to retrieve the comments And we'll start by subscribing to the observable from the service. When we pass it an undefined key, It'll just pull the very first page from the database. The emitted value is going to be an array of comments. We'll go ahead and Slice the array with the first two comments to show to the user, and then the 3rd comment will be the offset for the next page. And if that comment doesn't exist then we'll just disable the button in the actual template. We're using the lodash get function to Call this key without raising an error if it doesn't actually exist. Now we can run this function with n g on a net and that'll populate the first page of comments. We also use it in our next page function, But this time we pass it the key for the next page. So at this point we can navigate forward, but the tricky part is going backwards. Anytime the next page function is triggered, we save the current key in an array. It's only when the user starts going backwards that we Dart popping off the last element that was added to this array, similar to a stack data structure. We know the user is back on the first page once the array is empty. After we update the previous keys array we can then load the comments for that page. If we go back to the app now we can see we can navigate through the comments using the Next and Previous buttons and they're disabled when we Reach the end or the beginning of the list. If you want to learn more about pagination and different possible implementations, check out the link in the description. That's it for this episode. If you found the video helpful, please like and subscribe. And if you wanna support the channel, Consider becoming a pro subscriber at angularfirebase.com. For just a few bucks a month, you'll get access to exclusive content as well as free 1 on 1 project consulting. Thanks for watching and I'll see you next time.
        