2

I have a less then ideal situation in which I can not change the signature of a function but need to have it pass additional information in its output for a new feature.

Is this ok to do? 

q = [ 1 , 2 ,3]
q.meta-data = {additional:'information'}

Is this only assigned to q?
Does this have any effect on other array objects?
Is there a situation where this would break something or will it continue to function as normal?

Tegra Detra
  • 24,551
  • 17
  • 53
  • 78

6 Answers6

3

Why not just split the data and the meta-data into two properties?

q = {
  data: [1, 2, 3],
  'meta-data': { additional: 'information' }
};
Wex
  • 15,539
  • 10
  • 64
  • 107
  • 1
    This is a much better idea, assuming he can restructure his data! :-) – gen_Eric Aug 28 '13 at 17:35
  • the issue is it takes an arbitrary # of arrays as an argument and iterates over them the implementation is out side of our reach so passing anything additional will wax the whole thing – Tegra Detra Aug 28 '13 at 20:38
3

No, it doesn't assign anything to other arrays - as you work with a specific object here, not its prototype.

But yes, it can bite you back in some situations. For example, some other developer might think that it's a smart idea to iterate over that Array stored in q with for-in loop.

raina77ow
  • 103,633
  • 15
  • 192
  • 229
  • In regards to the `for-in` loop, http://stackoverflow.com/questions/500504/why-is-using-for-in-with-array-iteration-such-a-bad-idea?rq=1 – Wex Aug 28 '13 at 17:32
  • 1
    @Wex Yes, definitely. But some people never learn, unfortunately. – raina77ow Aug 28 '13 at 17:34
2

If you assign a property to q, that only affects just q. Other arrays will be fine.

The only issue you'd have with this approach is if you use for..in to loop over arrays. As long as you only ever loop over it with a "normal" for loop or .forEach (which you should be doing anyway), you shouldn't have any issues.

P.S. q.meta-data is a syntax error (the -). You need to do q.metadata (or q.meta_data) or q['meta-data'].

gen_Eric
  • 223,194
  • 41
  • 299
  • 337
1

The other answers are great, but you could also convert the array to an "array-like" object.

objq = {};
q.forEach(function (elem, idx) {
    objq[idx] = elem;
});
objq.length = q.length;
objq["meta-data"] = {additional: "information"};

objq does not have array methods, but you can call them:

Array.prototype.forEach.call(objq, function (elem) { console.log(elem); });
Explosion Pills
  • 188,624
  • 52
  • 326
  • 405
  • @RocketHazmat or you could use `Array.prototype.push.call` – Explosion Pills Aug 28 '13 at 17:43
  • I wouldn't recommend this for a couple reasons. First, you're confounding data and meta-data. How is anyone supposed to retrieve the information they actually care about? Also, you can't use Array operations if you're storing the data in an object. – Wex Aug 28 '13 at 17:53
0

I personally do not like adding properties to arrays since this can have unintended consequences. I would probably go with adding an addition parameter that acts as an output parameter. Something like this:

function cantChangeReturn(arg1, arg2, optionalOutputArg) {
  // do stuff
  if (optionalOutputArg) {
    optionalOutputArg.extraResult = extraResult;
  }
  return result;
}

This way, the extra data does not leak to other parts of the program that do not need it and do not expect it.

Andrew Eisenberg
  • 28,387
  • 9
  • 92
  • 148
0

In case you don't want to create a wrapper for the data. It's a bit safer to attach meta data using symbols.

const data = [1, 2, 3];

// A "secret" key to obtain meta data.
const metaKey = Symbol();

data[metaKey] = {additional: 'information'}

// The meta does not appear in for-in anymore.
for (let item in data) {
  console.log(item);
}

// But you still can obtain meta if you have access to the 'metaKey' variable.
console.log(data[metaKey]);

The main downside of this approach is that you need to pass the key to the consumer of this meta data.

ya.teck
  • 2,060
  • 28
  • 34