问如何在javascript中创建一个包含2种数据类型的块函数

EN

let strings = Array(10).fill('title');
let objects = Array.from({ length: 30 }, () => ({ title: 'title', id: 'id' }));
function shuffle(arr1, arr2) {
  if (!arr1.length || !arr2.length) return [...arr1, ...arr2];
  return Math.random() > 0.5
    ? [arr1[0], ...shuffle(arr1.slice(1), arr2)]
    : [arr2[0], ...shuffle(arr1, arr2.slice(1))];
}
const data = shuffle(objects, strings);
console.log('Data: ', data);


function splitChunks(data, groupSize) {
  let cache = [];
  const chunks = data.reduce((acc, val) => {
    if (val.title) {
      cache.push(val);
      if (cache.length === groupSize) {
        acc.push(cache);
        cache = [];
      }
    } else {
      acc.push(val);
    }
    return acc;
  }, []);

  if (cache.length) {
    chunks.push(cache);
  }
  return chunks;
}

let chunks = splitChunks(data, 4);
console.log('Chunks:', chunks);

type UnchunkedArray<T> = (string | T)[];
type ChunkedArray<T> = ([string] | T[])[];

type DataObject = {
  id: number;
  title:string;
};

// Generate input array test data:
function createUnchunkedArray ({
  groups = 3,
  minGroupLength = 7,
  maxGroupLength = 10,
} = {}): UnchunkedArray<DataObject> {
  let id = 0;
  const array: UnchunkedArray<DataObject> = [];

  for (let group = 0; group < groups; group += 1) {
    array.push(`group ${group}`);

    const groupLength = Math.floor(
      Math.random()
      * (maxGroupLength - minGroupLength + 1)
    ) + minGroupLength;

    for (let i = 0; i < groupLength; i += 1) {
      array.push({id, title: `title ${group}-${i}`});
      id += 1;
    }
  }

  return array;
}

function chunkByCount (
  input: UnchunkedArray<DataObject>,
  count: number,
): ChunkedArray<DataObject> {
  const result: ChunkedArray<DataObject> = [];
  let chunk: DataObject[] = [];

  for (const element of input) {
    if (typeof element === 'string') {
      // If each string indicates that chunking should re-start,
      // then use the following code block here. Else, just remove it:
      if (chunk.length > 0) {
        result.push(chunk);
        chunk = [];
      }

      result.push([element]);
      continue;
    }

    chunk.push(element);

    if (chunk.length === count) {
      result.push(chunk);
      chunk = [];
    }
  }

  if (chunk.length > 0) result.push(chunk);
  return result;
}


// Usage example:

console.clear();
const input = createUnchunkedArray();
// Will be 2, 3, or 4:
const chunkCount = Math.floor(Math.random() * 3) + 2;
const chunked = chunkByCount(input, chunkCount);
console.log('Chunk count:', chunkCount);
console.log(chunked);

"use strict";
// Not used here, but you might find this type useful somewhere in context of the problem:
// type RepeatedTuple<N, T, Tup extends T[] = [T]> = Tup['length'] extends N
//   ? Tup
//   : RepeatedTuple<N, T, [...Tup, T]>;
// Generate input array test data:
function createUnchunkedArray({ groups = 3, minGroupLength = 7, maxGroupLength = 10, } = {}) {
    let id = 0;
    const array = [];
    for (let group = 0; group < groups; group += 1) {
        array.push(`group ${group}`);
        const groupLength = Math.floor(Math.random()
            * (maxGroupLength - minGroupLength + 1)) + minGroupLength;
        for (let i = 0; i < groupLength; i += 1) {
            array.push({ id, title: `title ${group}-${i}` });
            id += 1;
        }
    }
    return array;
}
function chunkByCount(input, count) {
    const result = [];
    let chunk = [];
    for (const element of input) {
        if (typeof element === 'string') {
            // If each string indicates that chunking should re-start,
            // then use the following code block here. Else, just remove it:
            if (chunk.length > 0) {
                result.push(chunk);
                chunk = [];
            }
            result.push([element]);
            continue;
        }
        chunk.push(element);
        if (chunk.length === count) {
            result.push(chunk);
            chunk = [];
        }
    }
    if (chunk.length > 0)
        result.push(chunk);
    return result;
}
// Usage example:
console.clear();
const input = createUnchunkedArray();
// Will be 2, 3, or 4:
const chunkCount = Math.floor(Math.random() * 3) + 2;
const chunked = chunkByCount(input, chunkCount);
console.log('Chunk count:', chunkCount);
console.log(chunked);