Hacker News Board Hacker News, browsed like a classic message board
Live data from Hacker News

ES6: The features I'm most excited about

justicen.com

Post reply on HN
Print view View original

41–50 of 144 posts

Re: ES6: The features I'm most excited about

#41

Post by haberman »

jkrems wrote: post #32
haberman wrote: post #20

Earlier quoted context omitted.

So in the first function you call reject, but in the second function you throw? I don't love the asymmetry. Also how do you return a value from the second callback? Just return? If throw and return work that way for then() functions, why not the same for the initial function?

Because the initial one is where you'd interface (potentially) with non-promise code. E.g. in order to wrap a node-style function, you can't throw or return. But in general you shouldn't need to use `new Promise()`, that should in most cases be reserved to more general, low-level code (e.g. a promisify implementation).

I'm writing code against indexedDB (which doesn't use promises), but I want to expose promises to my callers. So I'm wrapping my indexedDB usage in Promises.

Also some of indexedDB doesn't seem like it would fit with promises, since some operations have 3 or more callbacks (onsuccess, onerror, onupgradeneeded).

Re: ES6: The features I'm most excited about

#42

Post by chncdcksn »

haberman wrote: post #14

I've just been playing with Promises and like them a lot. But one thing I find strange is that ".then()" creates a new promise, but with no way to reject it. ie. I can't write: return new Promise((resolve, reject) => { // Do some stuff, call resolve()/reject() on success/failure. }).then((step1Val, resolve, reject) => { // Do some stuff, call resolve()/reject() on success/failure. // But this doesn't actually work, b…

.then() does create a new promise. Return Promise.reject() in the fulfillment function to reject the new promise.

  somethingThatReturnsPromiseWithoutError()
    .then((res) => {
      return Promise.reject("some error");
    })
    .catch((err) => {
      console.log(err); // => some error
    });
Promise.resolve() and Promise.reject() return a promise resolved or rejected to the value passed in the first argument. Returning a promise in the fulfillment function passed to .then() chains the promises together.

  somethingThatReturnsPromise()
    .then((foo) => {
      return foo.bar;
      // Or if you like it more verbose
      return Promise.resolve(foo.bar);
      // Or pass bar to a function modifying bar that returns a promise
      return modifyBarReturnPromise(foo.bar);
    })
    .then((newBar) => {
      console.log(newBar);
    });
In your case, if you need step1Val in next promise chain, I personally do this, however people more familiar with promises may know of a better way to do it (maybe with something like Promise.all() or Promise.props() in the BlueBird library).

  somethingThatReturnsPromise()
    .then((first) => {
       doSomethingWithFirstAndReturnPromise(first)
         .then((second) => {
           console.log(first + second);
         });
    });

Re: ES6: The features I'm most excited about

#43

Post by seniorsassycat »

haberman wrote: post #14

I've just been playing with Promises and like them a lot. But one thing I find strange is that ".then()" creates a new promise, but with no way to reject it. ie. I can't write: return new Promise((resolve, reject) => { // Do some stuff, call resolve()/reject() on success/failure. }).then((step1Val, resolve, reject) => { // Do some stuff, call resolve()/reject() on success/failure. // But this doesn't actually work, b…

I like Jquery's Deferred better then ES6 Promise. Promises lack the `always` callback, they don't have any `progress` events.

The spec on mdn[0] doesn't mention asynchronous `then` or `catch` behavior. If the callback in Jquery `Deferred#then` returns a Deferred that deferred will be returned by `then`.

    // Basic async function, resolves after n milliseconds
    function wait(n) {
      var promise = $.Deferred();
      setTimeout(promise.resolve, n);
      return promise;
    }

    wait(10)
      .then(function() {
        console.log('first');  // prints first after 10 milliseconds
        return wait(10);
      })
      .then(function() {
        console.log('second'); // prints second after 20 milliseconds
        return 'done';
      })
You can 'flip' a failed promise by returning a resolve promise in the fail callback.

    var promise = $.Deferred();
    setTimeout(promise.reject, 100)

    promise.then(null, function () {
      return $.Deferred().resolve([]);
    }).done(function(arg) {
      console.log(arg); // Prints '[]'
    })
[0] https://developer.mozilla.org/en-US/docs/Web/JavaScript/Refe...

Re: ES6: The features I'm most excited about

#44

Post by inglor »

haberman wrote: post #14

I've just been playing with Promises and like them a lot. But one thing I find strange is that ".then()" creates a new promise, but with no way to reject it. ie. I can't write: return new Promise((resolve, reject) => { // Do some stuff, call resolve()/reject() on success/failure. }).then((step1Val, resolve, reject) => { // Do some stuff, call resolve()/reject() on success/failure. // But this doesn't actually work, b…

You can reject inside a `then` by `throw`ing an error, like synchronous try-catch.

Re: ES6: The features I'm most excited about

#45

Post by inglor »

striking wrote: post #11
savanaly wrote: post #6

Earlier quoted context omitted.

What exactly did you have in mind other than "new Promise()" to create a promise?

new Promise(function(resolve, reject){ /* code */ }) it's a little much

That's because 99% of times when people use it it's an anti pattern: stackoverflow.com/questions/23803743/what-is-the-explicit-promise-construction-antipattern-and-how-do-i-avoid-it

Re: ES6: The features I'm most excited about

#46

Post by thwarted »

nodesocket wrote: post #9

I was just talking to my friend who works at NetFlix on the frontend team about ES6, he is most excited about destructuring `let { name, age, gender } = user;`. I however advocate that the new class syntax is the best part of ES6. Take the following trivial OOP example, which I think reads so much easier a lot like PHP. "use strict"; class Vehicle { constructor(name) { this.kind = 'Vehicle'; this.name = name; } print…

Why can all this new syntax be added, but the "use strict" pragma is still specified by a string? It made sense to send messages to the interpreter in a backwards compatible way, but now it just seems odd.

Re: ES6: The features I'm most excited about

#47

Post by nodesocket »

thwarted wrote: post #46
nodesocket wrote: post #9

I was just talking to my friend who works at NetFlix on the frontend team about ES6, he is most excited about destructuring `let { name, age, gender } = user;`. I however advocate that the new class syntax is the best part of ES6. Take the following trivial OOP example, which I think reads so much easier a lot like PHP. "use strict"; class Vehicle { constructor(name) { this.kind = 'Vehicle'; this.name = name; } print…

Why can all this new syntax be added, but the "use strict" pragma is still specified by a string? It made sense to send messages to the interpreter in a backwards compatible way, but now it just seems odd.

Not entirely sure if browsers require "use strict;", but io.js (node) does.

Re: ES6: The features I'm most excited about

#48

Post by AgentME »

The first module example is incorrect:

    // myModule.js
    export function myModule(someArg) {
      return someArg;
    }

    // main.js
    import myModule from 'myModule';
The import is importing a non-existent default export. Either the export needs to be changed to a default export:

    export default function myModule(someArg) {
-or- the import needs to be changed to importing a member:

    import {myModule} from 'myModule';

Re: ES6: The features I'm most excited about

#49

Post by niix »

AgentME wrote: post #48

The first module example is incorrect: // myModule.js export function myModule(someArg) { return someArg; } // main.js import myModule from 'myModule'; The import is importing a non-existent default export. Either the export needs to be changed to a default export: export default function myModule(someArg) { -or- the import needs to be changed to importing a member: import {myModule} from 'myModule';

Thanks, fixed.
Post reply on HN