Menu Docs
Página inicial do Docs
/
Manual do MongoDB
/
Referência
/
Métodos de mongosh
/
Cursors

cursor.skip()

Nesta página

  • Definição
  • Comportamento
  • Exemplo de paginação

Definição

cursor.skip(<offset>)

Importante

Método mongosh

Esta página documenta um método mongosh. Esta não é a documentação de um driver de idioma específico, como Node.js.

Para drivers de API do MongoDB, consulte a documentação do driver do MongoDB específica da linguagem.

Chame o método skip() em um cursor para controlar onde o MongoDB começa a retornar resultados. Essa abordagem pode ser útil na implementação de resultados paginados.

Observação

Você deve aplicar skip() ao cursor antes de recuperar quaisquer documentos do banco de dados.

O método skip() tem o seguinte parâmetro:

Parâmetro
Tipo
Descrição
offset
número
O número de documentos a ignorar no conjunto de resultados.

Comportamento

Usando com skip() sort()

Se estiver usando skip() com sort(), certifique-se de incluir pelo menos um campo em sua classificação que contenha valores exclusivos, antes de passar os resultados para skip().

A classificação em campos que contêm valores duplicados pode retornar uma ordem de classificação inconsistente para esses campos duplicados em várias execuções, especialmente quando a **coleção** está recebendo gravações ativamente.

A maneira mais fácil de garantir consistência de classificação é incluir o campo _id em sua query de classificação.

Consulte Classificação consistente com o método sort() para obter mais informações.

Usando com skip() limit()

Quando você encadeia skip() e limit(), a ordem de encadeamento do método não afeta os resultados. O servidor sempre aplica a operação de ignorar com base na ordem de classificação antes de aplicar o limite de quantos documentos retornar.

O exemplo de código a seguir mostra diferentes ordens de encadeamento para skip() e limit() que sempre produzem os mesmos resultados de consulta para o mesmo conjunto de dados:

db.myColl.find().sort({_id: 1}).skip(3).limit(6);
db.myColl.find().sort({_id: 1}).limit(6).skip(3);

Exemplo de paginação

Usando skip()

A função JavaScript a seguir usa skip() para paginar uma coleção pelo seu campo _id:

function printStudents(pageNumber, nPerPage) {
  print( "Page: " + pageNumber );
  db.students.find()
             .sort( { _id: 1 } )
             .skip( pageNumber > 0 ? ( ( pageNumber - 1 ) * nPerPage ) : 0 )
             .limit( nPerPage )
             .forEach( student => {
               print( student.name );
             } );
}

O método skip() exige que o servidor verifique desde o início do conjunto de resultados de entrada antes de começar a retornar resultados. À medida que a compensação aumenta, skip() ficará mais lento.

Usando queries de intervalo

As queries do intervalo podem usar índices para evitar a digitalização de documentos indesejados, geralmente gerando melhor desempenho à medida que a compensação aumenta, em comparação com o uso de skip() na paginação.

Ordem decrescente

Use este procedure para implementar a pagination com querys de intervalo:

  • Escolha um campo como _id que geralmente muda em uma direção consistente ao longo do tempo e tem um índice único para evitar valores duplicados,

  • Query de documentos cujo campo é menor que o valor inicial usando os operadores $lt e sort(), eC

  • Armazene o valor do último field seen para a próxima query.

Por exemplo, a função a seguir usa o procedimento acima para imprimir páginas de nomes de estudantes de uma coleção, classificadas aproximadamente na ordem dos documentos mais recentes, usando primeiro o campo _id (ou seja, em ordem decrescente):

function printStudents(startValue, nPerPage) {
  let endValue = null;
  db.students.find( { _id: { $lt: startValue } } )
             .sort( { _id: -1 } )
             .limit( nPerPage )
             .forEach( student => {
               print( student.name );
               endValue = student._id;
             } );
  return endValue;
}

Em seguida, você pode usar o código a seguir para imprimir todos os nomes dos alunos usando essa função de paginação, usando MaxKey para começar com a maior chave possível:

let currentKey = MaxKey;
while (currentKey !== null) {
  currentKey = printStudents(currentKey, 10);
}

Observação

Embora os valores de ObjectId devam aumentar ao longo do tempo, eles não são necessariamente monotônicos. Isso ocorre porque eles:

  • Contêm apenas um segundo de resolução temporal, portanto, os valores de ObjectId criados no mesmo segundo não têm uma ordem garantida e

  • São gerados por clientes, que podem ter relógios de sistema diferentes.

Ordem ascendente

O retorno de resultados paginados em ordem crescente é semelhante ao anterior, mas usa $gt com uma ordem de classificação crescente:

function printStudents(startValue, nPerPage) {
  let endValue = null;
  db.students.find( { _id: { $gt: startValue } } )
             .sort( { _id: 1 } )
             .limit( nPerPage )
             .forEach( student => {
               print( student.name );
               endValue = student._id;
             } );
  return endValue;
}

O uso desta função também é semelhante, mas com MinKey como a chave inicial:

let currentKey = MinKey;
while (currentKey !== null) {
  currentKey = printStudents(currentKey, 10);
}

Voltar

cursor.size

Próximo

cursor.sort