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

Re: [jslint] I must use 'new String'

Expand Messages
  • Jakob Kruse
    What s wrong with var str = somestring ; str.id = 123; ? /Jakob ... From: Woomla [mailto:woomla@ymail.com] To: jslint_com@yahoogroups.com Sent: Wed, 17 Feb
    Message 1 of 15 , Feb 17, 2010
    • 0 Attachment
      What's wrong with

      var str = "somestring";
      str.id = 123;

      ?

      /Jakob

      ----- Original Message -----
      From: Woomla [mailto:woomla@...]
      To:
      jslint_com@yahoogroups.com
      Sent: Wed, 17 Feb 2010 13:21:50 +0100
      Subject:
      [jslint] I must use 'new String'


      > jslint doesn't expect to see new String, but I need it because I want to
      > set a property of the string:
      >
      > var str = new String('somestring');
      > str.id = 123;
      >
      > Or is there another way to do this?
      >
      >
      >
      > [Non-text portions of this message have been removed]
      >
      >
    • Harry Whitfield
      ... Running the following code in Widget Tester: var str1 = something ; print( typeof str1: + typeof str1); var str2 = new String( anything ); print( typeof
      Message 2 of 15 , Feb 17, 2010
      • 0 Attachment
        On 17 Feb 2010, at 12:38:45, Jakob Kruse wrote:

        > What's wrong with
        >
        > var str = "somestring";
        > str.id = 123;
        >
        > ?
        >
        > /Jakob

        Running the following code in Widget Tester:

        var str1 = "something";
        print("typeof str1: " + typeof str1);
        var str2 = new String("anything");
        print("typeof str2: " + typeof str2);
        str1.id = 123;
        print("str1.id === undefined: " + (str1.id === undefined));
        print("str1.id: " + str1.id);
        str2.id = 456;
        print("str2.id === undefined: " + (str2.id === undefined));
        print("str2.id: " + str2.id);

        produces this output:

        typeof str1: string
        typeof str2: object
        str1.id === undefined: true
        str1.id: undefined
        str2.id === undefined: false
        str2.id: 456

        Harry.
      • Klemen Slavič
        Why not use JSON to carry values in such a case? var a = { value: somestring , id: 123 }; ... [Non-text portions of this message have been removed]
        Message 3 of 15 , Feb 17, 2010
        • 0 Attachment
          Why not use JSON to carry values in such a case?

          var a = {
          value: "somestring",
          id: 123
          };

          On 17 February 2010 14:04, Harry Whitfield <g7awz@...> wrote:

          >
          >
          >
          > On 17 Feb 2010, at 12:38:45, Jakob Kruse wrote:
          >
          > > What's wrong with
          > >
          > > var str = "somestring";
          > > str.id = 123;
          > >
          > > ?
          > >
          > > /Jakob
          >
          > Running the following code in Widget Tester:
          >
          > var str1 = "something";
          > print("typeof str1: " + typeof str1);
          > var str2 = new String("anything");
          > print("typeof str2: " + typeof str2);
          > str1.id = 123;
          > print("str1.id === undefined: " + (str1.id === undefined));
          > print("str1.id: " + str1.id);
          > str2.id = 456;
          > print("str2.id === undefined: " + (str2.id === undefined));
          > print("str2.id: " + str2.id);
          >
          > produces this output:
          >
          > typeof str1: string
          > typeof str2: object
          > str1.id === undefined: true
          > str1.id: undefined
          > str2.id === undefined: false
          > str2.id: 456
          >
          > Harry.
          >
          >
          >


          [Non-text portions of this message have been removed]
        • walfisch_in_the_sea
          Or: var string = { toString: function () { return The actual String ; }, id: 123 }; alert(string); alert(string.id);
          Message 4 of 15 , Feb 17, 2010
          • 0 Attachment
            Or:

            var string = {
            toString: function () {
            return "The actual String";
            },
            id: 123
            };

            alert(string);
            alert(string.id);




            --- In jslint_com@yahoogroups.com, Klemen Slavič <krof.drakula@...> wrote:
            >
            > Why not use JSON to carry values in such a case?
            >
            > var a = {
            > value: "somestring",
            > id: 123
            > };
            >
            > On 17 February 2010 14:04, Harry Whitfield <g7awz@...> wrote:
            >
            > >
            > >
            > >
            > > On 17 Feb 2010, at 12:38:45, Jakob Kruse wrote:
            > >
            > > > What's wrong with
            > > >
            > > > var str = "somestring";
            > > > str.id = 123;
            > > >
            > > > ?
            > > >
            > > > /Jakob
            > >
            > > Running the following code in Widget Tester:
            > >
            > > var str1 = "something";
            > > print("typeof str1: " + typeof str1);
            > > var str2 = new String("anything");
            > > print("typeof str2: " + typeof str2);
            > > str1.id = 123;
            > > print("str1.id === undefined: " + (str1.id === undefined));
            > > print("str1.id: " + str1.id);
            > > str2.id = 456;
            > > print("str2.id === undefined: " + (str2.id === undefined));
            > > print("str2.id: " + str2.id);
            > >
            > > produces this output:
            > >
            > > typeof str1: string
            > > typeof str2: object
            > > str1.id === undefined: true
            > > str1.id: undefined
            > > str2.id === undefined: false
            > > str2.id: 456
            > >
            > > Harry.
            > >
            > >
            > >
            >
            >
            > [Non-text portions of this message have been removed]
            >
          • Stefan Weiss
            ... That s not JSON, it s just an object literal. As to the previous example: var str = somestring ; str.id = 123; str.id; // undefined The reason why this
            Message 5 of 15 , Feb 17, 2010
            • 0 Attachment
              On 17/02/10 14:11, Klemen Slavič wrote:
              > Why not use JSON to carry values in such a case?
              >
              > var a = {
              > value: "somestring",
              > id: 123
              > };

              That's not JSON, it's just an object literal.

              As to the previous example:

              var str = "somestring";
              str.id = 123;
              str.id; // undefined

              The reason why this can't work is that in lines 2 and 3, str is
              converted from a string primitive to a new String object. This happens
              every time you try to use a string (or number, or boolean) primitive
              type like an object --> str gets auto-converted into an object twice,
              but only internally, for the purpose of property lookup. The two created
              String objects are then thrown away, and the "id" property is lost.

              For the OP: I agree with Klemen and the walfisch - wrapping your string
              and any additional properties in a custom object is the way to go.
              Augmenting one instance of a String object sounds like flaky design; I
              sure wouldn't expect it if I read your code.


              --
              stefan
            • Klemen Slavič
              Ah, yes, I misspoke. *Note to self: proof email before replying.* ... [Non-text portions of this message have been removed]
              Message 6 of 15 , Feb 17, 2010
              • 0 Attachment
                Ah, yes, I misspoke.

                *Note to self: proof email before replying.*

                On 18 February 2010 06:30, Stefan Weiss <weiss@...> wrote:

                >
                >
                > On 17/02/10 14:11, Klemen Slavič wrote:
                > > Why not use JSON to carry values in such a case?
                > >
                > > var a = {
                > > value: "somestring",
                > > id: 123
                > > };
                >
                > That's not JSON, it's just an object literal.
                >
                > As to the previous example:
                >
                >
                > var str = "somestring";
                > str.id = 123;
                > str.id; // undefined
                >
                > The reason why this can't work is that in lines 2 and 3, str is
                > converted from a string primitive to a new String object. This happens
                > every time you try to use a string (or number, or boolean) primitive
                > type like an object --> str gets auto-converted into an object twice,
                > but only internally, for the purpose of property lookup. The two created
                > String objects are then thrown away, and the "id" property is lost.
                >
                > For the OP: I agree with Klemen and the walfisch - wrapping your string
                > and any additional properties in a custom object is the way to go.
                > Augmenting one instance of a String object sounds like flaky design; I
                > sure wouldn't expect it if I read your code.
                >
                > --
                > stefan
                >
                >
                >


                [Non-text portions of this message have been removed]
              • Morgaut Alexandre Louis Marc
                For the exposed use case I wouldn t recommend this kind of weird custom objects wich wouldn t have any string methods and wouldn t be seen as string by typeof
                Message 7 of 15 , Feb 17, 2010
                • 0 Attachment
                  For the exposed use case I wouldn't recommend this kind of weird
                  custom objects wich wouldn't have any string methods and wouldn't be
                  seen as string by typeof

                  My suggestion would be to use an external object for additional
                  properties like this :

                  var strProps = {};

                  var str = "something";

                  strProps[str] = {
                  id: 123
                  };

                  You can either use a namespaced strProps (like myApp.strProps) or a
                  local one for more privacy depending of your requirements

                  Alexandre



                  Le 18 févr. 10 à 06:30, Stefan Weiss a écrit :

                  > On 17/02/10 14:11, Klemen Slavič wrote:
                  > > Why not use JSON to carry values in such a case?
                  > >
                  > > var a = {
                  > > value: "somestring",
                  > > id: 123
                  > > };
                  >
                  > That's not JSON, it's just an object literal.
                  >
                  > As to the previous example:
                  >
                  > var str = "somestring";
                  > str.id = 123;
                  > str.id; // undefined
                  >
                  > The reason why this can't work is that in lines 2 and 3, str is
                  > converted from a string primitive to a new String object. This happens
                  > every time you try to use a string (or number, or boolean) primitive
                  > type like an object --> str gets auto-converted into an object twice,
                  > but only internally, for the purpose of property lookup. The two
                  > created
                  > String objects are then thrown away, and the "id" property is lost.
                  >
                  > For the OP: I agree with Klemen and the walfisch - wrapping your
                  > string
                  > and any additional properties in a custom object is the way to go.
                  > Augmenting one instance of a String object sounds like flaky design; I
                  > sure wouldn't expect it if I read your code.
                  >
                  > --
                  > stefan
                  >
                  >



                  [Non-text portions of this message have been removed]
                • Stefan Weiss
                  ... The OP was planning on using a String object, which would have a type of object , so I don t think that matters much. Furthermore, the receiving code
                  Message 8 of 15 , Feb 18, 2010
                  • 0 Attachment
                    On 18/02/10 08:37, Morgaut Alexandre Louis Marc wrote:
                    > For the exposed use case I wouldn't recommend this kind of weird
                    > custom objects wich wouldn't have any string methods and wouldn't be
                    > seen as string by typeof

                    The OP was planning on using a String object, which would have a type of
                    "object", so I don't think that matters much. Furthermore, the receiving
                    code wasn't expecting normal Strings anyway (it would be looking for an
                    "id" property). If plain Object objects are too "weird", he could make
                    it official and define a constructor:

                    function SpecialString (str, id) {
                    this.value = str;
                    this.id = id;
                    }

                    var str = new SpecialString("somestring", 123);

                    This way, there would be no confusion, and no more JSLint warnings.

                    > My suggestion would be to use an external object for additional
                    > properties like this :
                    >
                    > var strProps = {};
                    >
                    > var str = "something";
                    >
                    > strProps[str] = {
                    > id: 123
                    > };
                    >
                    > You can either use a namespaced strProps (like myApp.strProps) or a
                    > local one for more privacy depending of your requirements

                    That would work, of course, but it would separate two parts of
                    information which belong together as an entity. I find that less
                    appealing than having them in one object. You also coulnd't have two
                    strings with the same value but different IDs.


                    --
                    stefan
                  • Woomla
                    ... I ve come up with the solution below. It runs in FF and IE and it uses data hiding. By implementing toString it behaves like a regular string. Only typeof
                    Message 9 of 15 , Feb 18, 2010
                    • 0 Attachment
                      --- In jslint_com@yahoogroups.com, Stefan Weiss <weiss@...> wrote:
                      > The OP was planning on using a String object, which would have a type of
                      > "object", so I don't think that matters much. Furthermore, the receiving
                      > code wasn't expecting normal Strings anyway (it would be looking for an
                      > "id" property). If plain Object objects are too "weird", he could make
                      > it official and define a constructor:
                      >
                      > function SpecialString (str, id) {
                      > this.value = str;
                      > this.id = id;
                      > }
                      >
                      > var str = new SpecialString("somestring", 123);
                      >
                      > This way, there would be no confusion, and no more JSLint warnings.


                      I've come up with the solution below. It runs in FF and IE and it uses data hiding. By implementing toString it behaves like a regular string. Only typeof returns 'object'.


                      var MyString = (function ()
                      {
                      var thevalue, itself;
                      thevalue = '';
                      itself = function (value)
                      {
                      thevalue = value;
                      };
                      itself.prototype.$family = {name: 'mystring'};
                      itself.prototype.toString = function ()
                      {
                      return thevalue;
                      };
                      return itself;
                      }());
                    • Klemen Slavič
                      Regarding the type; I think it s for the best that it returns object instead of string ; that way, you know you re handling a special type instead of a
                      Message 10 of 15 , Feb 18, 2010
                      • 0 Attachment
                        Regarding the type; I think it's for the best that it returns 'object'
                        instead of 'string'; that way, you know you're handling a special type
                        instead of a vanilla string, which is much more concise and understandable.



                        On 18 February 2010 15:13, Woomla <woomla@...> wrote:

                        >
                        >
                        > --- In jslint_com@yahoogroups.com <jslint_com%40yahoogroups.com>, Stefan
                        > Weiss <weiss@...> wrote:
                        > > The OP was planning on using a String object, which would have a type of
                        > > "object", so I don't think that matters much. Furthermore, the receiving
                        > > code wasn't expecting normal Strings anyway (it would be looking for an
                        > > "id" property). If plain Object objects are too "weird", he could make
                        > > it official and define a constructor:
                        > >
                        > > function SpecialString (str, id) {
                        > > this.value = str;
                        > > this.id = id;
                        > > }
                        > >
                        > > var str = new SpecialString("somestring", 123);
                        > >
                        > > This way, there would be no confusion, and no more JSLint warnings.
                        >
                        > I've come up with the solution below. It runs in FF and IE and it uses data
                        > hiding. By implementing toString it behaves like a regular string. Only
                        > typeof returns 'object'.
                        >
                        > var MyString = (function ()
                        > {
                        > var thevalue, itself;
                        > thevalue = '';
                        > itself = function (value)
                        > {
                        > thevalue = value;
                        > };
                        > itself.prototype.$family = {name: 'mystring'};
                        > itself.prototype.toString = function ()
                        > {
                        > return thevalue;
                        > };
                        > return itself;
                        > }());
                        >
                        >
                        >


                        [Non-text portions of this message have been removed]
                      • Stefan Weiss
                        ... I wouldn t do that. The string value is now bound to the variable thevalue instead of to the object itself: var str1 = new MyString( foo ); var str2 = new
                        Message 11 of 15 , Feb 18, 2010
                        • 0 Attachment
                          On 18/02/10 15:13, Woomla wrote:
                          > I've come up with the solution below. It runs in FF and IE and it
                          > uses data hiding. By implementing toString it behaves like a regular
                          > string.
                          > Only typeof returns 'object'.
                          >
                          > var MyString = (function ()
                          > {
                          > var thevalue, itself;
                          > thevalue = '';
                          > itself = function (value)
                          > {
                          > thevalue = value;
                          > };
                          > itself.prototype.$family = {name: 'mystring'};
                          > itself.prototype.toString = function ()
                          > {
                          > return thevalue;
                          > };
                          > return itself;
                          > }());

                          I wouldn't do that. The string value is now bound to the variable
                          thevalue instead of to the object itself:

                          var str1 = new MyString("foo");
                          var str2 = new MyString("bar");
                          str1.toString(); // bar
                          str2.toString(); // bar

                          Why not use a normal constructor?

                          function MyString (str, id) {
                          this.value = str;
                          this.id = id;
                          }
                          MyString.prototype = {
                          $family: "mystring",
                          toString: function () {
                          return this.value;
                          }
                          };

                          No closures required.

                          Or, if you really _have_ keep the properties internal:

                          function makeMeAString (str, id) {
                          var secretStr = str,
                          secretId = id;
                          return {
                          $family: "mystring",
                          toString: function () { return secretStr; },
                          getId: function () { return secretId; }
                          };
                          }

                          var str1 = makeMeAString("foo", 123);
                          var str2 = makeMeAString("bar", 123);
                          str1.toString(); // "foo"
                          str2.toString(); // "bar"
                          str1.getId(); // "123"
                          str2.$family; // "mystring"

                          But I don't see the advantage in your case.


                          --
                          stefan
                        • Woomla
                          ... This doesn t work. I must use this.value in function itself and toString because otherwise the value is not bound to the object and subsequent MyString
                          Message 12 of 15 , Feb 18, 2010
                          • 0 Attachment
                            --- In jslint_com@yahoogroups.com, "Woomla" <woomla@...> wrote:
                            > I've come up with the solution below. It runs in FF and IE and it uses data hiding. By implementing toString it behaves like a regular string. Only typeof returns 'object'.
                            >
                            >
                            > var MyString = (function ()
                            > {
                            > var thevalue, itself;
                            > thevalue = '';
                            > itself = function (value)
                            > {
                            > thevalue = value;
                            > };
                            > itself.prototype.$family = {name: 'mystring'};
                            > itself.prototype.toString = function ()
                            > {
                            > return thevalue;
                            > };
                            > return itself;
                            > }());


                            This doesn't work. I must use this.value in function itself and toString because otherwise the value is not bound to the object and subsequent MyString objects will overwrite this value.
                          • Stoyan Stefanov
                            How about using the Object() constructor as a factory to create a string object: var str = Object(Œsomestring¹); There¹s no `new` a.constructor.name ===
                            Message 13 of 15 , Feb 19, 2010
                            • 0 Attachment
                              How about using the Object() constructor as a factory to create a string
                              object:

                              var str = Object(Œsomestring¹);

                              There¹s no `new`

                              a.constructor.name === ³String² // true

                              Stoyan


                              On 2/17/10 4:21 AM, "Woomla" <woomla@...> wrote:

                              >
                              >
                              >
                              >
                              >
                              > jslint doesn't expect to see new String, but I need it because I want to
                              > set a property of the string:
                              >
                              > var str = new String('somestring');
                              > str.id = 123;
                              >
                              > Or is there another way to do this?
                              >
                              > [Non-text portions of this message have been removed]
                              >
                              >
                              >
                              >
                              >



                              [Non-text portions of this message have been removed]
                            • Jordan
                              Simply use: var str = String( blah ); to ensure that all of the String prototype s methods are applied. JSLint encourages this usage in this case. However,
                              Message 14 of 15 , Feb 19, 2010
                              • 0 Attachment
                                Simply use:
                                var str = String('blah');

                                to ensure that all of the String prototype's methods are applied. JSLint encourages this usage in this case.

                                However, rather than setting properties on strings, you might want to consider {str: 'string', id: 123} because then you're not dependent on the string being an object.

                                --- In jslint_com@yahoogroups.com, "Woomla" <woomla@...> wrote:
                                >
                                > jslint doesn't expect to see new String, but I need it because I want to
                                > set a property of the string:
                                >
                                > var str = new String('somestring');
                                > str.id = 123;
                                >
                                > Or is there another way to do this?
                                >
                                >
                                >
                                > [Non-text portions of this message have been removed]
                                >
                              Your message has been successfully submitted and would be delivered to recipients shortly.