Loading ...
Sorry, an error occurred while loading the content.

option.unparam

Expand Messages
  • Douglas Crockford
    JSLint will now report unused parameters. If you want to suppress that report, set option.unparam to true.
    Message 1 of 9 , Apr 30, 2011
    • 0 Attachment
      JSLint will now report unused parameters. If you want to suppress
      that report, set option.unparam to true.
    • IceBox
      ... For instance (letting option.unparam to the default), function(unusedParam, usedParam) {... The style adopted should be function() { var usedParam =
      Message 2 of 9 , May 1, 2011
      • 0 Attachment
        --- In jslint_com@yahoogroups.com, "Douglas Crockford" <douglas@...> wrote:
        >
        > JSLint will now report unused parameters. If you want to suppress
        > that report, set option.unparam to true.
        >

        For instance (letting option.unparam to the default),

        function(unusedParam, usedParam) {...

        The style adopted should be

        function() {
        var usedParam = arguments[1];
        ...

        Is it "correct"?

        Regards,
        Alberto
      • Zhami
        I often include names for arguments that aren t used as a form of reminder/documentation (say, for callbacks that are being invoked by libraries that are not
        Message 3 of 9 , May 1, 2011
        • 0 Attachment
          I often include names for arguments that aren't used as a form of reminder/documentation (say, for callbacks that are being invoked by libraries that are not mine).

          Perhaps JSLint could allow for a pragma or directive within a function body that indicates that the named argument is intentionally not be used.

          --- In jslint_com@yahoogroups.com, "Douglas Crockford" <douglas@...> wrote:
          >
          > JSLint will now report unused parameters. If you want to suppress
          > that report, set option.unparam to true.
          >
        • Douglas Crockford
          ... No. That would be stupid. It is unwise to be designing functions with unused parameters. But if you do so anyway, then you should use option.unparam.
          Message 4 of 9 , May 1, 2011
          • 0 Attachment
            --- In jslint_com@yahoogroups.com, "IceBox" <albertosantini@...> wrote:
            >
            >
            > --- In jslint_com@yahoogroups.com, "Douglas Crockford" <douglas@> wrote:
            > >
            > > JSLint will now report unused parameters. If you want to suppress
            > > that report, set option.unparam to true.
            > >
            >
            > For instance (letting option.unparam to the default),
            >
            > function(unusedParam, usedParam) {...
            >
            > The style adopted should be
            >
            > function() {
            > var usedParam = arguments[1];
            > ...
            >
            > Is it "correct"?

            No. That would be stupid. It is unwise to be designing functions with unused parameters. But if you do so anyway, then you should use option.unparam.
          • Douglas Crockford
            ... If you want to suppress that report, set option.unparam to true.
            Message 5 of 9 , May 1, 2011
            • 0 Attachment
              --- In jslint_com@yahoogroups.com, "Zhami" <stuart@...> wrote:

              > I often include names for arguments that aren't used as a form of reminder/documentation (say, for callbacks that are being invoked by libraries that are not mine).
              >
              > Perhaps JSLint could allow for a pragma or directive within a function body that indicates that the named argument is intentionally not be used.


              If you want to suppress that report, set option.unparam to true.
            • Zhami
              ... Douglas, I don t want to suppress that report for the entire file, as I believe this is yet another valuable warning you have added to JSLint. However,
              Message 6 of 9 , May 6, 2011
              • 0 Attachment
                --- In jslint_com@yahoogroups.com, "Douglas Crockford" <douglas@...> wrote:
                >
                > --- In jslint_com@yahoogroups.com, "Zhami" <stuart@> wrote:
                >
                > > I often include names for arguments that aren't used as a form of reminder/documentation (say, for callbacks that are being invoked by libraries that are not mine).
                > >
                > > Perhaps JSLint could allow for a pragma or directive within a function body that indicates that the named argument is intentionally not be used.
                >
                >
                > If you want to suppress that report, set option.unparam to true.
                >

                Douglas,

                I don't want to suppress that report for the entire file, as I believe this is yet another valuable warning you have added to JSLint.

                However, sometime the function is a callback and the unused param is left-wards of a param that I do use, and so must name the unused param to properly position.

                I did try turning off the report by an inline comment prior to the declaration of the function:

                /*jslint unparam: false */

                But that didn't work.

                I do think it would be useful to either be able to turn iteh reporting on and off around certain function, or to have a pragma *within* a function:

                /*jslint unparam: varname */

                which would let JSLint know that a named parameter is intentionally not used.

                Thanks for considering this.
              • Joshua Bell
                ... FWIW, I adopted the approach typically used in C/C++ to silence such warnings without disabling them: (function (global) { function unused() {} function
                Message 7 of 9 , May 6, 2011
                • 0 Attachment
                  On Fri, May 6, 2011 at 3:25 PM, Zhami <stuart@...> wrote:

                  > However, sometime the function is a callback and the unused param is
                  > left-wards of a param that I do use, and so must name the unused param to
                  > properly position.
                  >

                  FWIW, I adopted the approach typically used in C/C++ to silence such
                  warnings without disabling them:

                  (function (global) {

                  function unused() {}

                  function sample_function(a, b, c, d) {
                  unused(b, d);
                  // ....
                  }

                  }(this));

                  On the one hand, it is reasonably self-documenting and modern JS
                  environments should optimize this away. On the other, it's repetitive
                  clutter to include in every module, and seems hackish. (Perhaps we should
                  petition TC39 for Function.unused() or another standard no-op function.)

                  -- Josh


                  [Non-text portions of this message have been removed]
                • Zhami
                  ... Yes, there are ways to use effective no-ops to silence the warning (I just assign the unused parameter to a junk variable), but any such code-based
                  Message 8 of 9 , May 7, 2011
                  • 0 Attachment
                    --- In jslint_com@yahoogroups.com, Joshua Bell <josh@...> wrote:
                    >
                    > On Fri, May 6, 2011 at 3:25 PM, Zhami <stuart@...> wrote:
                    >
                    > > However, sometime the function is a callback and the unused param is
                    > > left-wards of a param that I do use, and so must name the unused param to
                    > > properly position.
                    > >
                    >
                    > FWIW, I adopted the approach typically used in C/C++ to silence such
                    > warnings without disabling them:
                    >
                    > (function (global) {
                    >
                    > function unused() {}
                    >
                    > function sample_function(a, b, c, d) {
                    > unused(b, d);
                    > // ....
                    > }
                    >
                    > }(this));
                    >
                    > On the one hand, it is reasonably self-documenting and modern JS
                    > environments should optimize this away. On the other, it's repetitive
                    > clutter to include in every module, and seems hackish. (Perhaps we should
                    > petition TC39 for Function.unused() or another standard no-op function.)

                    Yes, there are ways to use effective no-ops to silence the warning (I just assign the unused parameter to a junk variable), but any such code-based approach is a code solution to a non-code problem. What really is needed is a way to tell JSLint that the param is not actually used.
                  • Rob Richardson
                    I d like to know when I ve passed in more parameters than the function will use: /*jslint white: true, onevar: true, undef: true, nomen: true, regexp: true,
                    Message 9 of 9 , May 7, 2011
                    • 0 Attachment
                      I'd like to know when I've passed in more parameters than the function will
                      use:

                      /*jslint white: true, onevar: true, undef: true, nomen: true, regexp: true,
                      plusplus: true, bitwise: true, newcap: true */
                      (function () {
                      `
                      ` var a = function (one, two) {
                      ` // ...
                      ` };
                      `
                      ` a(1, 2, 3); // <-- I've passed in too many
                      `
                      }());

                      I grant that some functions declare themselves as having no (or fewer)
                      parameters, then inspect arguments to handle them all, but this is confusing
                      for the novice user of this code.

                      Rob
                    Your message has been successfully submitted and would be delivered to recipients shortly.