Initializing a Puppeteer Browser Outside of Scraping Function

To achieve this, you'll just need to separate the browser from your requests, like in a class, for example:

class PuppeteerScraper {
  async launch(options = {}) {
    this.browser = await puppeteer.launch(options);
    // you could reuse the page instance if it was defined here
  }

  /**
   * Pass the address and the function that will scrape your data,
   * in order to mantain the page inside this object
   */
  async goto(url, callback) {
    const page = await this.browser.newPage();
    await page.goto(url);

    /**evaluate its content */
    await callback(page);
    await page.close();
  }

  async close() {
    await this.browser.close();
  }
}

and, to implement it:

/**
 * scrape function, takes the page instance as its parameters
 */
async function evaluate_page(page) {
  const titles = await page.$$eval('.col-xs-6 .star-rating ~ h3 a', (itens) => {
    const text_titles = [];
    for (const item of itens) {
      if (item && item.textContent) {
        text_titles.push(item.textContent);
      }
    }
    return text_titles;
  });
  console.log('titles', titles);
}

(async () => {
  const scraper = new PuppeteerScraper();
  await scraper.launch({ headless: false });

  for (let i = 1; i <= 6; i++) {
    let link = `https://books.toscrape.com/catalogue/page-${i}.html`;
    await scraper.goto(link, evaluate_page);
  }
  scraper.close();
})();

altho, if you want something more complex, you could take a look how they done at Apify project.

About a year ago I tried to a make an React Native Pokemon Go helper app. Since there wasn't an api for pokemon nest and pokestops I created a server that scraped thesilphroad.com and I found the need to implement something like @Arkan said.

I wanted the server to be able to take multiple request, so I decided to initialize the browser when the server is booted up. When a request is received, the server checks to see if MAX_TABS have been reached. If reached, it waits, if not a new tab is opened and the scrape is performed

Here's the scraper.js

const puppeteer = require ('puppeteer')
const fs = require('fs')
const Page = require('./Page')
const exec = require('child_process').exec
const execSync = require('util').promisify(exec)
module.exports = class scraper {
    constructor(){
        this.browser = null
        this.getPages = null
        this.getTotalPages = null
        this.isRunning = false
        //browser permissions
        this.permissions = ['geolocation']
        this.MAX_TABS = 5
        //when puppeteer launches
        this.useFirstTab = true
    }
    async init(config={}){
        let headless = config.headless != undefined ? config.headless : true
        this.permissions = this.permissions.concat(config.permissions || [])
        //get local chromium location
        let browserPath = await getBrowserPath('firefox') || await getBrowserPath('chrome')
        this.browser = await puppeteer.launch({
            headless:headless,
            executablePath:browserPath,
            defaultViewport:null,
            args:[
                '--start-maximized',
            ]
        })
        this.getPages = this.browser.pages
        this.getTotalPages = ()=>{
            return this.getPages().then(pages=>pages.length).catch(err=>0)
        }
        this.isRunning = true
    }
    async waitForTab(){
        let time = Date.now()
        let cycles = 1
        await new Promise(resolve=>{
            let interval = setInterval(async()=>{
                let totalPages = await this.getTotalPages()
                if(totalPages < this.MAX_TABS){
                    clearInterval(interval)
                    resolve()
                }
                if(Date.now() - time > 100)
                    console.log('Waiting...')
                if(Date.now() - time > 20*1000){
                    console.log('... ...\n'.repeat(cycle)+'Still waiting...')
                    cycle++
                    time = Date.now()
                }
            },500)
        })
    }

    //open new tab and go to page
    async openPage(url,waitSelector,lat,long){
        await this.waitForTab()
        let pg
        //puppeteer launches with a blank tab, use this
        // if(this.useFirstTab){
        //  let pages = await this.browser.pages()
        //  pg = pages.pop()
        //  this.useFirstTab = false
        // }
        // else
        pg =    await this.browser.newPage()
        if(lat && long){
            await this.setPermissions(url)
        }
        let page = await new Page()
        await page.init(pg,url,waitSelector,lat,long)
        return page

    }
    async setPermissions(url){
        const context = this.browser.defaultBrowserContext();
        await context.overridePermissions(url,this.permissions)
    }
}

// assumes that the browser is in path
async function getBrowserPath(browserName){
    return execSync('command -v chromium').then(({stdout,stderr})=>{
        if(stdout.includes('not found'))
            return null
        return stdout
    }).catch(err=>null)
}

The scraper imports Page.js, which is just wrapper for a puppeteer Page object with the functions I used most made available

const path = require('path')
const fs = require('fs')
const userAgents = require('./staticData/userAgents.json')
const cookiesPath = path.normalize('./cookies.json')

// a wrapper for a puppeteer page with pre-made functions
module.exports = class Page{
    constuctor(useCookies=false){
        this.page = null
        this.useCookies = useCookies
        this.previousSession = this.useCookies && fs.existsSync(cookiesPath)
    }
    async close (){
        await this.page.close()
    }
    async init(page,url,waitSelector,lat,long){
        this.page = page
        let userAgent = userAgents[Math.floor(Math.random()*userAgents.length)]
        await this.page.setUserAgent(userAgent)
        await this.restoredSession()
        if(lat && long)
            await this.page.setGeolocation({
                latitude: lat || 59.95, longitude:long || 30.31667, accuracy:40
            })
        await this.page.goto(url)
        await this.wait(waitSelector)
        
    }
    async screenshotElement(selector='body',directory='./screenshots',padding=0,offset={}) {
      const rect = await this.page.evaluate(selector => {
        const el = document.querySelector(selector)
        const {x, y, width, height} = el.getBoundingClientRect()
        return {
            left: x, 
            top: y, 
            width, 
            height, 
            id: el.id
        }
      }, selector)
      
      let ext = 'jpeg'
      let filename = path.normalize(directory+'/'+Date.now())
      return await this.page.screenshot({
        type:ext,
        path:filename+' - '+selector.substring(5)+'.'+ext,
        clip: {
          x: rect.left - padding+(offset.left || 0),
          y: rect.top - padding+(offset.right || 0),
          width: rect.width + padding * 2+(offset.width||0),
          height: rect.height + padding * 2+ (offset.height||0)
        },
        encoding:'base64'
      })
    }
    async restoredSession(){
        if(!this.previousSession)
            return false
        let cookies = require(cookiesPath)
            for(let cookie of cookies){
                await this.page.setCookie(cookie)
            }
            console.log('Loaded previous session')
            return true
    }
    async saveSession(){
        //write cookie to file
        if(!this.useCookies)
            return
        const cookies = await this.page.cookies()
        fs.writeFileSync(cookiesPath,JSON.stringify(cookies,null,2))
        console.log('Wrote cookies to file')
    }
    //wait for text input elment and type text
    async type(selector,text,options={delay:150}){
        await this.wait(selector)
        await this.page.type(selector,text,options)
    }
    //click and waits
    async click(clickSelector,waitSelector=500){
        await this.page.click(clickSelector)
        await this.wait(waitSelector)
    }
    //hovers over element and waits
    async hover(selector,waitSelector=500){
        await this.page.hover(selector)
        await this.wait(1000)
        await this.wait(waitSelector)
    }
    //waits and suppresses timeout errors
    async wait(selector=500, waitForNav=false){
        try{
            //waitForNav is a puppeteer's waitForNavigation function
            //which for me does nothing but timeouts after 30s
            waitForNav && await this.page.waitForNavigation()
            await this.page.waitFor(selector)
        } catch (err){
            //print everything but timeout errors
            if(err.name != 'Timeout Error'){
                console.log('error name:',err.name)
                console.log(err)
                console.log('- - - '.repeat(4))
            }
            this.close()
        }
    }   
}
``