Mapping an array to object with default keys

best-books.js

const BOOKS = [
  '1',
  'The Stranger\nThe Outsider',
  'Albert Camus',
  '1942',
  'French',
  '2',
  'In Search of Lost Time\nRemembrance of Things Past',
  'Marcel Proust',
  '1913–27',
  'French'
];

let currentItem = 0;
const books = [];

const A = BOOKS.forEach((v, i) => {
  if (i % 5 == 0) {
    books[currentItem] = {};
    books[currentItem].id = BOOKS[i];
  } else if (i % 5 == 1) {
    books[currentItem].title = BOOKS[i];
  } else if (i % 5 == 2) {
    books[currentItem].author = BOOKS[i];
  } else if (i % 5 == 3) {
    books[currentItem].year = BOOKS[i];
  } else if (i % 5 == 4) {
    books[currentItem].lang = BOOKS[i];
    currentItem++;
  }
});

console.log(books);

// OUTPUT

[
  {
    id: '1',
    title: 'The Stranger\nThe Outsider',
    author: 'Albert Camus',
    year: '1942',
    lang: 'French'
  },
  {
    id: '2',
    title: 'In Search of Lost Time\nRemembrance of Things Past',
    author: 'Marcel Proust',
    year: '1913–27',
    lang: 'French'
  }
];

Here are the 4 most common ways :

1. using good ol' for ... loop :
2. using Array.forEach :
   
3. using Array.reduce :
   
4. using Ramda as a dependency (repo - docs) :
   

Happy coding dude :)

Here another implementation:

// utils
const chunk = (array, size) => {
  const chunked_arr = [];
  let index = 0;
  while (index < array.length) {
    chunked_arr.push(array.slice(index, size + index));
    index += size;
  }
  return chunked_arr;
};

const BOOKS = [
  "1",
  "The Stranger\nThe Outsider",
  "Albert Camus",
  "1942",
  "French",
  "2",
  "In Search of Lost Time\nRemembrance of Things Past",
  "Marcel Proust",
  "1913–27",
  "French"
];
const columnsMapping= ['id', 'title', 'author', 'year', 'lang']

// 1 - split in chunks
const booksChunks = chunk(BOOKS,columnsMapping.length)

// 2 - convert index base columns to named base
// the map loops through all the books
// the reduce maps the index of the book with the index of the columns mapping
const books = booksChunks.map((rawBook) => {
    return rawBook.reduce((accumulator, value, index)=>{
        return {
            ...accumulator,
            [columnsMapping[index]]:value
        }
    },{})
});

console.log(books);

Unreadable mode:

// utils
const chunk = (array, size) => {
  const chunked_arr = [];
  let index = 0;
  while (index < array.length) {
    chunked_arr.push(array.slice(index, size + index));
    index += size;
  }
  return chunked_arr;
};

const BOOKS = [
  "1",
  "The Stranger\nThe Outsider",
  "Albert Camus",
  "1942",
  "French",
  "2",
  "In Search of Lost Time\nRemembrance of Things Past",
  "Marcel Proust",
  "1913–27",
  "French"
];

console.log(chunk(BOOKS,5).map(([id, title, author, year, lang]) => ({ id, title, author, year, lang })));

Here are the 4 most common ways :

1. using good ol' for ... loop :
2. using Array.forEach :
   
3. using Array.reduce :
   
4. using Ramda as a dependency (repo - docs) :
   

Happy coding dude :)

Relly cool the idea to spread directly the array to columns name.

Here are the 4 most common ways :

1. using good ol' for ... loop :
2. using Array.forEach :
   
3. using Array.reduce :
   
4. using Ramda as a dependency (repo - docs) :
   

Happy coding dude :)

Absolutely brilliant! I love the reduce one. So elegant...

Many interesting ways here.
But most of them are too complex in my opinion. Why not use ES6 destructuring?
In combination with a recursive call makes it simple and readable.
What do you think?

 const booksList = [
  '1',
  'The Stranger\nThe Outsider',
  'Albert Camus',
  '1942',
  'French',
  '2',
  'In Search of Lost Time\nRemembrance of Things Past',
  'Marcel Proust',
  '1913–27',
  'French',
  '3',
  'The adventures of Huckleberry Finn',
  'Mark Twain',
  '1885',
  'English'
];

function createBooksFromList(listOfBooks) {
    const [id, title, author, year, language, ...rest] = listOfBooks;
    const result = [];
    result.push({
        id,
        title,
        author,
        year,
        language
    });
    if (rest.length) {
        return result.concat(createBooksFromList(rest));
    }
    return result;       
}

console.log(createBooksFromList(booksList));

Good point too @epatrasc, your chunk method is actually equivalent to ramda's splitEvery 👍

---

I love the idea of your ...rest parameter and recursive call @fidel-karsto ! 👍 ❤️

The same exact code as a one-liner :

const BOOKS = [
  '1',
  'The Stranger\nThe Outsider',
  'Albert Camus',
  '1942',
  'French',
  '2',
  'In Search of Lost Time\nRemembrance of Things Past',
  'Marcel Proust',
  '1913–27',
  'French',
  '3',
  'The adventures of Huckleberry Finn',
  'Mark Twain',
  '1885',
  'English'
];

const convert = ([ id, title, author, year, language, ...rest ]) => rest.length
? [{ id, title, author, year, language }].concat(convert(rest))
: [{ id, title, author, year, language }]

console.log(convert(BOOKS))

As mentioned above, this is how I would do it using Array.reduce()

const books = [
  '1',
  'The Stranger\nThe Outsider',
  'Albert Camus',
  '1942',
  'French',
  '2',
  'In Search of Lost Time\nRemembrance of Things Past',
  'Marcel Proust',
  '1913–27',
  'French',
  '3',
  'The adventures of Huckleberry Finn',
  'Mark Twain',
  '1885',
  'English'
]
const newList = books.reduce((acc, cur, index) => {
   if (index % 5 === 0) {
      const [id, title, author, year, language] = books.slice(index, index + 5);
      acc = [...acc, {id, title, author, year, language}];
   }

   return acc;
}, []);

class Book {
  constructor(id, title, author, year, lang) {
    this.id = id;
    this.title = title;
    this.author = author;
    this.year = year;
    this.lang = lang;
  }
}

const books = [];

for (let i=0; i<BOOKS.length; i+=5) {
  book = new Book(...BOOKS.slice(i, i+5));
  books.push(book);
}