Here is a shorter way of achieving it:

let result = objArray.map(a => a.foo);

OR

let result = objArray.map(({ foo }) => foo)

You can also check Array.prototype.map().

return immediately exits a function. Instead, you could do something like this:

return Object.values(data).flat();

Which would return:

[
  { isActive: false, status: 'Clos' },
  { isActive: true, status: 'Open' },
  { isActive: false, status: 'Winning' },
  { isActive: true, status: 'Closed' }
]

Where flat() flattens an Array of Arrays into a single Array.

You can access an element at a specific index using the bracket notation accessor.

var valueAtIndex1 = myValues[1];

On newer browsers/JavaScript engines (see browser compatibility here), you can also use the .at() method on arrays.

var valueAtIndex1 = myValues.at(1);

On positive indexes, both methods work the same (the first one being more common). Array.prototype.at() however allows you to access elements starting from the end of the array by passing a negative number. Passing -1 will give the last element of the array, passing -2 the second last, etc.

See more details at the MDN documentation.

If you are OK with manipulating your original array as you loop through it you could splice and concat similar to below (or you could use a clone of the array if you need to persist the original array):

var myStringArray = ["1","2","3","4","5","6","7","8","9","10"];

var loopByX = function(x){
  var y = myStringArray.splice(0,x);
  myStringArray = myStringArray.concat(y);
  
  return y;
}

console.log(loopByX(3));
console.log(loopByX(3));
console.log(loopByX(3));
console.log(loopByX(3));
console.log(loopByX(3));

If you want to go bi-directional (is that what you call it?), as mentioned in the comments, you could do it as below which then gives you the ability to go backwards or forward and the flexibility to do so in an arbitrary number:

var myStringArray = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"];

var loopByX = function(x) {
  var len = myStringArray.length;

  // Ensure x is always valid but you can add any behaviour here in that case yourself. As an example I return an empty array.
  if (Math.abs(x) > len) {
    return [];
  }

  var y = x > 0 ? myStringArray.splice(0, x) : myStringArray.splice(len + x, len);

  myStringArray = x > 0 ? myStringArray.concat(y) : y.concat(myStringArray);

  return y;
}

console.log(loopByX(20)); // invalid number
console.log(loopByX(-20)); // invalid number
console.log(loopByX(-3));
console.log(loopByX(-6));
console.log(loopByX(3));
console.log(loopByX(4));

Simply use find

([{name: 'joe', age: 'nine'}, {name: 'tom', age: 'ten'}].find( (s)=> s.name=="tom" )||{}).age //10

([{name: 'joe', age: 'nine'}, {name: 'tom', age: 'ten'}].find( (s)=> s.name=="tom2" )||{}).age //undefined

Demo

var names = [{
  name: 'joe',
  age: 'nine'
}, {
  name: 'tom',
  age: 'ten'
}];

function getAge(names, name) {
  return (names.find((s) => s.name == name) || {}).age;
}

console.log(getAge(names, "tom"))
console.log(getAge(names, "tom2"))

You can use the $.map function from jQuery :

var value = $.map(example, function () {
    return this.name;
});

This will return an array of the items.

You need to read some documentation about javascript syntax a little :p .

In this case, let's assume you have =:

var data = {"0":[{"Question":"abc","Answer":"abc 123"}]};

It is read like this: data is an object, containing a single key named "0", which is a reference to an array. The array contains a single entry. That entry is an object containing 2 keys, "Question" and "Answer", each being a string.

So, with that said:

data // is the object
data[0] // references the array of questions, note that it is in fact data["0"]
data[0][0] // references the first entry in the array of questions
data[0][0].Question // contains the first question's text
data[0][0].Answer // contains the first question's answer

Typically, you'd make a variable that represents what your dealing with to make it clear to whoever reads the code, e.g.

var first_question = data[0][0];

and use the properties from then on.