Syntax for an async arrow function
I can mark a JavaScript function as "async" (i.e., returning a promise) with the async keyword. Like this:
async function foo() {
// Do something
}
What is the equivalent syntax for arrow functions?
var foo = async () => await Promise.resolve('ha'); - works just fine
it doesn't work is meaningless ... are you getting an error? perhaps you're doing something else wrong, without the code that "doesn't work" and a meaningful description of how it doesn't work, can only guess that you're doing something wrong (or using an old browser)
Async arrow functions look like this:
const foo = async () => {
// do something
}
Async arrow functions look like this for a single argument passed to it:
const foo = async evt => {
// do something with evt
}
Async arrow functions look like this for multiple arguments passed to it:
const foo = async (evt, callback) => {
// do something with evt
// return response with callback
}
The anonymous form works as well:
const foo = async function() {
// do something
}
An async function declaration looks like this:
async function foo() {
// do something
}
Using async function in a callback:
const foo = event.onCall(async () => {
// do something
})
Using async method inside of a class:
async foo() {
// do something
}
This the simplest way to assign an async arrow function expression to a named variable:
const foo = async () => {
// do something
}
(Note that this is not strictly equivalent to async function foo() { }. Besides the differences between the function keyword and an arrow expression, the function in this answer is not "hoisted to the top".)
foo = function myName () {}. The name is myName and it is specified to only exist inside the anonymous function and not defined anywhere outside. It's purpose is to replace arguments.callee when writing recursive anonymous functions.
foo.name === 'foo'). But only because it's in the initializer of a const *statement*—meaning it's not quite right to call this a "named async arrow function expression". You're also correct that a named function expression's name is only bound inside its own body, but it is also stored in the function's name property, which is nice for debugging (and is more often the reason I'd name them).
fn.name as well as having a binding in scope (the variable).
Immediately Invoked Async Arrow Function:
(async () => {
console.log(await asyncFunction());
})();
Immediately Invoked Async Function Expression:
(async function () {
console.log(await asyncFunction());
})();
Async Arrow function syntax with parameters
const myFunction = async (a, b, c) => {
// Code here
}
Basic Example
folder = async () => {
let fold = await getFold();
//await localStorage.save('folder');
return fold;
};
async function foo() {
// do something
}
Is equivalent to:
const foo = async () => {
// do something
}
Calling foo with one argument like in the following example:
async function foo(arg1) {
// do something
}
Is equivalent to calling foo like this (both ways are acceptable since parentheses are optional but not required when just one argument is provided)
const foo = async arg1 => {
// do something
}
const foo = async (arg1) => {
// do something
}
if you call foo with two or more arguments
async function foo(arg1, arg2) {
// do something
}
Is equivalent to: (parentheses are now required)
const foo = async (arg1, arg2) => {
// do something
}
And for a practical example with an await use inside:
const foo = async () => await Promise.resolve('done');
You may also do:
YourAsyncFunctionName = async (value) => {
/* Code goes here */
}
My async function
const getAllRedis = async (key) => {
let obj = [];
await client.hgetall(key, (err, object) => {
console.log(object);
_.map(object, (ob)=>{
obj.push(JSON.parse(ob));
})
return obj;
// res.send(obj);
});
}
For a static async arrow function, it works like this:
static myFunction = async () => {
// your code here
}
Most simplest way
const MyFunction = async ()=>{
// do something here
}
Follow WeChat
Success story sharing
Want to stay one step ahead of the latest teleworks?
Subscribe Now相似问题
- var functionName = function() {} vs function functionName() {}
- Set a default parameter value for a JavaScript function
- What does "use strict" do in JavaScript, and what is the reasoning behind it?
- How can I remove a specific item from an array?
- For-each over an array in JavaScript
- Using async/await with a forEach loop
const foo = async () => {}creates a named async function namedfoo. It's entirely possible to do named functions this way (just no hoisting). In ES2016+ assignment of an anonymous function to a variable names it after the variable if it is declared there.foo = function bar () {}that was created to replacearguments.calleewhen writing recursive anonymous functions. What you have there is a variable namedfoothat is a reference to a function.const foo = async () => {}the name of the function is set tofoo- ecma-international.org/ecma-262/6.0/… and ecma-international.org/ecma-262/6.0/… - see discussion in esdiscuss.org/topic/…somefunctioncannot be changed after it is set. (It points to your anonymous async function.)