Question: Is it possible to loop a json object one by one ?  

let's say I have this object (text). I want to loop on `text` and get **next** item every 1 minute until I get them all. How can I do this in javascript ? 

```
 var text = 
        {
        "name":"John Johnson",
        "street":"Oslo West 16",
        "determine":"555 1234567",
        "JSON":"concernant",
        "you":"value"
        };

       setInterval(function(){
       //text.getnext
       }, 1000);

```

sorry if it is duplicated I have not found solution.

Answer: 
You could use the superb example of MDN for [Iterators](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Iterators_and_Generators#Iterators) and use it for the properties.

For every interval, the iterator is called with `next()` and then the value is checked. if done, clear the interval or display the property.

```js
function makeIterator(array) {
    var nextIndex = 0;
    return {
        next: function () {
            return nextIndex < array.length ?
                { value: array[nextIndex++], done: false } :
                { done: true };
        }
    };
}

var text = { "name": "John Johnson", "street": "Oslo West 16", "determine": "555 1234567", "JSON": "concernant", "you": "value" },
    iterator = makeIterator(Object.keys(text)),
    interval = setInterval(function () {
        var k = iterator.next();
        if (k.done) {
            clearInterval(interval);
        } else {
            console.log(text[k.value]);
        }                                // this value is for demo purpose
    }, 1000);                           // for a minute interval change to 60000
```
You should first solve the generic problem of sending out the element of an array with some delay. Once you've done that, it's easy enough to apply that to the keys of an object.

Here's a simple version using `setTimeout`:

```
function emitWithDelay(array, callback) {
  var n = 0;

  function emitOne() {
    if (n >= array.length) return;

    setTimeout(function() {
      callback(array[n++]);
      emitOne();
    }, 1000);

  }

  emitOne();
}

```

Now you can just do 

```
emitWithDelay(Object.keys(obj), myCallback);

```

### Streams

This is a good problem for using streams, or observables. It is as simple as

```
Observable.from(Object.keys(obj))
  .delay(1000)
  .subscribe(elt => console.log("got elt", elt));

```

### Async approach

Another idea is to use async functions, an ES7 feature, as follows:

```
async function emitWithDelay(array, callback) {
  for (elt of array) {
    callback(elt);
    await sleep(1000);
  }
}

```

Where `sleep` is something like

```
function sleep(n) {
  return new Promise(resolve => setTimeout(resolve, n));
}

```

As you can see, the possibilities are endless.