In nodeJs is there a way to loop through an array without using array size?

Let's say I have

myArray = ['item1', 'item2']

I tried

for (var item in myArray) {console.log(item)}

It prints 0 1

What I wish is to have item1 item2

Is there any other syntax that works without using

for (var i = 0; i < myArray.length; i++)

You can use Array.forEach

var myArray = ['1','2',3,4]

myArray.forEach(function(value){
  console.log(value);
});

What you probably want is for...of, a relatively new construct built for the express purpose of enumerating the values of iterable objects:

let myArray = ["a","b","c","d"];
for (let item of myArray) {
  console.log(item);
}

... as distinct from for...in, which enumerates property names (presumably¹ numeric indices in the case of arrays). Your loop displayed unexpected results because you didn't use the property names to get the corresponding values via bracket notation... but you could have:

let myArray = ["a","b","c","d"];
for (let key in myArray) {
  let value =  myArray[key]; // get the value by key
  console.log("key: %o, value: %o", key, value);
}

_{¹ Unfortunately, someone may have added enumerable properties to the array or its prototype chain which are not numeric indices... or they may have assigned an index leaving unassigned indices in the interim range. The issues are explained pretty well here. The main takeaway is that it's best to loop explicitly from 0 to array.length - 1 rather than using for...in.}

So, this is not (as I'd originally thought) an academic question, i.e.:

> Without regard for practicality, is it possible to avoid length when iterating over an array?

According to your comment (emphasis mine):

> [...] why do I need to calculate the size of an array whereas the interpreter can know it.

You have a misguided aversion to Array.https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/length">length</a></code>;. It's not calculated on the fly; it's updated whenever the length of the array changes. You're not going to see performance gains by avoiding it (apart from caching the array length rather than accessing the property):

http://jsperf.com/array-for-in-versus-for/2"><img src="http://i.stack.imgur.com/YMote.png" alt="loop test" />

Now, even if you did get some marginal performance increase, I doubt it would be enough to justify the risk of dealing with the aforementioned issues.

To print 'item1' , 'item2', this code would work.

var myarray = ['hello', ' hello again'];

for (var item in myarray) {
    console.log(myarray[item])
}

In ES5 there is no efficient way to iterate over a sparse array without using the length property. In ES6 you can use for...of. Take this examples:

'use strict';

var arr = ['one', 'two', undefined, 3, 4],
    output;

arr[6] = 'five';

output = '';
arr.forEach(function (val) {
    output += val + ' ';
});
console.log(output);

output = '';
for (var i = 0; i < arr.length; i++) {
    output += arr[i] + ' ';
}
console.log(output);

output = '';
for (var val of arr) {
    output += val + ' ';
};
console.log(output);

<!-- results pane console output; see http://meta.stackexchange.com/a/242491 -->
<script src="//gh-canon.github.io/stack-snippet-console/console.min.js"></script>

All array methods which you can use to iterate safely over dense arrays use the length property of an object created by calling ToObject internaly. See for instance the algorithm used in the forEach method: http://www.ecma-international.org/ecma-262/5.1/#sec-15.4.4.18 However in es6, you can use for...of safely for iterating over sparse arrays.

See also https://stackoverflow.com/questions/1510778/are-javascript-arrays-sparse.

This is the natural javascript option

var myArray = ['1','2',3,4]

myArray.forEach(function(value){
  console.log(value);
});

However it won't work if you're using await inside the forEach loop because forEach is not asynchronous. you'll be forced to use the second answer or some other equivalent:

let myArray = ["a","b","c","d"];
for (let item of myArray) {
  console.log(item);
}

Or you could create an asyncForEach explained here:

> https://codeburst.io/javascript-async-await-with-foreach-b6ba62bbf404

Use Iterators...

var myarray = ['hello', ' hello again'];
processArray(myarray[Symbol.iterator](), () => {
    console.log('all done')
})
function processArray(iter, cb) {
	var curr = iter.next()
	if(curr.done)
		return cb()
	console.log(curr.value)
	processArray(iter, cb)
}

More in depth overview: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols

    var count=0;
    let myArray = '{"1":"a","2":"b","3":"c","4":"d"}'
    var data = JSON.parse(myArray);
    for (let key in data) {
      let value =  data[key]; // get the value by key
      console.log("key: , value:", key, value);
      count = count + 1;
    }
   console.log("size:",count);

Use the built-in Javascript function called map. .map() will do the exact thing you're looking for!