Document paramètre de fonction déstructurée dans JSDoc

Auparavant, j'ai toujours documenté mes paramètres d'objet comme suit:

/**
 * Description of the function
 *
 * @param {Object} config - The configuration
 * @param {String} config.foo
 * @param {Boolean} [config.bar] - Optional value
 * @return {String}
 */
function doSomething (config = {}) {
  const { foo, bar } = config;
  console.log(foo, bar);
  // do something
}

Mais je ne sais pas quelle est la meilleure approche avec le paramètre de fonction déstructuré. Dois-je simplement ignorer l'objet, le définir d'une manière ou d'une autre ou quelle est la meilleure façon de le documenter?

/**
 * Description of the function
 *
 * @param {String} foo
 * @param {Boolean} [bar] - Optional value
 * @return {String}
 */
function doSomething ({ foo, bar } = {}) {
  console.log(foo, bar);
  // do something
}

J'ai l'impression que mon approche ci-dessus ne montre pas clairement que la fonction attend un objectparamètre différent et non deux.

Une autre façon de penser serait de l'utiliser @typedef, mais cela pourrait finir par être un énorme gâchis (en particulier dans un fichier plus volumineux avec de nombreuses méthodes)?

/**
 * @typedef {Object} doSomethingConfiguration
 * @property {String} foo
 * @property {Boolean} [bar] - Optional value
 */

/**
 * Description of the function
 *
 * @param {doSomethingConfiguration}
 * @return {String}
 */
function doSomething ({ foo, bar } = {}) {
  console.log(foo, bar);
  // do something
}

C'est ainsi que cela est prévu, comme décrit dans la documentation .

/**
 * My cool function.
 *
 * @param {Object} obj - An object.
 * @param {string} obj.prop1 - Property 1.
 * @param {string} obj.prop2 - Property 2.
 */
var fn = function ({prop1, prop2}) {
  // Do something with prop1 and prop2
}

Donc, votre premier exemple est à peu près correct.

Un autre exemple avec une imbrication plus profonde:

/**
 * Nesting example.
 *
 * @param {object} param
 * @param {number} param.a - First value
 * @param {object} param.b - Wrapper
 * @param {number} param.b.c - Second value
 * @return {number} sum a and b
 */
letters = ({a, b: {c}}) => a + c;

J'utilise personnellement celui-ci:

/**
* @param {{
  a: number
  b: number
}} param0
* @returns {number} The sum
*/
const func = ({ a, b }) => a + b;

Créez simplement l'objet ici.

Je profite également de TypeScript , et déclarerais obtional bcomme b?ou b: number | undefinedcomme JSDoc autorise également les unions

Voir "Documenter les propriétés d'un paramètre" de JSDoc :

/**
 * Assign the project to an employee.
 * @param {Object} employee - The employee who is responsible for the project.
 * @param {string} employee.name - The name of the employee.
 * @param {string} employee.department - The employee's department.
 */
Project.prototype.assign = function(employee) {
    // ...
};

( La vérification du type du compilateur Google Closure , qui était basée sur JSDoc mais détournée de JSDoc, permet également @param {{x:number,y:number}} point A "point-shaped" object.)