如何描述传递的匿名函数的参数？

Question

I want to describe curVal with JSDoc?

I tried @param just before arrays.every() and inside anonymous callback, but it didn't help for PhpStorm to resolve methods.

/**
 * @param {Array} curVal
 */
arrays.every(function (curVal) {
    /**
     * @param {Array} curVal
     */     
    curVal.???
});

I need it for convinience, I just want to easily access in IDE's autocompletion Array.prototype methods on object curVal

Answer 1

I think your best (and most legible) option is to give the function a name, eg

/**
 * @type {Number[]}
 */
var array = [ 1, 2, 3 ];

/**
 * @param {Number} curVal
 */
var fn = function (curVal) {
    // operate on curVal
};
array.forEach(fn);

I think you should (and perhaps must) specify the array type, as in my example, not not just {Array} , and I don't know what you mean by arrays.every , but I assume you meant to use .forEach from the Array object.

[Edit]

OK, now I understand, maybe something like this is what you want:

/**
 * @param {Array} curVal
 */
var fn = function (curVal) {
    curVal. // press Ctrl-Space here, and autocompletion will work
};

However, if you really want to use jsdoc with an anonymous function, something like this will work (and is closest to the code in your question):

var arrayOfArrays = [[1,2,3], [2,3,4]]
arrayOfArrays.every(/** @param {Array} curVal */function (curVal) {
    curVal. // press Ctrl-Space here, and autocompletion will work
});

(I use JetBrains' IntelliJ, not their PhpStorm IDE, but they share the same Javascript integration)

Answer 2

I don't know how smart PhpStorm is ( the docs say it recognizes Closure Compiler tags and type annotations ), but I can think of two possible solutions.

First is to tell it directly the type of the function param:

arrays.every(/** @param {Array} curVal */ function (curVal) {
  // ...
});

Or (Closure Compiler inline style):

arrays.every(function (/** Array */ curVal) {
  // ...
});

Second, and this will only work if PhpStorm is smart enough to know how Array.prototype.every 's callback gets its arguments, is to make sure it knows arrays is an array of arrays:

/** @type {Array.<Array>} */
var arrays = getArrays();

Or:

var arrays = /** Array.<Array> */ getArrays();