I understand the idea behind the article - explain proxies and have a fun project to do so, so it doesn't get boring as hell - but, in general, can we please stop using runtime features of a language to implement syntactic sugar?<p>Actual syntactic suger can make a program more readable, easier to debug and even more efficient. Those kind of hacks are neither.<p>It's not more readable because your expressions are limited to the original grammar, so you have to resort to weird compromises. It's harder to debug because you add layers of abstraction (like the proxies here) that have no purpose at all except changing how your code looks. And it's less efficient because those layers of abstraction will still stay with the program when it's being executed even though you only needed them while you were writing the code.<p>So, please, syntactic sugar is awesome and more thought should be given to letting users add their own sugars - but can we do it via metaprogramming and preprocessors and not by hacks like this?<p>(Disclaimer: This pattern annoys me to no end in Java, so it's gotten a bit of a pet peeve. No fault to the author of this post who has written an excellent article)
I used ES6 proxies recently to write a program which monitors changes on javascript data structures, and generates operation objects reflecting the changes to send to my data structure visualizer project[0].<p>You can see the source for the javascript client that does the monitoring with proxies here: <a href="https://github.com/westoncb/JS-Watcher/blob/master/watcher.js" rel="nofollow">https://github.com/westoncb/JS-Watcher/blob/master/watcher.j...</a> —it just works for arrays at the moment, but the basic idea is there. (I've written another much more complete client that does monitoring in Java; this JS one is more experimental.)<p>[0] <a href="https://www.youtube.com/watch?v=KwZmAgAuIkY" rel="nofollow">https://www.youtube.com/watch?v=KwZmAgAuIkY</a>
Recently I implemented a wrapper function that given an object returns a Proxy which has a get method that recursively calls itself with the accessed object path and finally returns the object and logs the full path. (The code is not complicated and only about as long as this post, but it's hard to type code on a phone)<p>The reason for this is to give me logging for this part of the application to aid in extracting it out to a separate service. That is, to see what from this part of the application is actually being used/called.<p>Edit: I meant to say that I wanted to share this because previously I hadn't yet found an interesting use for a Proxy.<p>Also, I thought of another use case: in the get method you could return a percentage of the time a different object, i.e. an A/B test.
> My proposed solution here is to try to capture the spirit of Python’s slice syntax rather than the exact syntax itself. We can accomplish this using an alternative syntax where we use double square brackets and commas in place of colons: array[::-1] => array[[,,-1]], array[:n] => array[[,n]], array[-5::2] => array[[-5,,2]], and so on. This might not be quite as concise as Python’s syntax, but it only requires two extra keystrokes per slice and I think it’s as close as we’re gonna get.<p>I wonder if it makes more sense to write a babel plugin to support the python syntax. Since everyone using es6 features are transpiling anyway.
Great PoC, but please, don't do this. At my first gig I had to work on a huge Lua code base, where the original author did tricks like this, effectively creating a new language. Learning by example how things should not be done is effective, but the suffering wasn't worth it.
Fun, I learned something today! I imagine the performance of proxies is pretty terrible, so this is just a toy - but it could come in handy for implementing equivalents of some of the nice syntax sugar that numpy and tensorflow have in JavaScript.
I wonder why not to use the call syntax for JS slices? I.e. use a(1, 3) to mean a[1:3]? The drawback is that 0 at the beginning of the slice cannot be skipped, but things like a() in place of a[:] or a(i, j, k) in place of a[i:j:k] will work.
We have a legacy angular2+ project (I know angular2+ is not that old) where we use a global object to store state. We are using ngrx in new code , but still need to access that monstrous global object. As other part of code is still updating that.<p>I'm thinking to replace that global object with recursive proxies so that all updates can be forwarded to ngrx store<p>And slowly replace all reads with ngrx selectors
Fan of katas? <a href="https://www.codewars.com/kata/5a6c75c8fd5777274e000042" rel="nofollow">https://www.codewars.com/kata/5a6c75c8fd5777274e000042</a>
Just by looking at the implementation I dare to bet that this is the most expensive slice ever invented in JS. And all that conversion and processing to only allow for arr[-1], oh my..