I've run into the strange assertion in a book in my point of view. I guess that I don't understand something but anyway it will be great if you shed light on the situation.

```
ajax('<host1>/items',                                       
   items => {
   for (let item of items) {
      ajax(`<host2>/items/${item.getId()}/info`,            
      dataInfo => {
        ajax(`<host3>/files/${dataInfo.files}`,            
           processFiles);
   });
  }
});

```

An author pay attention on : 

> 
> There’s another hidden problem with this code. Can you guess what it is? It occurs when you mix a synchronous artifact like a for..of imperative block invoking asynchronous functions. Loops aren’t aware that there’s latency in those calls, so they’ll always march ahead no matter what, which can cause some really unpredictable and hard-to-diagnose bugs. In these situations, you can improve matters by creating closures around your asynchronous functions, managed by using forEach() instead of the loop.
> 
> 
> 

Instead of it they offer the following:

```
ajax('/data',                            
  items  => {                            
     items.forEach(item => {
    // process each item             
 });

```

});

Frankly speaking I expected that if we use `let` for loop it means we create a closure for each iteration therefore I don't see any hidden problems there.