JavaScript-Entwicklerhandbuch für Azure FunctionsAzure Functions JavaScript developer guide

Dieses Handbuch enthält Informationen zu den Feinheiten des Schreibens von Azure Functions mit JavaScript.This guide contains information about the intricacies of writing Azure Functions with JavaScript.

Eine JavaScript-Funktion ist eine exportierte function, die ausgeführt wird, wenn sie ausgelöst wird (Trigger werden in „function.json“ konfiguriert).A JavaScript function is an exported function that executes when triggered (triggers are configured in function.json). Das erste Argument, das an jede Funktion übergeben wird, ist ein context-Objekt, das zum Empfangen und Senden von Bindungsdaten, für die Protokollierung und für die Kommunikation mit der Runtime verwendet wird.The first argument passed to every function is a context object, which is used for receiving and sending binding data, logging, and communicating with the runtime.

In diesem Artikel wird davon ausgegangen, dass Sie bereits die Entwicklerreferenz zu Azure Functionsgelesen haben.This article assumes that you have already read the Azure Functions developer reference. Führen Sie den Schnellstart zu Azure Functions durch, um Ihre erste Funktion mit Visual Studio Code oder im Portal zu erstellen.Complete the Functions quickstart to create your first function, using Visual Studio Code or in the portal.

Dieser Artikel eignet sich auch für die App-Entwicklung mit TypeScript.This article also supports TypeScript app development.

OrdnerstrukturFolder structure

Die erforderlichen Ordnerstruktur für ein JavaScript-Projekt sieht folgendermaßen aus.The required folder structure for a JavaScript project looks like the following. Diese Standardeinstellung kann geändert werden.This default can be changed. Weitere Informationen finden Sie im Abschnitt zu scriptFile weiter unten.For more information, see the scriptFile section below.

FunctionsProject
 | - MyFirstFunction
 | | - index.js
 | | - function.json
 | - MySecondFunction
 | | - index.js
 | | - function.json
 | - SharedCode
 | | - myFirstHelperFunction.js
 | | - mySecondHelperFunction.js
 | - node_modules
 | - host.json
 | - package.json
 | - extensions.csproj

Im Stammverzeichnis des Projekts befindet sich eine freigegebene Datei host.json, die zum Konfigurieren der Funktions-App verwendet werden kann.At the root of the project, there's a shared host.json file that can be used to configure the function app. Jede Funktion verfügt über einen Ordner mit einer eigenen Codedatei (JS-Datei) und Bindungskonfigurationsdatei („function.json“).Each function has a folder with its own code file (.js) and binding configuration file (function.json). Der Name des übergeordneten Verzeichnisses von function.json ist immer der Name Ihrer Funktion.The name of function.json's parent directory is always the name of your function.

Die in Version 2.x der Functions-Runtime erforderlichen Bindungserweiterungen sind in der Datei extensions.csproj definiert, die eigentlichen Bibliotheksdateien befinden sich im Ordner bin.The binding extensions required in version 2.x of the Functions runtime are defined in the extensions.csproj file, with the actual library files in the bin folder. Wenn Sie lokal entwickeln, müssen Sie Bindungserweiterungen registrieren.When developing locally, you must register binding extensions. Wenn Sie Funktionen im Azure-Portal entwickeln, wird diese Registrierung für Sie ausgeführt.When developing functions in the Azure portal, this registration is done for you.

Exportieren einer FunktionExporting a function

JavaScript-Funktionen müssen über module.exports (oder exports) exportiert werden.JavaScript functions must be exported via module.exports (or exports). Die exportierte Funktion muss eine JavaScript-Funktion sein, die ausgeführt wird, wenn sie ausgelöst wird.Your exported function should be a JavaScript function that executes when triggered.

Standardmäßig sucht die Functions-Runtime in index.js nach Ihrer Funktion, wobei sich index.js im gleichen übergeordneten Verzeichnis befindet wie die entsprechende Datei function.json.By default, the Functions runtime looks for your function in index.js, where index.js shares the same parent directory as its corresponding function.json. Im Standardfall sollte Ihre exportierte Funktion der einzige Export aus der zugehörigen Datei oder der Export mit dem Namen run oder index sein.In the default case, your exported function should be the only export from its file or the export named run or index. Um den Dateispeicherort zu konfigurieren und den Namen Ihrer Funktion zu exportieren, lesen Sie weiter unten die Beschreibung zum Konfigurieren des Einstiegspunkts Ihrer Funktion.To configure the file location and export name of your function, read about configuring your function's entry point below.

An die exportierte Funktion wird bei der Ausführung eine Reihe von Argumenten übergeben.Your exported function is passed a number of arguments on execution. Das erste angenommene Argument ist immer ein context-Objekt.The first argument it takes is always a context object. Wenn Ihre Funktion synchron ist (also keine Zusage zurückgibt), muss das context-Objekt übergeben werden, da der Aufruf von context.done zur korrekten Verwendung erforderlich ist.If your function is synchronous (doesn't return a Promise), you must pass the context object, as calling context.done is required for correct use.

// You should include context, other arguments are optional
module.exports = function(context, myTrigger, myInput, myOtherInput) {
    // function logic goes here :)
    context.done();
};

Exportieren einer Async-FunktionExporting an async function

Bei der Verwendung der Deklaration async function oder einfacher JavaScript-Zusagen in Version 2.x der Functions-Runtime müssen Sie den context.done-Rückruf nicht explizit aufrufen, um zu signalisieren, dass Ihre Funktion abgeschlossen wurde.When using the async function declaration or plain JavaScript Promises in version 2.x of the Functions runtime, you do not need to explicitly call the context.done callback to signal that your function has completed. Ihre Funktion wird abgeschlossen, wenn die exportierte asynchrone Funktion/Zusage abgeschlossen wird.Your function completes when the exported async function/Promise completes. Bei Funktionen für Version 1.x der Runtime müssen Sie jedoch context.done aufrufen, wenn die Ausführung des Codes abgeschlossen wurde.For functions targeting the version 1.x runtime, you must still call context.done when your code is done executing.

Beim folgenden Beispiel handelt es sich um eine einfache Funktion, die ihre Auslösung protokolliert und dann die Ausführung abschließt.The following example is a simple function that logs that it was triggered and immediately completes execution.

module.exports = async function (context) {
    context.log('JavaScript trigger function processed a request.');
};

Beim Exportieren einer asynchronen Funktion können Sie zudem eine Ausgabebindung für die Annahme des return-Werts konfigurieren.When exporting an async function, you can also configure an output binding to take the return value. Dies wird empfohlen, wenn Sie nur eine Ausgabebindung definiert haben.This is recommended if you only have one output binding.

Um eine Ausgabe mithilfe von return zuzuweisen, ändern Sie die name-Eigenschaft in function.json in $return.To assign an output using return, change the name property to $return in function.json.

{
  "type": "http",
  "direction": "out",
  "name": "$return"
}

In diesem Fall sollte die Funktion wie das folgende Beispiel aussehen:In this case, your function should look like the following example:

module.exports = async function (context, req) {
    context.log('JavaScript HTTP trigger function processed a request.');
    // You can call and await an async method here
    return {
        body: "Hello, world!"
    };
}

BindungenBindings

In JavaScript werden Bindungen in der Datei „function.json“ einer Funktion konfiguriert und definiert.In JavaScript, bindings are configured and defined in a function's function.json. Funktionen interagieren auf verschiedene Weise mit Bindungen.Functions interact with bindings a number of ways.

EingabenInputs

Eingaben werden in Azure Functions in zwei Kategorien unterteilt: die Triggereingabe und die zusätzliche Eingabe.Input are divided into two categories in Azure Functions: one is the trigger input and the other is the additional input. Trigger und andere Eingabebindungen (Bindungen des Typs direction === "in") können von einer Funktion auf drei Arten gelesen werden:Trigger and other input bindings (bindings of direction === "in") can be read by a function in three ways:

  • [Empfohlen] Als an die Funktion übergebene Parameter.[Recommended] As parameters passed to your function. Sie werden in der Reihenfolge, in der sie in function.json definiert sind, an die Funktion übergeben.They are passed to the function in the same order that they are defined in function.json. Die in function.json definierte name-Eigenschaft muss nicht mit dem Namen des Parameters übereinstimmen, obwohl dies empfehlenswert ist.The name property defined in function.json does not need to match the name of your parameter, although it should.

    module.exports = async function(context, myTrigger, myInput, myOtherInput) { ... };
    
  • Als Member des context.bindings-Objekts.As members of the context.bindings object. Jeder Member wird durch die in function.json definierte name-Eigenschaft benannt.Each member is named by the name property defined in function.json.

    module.exports = async function(context) { 
        context.log("This is myTrigger: " + context.bindings.myTrigger);
        context.log("This is myInput: " + context.bindings.myInput);
        context.log("This is myOtherInput: " + context.bindings.myOtherInput);
    };
    
  • Als Eingaben unter Verwendung des JavaScript-Objekts arguments.As inputs using the JavaScript arguments object. Dies entspricht im Wesentlichen dem Übergeben von Eingaben als Parameter, ermöglicht jedoch die dynamische Verarbeitung der Eingaben.This is essentially the same as passing inputs as parameters, but allows you to dynamically handle inputs.

    module.exports = async function(context) { 
        context.log("This is myTrigger: " + arguments[1]);
        context.log("This is myInput: " + arguments[2]);
        context.log("This is myOtherInput: " + arguments[3]);
    };
    

AusgabenOutputs

Ausgaben (Bindungen des Typs direction === "out") können von einer Funktion auf verschiedene Arten geschrieben werden.Outputs (bindings of direction === "out") can be written to by a function in a number of ways. In allen Fällen entspricht die in function.json definierte name-Eigenschaft der Bindung dem Namen des Objektmembers, der in die Funktion geschrieben wird.In all cases, the name property of the binding as defined in function.json corresponds to the name of the object member written to in your function.

Sie können Ausgabebindungen mit einer der folgenden Methoden Daten zuweisen. Achten Sie darauf, dass Sie nicht beide Methoden verwenden.You can assign data to output bindings in one of the following ways (don't combine these methods):

  • [Empfohlen für mehrere Ausgaben] Zurückgeben eines Objekts.[Recommended for multiple outputs] Returning an object. Bei Verwendung einer asynchronen Funktion (mit Rückgabe einer Zusage) kann ein Objekt mit zugewiesenen Ausgabedaten zurückgegeben werden.If you are using an async/Promise returning function, you can return an object with assigned output data. Im folgenden Beispiel werden die Ausgabebindungen in function.json mit „httpResponse“ und „queueOutput“ benannt.In the example below, the output bindings are named "httpResponse" and "queueOutput" in function.json.

    module.exports = async function(context) {
        let retMsg = 'Hello, world!';
        return {
            httpResponse: {
                body: retMsg
            },
            queueOutput: retMsg
        };
    };
    

    Bei Verwendung einer synchronen Funktion kann dieses Objekt mithilfe von context.done zurückgegeben werden (siehe Beispiel).If you are using a synchronous function, you can return this object using context.done (see example).

  • [Empfohlen für eine einzelne Ausgabe] Direktes Zurückgeben eines Werts und Verwenden des Bindungsnamens „$return“.[Recommended for single output] Returning a value directly and using the $return binding name. Dies ist nur bei asynchronen Funktionen (mit Rückgabe einer Zusage) möglich.This only works for async/Promise returning functions. Siehe dazu das Beispiel unter Exportieren einer Async-Funktion.See example in exporting an async function.

  • Zuweisen von Werten zu context.bindings. Sie können „context.bindings“ direkt Werte zuweisen.Assigning values to context.bindings You can assign values directly to context.bindings.

    module.exports = async function(context) {
        let retMsg = 'Hello, world!';
        context.bindings.httpResponse = {
            body: retMsg
        };
        context.bindings.queueOutput = retMsg;
        return;
    };
    

Datentyp für BindungenBindings data type

Verwenden Sie zum Definieren des Datentyps für eine Eingabebindung die dataType-Eigenschaft in der Bindungsdefinition.To define the data type for an input binding, use the dataType property in the binding definition. Um z.B. den Inhalt einer HTTP-Anforderung im Binärformat zu lesen, verwenden Sie den Typ binary:For example, to read the content of an HTTP request in binary format, use the type binary:

{
    "type": "httpTrigger",
    "name": "req",
    "direction": "in",
    "dataType": "binary"
}

Optionen für dataType sind binary, stream und string.Options for dataType are: binary, stream, and string.

context-Objektcontext object

Die Laufzeit verwendet ein context-Objekt, um Daten an Ihre und von Ihrer Funktion zu übergeben und Ihnen die Kommunikation mit der Laufzeit zu ermöglichen.The runtime uses a context object to pass data to and from your function and to let you communicate with the runtime. Das context-Objekt kann zum Lesen und Festlegen von Daten von Bindungen, zum Schreiben von Protokollen und für den context.done-Rückruf verwendet werden, wenn die exportierte Funktion asynchron ist.The context object can be used for reading and setting data from bindings, writing logs, and using the context.done callback when your exported function is synchronous.

Das context-Objekt ist immer der erste Parameter in einer Funktion.The context object is always the first parameter to a function. Es sollte angegeben werden, da es wichtige Methoden wie context.done und context.log enthält.It should be included because it has important methods such as context.done and context.log. Sie können dem Objekt einen beliebigen Namen geben (also etwa ctx oder c).You can name the object whatever you would like (for example, ctx or c).

// You must include a context, but other arguments are optional
module.exports = function(ctx) {
    // function logic goes here :)
    ctx.done();
};

context.bindings-Eigenschaftcontext.bindings property

context.bindings

Gibt ein benanntes Objekt zurück, das zum Lesen oder Zuweisen von Bindungsdaten verwendet wird.Returns a named object that is used to read or assign binding data. Auf Eingabe- und Triggerbindungsdaten kann durch Lesen der Eigenschaften in context.bindings zugegriffen werden.Input and trigger binding data can be accessed by reading properties on context.bindings. Auf Ausgabebindungsdaten kann durch Hinzufügen von Daten zu context.bindings zugegriffen werden.Output binding data can be assigned by adding data to context.bindings

Mit den folgenden Bindungsdefinitionen in der Datei „function.json“ können Sie beispielsweise auf den Inhalt einer Warteschlange von context.bindings.myInput zugreifen und Ausgaben mit context.bindings.myOutput einer Warteschlange zuweisen.For example, the following binding definitions in your function.json let you access the contents of a queue from context.bindings.myInput and assign outputs to a queue using context.bindings.myOutput.

{
    "type":"queue",
    "direction":"in",
    "name":"myInput"
    ...
},
{
    "type":"queue",
    "direction":"out",
    "name":"myOutput"
    ...
}
// myInput contains the input data, which may have properties such as "name"
var author = context.bindings.myInput.name;
// Similarly, you can set your output data
context.bindings.myOutput = { 
        some_text: 'hello world', 
        a_number: 1 };

Sie können die Ausgabebindungsdaten mit der context.done-Methode anstelle des context.binding-Objekts definieren (siehe unten).You can choose to define output binding data using the context.done method instead of the context.binding object (see below).

context.bindingData-Eigenschaftcontext.bindingData property

context.bindingData

Gibt ein benanntes Objekt zurück, das Triggermetadaten und Funktionsaufrufdaten (invocationId, sys.methodName, sys.utcNow, sys.randGuid) enthält.Returns a named object that contains trigger metadata and function invocation data (invocationId, sys.methodName, sys.utcNow, sys.randGuid). Ein Beispiel für Triggermetadaten finden Sie in diesem Event Hubs-Beispiel.For an example of trigger metadata, see this event hubs example.

context.Done-Methodecontext.done method

context.done([err],[propertyBag])

Gibt für die Runtime an, dass der Code abgeschlossen wurde.Lets the runtime know that your code has completed. Wenn die Funktion die async function-Deklaration verwendet, muss context.done() nicht verwendet werden.When your function uses the async function declaration, you do not need to use context.done(). Der Rückruf context.done wird implizit aufgerufen.The context.done callback is implicitly called. Asynchrone Funktionen sind in Node 8 oder einer höheren Version verfügbar, für die Version 2.x der Functions-Runtime erforderlich ist.Async functions are available in Node 8 or a later version, which requires version 2.x of the Functions runtime.

Wenn Ihre Funktion keine asynchrone Funktion ist, müssen Sie context.done aufrufen, um der Laufzeit mitzuteilen, dass Ihre Funktion vollständig ist.If your function is not an async function, you must call context.done to inform the runtime that your function is complete. Wenn diese Methode fehlt, tritt bei der Ausführung ein Timeout auf.The execution times out if it is missing.

Mit der context.done-Methode können Sie sowohl einen benutzerdefinierten Fehler an die Laufzeit als auch ein JSON-Objekt mit Ausgabebindungsdaten zurückgeben.The context.done method allows you to pass back both a user-defined error to the runtime and a JSON object containing output binding data. Eigenschaften, die an context.done übergeben werden, überschreiben alles, was für das context.bindings-Objekt festgelegt wurde.Properties passed to context.done overwrite anything set on the context.bindings object.

// Even though we set myOutput to have:
//  -> text: 'hello world', number: 123
context.bindings.myOutput = { text: 'hello world', number: 123 };
// If we pass an object to the done function...
context.done(null, { myOutput: { text: 'hello there, world', noNumber: true }});
// the done method overwrites the myOutput binding to be: 
//  -> text: 'hello there, world', noNumber: true

context.log-Methodecontext.log method

context.log(message)

Ermöglicht das Schreiben in die Streamingfunktionsprotokolle auf Standard-Ablaufverfolgungsebene.Allows you to write to the streaming function logs at the default trace level. Es sind zusätzliche Protokollierungsmethoden in context.log verfügbar, mit denen Sie auf anderen Ablaufverfolgungsebenen in das Funktionsprotokoll schreiben können:On context.log, additional logging methods are available that let you write function logs at other trace levels:

MethodeMethod BESCHREIBUNGDescription
error(message)error(message) Schreibt in Protokollierung auf Fehlerebene oder niedriger.Writes to error level logging, or lower.
warn(message)warn(message) Schreibt in Protokollierung auf Warnungsebene oder niedriger.Writes to warning level logging, or lower.
info(message)info(message) Schreibt in Protokollierung auf Informationsebene oder niedriger.Writes to info level logging, or lower.
verbose(message)verbose(message) Schreibt in Protokollierung auf ausführlicher Ebene.Writes to verbose level logging.

Das folgende Beispiel schreibt auf Warnungs-Ablaufverfolgungsebene ein Protokoll:The following example writes a log at the warning trace level:

context.log.warn("Something has happened."); 

Sie können den Ablaufverfolgungsebenen-Schwellenwert für die Protokollierung in der Datei „host.json“ konfigurieren.You can configure the trace-level threshold for logging in the host.json file. Weitere Informationen zum Schreiben von Protokollen finden Sie unter Schreiben von Ablaufverfolgungsausgaben weiter unten.For more information on writing logs, see writing trace outputs below.

Lesen Sie Überwachen von Azure Functions, um weitere Informationen zum Anzeigen und Abfragen von Funktionsprotokollen zu erhalten.Read monitoring Azure Functions to learn more about viewing and querying function logs.

Schreiben der Ablaufverfolgungsausgabe in die KonsoleWriting trace output to the console

In Functions verwenden Sie die context.log-Methoden, um die Ablaufverfolgungsausgabe in die Konsole zu schreiben.In Functions, you use the context.log methods to write trace output to the console. In Functions v2.x werden Ablaufverfolgungsausgaben über console.log auf der Ebene der Funktionen-App erfasst.In Functions v2.x, trace outputs using console.log are captured at the Function App level. Dies bedeutet, dass Ausgaben von console.log nicht an einen bestimmten Funktionsaufruf gebunden sind und nicht in den Protokollen einer bestimmten Funktion angezeigt werden.This means that outputs from console.log are not tied to a specific function invocation and aren't displayed in a specific function's logs. Sie werden jedoch an Application Insights weitergegeben.They do, however, propagate to Application Insights. In Functions v1.x können Sie console.log nicht verwenden, um in die Konsole zu schreiben.In Functions v1.x, you cannot use console.log to write to the console.

Beim Aufruf von context.log() wird Ihre Meldung auf der Standard-Ablaufverfolgungsebene, also der info-Ablaufverfolgungsebene, in die Konsole geschrieben.When you call context.log(), your message is written to the console at the default trace level, which is the info trace level. Das folgende Beispiel schreibt auf der „info“-Ablaufverfolgungsebene in die Konsole:The following code writes to the console at the info trace level:

context.log({hello: 'world'});  

Dieser Code entspricht dem Code oben:This code is equivalent to the code above:

context.log.info({hello: 'world'});  

Dieser Code schreibt auf der Fehlerebene in die Konsole:This code writes to the console at the error level:

context.log.error("An error has occurred.");  

Da error die höchste Ablaufverfolgungsebene ist, wird diese Ablaufverfolgung auf allen Ablaufverfolgungsebenen in die Ausgabe geschrieben, solange die Protokollierung aktiviert ist.Because error is the highest trace level, this trace is written to the output at all trace levels as long as logging is enabled.

Alle context.log-Methoden unterstützen das gleiche Parameterformat, das auch von der util.format-Methode in Node.js unterstützt wird.All context.log methods support the same parameter format that's supported by the Node.js util.format method. Beachten Sie den folgenden Code, der auf der standardmäßigen Ablaufverfolgungsebene Funktionsprotokolle schreibt:Consider the following code, which writes function logs by using the default trace level:

context.log('Node.js HTTP trigger function processed a request. RequestUri=' + req.originalUrl);
context.log('Request Headers = ' + JSON.stringify(req.headers));

Sie können den gleichen Code auch im folgenden Format schreiben:You can also write the same code in the following format:

context.log('Node.js HTTP trigger function processed a request. RequestUri=%s', req.originalUrl);
context.log('Request Headers = ', JSON.stringify(req.headers));

Konfigurieren der Ablaufverfolgungsebene für die KonsolenprotokollierungConfigure the trace level for console logging

Mit Functions 1.x können Sie den Ablaufverfolgungsebenen-Schwellenwert zum Schreiben in die Konsole definieren, sodass Sie mühelos mit Ihrer Funktion steuern können, wie Ablaufverfolgungen in die Konsole geschrieben werden.Functions 1.x lets you define the threshold trace level for writing to the console, which makes it easy to control the way traces are written to the console from your function. Legen Sie mit der tracing.consoleLevel-Eigenschaft in der Datei „host.json“ den Schwellenwert für alle Ablaufverfolgungen fest, die in die Konsole geschrieben werden.To set the threshold for all traces written to the console, use the tracing.consoleLevel property in the host.json file. Diese Einstellung gilt für alle Funktionen in Ihrer Funktionen-App.This setting applies to all functions in your function app. Im folgenden Beispiel wird der Schwellenwert für die Ablaufverfolgung festgelegt, um die ausführliche Protokollierung zu aktivieren:The following example sets the trace threshold to enable verbose logging:

{
    "tracing": {
        "consoleLevel": "verbose"
    }
}  

Die Werte von consoleLevel entsprechen den Namen der context.log-Methoden.Values of consoleLevel correspond to the names of the context.log methods. Um die gesamte Ablaufverfolgungsprotokollierung in der Konsole zu deaktivieren, setzen Sie consoleLevel auf off.To disable all trace logging to the console, set consoleLevel to off. Weitere Informationen finden Sie in der host.json-Referenz.For more information, see host.json reference.

HTTP: Trigger und BindungenHTTP triggers and bindings

HTTP- und Webhooktrigger und HTTP-Ausgabebindungen verwenden Request- und Response-Objekte, um das HTTP-Messaging darzustellen.HTTP and webhook triggers and HTTP output bindings use request and response objects to represent the HTTP messaging.

AnforderungsobjektRequest object

Das context.req-Objekt (Anforderungsobjekt) weist die folgenden Eigenschaften auf:The context.req (request) object has the following properties:

EigenschaftProperty BESCHREIBUNGDescription
bodybody Ein Objekt, das den Hauptteil der Anforderung enthält.An object that contains the body of the request.
headersheaders Ein Objekt, das die Header der Anforderung enthält.An object that contains the request headers.
methodmethod Die HTTP-Methode der Anforderung.The HTTP method of the request.
originalUrloriginalUrl Die URL der Anforderung.The URL of the request.
paramsparams Ein Objekt, das die Routingparameter der Anforderung enthält.An object that contains the routing parameters of the request.
queryquery Ein Objekt, das die Abfrageparameter enthält.An object that contains the query parameters.
rawBodyrawBody Der Hauptteil der Meldung als Zeichenfolge.The body of the message as a string.

AntwortobjektResponse object

Das context.res-Objekt (Antwortobjekt) weist die folgenden Eigenschaften auf:The context.res (response) object has the following properties:

EigenschaftProperty BESCHREIBUNGDescription
bodybody Ein Objekt, das den Hauptteil der Antwort enthält.An object that contains the body of the response.
headersheaders Ein Objekt, das die Header der Antwort enthält.An object that contains the response headers.
isRawisRaw Gibt an, dass die Formatierung für die Antwort übersprungen wird.Indicates that formatting is skipped for the response.
statusstatus Der HTTP-Statuscode der Antwort.The HTTP status code of the response.

Zugreifen auf Anforderung und AntwortAccessing the request and response

Beim Arbeiten mit HTTP-Triggern bestehen verschiedene Möglichkeiten, auf die HTTP-Anforderungsobjekte und -Antwortobjekte zuzugreifen:When you work with HTTP triggers, you can access the HTTP request and response objects in a number of ways:

  • Über die req- und res-Eigenschaft des context-Objekts.From req and res properties on the context object. Auf diese Weise können Sie die herkömmlichen Muster für den Zugriff auf HTTP-Daten über das context-Objekt verwenden, anstatt das gesamte context.bindings.name-Muster verwenden zu müssen.In this way, you can use the conventional pattern to access HTTP data from the context object, instead of having to use the full context.bindings.name pattern. Das folgende Beispiel veranschaulicht den Zugriff auf das req- und res-Objekt des context-Objekts:The following example shows how to access the req and res objects on the context:

    // You can access your http request off the context ...
    if(context.req.body.emoji === ':pizza:') context.log('Yay!');
    // and also set your http response
    context.res = { status: 202, body: 'You successfully ordered more coffee!' }; 
    
  • Über die benannten Eingabe- und Ausgabebindungen.From the named input and output bindings. Hierbei funktionieren die HTTP-Trigger und -Bindungen genauso wie jede andere Bindung.In this way, the HTTP trigger and bindings work the same as any other binding. Im folgenden Beispiel wird das Antwortobjekt mit einer als response benannten Bindung festgelegt:The following example sets the response object by using a named response binding:

    {
        "type": "http",
        "direction": "out",
        "name": "response"
    }
    
    context.bindings.response = { status: 201, body: "Insert succeeded." };
    
  • [Nur Antwort] Durch Aufrufen von context.res.send(body?: any).[Response only] By calling context.res.send(body?: any). Eine HTTP-Antwort wird mit der Eingabe body als Antworttext erstellt.An HTTP response is created with input body as the response body. context.done() wird implizit aufgerufen.context.done() is implicitly called.

  • [Nur Antwort] Durch Aufrufen von context.done().[Response only] By calling context.done(). Mit einer besonderen Art von HTTP-Bindung wird die Antwort zurückgegeben, die an die context.done()-Methode übergeben wird.A special type of HTTP binding returns the response that is passed to the context.done() method. Die folgende HTTP-Ausgabebindung definiert einen $return-Ausgabeparameter:The following HTTP output binding defines a $return output parameter:

    {
      "type": "http",
      "direction": "out",
      "name": "$return"
    }
    
     // Define a valid response object.
    res = { status: 201, body: "Insert succeeded." };
    context.done(null, res);   
    

Node-VersionNode version

Die folgende Tabelle zeigt die jeweilige von den Hauptversionen von Functions Runtime verwendete Node.js-Version:The following table shows the Node.js version used by each major version of the Functions runtime:

Functions-VersionFunctions version Node.js-VersionNode.js version
1.x1.x 6.11.2 (durch die Laufzeit gesperrt)6.11.2 (locked by the runtime)
2.x2.x Active LTS- und Maintenance LTS-Node.js-Versionen (~10 empfohlen).Active LTS and Maintenance LTS Node.js versions (~10 recommended). Legen Sie die Zielversion in Azure fest, indem Sie die App-Einstellung „WEBSITE_NODE_DEFAULT_VERSION“ auf ~10 festlegen.Target the version in Azure by setting the WEBSITE_NODE_DEFAULT_VERSION app setting to ~10.

Sie können die aktuelle Version anzeigen, die die Laufzeit verwendet, indem Sie die oben gezeigte App-Einstellung überprüfen oder process.version aus einer beliebigen Funktion ausgeben.You can see the current version that the runtime is using by checking the above app setting or by printing process.version from any function.

Verwaltung von AbhängigkeitenDependency management

Um Communitybibliotheken in Ihrem JavaScript-Code zu verwenden (wie im folgenden Beispiel gezeigt), müssen Sie sicherstellen, dass alle Abhängigkeiten für Ihre Funktions-App in Azure installiert sind.In order to use community libraries in your JavaScript code, as is shown in the below example, you need to ensure that all dependencies are installed on your Function App in Azure.

// Import the underscore.js library
var _ = require('underscore');
var version = process.version; // version === 'v6.5.0'

module.exports = function(context) {
    // Using our imported underscore.js library
    var matched_names = _
        .where(context.bindings.myInput.names, {first: 'Carla'});

Hinweis

Sie sollten eine package.json-Datei im Stammverzeichnis Ihrer Funktions-App definieren.You should define a package.json file at the root of your Function App. Wenn Sie die Datei definieren, nutzen alle Funktionen in der App gemeinsam die gleichen zwischengespeicherten Pakete, was die Leistung optimiert.Defining the file lets all functions in the app share the same cached packages, which gives the best performance. Wenn ein Versionskonflikt auftritt, können Sie ihn beheben, indem Sie eine package.json-Datei im Ordner einer bestimmten Funktion hinzufügen.If a version conflict arises, you can resolve it by adding a package.json file in the folder of a specific function.

Bei der Bereitstellung von Funktions-Apps aus der Quellcodeverwaltung lösen alle in Ihrem Repository vorhandenen package.json-Dateien während der Bereitstellung ein npm install im eigenen Ordner aus.When deploying Function Apps from source control, any package.json file present in your repo, will trigger an npm install in its folder during deployment. Bei einer Bereitstellung über das Portal oder die CLI müssen Sie die Pakete jedoch manuell installieren.But when deploying via the Portal or CLI, you will have to manually install the packages.

Es gibt zwei Möglichkeiten zum Installieren von Paketen für Ihre Funktions-App:There are two ways to install packages on your Function App:

Bereitstellen mit AbhängigkeitenDeploying with Dependencies

  1. Installieren Sie alle erforderlichen Pakete lokal, indem Sie npm install ausführen.Install all requisite packages locally by running npm install.

  2. Stellen Sie Ihren Code bereit, und stellen sicher, dass der Ordner node_modules in der Bereitstellung enthalten ist.Deploy your code, and ensure that the node_modules folder is included in the deployment.

Verwenden von KuduUsing Kudu

  1. Wechseln Sie zur Adresse https://<function_app_name>.scm.azurewebsites.net.Go to https://<function_app_name>.scm.azurewebsites.net.

  2. Klicken Sie auf Debugkonsole > CMD.Click Debug Console > CMD.

  3. Gehen Sie zu D:\home\site\wwwroot, und ziehen Sie dann die Datei „package.json“ auf den wwwroot-Ordner in der oberen Hälfte der Seite.Go to D:\home\site\wwwroot, and then drag your package.json file to the wwwroot folder at the top half of the page.
    Es gibt auch andere Möglichkeiten, Dateien in Ihre Funktionen-App hochzuladen.You can upload files to your function app in other ways also. Weitere Informationen finden Sie unter Aktualisieren von Funktionen-App-Dateien.For more information, see How to update function app files.

  4. Sobald die Datei „package.json“ hochgeladen ist, führen Sie den npm install-Befehl in der Kudu-Remoteausführungskonsole aus.After the package.json file is uploaded, run the npm install command in the Kudu remote execution console.
    Mit dieser Aktion werden die in der Datei „package.json“ angegebenen Pakete heruntergeladen und die Funktionen-App neu gestartet.This action downloads the packages indicated in the package.json file and restarts the function app.

UmgebungsvariablenEnvironment variables

In Functions werden App-Einstellungen, z.B. Dienstverbindungszeichenfolgen, während der Ausführung als Umgebungsvariablen verfügbar gemacht.In Functions, app settings, such as service connection strings, are exposed as environment variables during execution. Sie können über process.env auf diese Einstellungen zugreifen, wie hier in den zweiten und dritten Aufrufen von context.log() gezeigt, in denen die Umgebungsvariablen AzureWebJobsStorage und WEBSITE_SITE_NAME protokolliert werden:You can access these settings using process.env, as shown here in the second and third calls to context.log() where we log the AzureWebJobsStorage and WEBSITE_SITE_NAME environment variables:

module.exports = async function (context, myTimer) {
    var timeStamp = new Date().toISOString();

    context.log('Node.js timer trigger function ran!', timeStamp);
    context.log("AzureWebJobsStorage: " + process.env["AzureWebJobsStorage"]);
    context.log("WEBSITE_SITE_NAME: " + process.env["WEBSITE_SITE_NAME"]);
};

Es gibt mehrere Möglichkeiten zum Hinzufügen, Aktualisieren und Löschen von Funktionen-App-Einstellungen:There are several ways that you can add, update, and delete function app settings:

Wenn App-Einstellungen lokal ausgeführt werden, werden sie über die Projektdatei local.settings.json gelesen.When running locally, app settings are read from the local.settings.json project file.

Konfigurieren des FunktionseinstiegspunktsConfigure function entry point

Die function.json-Eigenschaften scriptFile und entryPoint können verwendet werden, um den Speicherort und den Namen Ihrer exportierten Funktion zu konfigurieren.The function.json properties scriptFile and entryPoint can be used to configure the location and name of your exported function. Diese Eigenschaften können wichtig sein, wenn Ihr JavaScript transpiliert ist.These properties can be important when your JavaScript is transpiled.

Verwenden von scriptFileUsing scriptFile

Standardmäßig wird eine JavaScript-Funktion aus der Datei index.js ausgeführt, einer Datei, die sich das gleiche übergeordnete Verzeichnis mit der entsprechenden Datei function.json teilt.By default, a JavaScript function is executed from index.js, a file that shares the same parent directory as its corresponding function.json.

scriptFile kann verwendet werden, um eine Ordnerstruktur zu erhalten, die wie im folgenden Beispiel aussieht:scriptFile can be used to get a folder structure that looks like the following example:

FunctionApp
 | - host.json
 | - myNodeFunction
 | | - function.json
 | - lib
 | | - sayHello.js
 | - node_modules
 | | - ... packages ...
 | - package.json

Die Datei function.json für myNodeFunction sollte eine scriptFile-Eigenschaft enthalten, die auf Datei mit der exportierten Funktion verweist, die ausgeführt werden soll.The function.json for myNodeFunction should include a scriptFile property pointing to the file with the exported function to run.

{
  "scriptFile": "../lib/sayHello.js",
  "bindings": [
    ...
  ]
}

Verwenden von entryPointUsing entryPoint

In scriptFile (oder index.js) muss eine Funktion mit module.exports exportiert werden, um gefunden und ausgeführt zu werden.In scriptFile (or index.js), a function must be exported using module.exports in order to be found and run. Standardmäßig ist die Funktion, die ausgeführt wird, wenn sie ausgelöst wird, der einzige Export aus dieser Datei, der Export mit dem Namen run oder der Export mit dem Namen index.By default, the function that executes when triggered is the only export from that file, the export named run, or the export named index.

Dies kann wie im folgenden Beispiel mit entryPoint in function.json konfiguriert werden:This can be configured using entryPoint in function.json, as in the following example:

{
  "entryPoint": "logFoo",
  "bindings": [
    ...
  ]
}

In Functions v2.x wird der Parameter this in Benutzerfunktionen unterstützt. Der Funktionscode kann dann wie im folgenden Beispiel aussehen:In Functions v2.x, which supports the this parameter in user functions, the function code could then be as in the following example:

class MyObj {
    constructor() {
        this.foo = 1;
    };

    logFoo(context) { 
        context.log("Foo is " + this.foo); 
        context.done(); 
    }
}

const myObj = new MyObj();
module.exports = myObj;

Beachten Sie in diesem Beispiel besonders, dass es keine Garantie dafür gibt, dass der Zustand zwischen den Ausführungen erhalten bleibt, auch wenn ein Objekt exportiert wird.In this example, it is important to note that although an object is being exported, there are no guarantees for preserving state between executions.

Lokales DebuggingLocal Debugging

Wenn ein Node.js-Prozess mit dem Parameter --inspect gestartet wird, lauscht er auf einen Debugclient auf dem angegebenen Port.When started with the --inspect parameter, a Node.js process listens for a debugging client on the specified port. Sie können in Azure Functions 2.x Argumente angeben, die an den Node.js-Prozess übergeben werden, der Ihren Code ausführt, indem Sie die Umgebungsvariable oder die App-Einstellung languageWorkers:node:arguments = <args> hinzufügen.In Azure Functions 2.x, you can specify arguments to pass into the Node.js process that runs your code by adding the environment variable or App Setting languageWorkers:node:arguments = <args>.

Fügen Sie unter Values in der Datei local.settings.json "languageWorkers:node:arguments": "--inspect=5858" hinzu, und fügen Sie einen Debugger an Port 5858 an, um lokal zu debuggen.To debug locally, add "languageWorkers:node:arguments": "--inspect=5858" under Values in your local.settings.json file and attach a debugger to port 5858.

Wenn Sie mit VS Code debuggen, wird der Parameter --inspect automatisch mit dem Wert port in der Datei „launch.json“ des Projekts hinzugefügt.When debugging using VS Code, the --inspect parameter is automatically added using the port value in the project's launch.json file.

In Version 1.x funktioniert die Einstellung languageWorkers:node:arguments nicht.In version 1.x, setting languageWorkers:node:arguments will not work. Sie können den Debugport mit dem Parameter --nodeDebugPort in den Azure Functions Core Tools festlegen.The debug port can be selected with the --nodeDebugPort parameter on Azure Functions Core Tools.

TypeScriptTypeScript

Wenn Sie Version 2.x der Azure Functions-Runtime als Ziel verwenden, können Sie mit der Azure Functions-Erweiterung für Visual Studio Code und den Azure Functions Core Tools Funktions-Apps mit Vorlagen erstellen, die Funktions-App-Projekte in TypeScript unterstützen.When you target version 2.x of the Functions runtime, both Azure Functions for Visual Studio Code and the Azure Functions Core Tools let you create function apps using a template that support TypeScript function app projects. Diese Vorlage generiert package.json- und tsconfig.json-Projektdateien, mit denen Sie JavaScript-Funktionen aus TypeScript-Code leichter mithilfe dieser Tools transpilieren, ausführen und veröffentlichen können.The template generates package.json and tsconfig.json project files that make it easier to transpile, run, and publish JavaScript functions from TypeScript code with these tools.

Die generierte .funcignore-Datei wird verwendet, um anzugeben, welche Dateien ausgeschlossen werden sollen, wenn ein Projekt in Azure veröffentlicht wird.A generated .funcignore file is used to indicate which files are excluded when a project is published to Azure.

TypeScript-Dateien (.ts) werden im Ausgabeverzeichnis dist in JavaScript-Dateien (.js) transpiliert.TypeScript files (.ts) are transpiled into JavaScript files (.js) in the dist output directory. TypeScript-Dateien verwenden in function.json den Parameter scriptFile, um den Speicherort der entsprechenden JS-Datei im Ordner dist anzugeben.TypeScript templates use the scriptFile parameter in function.json to indicate the location of the corresponding .js file in the dist folder. Der Ausgabespeicherort wird von der Vorlage mit dem Parameter outDir in der Datei tsconfig.json festgelegt.The output location is set by the template by using outDir parameter in the tsconfig.json file. Wenn Sie diese Einstellung oder den Namen des Ordners ändern, kann die Runtime den auszuführenden Code nicht finden.If you change this setting or the name of the folder, the runtime is not able to find the code to run.

Hinweis

In Version 1.x der Azure Functions-Runtime ist die experimentelle Unterstützung von TypeScript vorhanden.Experimental support for TypeScript exists version 1.x of the Functions runtime. Die experimentelle Version transpiliert TypeScript-Dateien in JavaScript-Dateien, wenn die Funktion aufgerufen wird.The experimental version transpiles TypeScript files into JavaScript files when the function is invoked. In Version 2.x wurde diese experimentelle Unterstützung durch eine toolgesteuerte Methode ersetzt, die die Transpilierung vor der Initialisierung des Hosts und während der Bereitstellung durchführt.In version 2.x, this experimental support has been superseded by the tool-driven method that does transpilation before the host is initialized and during the deployment process.

Die Art der lokalen Entwicklung und Bereitstellung aus einem TypeScript-Projekt hängen von Ihrem Entwicklungstool ab.The way that you locally develop and deploy from a TypeScript project depends on your development tool.

Visual Studio CodeVisual Studio Code

Mit der Azure Functions-Erweiterung für Visual Studio Code können Sie Ihre Funktionen mit TypeScript entwickeln.The Azure Functions for Visual Studio Code extension lets you develop your functions using TypeScript. Für die Azure Functions-Erweiterung sind die Azure Functions Core Tools erforderlich.The Core Tools is a requirement of the Azure Functions extension.

Wählen Sie beim Erstellen einer Funktions-App TypeScript als Sprache, um in Visual Studio Code eine TypeScript-Funktions-App zu erstellen.To create a TypeScript function app in Visual Studio Code, choose TypeScript as your language when you create a function app.

Wenn Sie auf F5 drücken, um die App lokal auszuführen, wird die Transpilierung durchgeführt, bevor der Host („func.exe“) initialisiert wird.When you press F5 to run the app locally, transpilation is done before the host (func.exe) is initialized.

Wenn Sie Ihre Funktions-App mit Deploy to function app... (In Funktions-App bereitstellen...) in Azure bereitstellen, generiert die Azure Functions-Erweiterung zunächst aus den TypeScript-Quelldateien einen produktionsbereiten Build aus JavaScript-Dateien.When you deploy your function app to Azure using the Deploy to function app... button, the Azure Functions extension first generates a production-ready build of JavaScript files from the TypeScript source files.

Azure Functions Core ToolsAzure Functions Core Tools

Bei der Verwendung der Core Tools unterscheidet sich ein TypeScript-Projekt auf vielfältige Weise von einem JavaScript-Projekt.There are several ways in which a TypeScript project differs from a JavaScript project when using the Core Tools.

Projekt erstellenCreate project

Wenn Sie ein TypeScript-Funktions-App-Projekt mit den Core Tools erstellen möchten, müssen Sie bei der Erstellung der Funktions-App die Sprache auf „TypeScript“ festlegen.To create a TypeScript function app project using Core Tools, you must specify the TypeScript language option when you create your function app. Wählen Sie dazu eine der folgenden Methoden:You can do this in one of the following ways:

  • Führen Sie den Befehl func init aus, wählen Sie node als Sprachstapel, und wählen Sie dann typescript.Run the func init command, select node as your language stack, and then select typescript.

  • Führen Sie den Befehl func init --worker-runtime typescript aus.Run the func init --worker-runtime typescript command.

Lokale AusführungRun local

Wenn Sie den Code Ihrer Funktions-App lokal mit den Core Tools ausführen möchten, verwenden Sie statt func host start die folgenden Befehle:To run your function app code locally using Core Tools, use the following commands instead of func host start:

npm install
npm start

Der Befehl npm start entspricht den folgenden Befehlen:The npm start command is equivalent to the following commands:

  • npm run build
  • func extensions install
  • tsc
  • func start

Veröffentlichen in AzurePublish to Azure

Bevor Sie den Befehl func azure functionapp publish zur Bereitstellung in Azure verwenden, erstellen Sie aus den TypeScript-Quelldateien einen produktionsbereiten Build aus JavaScript-Dateien.Before you use the func azure functionapp publish command to deploy to Azure, you create a production-ready build of JavaScript files from the TypeScript source files.

Mit den folgenden Befehlen können Sie Ihr TypeScript-Projekt mithilfe der Core Tools vorbereiten und veröffentlichen:The following commands prepare and publish your TypeScript project using Core Tools:

npm run build:production 
func azure functionapp publish <APP_NAME>

Ersetzen Sie in diesem Befehl <APP_NAME> durch den Namen Ihrer Funktions-App.In this command, replace <APP_NAME> with the name of your function app.

Überlegungen zu JavaScript-FunktionenConsiderations for JavaScript functions

Beachten Sie beim Arbeiten mit JavaScript-Funktionen die Überlegungen in den folgenden Abschnitten.When you work with JavaScript functions, be aware of the considerations in the following sections.

Auswählen von App Service-Plänen mit einzelner vCPUChoose single-vCPU App Service plans

Wenn Sie eine Funktions-App erstellen, die den App Service-Plan verwendet, sollten Sie statt eines Plans mit mehreren vCPUs einen Plan mit einer einzelnen vCPU auswählen.When you create a function app that uses the App Service plan, we recommend that you select a single-vCPU plan rather than a plan with multiple vCPUs. Derzeit führt Functions JavaScript-Funktionen auf virtuellen Computern mit einer einzelnen vCPU effizienter aus. Die Verwendung größerer virtueller Computer führt nicht zu den erwarteten Leistungsverbesserungen.Today, Functions runs JavaScript functions more efficiently on single-vCPU VMs, and using larger VMs does not produce the expected performance improvements. Bei Bedarf können Sie manuell horizontal hochskalieren, indem Sie weitere Instanzen virtueller Computer mit einer einzelnen vCPU hinzufügen. Sie können aber auch die automatische Skalierung aktivieren.When necessary, you can manually scale out by adding more single-vCPU VM instances, or you can enable autoscale. Weitere Informationen finden Sie unter Manuelles oder automatisches Skalieren der Instanzenzahl.For more information, see Scale instance count manually or automatically.

KaltstartCold Start

Bei der Entwicklung von Azure Functions im serverlosen Hostingmodell sind Kaltstarts Realität.When developing Azure Functions in the serverless hosting model, cold starts are a reality. Der Begriff Kaltstart bezieht sich auf die Tatsache, dass es beim ersten Start Ihrer Funktions-App nach einer Zeit der Inaktivität länger dauert, bis sie gestartet wird.Cold start refers to the fact that when your function app starts for the first time after a period of inactivity, it takes longer to start up. Insbesondere bei JavaScript-Funktionen mit großen Abhängigkeitsbäumen kann dies erheblich länger dauern.For JavaScript functions with large dependency trees in particular, cold start can be significant. Nach Möglichkeit sollten Sie die Funktionen als Paketdatei ausführen, um den Prozess des Kaltstarts zu beschleunigen.To speed up the cold start process, run your functions as a package file when possible. Bei vielen Bereitstellungsmethoden erfolgt die Ausführung standardmäßig über das Paketmodell. Wenn aber umfangreiche Kaltstarts durchgeführt werden und die Ausführung nicht auf diese Weise erfolgt, kann diese Änderung eine wesentliche Verbesserung bewirken.Many deployment methods use the run from package model by default, but if you're experiencing large cold starts and are not running this way, this change can offer a significant improvement.

VerbindungsbeschränkungenConnection Limits

Wenn Sie einen dienstabhängigen Client in einer Azure Functions-Anwendung verwenden, erstellen Sie nicht bei jedem Funktionsaufruf einen neuen Client.When you use a service-specific client in an Azure Functions application, don't create a new client with every function invocation. Erstellen Sie stattdessen einen einzelnen, statischen Client im globalen Bereich.Instead, create a single, static client in the global scope. Weitere Informationen finden Sie unter Verwalten von Verbindungen in Azure Functions.For more information, see managing connections in Azure Functions.

Verwenden von async und awaitUse async and await

Beim Schreiben von Azure Functions in JavaScript sollten Sie Code schreiben, indem Sie die Schlüsselwörter async und await verwenden.When writing Azure Functions in JavaScript, you should write code using the async and await keywords. Wenn Sie zum Schreiben von Code async und await anstelle von Rückrufen oder .then und .catch mit Zusagen verwenden, können Sie zwei häufige Probleme vermeiden:Writing code using async and await instead of callbacks or .then and .catch with Promises helps avoid two common problems:

  • Das Auslösen von nicht abgefangenen Ausnahmen, die zu einem Absturz des Node.js-Prozesses führen und sich unter Umständen auf die Ausführung anderer Funktionen auswirken.Throwing uncaught exceptions that crash the Node.js process, potentially affecting the execution of other functions.
  • Unerwartetes Verhalten, z. B. fehlende Protokolle aus „context.log“, die durch nicht korrekt erwartete asynchrone Aufrufe verursacht werden.Unexpected behavior, such as missing logs from context.log, caused by asynchronous calls that are not properly awaited.

Im Beispiel unten wird die asynchrone fs.readFile-Methode mit einer Error-First-Rückruffunktion als zweitem Parameter aufgerufen.In the example below, the asynchronous method fs.readFile is invoked with an error-first callback function as its second parameter. Durch diesen Code werden die beiden oben erwähnten Probleme verursacht.This code causes both of the issues mentioned above. Eine Ausnahme, die nicht explizit im richtigen Bereich abgefangen wird, hat zum Absturz des gesamten Prozesses geführt (erstes Problem).An exception that is not explicitly caught in the correct scope crashed the entire process (issue #1). Das Aufrufen von context.done() außerhalb des Bereichs der Rückruffunktion bedeutet, dass der Funktionsaufruf ggf. endet, bevor die Datei gelesen wird (zweites Problem).Calling context.done() outside of the scope of the callback function means that the function invocation may end before the file is read (issue #2). Bei diesem Beispiel führt ein zu frühes Aufrufen von context.done() zu fehlenden Protokolleinträgen, die mit Data from file: beginnen.In this example, calling context.done() too early results in missing log entries starting with Data from file:.

// NOT RECOMMENDED PATTERN
const fs = require('fs');

module.exports = function (context) {
    fs.readFile('./hello.txt', (err, data) => {
        if (err) {
            context.log.error('ERROR', err);
            // BUG #1: This will result in an uncaught exception that crashes the entire process
            throw err;
        }
        context.log(`Data from file: ${data}`);
        // context.done() should be called here
    });
    // BUG #2: Data is not guaranteed to be read before the Azure Function's invocation ends
    context.done();
}

Beide Fehler können vermieden werden, indem die Schlüsselwörter async und await verwendet werden.Using the async and await keywords helps avoid both of these errors. Sie sollten die Node.js-Hilfsfunktion util.promisify verwenden, um Error-First-Funktionen im Rückrufstil in „Awaitable“-Funktionen zu verwandeln.You should use the Node.js utility function util.promisify to turn error-first callback-style functions into awaitable functions.

Im folgenden Beispiel führen alle Ausnahmefehler, die während der Funktionsausführung ausgelöst werden, nur zu einem Fehler für den individuellen Aufruf, der eine Ausnahme ausgelöst hat.In the example below, any unhandled exceptions thrown during the function execution only fail the individual invocation that raised an exception. Das Schlüsselwort await bedeutet, dass Schritte, die auf readFileAsync folgen, erst nach Abschluss von readFile ausgeführt werden.The await keyword means that steps following readFileAsync only execute after readFile is complete. Bei Verwendung von async und await ist es auch nicht erforderlich, den Rückruf context.done() aufzurufen.With async and await, you also don't need to call the context.done() callback.

// Recommended pattern
const fs = require('fs');
const util = require('util');
const readFileAsync = util.promisify(fs.readFile);

module.exports = async function (context) {
    try {
        const data = await readFileAsync('./hello.txt');
    } catch (err) {
        context.log.error('ERROR', err);
        // This rethrown exception will be handled by the Functions Runtime and will only fail the individual invocation
        throw err;
    }
    context.log(`Data from file: ${data}`);
}

Nächste SchritteNext steps

Weitere Informationen finden Sie in den folgenden Ressourcen:For more information, see the following resources: