Кукловод - прокрутите вниз, пока больше не сможете

Попробуйте это:

const puppeteer = require('puppeteer');

(async () => {
    const browser = await puppeteer.launch({
        headless: false
    });
    const page = await browser.newPage();
    await page.goto('https://www.yoursite.com');
    await page.setViewport({
        width: 1200,
        height: 800
    });

    await autoScroll(page);

    await page.screenshot({
        path: 'yoursite.png',
        fullPage: true
    });

    await browser.close();
})();

async function autoScroll(page){
    await page.evaluate(async () => {
        await new Promise((resolve, reject) => {
            var totalHeight = 0;
            var distance = 100;
            var timer = setInterval(() => {
                var scrollHeight = document.body.scrollHeight;
                window.scrollBy(0, distance);
                totalHeight += distance;

                if (totalHeight >= scrollHeight){
                    clearInterval(timer);
                    resolve();
                }
            }, 100);
        });
    });
}

Источник: https://github.com/chenxiaochun/blog/issues/38

Прокрутку вниз страницы можно выполнить двумя способами:

1. используйте scrollIntoView (для прокрутки к той части страницы, которая может создать больше контента внизу) и селекторы (например, document.querySelectorAll('.class_name').length, чтобы проверить, было ли создано больше контента)
2. используйте scrollBy (для постепенной прокрутки страницы) и setTimeout или setInterval (для постепенной проверки, находимся ли мы внизу страницы)

Вот реализация с использованием scrollIntoView и селектора (при условии, что .class_name - это селектор, который мы прокручиваем для большего количества контента) на простом JavaScript, который мы можем запустить в браузере:

Метод 1: используйте scrollIntoView и селекторы

const delay = 3000;
const wait = (ms) => new Promise(res => setTimeout(res, ms));
const count = async () => document.querySelectorAll('.class_name').length;
const scrollDown = async () => {
  document.querySelector('.class_name:last-child')
    .scrollIntoView({ behavior: 'smooth', block: 'end', inline: 'end' });
}

let preCount = 0;
let postCount = 0;
do {
  preCount = await count();
  await scrollDown();
  await wait(delay);
  postCount = await count();
} while (postCount > preCount);
await wait(delay);

В этом методе мы сравниваем количество селекторов .class_name до прокрутки (preCount) и после прокрутки (postCount), чтобы проверить, находимся ли мы внизу страницы:

if (postCount > precount) {
  // NOT bottom of page
} else {
  // bottom of page
}

И вот две возможные реализации с использованием setTimeout или setInterval с scrollBy на простом JavaScript, которые мы можем запустить в консоли браузера:

Метод 2а: используйте setTimeout с scrollBy

const distance = 100;
const delay = 100;
while (document.scrollingElement.scrollTop + window.innerHeight < document.scrollingElement.scrollHeight) {
  document.scrollingElement.scrollBy(0, distance);
  await new Promise(resolve => { setTimeout(resolve, delay); });
}

Метод 2b: используйте setInterval с scrollBy

const distance = 100;
const delay = 100;
const timer = setInterval(() => {
  document.scrollingElement.scrollBy(0, distance);
  if (document.scrollingElement.scrollTop + window.innerHeight >= document.scrollingElement.scrollHeight) {
    clearInterval(timer);
  }
}, delay);

В этом методе мы сравниваем document.scrollingElement.scrollTop + window.innerHeight с document.scrollingElement.scrollHeight, чтобы проверить, находимся ли мы внизу страницы:

if (document.scrollingElement.scrollTop + window.innerHeight < document.scrollingElement.scrollHeight) {
  // NOT bottom of page
} else {
  // bottom of page
}

Если какой-либо из приведенных выше кодов JavaScript прокручивает страницу полностью вниз, значит, мы знаем, что он работает, и можем автоматизировать это с помощью Puppeteer.

Вот примеры сценариев Puppeteer Node.js, которые прокрутятся вниз до нижней части страницы и подождут несколько секунд, прежде чем закрыть браузер.

Кукловод, метод 1: используйте scrollIntoView с селектором (.class_name)

const puppeteer = require('puppeteer');

(async () => {
  const browser = await puppeteer.launch({
    headless: false,
    defaultViewport: null,
    args: ['--window-size=800,600']
  });
  const page = await browser.newPage();
  await page.goto('https://example.com');

  const delay = 3000;
  let preCount = 0;
  let postCount = 0;
  do {
    preCount = await getCount(page);
    await scrollDown(page);
    await page.waitFor(delay);
    postCount = await getCount(page);
  } while (postCount > preCount);
  await page.waitFor(delay);

  await browser.close();
})();

async function getCount(page) {
  return await page.$$eval('.class_name', a => a.length);
}

async function scrollDown(page) {
  await page.$eval('.class_name:last-child', e => {
    e.scrollIntoView({ behavior: 'smooth', block: 'end', inline: 'end' });
  });
}

Метод кукловода 2а: используйте setTimeout с scrollBy

const puppeteer = require('puppeteer');

(async () => {
  const browser = await puppeteer.launch({
    headless: false,
    defaultViewport: null,
    args: ['--window-size=800,600']
  });
  const page = await browser.newPage();
  await page.goto('https://example.com');

  await scrollToBottom(page);
  await page.waitFor(3000);

  await browser.close();
})();

async function scrollToBottom(page) {
  const distance = 100; // should be less than or equal to window.innerHeight
  const delay = 100;
  while (await page.evaluate(() => document.scrollingElement.scrollTop + window.innerHeight < document.scrollingElement.scrollHeight)) {
    await page.evaluate((y) => { document.scrollingElement.scrollBy(0, y); }, distance);
    await page.waitFor(delay);
  }
}

Метод кукловода 2b: используйте setInterval с scrollBy

const puppeteer = require('puppeteer');

(async () => {
  const browser = await puppeteer.launch({
    headless: false,
    defaultViewport: null,
    args: ['--window-size=800,600']
  });
  const page = await browser.newPage();
  await page.goto('https://example.com');

  await page.evaluate(scrollToBottom);
  await page.waitFor(3000);

  await browser.close();
})();

async function scrollToBottom() {
  await new Promise(resolve => {
    const distance = 100; // should be less than or equal to window.innerHeight
    const delay = 100;
    const timer = setInterval(() => {
      document.scrollingElement.scrollBy(0, distance);
      if (document.scrollingElement.scrollTop + window.innerHeight >= document.scrollingElement.scrollHeight) {
        clearInterval(timer);
        resolve();
      }
    }, delay);
  });
}

на основе ответа от этого url

await page.evaluate(() => {
  window.scrollBy(0, window.innerHeight);
});

Вы должны спросить себя, прокручиваете ли вы элемент, который требует от страницы отложенной загрузки данных до достижения этой DOM. Например, эта страница sephora: https://www.sephora.com/search?keyword=clean%20at%20sephora

Если это так, вам нужно дождаться загрузки обещания, прежде чем переходить, например, к нижнему колонтитулу, а scrollToElement, как и приведенные выше решения, без использования обещания не приведет вас к концу элемента.

В этом случае вам необходимо ввести Promise внутрь page.evaluate.

async function autoScroll(page) {
  await page.evaluate(async () => {
    await new Promise((resolve, reject) => {
      var totalHeight = 0;
      var distance = 100;
      var timer = setInterval(() => {
        var scrollHeight = document.body.scrollHeight;
        window.scrollBy(0, distance);
        totalHeight += distance;

        if (totalHeight >= scrollHeight) {
          clearInterval(timer);
          resolve();
        }
      }, 100);
    });
  });
}
await autoScroll(page);

Вы можете просто использовать следующий код, используя объект page.keyboard:

await page.keyboard.press('ArrowDown');
delay(2000) //wait for 2 seconds
await page.keyboard.press('ArrowUp');
function delay(milliseconds) { //function for waiting
        return new Promise(resolve => {
          setTimeout(() => {
            resolve();
          }, milliseconds);
        });
      }

Многие решения здесь предполагают постоянную высоту страницы. Эта реализация работает, даже если высота страницы изменяется (например, загружается новый контент, когда пользователь прокручивает страницу вниз).

await page.evaluate(() => new Promise((resolve) => {
  var scrollTop = -1;
  const interval = setInterval(() => {
    window.scrollBy(0, 100);
    if (document.documentElement.scrollTop !== scrollTop) {
      scrollTop = document.documentElement.scrollTop;
      return;
    }
    clearInterval(interval);
    resolve();
  }, 10);
}));

Довольно простое решение

let lastHeight = await page.evaluate('document.body.scrollHeight');

    while (true) {
        await page.evaluate('window.scrollTo(0, document.body.scrollHeight)');
        await page.waitForTimeout(2000); // sleep a bit
        let newHeight = await page.evaluate('document.body.scrollHeight');
        if (newHeight === lastHeight) {
            break;
        }
        lastHeight = newHeight;
    }

Намного легче:

    await page.evaluate(async () => {
      let scrollPosition = 0
      let documentHeight = document.body.scrollHeight

      while (documentHeight > scrollPosition) {
        window.scrollBy(0, documentHeight)
        await new Promise(resolve => {
          setTimeout(resolve, 1000)
        })
        scrollPosition = documentHeight
        documentHeight = document.body.scrollHeight
      }
    })