How to group by year? (month and day already working)

Question

This is for a Google Sheet which uses GAS but I was advised to try Javascript Tag.

So I got this script which will read column 1 where I have the dates, and will group all rows by month and within these will group rows by day. This is because within each day I've got a row for every hour or 4 hours or so.

I need this script to also group by year as well. So it goes like: Year Row -> Month Rows -> Day Rows

Month and day rows are working. I can't get the year grouping to work. Any ideas where to start?

The script:

function groupRow() {

    const timeZone = "GMT+1";
    const sheet = SpreadsheetApp.getActiveSheet();
    const rowStart = 5;
    const rows = sheet.getLastRow() - rowStart + 1;
    const values = sheet.getRange(rowStart, 1, rows, 1).getValues().flat();
    const o = [];

    values.forEach((date, i) => {
        const [m, d] = Utilities.formatDate(date, timeZone, "yyyyMM,dd").split(",");
        if (!o[m]) {
            o[m] = [];
        }
        if (!o[m][d]) {
            o[m][d] = [];
        }
        o[m][d].push(rowStart + i);
    });

    for (var m in o) {
     o[m] = Object.values(o[m]).sort((a,b) => parseInt(a) - parseInt(b));
    }

    Object.values(o).forEach(m => {
        for (const d of m) {
            if (d.length === 1) {
            continue;
            }
            const range = `${ d[1] }:${ d.slice(-1)[0] }`;
            sheet.getRange(range).shiftRowGroupDepth(1);
        }
        const a = m.flat();
        if (a.length === 1) {
            return;
        }
        const range = `${ a[1] }:${ a.slice(-1)[0] }`;
        sheet.getRange(range).shiftRowGroupDepth(1);
    });
}

Here's the link for dummy file: https://docs.google.com/spreadsheets/d/1ExXtmQ8nyuV1o_UtabVJ-TifIbORItFMWjtN6ZlruWc/edit?usp=sharing

Answer 1

Well, it's me again. :) I can't sleep whenever there is some unsolved code.

It seems work to a degree:

function groupRow() {

  var timeZone = "GMT+1";
  var sheet = SpreadsheetApp.getActiveSheet();
  var rowStart = 5;
  var rows = sheet.getLastRow() - rowStart + 1;
  var values = sheet.getRange(rowStart, 1, rows, 1).getValues().flat();
  var o = {};

  // make the object {'year': { 'month':[days] } }
  values.forEach((date, i) => {
      var [y, m, d] = Utilities.formatDate(date, timeZone, "yyyy,MM,dd").split(",");
      // console.log(y, m, d);
      if (!o[y]) o[y] = {};
      if (!o[y][m]) o[y][m] = {};
      if (!o[y][m][d]) o[y][m][d] = [];
      o[y][m][d].push(rowStart + i);
  });
  
  // convert the unordered object {year:{month:[days]}}
  // into the ordered 3d-array [year[month[days]]]
  const numsort = (a,b) => parseInt(a) - parseInt(b);
  var years = Object.keys(o).sort(numsort)
    .map(y => Object.keys(o[y]).sort(numsort)
    .map(m => Object.values(o[y][m]).sort(numsort)));
  
  // group rows by years
  years.forEach(y => shift_rows(y.map(m => m.flat()).flat(),sheet));

  // group rows by months
  years.flat().forEach(m => shift_rows(m.flat(),sheet));

  // group rows by days
  years.flat().flat().forEach(d => shift_rows(d.flat(),sheet));

  function shift_rows(rows,sheet) {
    if (rows.length === 1) return;
    var range = `${ rows[1] }:${ rows.slice(-1) }`;
    sheet.getRange(range).shiftRowGroupDepth(1);
  }

}

But the code is really complicated already. It's need to test and... most likely, to rewrite it from scratch.

Answer 2

This approach to handling row groups tries to focus on readability/maintainability over efficiency, by minimizing array manipulation. If the code runs too slowly, then you can consider performance optimizations - but those can generally make the code harder to read.

It also tries to make the code easier to test by breaking it down into multiple separate functions, where each function tries to do as little logic as possible (I'm sure that could be improved & simplified, even further).

It makes 3 passes over the dates data, one for each type of grouping (year, month, and date). That's the big compromise vs. efficiency.

I've presented it here as a runnable snippet with some hard-coded data, not as a full GAS script, since the core of the logic is pure JavaScript.

var src_data = [
  'Thu Aug 26 2021 21:27:26 GMT-0400 (Eastern Daylight Time)',
  'Fri Aug 27 2021 21:27:26 GMT-0400 (Eastern Daylight Time)',
  'Fri Aug 27 2021 23:51:26 GMT-0400 (Eastern Daylight Time)',
  'Sun Aug 29 2021 09:27:26 GMT-0400 (Eastern Daylight Time)',
  'Sat Sep 04 2021 07:03:26 GMT-0400 (Eastern Daylight Time)',
  'Sat Sep 04 2021 16:39:26 GMT-0400 (Eastern Daylight Time)',
  'Fri Sep 17 2021 00:49:02 GMT-0400 (Eastern Daylight Time)',
  'Fri Sep 17 2021 03:13:02 GMT-0400 (Eastern Daylight Time)',
  'Wed Sep 22 2021 03:13:02 GMT-0400 (Eastern Daylight Time)',
  'Tue Sep 28 2021 03:13:02 GMT-0400 (Eastern Daylight Time)',
  'Wed Sep 29 2021 11:22:38 GMT-0400 (Eastern Daylight Time)',
  'Wed Sep 29 2021 12:34:38 GMT-0400 (Eastern Daylight Time)',
  'Mon Oct 11 2021 12:34:38 GMT-0400 (Eastern Daylight Time)',
  'Tue Oct 12 2021 19:46:38 GMT-0400 (Eastern Daylight Time)',
  'Thu Nov 04 2021 19:46:38 GMT-0400 (Eastern Daylight Time)',
  'Mon Nov 29 2021 09:13:02 GMT-0500 (Eastern Standard Time)',
  'Thu Dec 23 2021 22:39:26 GMT-0500 (Eastern Standard Time)',
  'Mon Jan 17 2022 12:05:50 GMT-0500 (Eastern Standard Time)',
  'Fri Feb 11 2022 01:32:14 GMT-0500 (Eastern Standard Time)',
  'Mon Mar 07 2022 14:58:38 GMT-0500 (Eastern Standard Time)',
  'Mon Mar 07 2022 14:58:39 GMT-0500 (Eastern Standard Time)' 
];


var dates = src_data.map(d => new Date(d));

// The starting row of our data in the spreadsheet:
var rowStart = 5;

// We will compare each new date against the previous date to see
// if the period has changed:
var prevDate;

// Build a range of potentially groupable dates, because they share the
// same period. These are the array range start & end positions:
var rangeStart;
var rangeEnd;

// the type of grouping to create:
var groupingPeriod;

//
// entry point:
//
groupDates('year');
groupDates('month');
groupDates('date');

// process the array of dates:
function groupDates(period) {
  groupingPeriod = period;
  console.log('finding groups by ' + period + ':') ;
  dates.forEach((date, idx) => {
    // The first date is a special case:
    if (idx === 0) {
      processInitialDate(date);
    } else {
      // everything which is not the first date:
      processDate(date, idx);
    }
  } );
}

// Some initial set-up (and we know we cannot create
// a group containing only the first date):
function processInitialDate(date) {
  prevDate = date;
  rangeStart = 0;
  rangeEnd = rangeStart;
}

// All dates except the first one:
function processDate(date, idx) {
  if (periodHasChanged(date, prevDate, groupingPeriod)) {
      createGroup();
      // start a new range:
      rangeStart = rangeEnd +1; 
      rangeEnd = rangeStart;
  } else {
    // extend the current range:
    rangeEnd++;
    // the final value in the array is a special case, which
    // would otherwise not be processed (because there is no 
    // "next" date to compare it against):
    if (idx === dates.length -1) {
      createGroup();
    }
  }
  prevDate = date;
}

function periodHasChanged(currDate, prevDate, period) {
  switch(period) {
    case 'year':
      var currPeriod = currDate.getYear();
      var prevPeriod = prevDate.getYear();
      break;
    case 'month':
      var currPeriod = currDate.getMonth();
      var prevPeriod = prevDate.getMonth();
      break;
    case 'date':
      var currPeriod = currDate.getDate();
      var prevPeriod = prevDate.getDate();
      break;
  }
  return currPeriod !== prevPeriod;
}

function createGroup() {
  var rangeGroup = dates.slice(rangeStart, rangeEnd +1);
  // only create the group if it contains at least 2 dates:
  if (rangeGroup.length > 1) {
    // make the group here - but for testing, we just log it to the console:
    // TODO - build the sheet range, by adjusting the array rangeStart 
    // and rangeEnd values, using the rowStart value defined earlier.
    //range.shiftRowGroupDepth(1); 
    console.log( rangeGroup );
  }
}

<!doctype html>
<html>
<head>
  <meta charset="UTF-8">
  <title>Demo</title>
</head>

<body>

</body>
</html>

---

Here is the full GAS script I used:

function groupingDemo() {
  //const timeZone = "GMT+1";
  rowStart = 5;
  sheet = SpreadsheetApp.getActiveSheet();
  rows = sheet.getLastRow() - rowStart + 1;
  dates = sheet.getRange(rowStart, 1, rows, 1).getValues().flat();

  groupDates(dates, 'year');
  groupDates(dates, 'month');
  groupDates(dates, 'date');
}

// spreadsheet items:
var sheet;
var rowStart;
var dates;

// We will compare each new date against the previous date to see
// if the period has changed:
var prevDate;

// Build a range of potentially groupable dates, because they share the
// same period. These are the array range start & end positions:
var rangeStart;
var rangeEnd;

// the type of grouping to create:
var groupingPeriod;

// process the array of dates:
function groupDates(dates, period) {
  groupingPeriod = period;
  console.log('finding groups by ' + period + ':') ;
  dates.forEach((date, idx) => {
    // The first date is a special case:
    if (idx === 0) {
      processInitialDate(date);
    } else {
      // everything which is not the first date:
      processDate(date, idx);
    }
  } );
}

// Some initial set-up (and we know we cannot create
// a group containing only the first date):
function processInitialDate(date) {
  prevDate = date;
  rangeStart = 0;
  rangeEnd = rangeStart;
}

// All dates except the first one:
function processDate(date, idx) {
  if (periodHasChanged(date, prevDate, groupingPeriod)) {
      createGroup();
      // start a new range:
      rangeStart = rangeEnd +1; 
      rangeEnd = rangeStart;
  } else {
    // extend the current range:
    rangeEnd++;
    // the final value in the array is a special case, which
    // would otherwise not be processed (because there is no 
    // "next" date to compare it against):
    if (idx === dates.length -1) {
      createGroup();
    }
  }
  prevDate = date;
}

function periodHasChanged(currDate, prevDate, period) {
  switch(period) {
    case 'year':
      var currPeriod = currDate.getYear();
      var prevPeriod = prevDate.getYear();
      break;
    case 'month':
      var currPeriod = currDate.getMonth();
      var prevPeriod = prevDate.getMonth();
      break;
    case 'date':
      var currPeriod = currDate.getDate();
      var prevPeriod = prevDate.getDate();
      break;
  }
  return currPeriod !== prevPeriod;
}

function createGroup() {
  const sheet = SpreadsheetApp.getActiveSheet();
  var rangeGroup = dates.slice(rangeStart, rangeEnd +1);
  // only create the group if it contains at least 2 dates:
  if (rangeGroup.length > 1) {
    // make a new group (we use the "+1" to avoid contiguous groups being merged):
    var range = `${ rowStart + rangeStart +1 }:${ rowStart + rangeEnd }`;
    sheet.getRange(range).shiftRowGroupDepth(1);

    // uncomment these to see what's going on:
    //console.log( rangeGroup );
    //console.log( 'sheet rows: ' + `${ rowStart + rangeStart +1 }:${ rowStart + rangeEnd }` )
  }
}

The results:

And if you un-comment the logging statements, you see the following logs:

finding groups by year:

[ Thu Aug 26 2021 21:27:26 GMT-0400 (Eastern Daylight Time),
  Fri Aug 27 2021 21:27:26 GMT-0400 (Eastern Daylight Time),
  Fri Aug 27 2021 23:51:26 GMT-0400 (Eastern Daylight Time),
  Sun Aug 29 2021 09:27:26 GMT-0400 (Eastern Daylight Time),
  Sat Sep 04 2021 07:03:26 GMT-0400 (Eastern Daylight Time),
  Sat Sep 04 2021 16:39:26 GMT-0400 (Eastern Daylight Time),
  Fri Sep 17 2021 00:49:02 GMT-0400 (Eastern Daylight Time),
  Fri Sep 17 2021 03:13:02 GMT-0400 (Eastern Daylight Time),
  Wed Sep 22 2021 03:13:02 GMT-0400 (Eastern Daylight Time),
  Tue Sep 28 2021 03:13:02 GMT-0400 (Eastern Daylight Time),
  Wed Sep 29 2021 11:22:38 GMT-0400 (Eastern Daylight Time),
  Wed Sep 29 2021 12:34:38 GMT-0400 (Eastern Daylight Time),
  Mon Oct 11 2021 12:34:38 GMT-0400 (Eastern Daylight Time),
  Tue Oct 12 2021 19:46:38 GMT-0400 (Eastern Daylight Time),
  Thu Nov 04 2021 19:46:38 GMT-0400 (Eastern Daylight Time),
  Mon Nov 29 2021 09:13:02 GMT-0500 (Eastern Standard Time),
  Thu Dec 23 2021 22:39:26 GMT-0500 (Eastern Standard Time) ]

sheet rows: 6:21

[ Mon Jan 17 2022 12:05:50 GMT-0500 (Eastern Standard Time),
  Fri Feb 11 2022 01:32:14 GMT-0500 (Eastern Standard Time),
  Mon Mar 07 2022 14:58:38 GMT-0500 (Eastern Standard Time) ]

sheet rows: 23:24

finding groups by month:

[ Thu Aug 26 2021 21:27:26 GMT-0400 (Eastern Daylight Time),
  Fri Aug 27 2021 21:27:26 GMT-0400 (Eastern Daylight Time),
  Fri Aug 27 2021 23:51:26 GMT-0400 (Eastern Daylight Time),
  Sun Aug 29 2021 09:27:26 GMT-0400 (Eastern Daylight Time) ]

sheet rows: 6:8

[ Sat Sep 04 2021 07:03:26 GMT-0400 (Eastern Daylight Time),
  Sat Sep 04 2021 16:39:26 GMT-0400 (Eastern Daylight Time),
  Fri Sep 17 2021 00:49:02 GMT-0400 (Eastern Daylight Time),
  Fri Sep 17 2021 03:13:02 GMT-0400 (Eastern Daylight Time),
  Wed Sep 22 2021 03:13:02 GMT-0400 (Eastern Daylight Time),
  Tue Sep 28 2021 03:13:02 GMT-0400 (Eastern Daylight Time),
  Wed Sep 29 2021 11:22:38 GMT-0400 (Eastern Daylight Time),
  Wed Sep 29 2021 12:34:38 GMT-0400 (Eastern Daylight Time) ]

sheet rows: 10:16

[ Mon Oct 11 2021 12:34:38 GMT-0400 (Eastern Daylight Time),
  Tue Oct 12 2021 19:46:38 GMT-0400 (Eastern Daylight Time) ]

sheet rows: 18:18

[ Thu Nov 04 2021 19:46:38 GMT-0400 (Eastern Daylight Time),
  Mon Nov 29 2021 09:13:02 GMT-0500 (Eastern Standard Time) ]

sheet rows: 20:20

finding groups by date:

[ Fri Aug 27 2021 21:27:26 GMT-0400 (Eastern Daylight Time),
  Fri Aug 27 2021 23:51:26 GMT-0400 (Eastern Daylight Time) ]

sheet rows: 7:7

[ Sat Sep 04 2021 07:03:26 GMT-0400 (Eastern Daylight Time),
  Sat Sep 04 2021 16:39:26 GMT-0400 (Eastern Daylight Time) ]

sheet rows: 10:10

[ Fri Sep 17 2021 00:49:02 GMT-0400 (Eastern Daylight Time),
  Fri Sep 17 2021 03:13:02 GMT-0400 (Eastern Daylight Time) ]

sheet rows: 12:12

[ Wed Sep 29 2021 11:22:38 GMT-0400 (Eastern Daylight Time),
  Wed Sep 29 2021 12:34:38 GMT-0400 (Eastern Daylight Time) ]

sheet rows: 16:16