`String.prototype.symbolAt()` (improved `String.prototype.charAt()`)

Andrea Giammarchi andrea.giammarchi at gmail.com
Sat Oct 19 11:18:38 PDT 2013


AFAIK that's also what Allen said didn't want to implement in core. An
expensive operation per each invocation due stateless loop over arbitrary
indexes.

Although, strings are immutable in JS so I'd implement that logic creating
a snapshot once and use that as if it was an Array ... something like the
following:

```javascript

!function(dict){

  function getOrCreate(str) {
    if (!(str in dict)) {
      dict[str] = {
        i: 0,
        l: 0,
        v: (Array.from || function(){
          // miserable callback
          return str.split('')
        })(str)
        // or the for/of loop
      };
    }
    // times it's used
    dict[str].i++;
    return dict[str].v;
  }

  setInterval(function () {
    var key, value;
    for(key in dict) {
      value = dict[key];
      value.l = value.i - value.l;
      // used only once or never used again
      if (value.l < 2) {
        // free all the RAM
        delete dict[key];
      }
    }
  }, 5000); // 5 seconds should be enough ?
            // incremental works better with
            // slower timeout though
            // 500 might be good too

  Object.defineProperties(
    String.prototype,
    {
      at: {
        configurable: true,
        writable: true,
        value: function at(i) {
          return getOrCreate(this)[i];
        }
      },
      // or any meaningful name
      size: {
        configurable: true,
        get: function () {
          return getOrCreate(this).length;
        }
      }
    }
  );

}(Object.create(null));


// @example
var str = 'abc';
alert([
  str.size, // 3
  str.at(1) // b
]);


```

Regards




On Sat, Oct 19, 2013 at 10:54 AM, Domenic Denicola <
domenic at domenicdenicola.com> wrote:

> From: Mathias Bynens [mailto:mathias at qiwi.be]
>
>
> > This brings us back to the earlier discussion of whether something like
> `String.prototype.codePoints` should be added:
> http://esdiscuss.org/topic/how-to-count-the-number-of-symbols-in-a-stringIt could be a getter or a generator… Or does `for…of` iteration handle this
> use case adequately?
>
> It sounds like you are proposing a second name for
> `String.prototype[Symbol.iterator]`, which does not sound very useful.
>
> A property for the string's "real length" does seem somewhat useful, as
> does a method that does random-access on "real characters." Certainly more
> useful than the proposed symbolAt/at. But I suppose we can pave whatever
> cowpaths arise.
>
> My proposed cowpaths:
>
> ```js
> Object.mixin(String.prototype, {
>   realCharacterAt(i) {
>     let index = 0;
>     for (var c of this) {
>       if (index++ === i) {
>         return c;
>       }
>     }
>   }
>   get realLength() {
>     let counter = 0;
>     for (var c of this) {
>       ++counter;
>     }
>     return counter;
>   }
> });
> ```
>
> This would allow you to e.g. find the character in the "real" middle of a
> string with code like
>
> ```js
> var middleIndex = Math.floor(theString.realLength / 2);
> var middleRealCharacter = theString.realCharacterAt(middleIndex);
> ```
>
> _______________________________________________
> es-discuss mailing list
> es-discuss at mozilla.org
> https://mail.mozilla.org/listinfo/es-discuss
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.mozilla.org/pipermail/es-discuss/attachments/20131019/790ca9bf/attachment.html>


More information about the es-discuss mailing list