GAS Googleカレンダーのイベント時間を区間別に集計

Question

前提・実現したいこと

独学で勉強を始めたばかりで、コードが読みづらかったらすみません。
GASでGoogleカレンダーの一定期間内のイベントをすべて取得し、
時間を区間別6:00~8:00 8:00~18:00 18:00~22:00 22:00~6:00に集計させるシステムを作っています。

下記コードが、イベント一つひとつを設定時間で区切り、配列を組みなおす部分です。
main()内startTime endTimeは取り出した一つのイベントの開始時刻、終了時刻です。

ご質問は、

• separateTime()の簡略化
• getFirst()の一般化（現在3日以上の長さのイベントが考慮されていない）
• もっと簡単な集計方法 or 考え方はないか？

です。
お知恵をお貸しいただけたら幸いです。
よろしくお願いいたします。

function main() {
  const startTime = new Date('2021/11/19 23:00')
  const endTime = new Date('2021/11/20 7:00')

  Logger.log(separateTime(startTime, endTime))
  // {blocks=[[Fri Nov 19 23:00:00 GMT+09:00 2021, Sat Nov 20 06:00:00 GMT+09:00 2021], [Sat Nov 20 06:00:00 GMT+09:00 2021, Sat Nov 20 07:00:00 GMT+09:00 2021]], 
  //  diff=[7.0, 1.0], 
  //  index=4.0}
}

// sepの時間で分割する
function separateTime(startTime, endTime) {
  const separatePoints = getFirst(startTime);
  const sep = separatePoints[0];
  const index = separatePoints[1];


  if (!(sep < endTime)) {
    return {
      blocks : [[startTime, endTime]],
      diff : [(endTime - startTime) / 1000 / 3600],
      index : index
    };
  }

  const sep2 = getFirst(sep);
  if (!(sep2 < endTime)) {
    return {
      blocks : [[startTime, sep], [sep, endTime]],
      diff : [(sep - startTime) / 1000 / 3600, (endTime - sep) / 1000 / 3600],
      index : index
    };
  }

  const sep3 = getFirst(sep2);
  if (!(sep3 < endTime)) {
    return {
      blocks : [[startTime, sep], [sep, sep2], [sep2, endTime]],
      diff : [(sep - startTime) / 1000 / 3600, (sep2 - sep) / 1000 / 3600, (endTime - sep2) / 1000 / 3600],
      index : index
    };
  }

  const sep4 = getFirst(sep3);
  if (!(sep4 < endTime)) {
    return {
      blocks : [[startTime, sep], [sep, sep2], [sep2, sep3], [sep3, endTime]],
      diff : [(sep - startTime) / 1000 / 3600, (sep2 - sep) / 1000 / 3600, (sep3 - sep2) / 1000 / 3600, (endTime - sep3) / 1000 / 3600],
      index : index
    };
  }

  const sep5 = getFirst(sep4);
  if (!(sep5 < endTime)) {
    return {
      blocks : [[startTime, sep], [sep, sep2], [sep2, sep3], [sep3, sep4], [sep4, endTime]],
      diff : [(sep - startTime) / 1000 / 3600, (sep2 - sep) / 1000 / 3600, (sep3 - sep2) / 1000 / 3600, (sep4 - sep3) / 1000 / 3600, (endTime - sep4) / 1000 / 3600],
      index : index
    };
  }

  const sep6 = getFirst(sep5);
  if (!(sep6 < endTime)) {
    return {
      blocks : [[startTime, sep], [sep, sep2], [sep2, sep3], [sep3, sep4], [sep4, sep5], [sep5, endTime]],
      diff : [(sep - startTime) / 1000 / 3600, (sep2 - sep) / 1000 / 3600, (sep3 - sep2) / 1000 / 3600, (sep4 - sep3) / 1000 / 3600, (sep5 - sep4) / 1000 / 3600, (endTime - sep5) / 1000 / 3600],
      index : index
    };
  }

  const sep7 = getFirst(sep6);
  if (!(sep7 < endTime)) {
    return {
      blocks : [[startTime, sep], [sep, sep2], [sep2, sep3], [sep3, sep4], [sep4, sep5], [sep5, sep6], [sep6, endTime]],
      diff : [(sep - startTime) / 1000 / 3600, (sep2 - sep) / 1000 / 3600, (sep3 - sep2) / 1000 / 3600, (sep4 - sep3) / 1000 / 3600, (sep5 - sep4) / 1000 / 3600, (sep6 - sep5) / 1000 / 3600, (endTime - sep6) / 1000 / 3600],
      index : index
    };
  }

  return {
    blocks : [[startTime, sep], [sep, sep2], [sep2, sep3], [sep3, sep4], [sep4, sep5], [sep5, sep6], [sep6, sep7], [sep7, endTime]],
    diff : [(sep - startTime) / 1000 / 3600, (sep2 - sep) / 1000 / 3600, (sep3 - sep2) / 1000 / 3600, (sep4 - sep3) / 1000 / 3600, (sep5 - sep4) / 1000 / 3600, (sep6 - sep5) / 1000 / 3600, (sep7 - sep6) / 1000 / 3600, (endTime - sep7) / 1000 / 3600],
    index : index
    };
}

// startTimeに合わせて初期値を取得
function getFirst(startTime) {
  const point = ['6:00', '8:00', '18:00', '22:00', '30:00', '32:00', '42:00', '46:00'];

  const start = new Date(startTime);
  const d = [];

  // startTime以降の最初の時間を取得
  for (let i of point) {
    start.setHours(i.match(/.*:/)[0].replace(':', ''));
    start.setMinutes(i.match(/:.*/)[0].replace(':', ''));
    d.push(Math.floor((start - startTime) / 1000 / 3600));
  }

  const index = d.findIndex(function(element){
    return element > 0 && function (a, b) {return Math.min(a, b);};
  });
  
  const ret = new Date(startTime);
  ret.setHours(point[index].match(/.*:/)[0].replace(':', ''));
  ret.setMinutes(point[index].match(/:.*/)[0].replace(':', ''));

  return [ret, index];
}

Comments

[退会済みユーザー]

たとえば、main()の中の日時を
const startTime = new Date('2021/11/19 3:00')
const endTime = new Date('2021/11/19 19:00')
に変えて実行したとき、blocksは
[[03:00,06:00],[06:00,19:00]]　　（日付は省略し、時刻はわかりやすい表記にしています）
となりますが、これは期待する動作なのでしょうか？
文面からすると
[[03:00,06:00],[06:00,08:00],[08:00,18:00],[18:00,19:00]]
となるのが実際に期待する動作である、という理解でよろしいでしょうか？

[msmll0]

ほんとだ..気づかなかったです。
おっしゃる通りです。
下の配列が期待する戻り値です。

Answer 1

・考え方
1日の区切り点を持った定規のようなものがあり、
この定規を前後に並べた無限の長さのタイムラインのようなものがあるとみなします。

そのタイムライン上に、分割対象となるスケジュール（target）がのっかっているとみなします。

これを最終的には下の図の2番目のような形に分割したいということになります。

分割手順は下記のようになります。

１．targetの開始時刻に一番近いタイムライン（定規の左端の部分）をスタート地点にセットします。
便宜上、この部分の時刻を「edge」（端）と呼ぶことにします。

２．このedgeを、各区切り時間の分だけ加算していき、その都度edgeとtargetの開始時刻を比較します。
（「edgeを後ろに伸ばしていく」）

「edgeが示す時刻 ≦ targetの開始時刻」である間は、まだ分割を開始せず、次の区切り時間を加算してedgeを右に進めるだけです。

３．「edgeが示す時刻＞targetの開始時刻」 となったら分割処理を開始します。

edgeを区切り時間分だけ進めながら、その都度edgeのところで分割し、分割した時刻データを格納していきます。

　
４．edgeを進めていき、「edgeが示す時刻 ≧ targetの終了時刻」になったら、最後のデータを格納して分割を終了します。

---

参考ソースコードは以下になります。

class BreakPointsRuler {
  
  /**
   * BreakPointsRulerのインスタンスを生成します.
   * BreakPointsRulerは、区切り時刻間隔のテーブル `intervals`と
   * スケジュールの分割基準となる日付時刻 `edge` を保持します。
   * 
   * @param {Array[Date]} points 区切り時刻（日付オブジェクト）の配列
   * @param {Date} startDate 分割対象スケジュールの開始時刻
   * @memberof BreakPointsRuler
   */
  constructor(points, startDate) {

    /**
     * 分割基準となる現時点の区切り時刻を表します。
     * getNextEdge()を呼び出すと、内部に保持されている区切り
     * 時間間隔が加算された値に変わります。
     * @type {Date}
     */
    this.edge = this.getNearestEdge(points, startDate);

    /**
     * 区切り時刻の時間間隔の配列です。
     * @type {Array[Date]}
     */
    this.intervals = this.getIntervals(points);

    /**
     * intervals内の要素を循環して返すためのインデックスカウンターです。
     * @type {number}
     */
    this.counter = 0;
  }

  /**
   * 現在のedgeを返す関数です。
   * @return {Date} 現在のedge 
   * @memberof BreakPointsRuler
   */
  getEdge() {
    return new Date(this.edge.getTime());
  }

  /**
   * 指定された区切り時刻配列の最初の要素を、
   * 指定されたスケジュールイベントの開始日時を越えない
   * 最も近い日付に変換して返します。
   * @param {Array[Date]} points 区切り時刻の配列
   * @param {Date} startDate 分割対象スケジュールの開始時刻
   * @return {Date} イベントの開始時刻に最も近い日付時刻
   * @memberof BreakPointsRuler
   */
  getNearestEdge(points, startDate) {
    const nearestEdge = new Date();
    // スケジュールの開始時刻が、 指定された区切り時刻よりも早い場合は
    // 開始地点を1日前に設定する。
    if (startDate.getHours() < points[0].getHours()) {
      nearestEdge.setDate(startDate.getDate() - 1);
    } else {
      nearestEdge.setDate(startDate.getDate());
    }

    // 時/分/秒を区切り時刻と同じ値に設定する。ミリ秒はゼロに初期化する。
    nearestEdge.setHours(
      points[0].getHours(),
      points[0].getMinutes(),
      points[0].getSeconds(),
      0
    );

    return nearestEdge;
  }

  /**
   * 指定された区切り時刻配列の各要素の
   * 間隔（ミリ秒）の配列を返します。
   * 
   * 与えられる区切り時刻の配列は昇順でなければなりません。
   * 最後の要素は、最初の要素に24時間を足した時刻と元データ
   * の最後の要素の時刻の差になります。
   * 
   * 配列内の要素の合計は86400000(24時間*60分*60秒*1000）となります。
   * 
   * 例）["1:00","9:00","21:00"]
   *   -> [3600000,  28800000, 43200000, 14400000]
   * 
   * @param {Array[Date]} points 区切り時刻の配列
   * @return {Array[number]}  指定された区切り時刻配列の各要素の間隔(ミリ秒)
   * @memberof BreakPointsRuler
   */
  getIntervals(points) {
    //最初の区切り時刻を1日加算して、翌日の区切り時刻を作っておく。
    const next = new Date(points[0].getTime());
    next.setDate(points[0].getDate() + 1);

    // 前後の時間差（秒数）を計算し配列に格納
    const intervals = points.map((e, idx, ary) => {
      if (idx === points.length - 1)
        // 翌日の1番目のpointと当日の最後のpointの時間差
        return next.getTime() - ary[idx].getTime();
      else
        // 次のpointとの時間差
        return ary[idx + 1].getTime() - e.getTime();
    })
    return intervals;
  }


  /**
   * 現在のedgeが示す日付時刻に次の区切り時刻までの時間間隔を加算した
   * 日付時刻を返す関数です。
   * 
   * この関数を実行すると、このクラスの内部変数edgeが更新されるとともに、
   * 更新されたedgeと同じ日付時刻を持つ新しい日付オブジェクトが返されます。
   * 
   * 加算する時間間隔は、この関数を呼び出すごとに順繰りに変わります。
   * 
   * @return {Date} 現在のedgeに、次の区切り時間間隔を加算した日付時刻
   * @memberof BreakPointsRuler
   */
  getNextEdge() {
    // edgeに区切り時間を加算
    this.edge = new Date(this.edge.getTime() + this.intervals[this.counter]);
    // カウンターをインクリメント。
    // ただし配列長に一致した場合はゼロに戻す。
    this.counter++;
    if (this.counter % this.intervals.length === 0) this.counter = 0;
    
    return new Date(this.edge.getTime());
  }

}

/**
 *  1日内の区切り時刻を表す文字列（HH:mm形式）の配列を
 *  日付時刻の配列に変換します。
 * 呼び出し例）
 *  convertPoints(["01:00","09:00","21:00"])
 * @param {Array[string]} points 1日内の区切りを表す文字列（HH:mm形式）の配列
 * @return {Array[Date]} pointsに対応する日付時刻の配列 
 */
function convertPoints(points) {
  return points.map(
    point => new Date(
      2021,1,1,
      parseInt(point.match(/.*:/)[0].replace(':', '')),
      parseInt(point.match(/:.*/)[0].replace(':', '')),
      0,0
    )
  );
}

function main() {
  const startTime = new Date('2021/11/19 03:00')
  const endTime = new Date('2021/11/19 19:00')

  const point = ['6:00', '8:00', '18:00', '22:00'];
  
  // pointの要素を日付時刻型に変換
  const points = convertPoints(point);

  const ruler = new BreakPointsRuler(points, startTime)

  let edge = ruler.getEdge();

  let start = new Date(startTime);

  // 結果格納用の配列
  const result = [];

  // ２．「edgeが示す時刻 ≦ targetの開始時刻」である間は、
  //  まだ分割を開始せず、次の区切り時間を加算してedgeを右に進めるだけ。
  while (edge.getTime() <= startTime.getTime()) {
    edge = ruler.getNextEdge();
  }

  // ３．「edgeが示す時刻＞targetの開始時刻」 となったら分割処理を開始。  

  // edgeが示す時刻＜targetの終了時刻の間、通常の分割処理を行う
  while (edge.getTime() < endTime.getTime()) {
    // 分割した時刻の端点をresultに格納
    result.push([start, edge]);

    // startを現在のedgeの時刻に更新する。
    start = new Date(edge);

    // edgeを区切り時間分だけ進める。
    edge = ruler.getNextEdge();
  } 

  // ４．edgeが示す時刻≧targetの終了時刻になったら
  // 最後のピースを格納して分割を終了   
  result.push([start, endTime]);
  
  // 結果の表示
  Logger.log(result.map(e => 
      Utilities.formatDate(e[0],"Asia/Tokyo","MM/dd HH:mm:ss")+ "~"
    + Utilities.formatDate(e[1],"Asia/Tokyo","MM/dd HH:mm:ss")).join('\n'));
}

---

#【補足】

現在3日以上の長さのイベントが考慮されていない

御記載の通り、元質問文では、イベントの長さに対応した固定の配列を用意しておき
for文でその配列の要素を順番に呼び出して、スケジュールを分割しようとされています。

  const point = ['6:00', '8:00', '18:00', '22:00', '30:00', '32:00', '42:00', '46:00'];
略
  // startTime以降の最初の時間を取得
  for (let i of point) {
（以下略）

しかし、無限の長さの固定配列を用意する必要はありません。

区切り時刻のデータは1日分の繰り返しになっているので、24時間ごとに同じ間隔が繰り返されます。

 ['6:00', '8:00', '18:00', '22:00']

=>　区切り時間の間隔は、「2時間、10時間、4時間、8時間・・・」の繰り返し

したがって、１つの区切り時刻のデータから、順番に時間間隔を取り出せる仕組みがあればよいということになります。

これを実現しているのが、BreakPointsRulerクラス内のgetNextEdge()関数になります。

    
    this.counter = 0;
（略）
  getNextEdge() {
    // edgeに区切り時間を加算
    this.edge = new Date(this.edge.getTime() + this.intervals[this.counter]);
    // カウンターをインクリメント。
    // ただし配列長に一致した場合はゼロに戻す。
    this.counter++;
    if (this.counter % this.intervals.length === 0) this.counter = 0;
    
    return new Date(this.edge.getTime());
  }

getIntervals関数にて、区切り時刻のデータ ['6:00', '8:00', '18:00', '22:00']を
あらかじめ、時間間隔の配列intervalsに変換して保持しておきます。

上記の例だと

6:00 -> 8:00 : 2h = 7200000 ms （ミリ秒）
8:00 -> 18:00 : 10h = 36000000 ms
18:00 -> 22:00 : 4h = 14400000 ms
22:00 -> 6:00 : 8h = 28800000 ms

以上より、

intervals = [7200000,36000000,14400000,28800000]

に変換されます。

edge += interval[counter] とすることで、edgeを各時間間隔分だけ動かすことができます。

オブジェクト内で counterを保持しておき、getNextEdge()を呼び出すごとに
counter(インデックス) を１加算します。

counter が intervals配列の最大値に達したら、counter をゼロにします。

このようにすることで、たとえばintervalsの要素数が4つの場合、
counterは、0 -> 1 -> 2 -> 3 -> 0 -> 1 -> 2 -> 3...
と無限に繰り返すことになり、順番に区切り時刻の間隔を呼び出せます。

（他にはジェネレータを使う方法もあります）

Comments

[msmll0]

図までご用意いただいて丁寧にご教授くださり、誠にありがとうございます。
考え方・補足共に初心者でも理解しやすく、感謝の念に堪えません。

特に、
・２．このedgeを、各区切り時間の分だけ加算していき、その都度edgeとtargetの開始時刻を比較します。
（「edgeを後ろに伸ばしていく」）
・１つの区切り時刻のデータから、順番に時間間隔を取り出せる仕組みがあればよい

この2つの考え方とその実装には衝撃が走りました。
時間を点（定刻）ではなく線（間隔）として捉え、それをつなげる（加算する）ことで無限（一般化）を表現できるのですね。
また、オブジェクト指向は今まで便利そうだと思っても設計方法や使い方が分からずすべて配列でごり押ししていました。
オブジェクト指向はより汎用性に富む考え方なのですね。簡単に見やすい仕組みも作れますし..

このご回答により、考え方の幅が倍以上に伸びた所感です。
今後はオブジェクト指向を意識して、頂いた考え方を幅広く実現させられる技術を得ることを目的に経験を積みたいと思います。
ありがとうございました。