Destructuring and Recursion in ES6

115 点作者 StylifyYourBlog超过 10 年前

12 条评论

Hah, I'm tempted to go through the Ocaml 99 problems (which was inspired by the Prolog version) using ES6 [1]. Turns out, with recursion and a head and tail function, you can do virtually anything with lists.I hope the popular JS engines optimize the hell out of the gathering operator, and adds TCO (it's on the ES6 spec, evidently). Then we won't even need to cross our fingers when we describe JS as a functional language to our peers.And with the increasing emphasis on immutability, as preached by the React crowd, with cross seeding from the Clojurescript-React connections, JS grows even closer to being a Scheme [2].If ES7 would lock down 'use strict' mode against even more of JS's weak-typing bloopers, things would be even better yet. I don't see why they shouldn't. They whole reason for 'use strict' is to give people who need backwards compatibility an out.Incidentally, I'm also having great success using ES6 arrow functions at work, thanks to 6to5 [3]. I do a lot of d3 work, and arrow functions have made using d3, particularly the ubiquitous d3 accessor functions, so much nicer. Highly recommended.For the first time since Node, I'm actually getting excited about Javascript's prospects. Now, if only they'd add types, and sum types...1. <a href="http://ocaml.org/learn/tutorials/99problems.html" rel="nofollow">http://ocaml.org/learn/tutorials/99problems.html</a>2. No, I don't actually believe that JS is a Scheme in disguise.3. <a href="https://github.com/6to5/6to5" rel="nofollow">https://github.com/6to5/6to5</a>

评论 #8986555 未加载

评论 #8990338 未加载

评论 #8987322 未加载

reconbot超过 10 年前

It's hard to believe this is javascript. I write that with a lot of love. These are some of my favorite language features but It's going to take some adjustment to be comfortable using and reading them in JS.

评论 #8985075 未加载

评论 #8988438 未加载

iMark超过 10 年前

ES6 transpiling has been a bit of a revelation to me lately. Object destructuring is also exceedingly useful.On a bit of a tangent from the article, I'm interested by the use of const as the default for variable declaration. My background is such that I've always considered constants as things that are class level constants (thank you Java), but reading up on Swift has made me rethink this.Clearly const has the potential to reduce runtime errors. I'd appreciate it if anyone could recommend any further reading on the subject.

评论 #8985240 未加载

philsnow超过 10 年前

I've never liked this corner of JS, and haven't kept up on ES6 or any of the modern dialects of JS, but it looks like `undefined` is still hanging around as a first-class thing?<pre><code> const length = ([first, ...rest]) => first === undefined ? 0 : 1 + length(rest); </code></pre> Having worked in languages that support multiple (destructuring or not) function definitions, this doesn't look quite right.Here's something I typed into chrome's JS console:<pre><code> > [1,2,3].length 3 > [undefined, 2, 3].length 3 </code></pre> Wouldn't the above-defined ES6 `length` function return 0 for the latter array?To mock up a similar syntax that would handle this more gracefully (and more sensically):<pre><code> const length = case ([]) => 0, ([first, ...rest]) => 1 + length(rest); </code></pre> Wouldn't it be better in general to be able to destructure arguments using syntax? If you can't use a case-like syntax for this, what do you do to be able to handle different structures?

评论 #8986952 未加载

评论 #8986889 未加载

peferron超过 10 年前

I've been pondering a few style questions recently:1. When to use 'function' vs '=>'?Leaving aside hoisting and handling of 'this', 'function' and '=>' are usually interchangeable:<pre><code> function foo(x) { // do something } let foo = x => { // do something } </code></pre> I prefer to keep using 'function' because it's immediately obvious to the reader that we are creating a function. With '=>', the reader doesn't know if foo is a function or not until reaching '=>', which is located after the argument list. There's also almost no terseness gain. A potential win for '=>' though would be the ability to declare the function as 'const'.With closures, '=>' wins because the reader already expects a function, and the terseness gain is significant:<pre><code> somearray.map(function(x) { // do something }); somearray.map(x => { // do something }); </code></pre> 2. When to use {} around the function body?<pre><code> somearray.forEach(x => /* a single statement */); somearray.forEach(x => {/* a single statement */}); </code></pre> {} around the function body are optional if there's only a single statement. However, for clarity, I still use {} when I want to make it clear that we are not using the return value. I think that might be overkill though: the reader should aready expect that 'map', 'filter' and friends will use the return value, while 'forEach' will not.3. 'let' or 'const'?This one is already mentioned in a sibling comment, so let's keep the discussion there.I realize that these are tiny style decisions that will probably incite endless bikeshedding, but I'm still interested in hearing opinions from fellow HNers. :)

评论 #8986855 未加载

评论 #8989014 未加载

whichdan超过 10 年前

<pre><code> const description = (nameAndOccupation) => { const [[first, last], occupation] = nameAndOccupation; return `${first} is a ${occupation}`; } description([["Reginald", "Braithwaite"], "programmer"]) //=> "Reginald is a programmer" </code></pre> This is going to make code a lot more readable. I'm excited!

评论 #8984987 未加载

评论 #8985073 未加载

评论 #8986655 未加载

phpnode超过 10 年前

obligatory mention that 6to5[0] lets you use all this stuff, and more, today. I've been using it for 3 months now and it has totally transformed the way I write JS applications, it's awesome.[0] <a href="https://6to5.org/" rel="nofollow">https://6to5.org/</a>

janjongboom超过 10 年前

Also coming to ES6 is destructuring objects:<pre><code> function doSomething(aObj) { let { x, y } = aObj; } doSomething({ x: 1, y: 4 })</code></pre>

taylodl超过 10 年前

Yet another validation of Greenspun's tenth rule. Now if only ES6 would get proper tail recursion then we'd be all set!

评论 #8985288 未加载

fenollp超过 10 年前

So basically pattern matching, shorter syntax for lambdas, string manipulation à la Ruby (but with backquotes, why?) and… confusing list with array EVERYWHERE in the language? No TCO? A `map` (sorry, `mapWith`) that creates then concatenates lists?2015 sounds amazing!

评论 #8985977 未加载

noobermin超过 10 年前

Completely unrelated, but even assuming the author of the article posts here, are you from Columbus OH? I've gone to One-Line Coffee (the source of the first pic) myself a number of times!

drapper超过 10 年前

Don't want to come off overly bitter, it's certainly interesting, but I'd like to see some practical uses of this, besides reimplementation of map() and other "low-level" functions...

评论 #8985819 未加载