Styjun

I have this algorithm exercise that splits an array into smaller parts. This is working right, but I did not understand the operation. Could someone explain this to me in more detail. Please.

const letters = ['a', 'b', 'c', 'd', 'e']

function chunk(array, size) 
 const chunked = [];

 for (let element of array) 
 const last = chunked[chunked.length - 1]

 if (!last 

 return chunked;



console.log(chunk(letters, 2))

It returns:

['a','b']
['c'.'d']
['e']

This parameter that in this case is the number 2, which is passed in the function, is the number of items that each array contains.

console.log(chunk(letters, 2))

I didn't understand the fact that it generated 2 arrays 'chunked' and 'last' and in the end only return 'chunked'. But I did not understand the link between the 2 arrays: 'chunked' and 'last'

You are creating an array of arrays. The outer array is called chunked. The last array is the last inner array up to this point. chunked looks like:

[[/*some values*/], [/*some values*/], [/* this is last */]]

That's what this line is doing:

const last = chunked[chunked.length - 1] // get the final child array in chunked

You then decide whether to push the current value into this subarray or add a new subarray. This choice is determined by whether the length of last is less than the chunk size — in other words whether it is full. That's what this test is doing:

if (!last || last.length === size) 

The !last part is used to check if there is a last array because on the first iteration it won't exist yet — the outer array is empty.

For what it's worth, it might be easier to understand it you just use a simple loop that increments by chunk size:

const letters = ['a', 'b', 'c', 'd', 'e']

function chunk(array, size) 
 const chunked = [];
 
 for (let i = 0; i < array.length; i+=size) 
 chunked.push(array.slice(i, i+size))
 
 return chunked



console.log(chunk(letters, 2))

Generally there are three things:

1. 
   last contains the last chunk, freshly taken for each iteration, which grows until it reaches the specified size


2. when last reaches the specified size, chunked.push([element]) pushes a new array into chunked ([element] without an array in front of it, is a short syntax for creating a new array with a single element - and for the next iteration, that is going to be the last chunk. Try writing console.log(1), console.log([1]) and perhaps console.log([1,2]) into a JS console to see their difference.


3. if the last chunk has not reached the specified size, the element is just appended to it

In particular there is one "trick", for the first iteration: when chunked is an empty array at the beginning, last = chunked[chunked.length - 1] translates to chunked[-1]. Unlike many other languages, JavaScript does not die or throw an exception here, it just says the given element is undefined, which is a falsy value and triggers the !last condition, thus the push([element]) thing will run. This is how the first chunk is created.

this will get the last element of chunked array , which is either undefined or the last chunk array

const last = chunked[chunked.length - 1]

then you check if last is undefined or is an array with size of size then you add new array to chunked array with the current element

if (!last || last.length === size) 
 chunked.push([element])

else , which mean that last is an array with size less than size , you push current element to last

else 
 last.push(element)

1. a function chunk which take 2 arguments, an array and length of chunks


2. a chunked array is defined


3. using for loop iterating over the array


4. if the last array is not the last array inside chunked array or last element of chunked array is equal to size argument, then push new element from array array inside another array so that it form a chunked array


5. else push the new element from array array to last array of chunked array


6. return chunked array

More or less: initialize an empty array chunked.

Inside a loop: look into chunked's last element. Is it non-existent, or is it already exactly the required length? If yes, take the next letter, make a 1-element array out of it, and append it to chunked. If no, then append the letter to chunked's last element instead.

Run the code in a debugger, set watch expressions for chunked, last and element and watch what's happening to them.