Increasing performance of v-data-table with custom cells and async data loading

Question

I'm creating a page with v-data-table. Some content of this table is loading at mounted stage, but the data for one column should be loaded line-by-line in the background by async API calls after rendering the whole table. Table rows should also be colored based on data returned from API call.

I've already developed this page, but stuck into one issue - when the table contains composite cells that was redefined by item slot (by example, a cell with icons, tooltips or spans), table row update time significantly increases.

According to business logic, the page may contain a large amount of rows, but I can't use v-data-table pagination to reduce entries count at one page.

The question is - how can I update row (in fact, just its color and one cell value) with a little performance loss as possible?

There is a Codepen with this problem. The way of loading data into the page is completely preserved in this Codepen, but API calls was replaced by promises with fixed timeout.

The problem still exists in Codepen. By default all the requests for 100 items have passed in 12-13 seconds (there's a counter at the bottom of the page). When I comment out last td, they're passed just in 7-8 seconds. When I comment out another one td (second from the end), they're passed in 6 seconds. When I increase items count to 1000, row update time is also increases.

new Vue({
  el: '#app',
  vuetify: new Vuetify(),
  data () {
    return {
      headers: [
        {
          text: 'Dessert (100g serving)',
          value: 'name',
        },
        { text: 'Second name', value: 'secondName' },
        { text: 'Fat (g)', value: 'fat' },
        { text: 'Carbs (g)', value: 'carbs' },
        { text: 'Protein (g)', value: 'protein' },
        { text: 'Max value', value: 'maxValue' },
        { text: 'Actions', value: 'id' },
      ],
      desserts: [],
      timerStart: null,
      loadingTime: null,
    }
  },
  created() {
    this.generateDesserts();
  },
  mounted() {
    this.countMaxValues(this.desserts).then(() => {
      this.loadingTime = (Date.now() - this.timerStart) / 1000;
    });
  },
  methods: {
    generateDesserts() {
      let dessertNames = [
        'Frozen Yogurt  ',
        'Ice cream sandwich ',
        'Eclair',
        'Cupcake',
        'Gingerbread',
        'Jelly bean',
        'Lollipop',
        'Honeycomb',
        'Donut',
        'KitKat',
        null
      ];
      for (let i = 0; i < 100; i++) {
        let dessert = {
          id: i,
          name: dessertNames[Math.floor(Math.random() * dessertNames.length)],
          secondName: dessertNames[8 + Math.floor(Math.random() * (dessertNames.length - 8))],
          fat: Math.random() * 100,
          carbs: Math.floor(Math.random() * 100),
          protein: Math.random() * 10
        };
        this.desserts.push(dessert);
      }
    },
    async countMaxValues(array) {
      this.timerStart = Date.now();
      for (const item of array) {
        await this.countMaxValue(item).catch(() => {
          //Even when one request throws error we should not stop others
        })
      }
    },
    async countMaxValue(item) {
      await new Promise(resolve => setTimeout(resolve, 50)).then(() => {
        let maxVal = Math.random() * 100;
        item.maxValue = maxVal < 20 ? null : maxVal;
        this.desserts.splice(item.id, 1, item);
      });
    }
  }
})


  
    
        
    
    {{ "Page loading time (sec): " + (loadingTime || '...') }}

user_2438933 · Answer

It seems Vue can update DOM more efficient if it is wrap in component (Sorry, I don't know in detail why).

This is your original code in JSFiddle. It will use around 12-13 seconds.

Then I create a component which wrap your entire tr:

const Tr = {
  props: {
    item: Object
  },
    template: `
    
      ... // change props.item to item
    
  `
}

new Vue({
  el: '#app',
  vuetify: new Vuetify(),
  components: {
    'tr-component': Tr // register Tr component
  },
  ...

  async countMaxValue(item) {
    await new Promise(resolve => setTimeout(resolve, 50)).then(() => {
      let maxVal = Math.random() * 100;
      // update entire object instead of one property since we send it as object to Tr
      let newItem = {
        ...item,
        maxValue: maxVal < 20 ? null : maxVal
      }
      this.desserts.splice(newItem.id, 1, newItem);
    });
  }
})

And your html will looks like:

The result will use around 6-7 seconds which is only 1-2 seconds to update DOM.

Or if you find out that your function trigger very fast (In your example use 50ms which is too fast in my opinion) you could try throttle it to less update DOM.

...
methods: {
  async countMaxValue(item) {
    await new Promise(resolve => setTimeout(resolve, 50)).then(() => {
      let maxVal = Math.random() * 100;
      let newItem = {
        ...item,
        maxValue: maxVal < 20 ? null : maxVal
      }
      this.changes.push(newItem) // keep newItem to change later
      this.applyChanges() // try to apply changes if it already schedule it will do nothing
    });
  },
  applyChanges () {
    if (this.timeoutId) return
    this.timeoutId = setTimeout(() => {
      while (this.changes.length) {
        let item = this.changes.pop()
        this.desserts.splice(item.id, 1, item)
      }
      this.timeoutId = null
    }, 1500)
  }
}

The result will use around 5-6 seconds but as you can see it's not immediately update.

Or you may try to call your API in parallel such as 10 requests, you could reduce from to wait 100 * 50 ms to around 10 * 50 ms (mathematically).

I hope this help.

Increasing performance of v-data-table with custom cells and async data loading

1 Answers