Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich. # JavaScript-Laufzeit-Features für CloudFront-Funktionen Die JavaScript-Laufzeitumgebung von CloudFront-Funktionen ist mit [ECMAScript (ES) Version 5.1](https://www.ecma-international.org/ecma-262/5.1/) kompatibel und unterstützt auch einige Features der ES-Versionen 6 bis 12. Wir empfehlen, die JavaScript-Laufzeitumgebung 2.0 für die neuesten Features zu verwenden. Die Features der JavaScript-Laufzeitumgebung 2.0 weisen im Vergleich zu 1.0 die folgenden Änderungen auf: + Puffermodul-Methoden sind verfügbar. + Die folgenden nicht standardmäßigen Prototyp-Methoden für Zeichenfolgen sind nicht verfügbar: + `String.prototype.bytesFrom()` + `String.prototype.fromBytes()` + `String.prototype.fromUTF8()` + `String.prototype.toBytes()` + `String.prototype.toUTF8()` + Das kryptografische Modul weist die folgenden Änderungen auf: + `hash.digest()` – Der Rückgabetyp wird in `Buffer` geändert, wenn keine Kodierung angegeben ist. + `hmac.digest()` – Der Rückgabetyp wird in `Buffer` geändert, wenn keine Kodierung angegeben ist. + Weitere Informationen zu den zusätzlichen neuen Features finden Sie unter [Features von JavaScript Runtime 2.0 für CloudFront-Funktionen](functions-javascript-runtime-20.md). **Topics** + [Funktionen von JavaScript Runtime 1.0](functions-javascript-runtime-10.md) + [Features von JavaScript Runtime 2.0](functions-javascript-runtime-20.md) # Funktionen von JavaScript Runtime 1.0 für CloudFront-Funktionen Die JavaScript-Laufzeitumgebung von CloudFront-Funktionen ist mit [ECMAScript (ES) Version 5.1](https://262.ecma-international.org/5.1/) kompatibel und unterstützt auch einige Features der ES-Versionen 6 bis 9. Sie enthält auch einige nicht standardmäßige Methoden, die nicht Teil der ES-Spezifikationen sind. In den folgenden Themen werden alle unterstützten Sprachfunktionen aufgeführt. **Topics** + [ ## Kernfunktionen ](#writing-functions-javascript-features-core) + [ ## Primitive Objekte ](#writing-functions-javascript-features-primitive-objects) + [ ## Integrierte Objekte ](#writing-functions-javascript-features-builtin-objects) + [ ## Fehlertypen ](#writing-functions-javascript-features-error-types) + [ ## Globale ](#writing-functions-javascript-features-globals) + [ ## Integrierten Module ](#writing-functions-javascript-features-builtin-modules) + [ ## Eingeschränkte Funktionen ](#writing-functions-javascript-features-restricted-features) ## Kernfunktionen Die folgenden Kern-Features von ES werden unterstützt. **Typen** Alle ES 5.1-Typen werden unterstützt. Dies umfasst boolesche Werte, Zahlen, Zeichenfolgen, Objekte, Arrays, Funktionen, Funktionskonstruktoren und reguläre Ausdrücke. **Operatoren** Alle ES 5.1-Operatoren werden unterstützt. Der Potenzierungsoperator (`**`) wird unterstützt. **Anweisungen** `const`- und `let`-Anweisungen werden nicht unterstützt. Die folgenden ES 5.1-Anweisungen werden unterstützt: + `break` + `catch` + `continue` + `do-while` + `else` + `finally` + `for` + `for-in` + `if` + `return` + `switch` + `throw` + `try` + `var` + `while` + Bezeichnete Anweisungen **Literale** ES 6-Vorlagenliterale werden unterstützt: mehrzeilige Zeichenfolgen, Interpolation von Ausdrücken und Verschachtelungsvorlagen. **Funktionen** Alle Features von ES 5.1 werden unterstützt. ES 6-Pfeilfunktionen werden unterstützt, und die ES 6 Rest-Parametersyntax wird unterstützt. **Unicode** Quelltext und Zeichenfolgenliterale können Unicode-codierte Zeichen enthalten. Unicode-Code-Punkt-Escape-Sequenzen von sechs Zeichen (z. B. `\uXXXX`) werden ebenfalls unterstützt. **Strikter Modus** Funktionen arbeiten standardmäßig im strikten Modus, sodass Sie Ihrem Funktionscode keine `use strict`-Anweisung hinzufügen müssen. Dies können nicht geändert werden. ## Primitive Objekte Die folgenden primitiven Objekte von ES werden unterstützt. **Objekt** Die folgenden ES 5.1-Methoden für Objekte werden unterstützt: + `create` (ohne Eigenschaftenliste) + `defineProperties` + `defineProperty` + `freeze` + `getOwnPropertyDescriptor` + `getOwnPropertyNames` + `getPrototypeOf` + `hasOwnProperty` + `isExtensible` + `isFrozen` + `prototype.isPrototypeOf` + `isSealed` + `keys` + `preventExtensions` + `prototype.propertyIsEnumerable` + `seal` + `prototype.toString` + `prototype.valueOf` Die folgenden ES 6-Methoden für Objekte werden unterstützt: + `assign` + `is` + `prototype.setPrototypeOf` Die folgenden ES 8-Methoden für Objekte werden unterstützt: + `entries` + `values` **Zeichenfolge** Die folgenden ES 5.1-Methoden für Zeichenfolgen werden unterstützt: + `fromCharCode` + `prototype.charAt` + `prototype.concat` + `prototype.indexOf` + `prototype.lastIndexOf` + `prototype.match` + `prototype.replace` + `prototype.search` + `prototype.slice` + `prototype.split` + `prototype.substr` + `prototype.substring` + `prototype.toLowerCase` + `prototype.trim` + `prototype.toUpperCase` Die folgenden ES 6-Methoden für Zeichenfolgen werden unterstützt: + `fromCodePoint` + `prototype.codePointAt` + `prototype.endsWith` + `prototype.includes` + `prototype.repeat` + `prototype.startsWith` Die folgenden ES 8-Methoden für Zeichenfolgen werden unterstützt: + `prototype.padStart` + `prototype.padEnd` Die folgenden ES 9-Methoden für Zeichenfolgen werden unterstützt: + `prototype.trimStart` + `prototype.trimEnd` Die folgenden nicht standardmäßigen Methoden für Zeichenfolgen werden unterstützt: + `prototype.bytesFrom(array | string, encoding)` Erstellt eine Bytezeichenfolge aus einem Array von Oktetten oder einer codierten Zeichenfolge. Die Optionen für die Zeichenfolgencodierung sind `hex`, `base64` und `base64url`. + `prototype.fromBytes(start[, end])` Erstellt eine Unicode-Zeichenfolge aus einer Bytezeichenfolge, in der jedes Byte durch den entsprechenden Unicode-Codepunkt ersetzt wird. + `prototype.fromUTF8(start[, end])` Erstellt eine Unicode-Zeichenfolge aus einer UTF-8-codierten Bytezeichenfolge. Wenn die Codierung falsch ist, wird zurückgegebe `null`. + `prototype.toBytes(start[, end])` Erstellt eine Bytezeichenfolge aus einer Unicode-Zeichenfolge. Alle Zeichen müssen im Bereich von [0,255] liegen. Wenn nicht, wird zurückgegebe `null`. + `prototype.toUTF8(start[, end])` Erstellt eine UTF-8-codierte Bytezeichenfolge aus einer Unicode-Zeichenfolge. **Nummer** Alle ES 5.1-Methoden für Zahlen werden unterstützt. Die folgenden ES 6-Methoden für Zahlen werden unterstützt: + `isFinite` + `isInteger` + `isNaN` + `isSafeInteger` + `parseFloat` + `parseInt` + `prototype.toExponential` + `prototype.toFixed` + `prototype.toPrecision` + `EPSILON` + `MAX_SAFE_INTEGER` + `MAX_VALUE` + `MIN_SAFE_INTEGER` + `MIN_VALUE` + `NEGATIVE_INFINITY` + `NaN` + `POSITIVE_INFINITY` ## Integrierte Objekte Die folgenden integrierten Objekte von ES werden unterstützt. **Math-Knoten** Alle Mathematikmethoden von ES 5.1 werden unterstützt. In der Laufzeitumgebung von CloudFront-Funktionen verwendet die `Math.random()`-Implementierung OpenBSD `arc4random`, das den Zeitstempel der Funktion als Startwert verwendet. Die folgenden ES 6-Mathematikmethoden werden unterstützt: + `acosh` + `asinh` + `atanh` + `cbrt` + `clz32` + `cosh` + `expm1` + `fround` + `hypot` + `imul` + `log10` + `log1p` + `log2` + `sign` + `sinh` + `tanh` + `trunc` + `E` + `LN10` + `LN2` + `LOG10E` + `LOG2E` + `PI` + `SQRT1_2` + `SQRT2` **Datum** Alle `Date`-Features von ES 5.1 werden unterstützt. Aus Sicherheitsgründen gibt `Date` immer den gleichen Wert – die Startzeit der Funktion – während der Lebensdauer einer einzelnen Funktionsausführung zurück. Weitere Informationen finden Sie unter [Eingeschränkte Funktionen](#writing-functions-javascript-features-restricted-features). **Funktion** Die Methoden `apply`, `bind` und `call` werden unterstützt. Funktionskonstruktoren werden nicht unterstützt. **Reguläre Ausdrücke** Alle Features für reguläre Ausdrücke von ES 5.1 werden unterstützt. Die Sprache für reguläre Ausdrücke ist Perl-kompatibel. ES 9 benannte Aufnahmegruppen werden unterstützt. **JSON** Alle Funktionen von ES 5.1 JSON werden unterstützt, einschließlich `parse` und `stringify`. **Array** Die folgenden ES 5.1-Methoden für Arrays werden unterstützt: + `isArray` + `prototype.concat` + `prototype.every` + `prototype.filter` + `prototype.forEach` + `prototype.indexOf` + `prototype.join` + `prototype.lastIndexOf` + `prototype.map` + `prototype.pop` + `prototype.push` + `prototype.reduce` + `prototype.reduceRight` + `prototype.reverse` + `prototype.shift` + `prototype.slice` + `prototype.some` + `prototype.sort` + `prototype.splice` + `prototype.unshift` Die folgenden ES 6-Methoden für Arrays werden unterstützt: + `of` + `prototype.copyWithin` + `prototype.fill` + `prototype.find` + `prototype.findIndex` Die folgenden ES 7-Methoden für Arrays werden unterstützt: + `prototype.includes` **Eingegebene Arrays** Die folgenden von ES 6 eingegebenen Arrays werden unterstützt: + `Int8Array` + `Uint8Array` + `Uint8ClampedArray` + `Int16Array` + `Uint16Array` + `Int32Array` + `Uint32Array` + `Float32Array` + `Float64Array` + `prototype.copyWithin` + `prototype.fill` + `prototype.join` + `prototype.set` + `prototype.slice` + `prototype.subarray` + `prototype.toString` **ArrayBuffer** Die folgenden Methoden für `ArrayBuffer` werden unterstützt: + `prototype.isView` + `prototype.slice` **Promise** Die folgenden Methoden für Versprechen werden unterstützt: + `reject` + `resolve` + `prototype.catch` + `prototype.finally` + `prototype.then` **Crypto** Das kryptografische Modul bietet standardmäßige Hashing- und Hash-basierte HMAC-Helfer (Message Authentication Code). Sie können das Modul mit lade `require('crypto')`. Das Modul stellt die folgenden Methoden bereit, die sich genau wie ihre Gegenstücke von Node.js verhalten: + `createHash(algorithm)` + `hash.update(data)` + `hash.digest([encoding])` + `createHmac(algorithm, secret key)` + `hmac.update(data)` + `hmac.digest([encoding])` Weitere Informationen finden Sie unter [Krypto (Hash und HMAC)](#writing-functions-javascript-features-builtin-modules-crypto) im Abschnitt über integrierte Module. **Konsole** Dies ist ein Hilfsobjekt zum Debuggen. Es unterstützt nur die `log()`-Methode, um Protokollnachrichten aufzuzeichnen. CloudFront Functions unterstützt keine Kommasyntax, wie z. B. `console.log('a', 'b')`. Verwenden Sie stattdessen das Format `console.log('a' + ' ' + 'b')`. ## Fehlertypen Die folgenden Fehlerobjekte werden unterstützt: + `Error` + `EvalError` + `InternalError` + `MemoryError` + `RangeError` + `ReferenceError` + `SyntaxError` + `TypeError` + `URIError` ## Globale Das `globalThis`-Objekt wird unterstützt. Die folgenden globalen Funktionen von ES 5.1 werden unterstützt: + `decodeURI` + `decodeURIComponent` + `encodeURI` + `encodeURIComponent` + `isFinite` + `isNaN` + `parseFloat` + `parseInt` Die folgenden globalen Konstanten werden unterstützt: + `NaN` + `Infinity` + `undefined` ## Integrierten Module Die folgenden integrierten Module werden unterstützt. **Topics** + [ ### Krypto (Hash und HMAC) ](#writing-functions-javascript-features-builtin-modules-crypto) + [ ### Abfragezeichenfolge ](#writing-functions-javascript-features-builtin-modules-query-string) ### Krypto (Hash und HMAC) Das kryptographische Modul (`crypto`) bietet standardmäßige Hashing- und HMAC-Helfer (Hash-basierter Nachrichtenauthentifizierungscode). Sie können das Modul mit lade `require('crypto')`. Das Modul bietet die folgenden Methoden, die sich genau wie ihre Gegenstücke von Node.js verhalten. **Hashing-Methoden** `crypto.createHash(algorithm)` Erstellt und gibt ein Hash-Objekt zurück, mit dem Sie Hash-Digests mit dem angegebenen Algorithmus generieren können: `md5`, `sha1` oder `sha256`. `hash.update(data)` Aktualisiert den Hash-Inhalt mit dem angegebenen `data`. `hash.digest([encoding])` Berechnet den Digest aller mit übergebenen Date `hash.update()`. Die Codierung kann `hex`, `base64` oder `base64url` sein. **HMAC-Methoden** `crypto.createHmac(algorithm, secret key)` Erstellt und gibt ein HMAC-Objekt zurück, das das angegebene `algorithm` und `secret key` verwendet. Der Algorithmus kann `md5`, `sha1` oder `sha256` sein. `hmac.update(data)` Aktualisiert den HMAC-Inhalt mit den angegebenen `data`. `hmac.digest([encoding])` Berechnet den Digest aller mit übergebenen Date `hmac.update()`. Die Codierung kann `hex`, `base64` oder `base64url` sein. ### Abfragezeichenfolge **Anmerkung** Das [CloudFront Functions-Ereignisobjekt](functions-event-structure.md) parst automatisch URL-Abfragezeichenfolgen für Sie. Das bedeutet, dass Sie dieses Modul in den meisten Fällen nicht verwenden müssen. Das Modul für Abfragezeichenfolgen (`querystring`) bietet Methoden zum Analysieren und Formatieren von URL-Abfragezeichenfolgen. Sie können das Modul mit lade `require('querystring')`. Das Modul bietet die folgenden Methoden. `querystring.escape(string)` URL-kodiert die angegebene `string` und gibt eine entflohene Abfragezeichenfolge zurück. Die Methode wird von `querystring.stringify()` verwendet und sollte nicht direkt verwendet werden. `querystring.parse(string[, separator[, equal[, options]]])` Analysiert eine Abfragezeichenfolge (`string`) und gibt ein Objekt zurück. Der `separator`-Parameter ist eine Teilzeichenfolge zum Abgrenzen von Schlüssel- und Wertepaaren in der Abfragezeichenfolge. Standardmäßig ist dies `&`. Der `equal`-Parameter ist eine Teilzeichenfolge zum Abgrenzen von Schlüsseln und Werten in der Abfragezeichenfolge. Standardmäßig ist dies `=`. Der `options`-Parameter ist ein Objekt mit den folgenden Schlüsseln: `decodeURIComponent function` Eine Funktion zum Entschlüsseln von prozentkodierten Zeichen in der Abfragezeichenfolge. Standardmäßig ist dies `querystring.unescape()`. `maxKeys number` Die maximale Anzahl der Schlüssel zum Parsen. Standardmäßig ist dies `1000`. Verwenden Sie den Wert `0`, um die Beschränkungen für das Zählen von Schlüsseln aufzuheben. Standardmäßig wird davon ausgegangen, dass prozentcodierte Zeichen innerhalb der Abfragezeichenfolge die UTF-8-Codierung verwenden. Ungültige UTF-8-Sequenzen werden durch das Ersatzzeichen `U+FFFD` ersetzt. Zum Beispiel für die folgende Abfragezeichenfolge: ``` 'name=value&abc=xyz&abc=123' ``` Der Rückgabewert von `querystring.parse()` ist: ``` { name: 'value', abc: ['xyz', '123'] } ``` `querystring.decode()` ist ein Alias für `querystring.parse()`. `querystring.stringify(object[, separator[, equal[, options]]])` Serialisiert ein `object` und gibt eine Abfragezeichenfolge zurück. Der `separator`-Parameter ist eine Teilzeichenfolge zum Abgrenzen von Schlüssel- und Wertepaaren in der Abfragezeichenfolge. Standardmäßig ist dies `&`. Der `equal`-Parameter ist eine Teilzeichenfolge zum Abgrenzen von Schlüsseln und Werten in der Abfragezeichenfolge. Standardmäßig ist dies `=`. Der `options`-Parameter ist ein Objekt mit den folgenden Schlüsseln: `encodeURIComponent function` Die Funktion, die zum Konvertieren von URL-unsicheren Zeichen in die prozentuale Kodierung in der Abfragezeichenfolge verwendet wird. Standardmäßig ist dies `querystring.escape()`. Standardmäßig werden Zeichen, die eine prozentuale Kodierung innerhalb der Abfragezeichenfolge erfordern, als UTF-8 codiert. Um eine andere Codierung zu verwenden, geben Sie die Option `encodeURIComponent` an. Zum Beispiel für den folgenden Code: ``` querystring.stringify({ name: 'value', abc: ['xyz', '123'], anotherName: '' }); ``` Der Rückgabewert ist: ``` 'name=value&abc=xyz&abc=123&anotherName=' ``` `querystring.encode()` ist ein Alias für `querystring.stringify()`. `querystring.unescape(string)` Dekodiert die prozentualen Zeichen der URL in der angegebenen `string` und gibt eine nicht entdeckene Abfragezeichenfolge zurück. Diese Methode wird von `querystring.parse()` verwendet und sollte nicht direkt verwendet werden. ## Eingeschränkte Funktionen Die folgenden JavaScript-Sprach-Features werden aufgrund von Sicherheitsbedenken entweder nicht unterstützt oder eingeschränkt. **Dynamische Codeauswertung** Die dynamische Codeauswertung wird nicht unterstützt. Sowohl `eval()`- als auch `Function`-Konstruktoren geben einen Fehler aus, wenn sie versucht werden. Zum Beispiel gibt `const sum = new Function('a', 'b', 'return a + b')` einen Fehler aus. **Timer ** Die Funktionen `setTimeout()`, `setImmediate()` und `clearTimeout()` werden nicht unterstützt. Es gibt keine Bestimmung, innerhalb einer Funktionsausführung zu verschieben oder zu ergeben. Ihre Funktion muss synchron bis zum Abschluss ausgeführt werden. **Datum und Zeitstempel** Aus Sicherheitsgründen besteht kein Zugang zu hochauflösenden Timern. Alle `Date`-Methoden zum Abfragen der aktuellen Uhrzeit geben während der Lebensdauer einer einzelnen Funktionsausführung immer den gleichen Wert zurück. Der zurückgegebene Zeitstempel ist die Zeit, zu der die Funktion gestartet wurde. Folglich können Sie die verstrichene Zeit in Ihrer Funktion nicht messen. **Zugriff auf das Dateisystem** Es gibt keinen Zugriff auf das Dateisystem. Zum Beispiel gibt es kein `fs`-Modul für den Dateisystemzugriff wie in Node.js. **Prozesszugriff** Es gibt keinen Prozesszugriff. Zum Beispiel gibt es kein globales `process`-Objekt für die Verarbeitung von Informationszugriffen wie in Node.js. **Umgebungsvariablen** Es gibt keinen Zugriff auf Umgebungsvariablen. Stattdessen können Sie CloudFront KeyValueStore verwenden, um einen zentralen Datenspeicher mit Schlüssel-Wert-Paaren für CloudFront Functions zu erstellen. CloudFront KeyValueStore ermöglicht dynamische Updates Ihrer Konfigurationsdaten, ohne dass Codeänderungen implementiert werden müssen. Sie müssen die [JavaScript-Laufzeitumgebung 2.0](functions-javascript-runtime-20.md) verwenden, um CloudFront KeyValueStore verwenden zu können. Weitere Informationen finden Sie unter [Amazon CloudFront Schlüsselwertspeicher](kvs-with-functions.md). **Netzwerkzugriff** Es gibt keine Unterstützung für Netzwerkaufrufe. Zum Beispiel werden XHR, HTTP(S) und Socket nicht unterstützt. # Features von JavaScript Runtime 2.0 für CloudFront-Funktionen Die JavaScript-Laufzeitumgebung von CloudFront-Funktionen ist mit [ECMAScript (ES) Version 5.1](https://262.ecma-international.org/5.1/) kompatibel und unterstützt auch einige Features der ES-Versionen 6 bis 12. Sie enthält auch einige nicht standardmäßige Methoden, die nicht Teil der ES-Spezifikationen sind. In den folgenden Themen werden alle unterstützten Features dieser Laufzeit aufgeführt. **Topics** + [ ## Kern-Features ](#writing-functions-javascript-features-core-20) + [ ## Primitive Objekte ](#writing-functions-javascript-features-primitive-objects-20) + [ ## Integrierte Objekte ](#writing-functions-javascript-features-builtin-objects-20) + [ ## Fehlertypen ](#writing-functions-javascript-features-error-types-20) + [ ## Globale ](#writing-functions-javascript-features-globals-20) + [ ## Integrierten Module ](#writing-functions-javascript-features-builtin-modules-20) + [ ## Eingeschränkte Features ](#writing-functions-javascript-features-restricted-features-20) ## Kern-Features Die folgenden Kern-Features von ES werden unterstützt. **Typen** Alle ES 5.1-Typen werden unterstützt. Dies umfasst boolesche Werte, Zahlen, Zeichenfolgen, Objekte, Arrays, Funktionen und reguläre Ausdrücke. **Operatoren** Alle ES 5.1-Operatoren werden unterstützt. Der Potenzierungsoperator (`**`) wird unterstützt. **Anweisungen** Die folgenden ES 5.1-Anweisungen werden unterstützt: + `break` + `catch` + `continue` + `do-while` + `else` + `finally` + `for` + `for-in` + `if` + `label` + `return` + `switch` + `throw` + `try` + `var` + `while` Die folgenden ES 6-Anweisungen werden unterstützt: + `const` + `let` Die folgenden ES 8-Anweisungen werden unterstützt: + `async` + `await` `async`, `await`, `const` und `let` werden in der JavaScript-Laufzeitumgebung 2.0 unterstützt. `await` kann nur innerhalb von `async`-Funktionen verwendet werden. `async`-Argumente und -Schließungen werden nicht unterstützt. **Literale** ES 6-Vorlagenliterale werden unterstützt: mehrzeilige Zeichenfolgen, Interpolation von Ausdrücken und Verschachtelungsvorlagen. **Funktionen** Alle Features von ES 5.1 werden unterstützt. ES 6-Pfeilfunktionen werden unterstützt, und die ES 6 Rest-Parametersyntax wird unterstützt. **Unicode** Quelltext und Zeichenfolgenliterale können Unicode-codierte Zeichen enthalten. Unicode-Code-Punkt-Escape-Sequenzen von sechs Zeichen (z. B. `\uXXXX`) werden ebenfalls unterstützt. **Strikter Modus** Funktionen arbeiten standardmäßig im strikten Modus, sodass Sie Ihrem Funktionscode keine `use strict`-Anweisung hinzufügen müssen. Dies können nicht geändert werden. ## Primitive Objekte Die folgenden primitiven Objekte von ES werden unterstützt. **Objekt** Die folgenden ES 5.1-Methoden für Objekte werden unterstützt: + `Object.create()` (ohne Eigenschaftenliste) + `Object.defineProperties()` + `Object.defineProperty()` + `Object.freeze()` + `Object.getOwnPropertyDescriptor()` + `Object.getOwnPropertyDescriptors()` + `Object.getOwnPropertyNames()` + `Object.getPrototypeOf()` + `Object.isExtensible()` + `Object.isFrozen()` + `Object.isSealed()` + `Object.keys()` + `Object.preventExtensions()` + `Object.seal()` Die folgenden ES 6-Methoden für Objekte werden unterstützt: + `Object.assign()` Die folgenden ES 8-Methoden für Objekte werden unterstützt: + `Object.entries()` + `Object.values()` Die folgenden ES-5.1-Prototyp-Methoden für Objekte werden unterstützt: + `Object.prototype.hasOwnProperty()` + `Object.prototype.isPrototypeOf()` + `Object.prototype.propertyIsEnumerable()` + `Object.prototype.toString()` + `Object.prototype.valueOf()` Die folgenden ES 6-Prototyp-Methoden für Objekte werden unterstützt: + `Object.prototype.is()` + `Object.prototype.setPrototypeOf()` **String** Die folgenden ES 5.1-Methoden für Zeichenfolgen werden unterstützt: + `String.fromCharCode()` Die folgenden ES 6-Methoden für Zeichenfolgen werden unterstützt: + `String.fromCodePoint()` Die folgenden ES-5.1-Prototyp-Methoden für Zeichenfolgen werden unterstützt: + `String.prototype.charAt()` + `String.prototype.concat()` + `String.prototype.indexOf()` + `String.prototype.lastIndexOf()` + `String.prototype.match()` + `String.prototype.replace()` + `String.prototype.search()` + `String.prototype.slice()` + `String.prototype.split()` + `String.prototype.substr()` + `String.prototype.substring()` + `String.prototype.toLowerCase()` + `String.prototype.trim()` + `String.prototype.toUpperCase()` Die folgenden ES 6-Prototyp-Methoden für Zeichenfolgen werden unterstützt: + `String.prototype.codePointAt()` + `String.prototype.endsWith()` + `String.prototype.includes()` + `String.prototype.repeat()` + `String.prototype.startsWith()` Die folgenden ES 8-Prototyp-Methoden für Zeichenfolgen werden unterstützt: + `String.prototype.padStart()` + `String.prototype.padEnd()` Die folgenden ES 9-Prototyp-Methoden für Zeichenfolgen werden unterstützt: + `String.prototype.trimStart()` + `String.prototype.trimEnd()` Die folgenden ES 12-Prototyp-Methoden für Zeichenfolgen werden unterstützt: + `String.prototype.replaceAll()` **Anmerkung** `String.prototype.replaceAll()` ist neu in JavaScript Runtime 2.0. **Anzahl** ALLE ES 5-Zahlen werden unterstützt. Die folgenden ES 6-Eigenschaften für Zahlen werden unterstützt: + `Number.EPSILON` + `Number.MAX_SAFE_INTEGER` + `Number.MIN_SAFE_INTEGER` + `Number.MAX_VALUE` + `Number.MIN_VALUE` + `Number.NaN` + `Number.NEGATIVE_INFINITY` + `Number.POSITIVE_INFINITY` Die folgenden ES 6-Methoden für Zahlen werden unterstützt: + `Number.isFinite()` + `Number.isInteger()` + `Number.isNaN()` + `Number.isSafeInteger()` + `Number.parseInt()` + `Number.parseFloat()` Die folgenden ES 5.1-Prototyp-Methoden für Zahlen werden unterstützt: + `Number.prototype.toExponential()` + `Number.prototype.toFixed()` + `Number.prototype.toPrecision()` Numerische ES 12-Trennzeichen werden unterstützt. Numerische ES 12-Trennzeichen sind neu in JavaScript Runtime 2.0. ## Integrierte Objekte Die folgenden integrierten Objekte von ES werden unterstützt. **Math-Knoten** Alle Mathematikmethoden von ES 5.1 werden unterstützt. In der Laufzeitumgebung von CloudFront-Funktionen verwendet die `Math.random()`-Implementierung OpenBSD `arc4random`, das den Zeitstempel der Funktion als Startwert verwendet. Die folgenden ES 6-Mathematikeigenschaften werden unterstützt: + `Math.E` + `Math.LN10` + `Math.LN2` + `Math.LOG10E` + `Math.LOG2E` + `Math.PI` + `Math.SQRT1_2` + `Math.SQRT2` Die folgenden ES 6-Mathematikmethoden werden unterstützt: + `Math.abs()` + `Math.acos()` + `Math.acosh()` + `Math.asin()` + `Math.asinh()` + `Math.atan()` + `Math.atan2()` + `Math.atanh()` + `Math.cbrt()` + `Math.ceil()` + `Math.clz32()` + `Math.cos()` + `Math.cosh()` + `Math.exp()` + `Math.expm1()` + `Math.floor()` + `Math.fround()` + `Math.hypot()` + `Math.imul()` + `Math.log()` + `Math.log1p()` + `Math.log2()` + `Math.log10()` + `Math.max()` + `Math.min()` + `Math.pow()` + `Math.random()` + `Math.round()` + `Math.sign()` + `Math.sinh()` + `Math.sin()` + `Math.sqrt()` + `Math.tan()` + `Math.tanh()` + `Math.trunc()` **Datum** Alle `Date`-Features von ES 5.1 werden unterstützt. Aus Sicherheitsgründen gibt `Date` immer den gleichen Wert – die Startzeit der Funktion – während der Lebensdauer einer einzelnen Funktionsausführung zurück. Weitere Informationen finden Sie unter [Eingeschränkte Funktionen](functions-javascript-runtime-10.md#writing-functions-javascript-features-restricted-features). **Funktion** Die folgenden ES-5.1-Prototyp-Methoden werden unterstützt: + `Function.prototype.apply()` + `Function.prototype.bind()` + `Function.prototype.call()` Funktionskonstruktoren werden nicht unterstützt. **Reguläre Ausdrücke** Alle Features für reguläre Ausdrücke von ES 5.1 werden unterstützt. Die Sprache für reguläre Ausdrücke ist Perl-kompatibel. Die folgenden ES-5.1-Prototyp-Zugriffseigenschaften werden unterstützt: + `RegExp.prototype.global` + `RegExp.prototype.ignoreCase` + `RegExp.protoype.multiline` + `RegExp.protoype.source` + `RegExp.prototype.sticky` + `RegExp.prototype.flags` **Anmerkung** `RegExp.prototype.sticky` und `RegExp.prototype.flags` sind neu in JavaScript Runtime 2.0. Die folgenden ES-5.1-Prototyp-Methoden werden unterstützt: + `RegExp.prototype.exec()` + `RegExp.prototype.test()` + `RegExp.prototype.toString()` + `RegExp.prototype[@@replace]()` + `RegExp.prototype[@@split]()` **Anmerkung** `RegExp.prototype[@@split]()` ist neu in JavaScript Runtime 2.0. Die folgenden ES-5.1-Instance-Eigenschaften werden unterstützt: + `lastIndex` ES 9 benannte Aufnahmegruppen werden unterstützt. **JSON** Die folgenden ES 5.1-Mathematikmethoden werden unterstützt: + `JSON.parse()` + `JSON.stringify()` **Array** Die folgenden ES 5.1-Methoden für Arrays werden unterstützt: + `Array.isArray()` Die folgenden ES 6-Methoden für Arrays werden unterstützt: + `Array.of()` Die folgenden ES-5.1-Prototyp-Methoden werden unterstützt: + `Array.prototype.concat()` + `Array.prototype.every()` + `Array.prototype.filter()` + `Array.prototype.forEach()` + `Array.prototype.indexOf()` + `Array.prototype.join()` + `Array.prototype.lastIndexOf()` + `Array.prototype.map()` + `Array.prototype.pop()` + `Array.prototype.push()` + `Array.prototype.reduce()` + `Array.prototype.reduceRight()` + `Array.prototype.reverse()` + `Array.prototype.shift()` + `Array.prototype.slice()` + `Array.prototype.some()` + `Array.prototype.sort()` + `Array.prototype.splice()` + `Array.prototype.unshift()` Die folgenden ES 6-Prototyp-Methoden werden unterstützt: + `Array.prototype.copyWithin()` + `Array.prototype.fill()` + `Array.prototype.find()` + `Array.prototype.findIndex()` Die folgenden ES 7-Prototyp-Methoden werden unterstützt: + `Array.prototype.includes()` **Eingegebene Arrays** Die folgenden von ES 6 eingegebenen Array-Konstruktoren werden unterstützt: + `Float32Array` + `Float64Array` + `Int8Array` + `Int16Array` + `Int32Array` + `Uint8Array` + `Uint8ClampedArray` + `Uint16Array` + `Uint32Array` Die folgenden ES-6-Methoden werden unterstützt: + `TypedArray.from()` + `TypedArray.of()` **Anmerkung** `TypedArray.from()` und `TypedArray.of()` sind neu in JavaScript Runtime 2.0. Die folgenden ES 6-Prototyp-Methoden werden unterstützt: + `TypedArray.prototype.copyWithin()` + `TypedArray.prototype.every()` + `TypedArray.prototype.fill()` + `TypedArray.prototype.filter()` + `TypedArray.prototype.find()` + `TypedArray.prototype.findIndex()` + `TypedArray.prototype.forEach()` + `TypedArray.prototype.includes()` + `TypedArray.prototype.indexOf()` + `TypedArray.prototype.join()` + `TypedArray.prototype.lastIndexOf()` + `TypedArray.prototype.map()` + `TypedArray.prototype.reduce()` + `TypedArray.prototype.reduceRight()` + `TypedArray.prototype.reverse()` + `TypedArray.prototype.some()` + `TypedArray.prototype.set()` + `TypedArray.prototype.slice()` + `TypedArray.prototype.sort()` + `TypedArray.prototype.subarray()` + `TypedArray.prototype.toString()` **Anmerkung** `TypedArray.prototype.every()`, `TypedArray.prototype.fill()`, `TypedArray.prototype.filter()`, `TypedArray.prototype.find()`, `TypedArray.prototype.findIndex()`, `TypedArray.prototype.forEach()`, `TypedArray.prototype.includes()`, `TypedArray.prototype.indexOf()`, `TypedArray.prototype.join()`, `TypedArray.prototype.lastIndexOf()`, `TypedArray.prototype.map()`, `TypedArray.prototype.reduce()`, `TypedArray.prototype.reduceRight()`, `TypedArray.prototype.reverse()` und `TypedArray.prototype.some()` sind neu in JavaScript Runtime 2.0. **ArrayBuffer** Die folgenden ES 6-Methoden für ArrayBuffer werden unterstützt: + `isView()` Die folgenden ES 6-Prototypen-Methoden für ArrayBuffer werden unterstützt: + `ArrayBuffer.prototype.slice()` **Promise** Die folgenden ES 6-Methoden für Versprechen werden unterstützt: + `Promise.all()` + `Promise.allSettled()` + `Promise.any()` + `Promise.reject()` + `Promise.resolve()` + `Promise.race()` **Anmerkung** `Promise.all()`, `Promise.allSettled()`, `Promise.any()` und `Promise.race()` sind neu in JavaScript Runtime 2.0. Die folgenden ES 6-Prototyp-Methoden für Versprechen werden unterstützt: + `Promise.prototype.catch()` + `Promise.prototype.finally()` + `Promise.prototype.then()` **DataView** Die folgenden ES 6-Prototyp-Methoden werden unterstützt: + `DataView.prototype.getFloat32()` + `DataView.prototype.getFloat64()` + `DataView.prototype.getInt16()` + `DataView.prototype.getInt32()` + `DataView.prototype.getInt8()` + `DataView.prototype.getUint16()` + `DataView.prototype.getUint32()` + `DataView.prototype.getUint8()` + `DataView.prototype.setFloat32()` + `DataView.prototype.setFloat64()` + `DataView.prototype.setInt16()` + `DataView.prototype.setInt32()` + `DataView.prototype.setInt8()` + `DataView.prototype.setUint16()` + `DataView.prototype.setUint32()` + `DataView.prototype.setUint8()` **Anmerkung** Alle Prototyp-Methoden von Dataview ES 6 sind neu in JavaScript Runtime 2.0. **Symbol** Die folgenden ES-6-Methoden werden unterstützt: + `Symbol.for()` + `Symbol.keyfor()` **Anmerkung** Alle Methoden von Symbol ES 6 sind neu in JavaScript Runtime 2.0. **Textdecoder** Die folgenden Prototyp-Methoden werden unterstützt: + `TextDecoder.prototype.decode()` Die folgenden Prototyp-Zugriffseigenschaften werden unterstützt: + `TextDecoder.prototype.encoding` + `TextDecoder.prototype.fatal` + `TextDecoder.prototype.ignoreBOM` **Text-Encoder** Die folgenden Prototyp-Methoden werden unterstützt: + `TextEncoder.prototype.encode()` + `TextEncoder.prototype.encodeInto()` ## Fehlertypen Die folgenden Fehlerobjekte werden unterstützt: + `Error` + `EvalError` + `InternalError` + `RangeError` + `ReferenceError` + `SyntaxError` + `TypeError` + `URIError` ## Globale Das `globalThis`-Objekt wird unterstützt. Die folgenden globalen Funktionen von ES 5.1 werden unterstützt: + `decodeURI()` + `decodeURIComponent()` + `encodeURI()` + `encodeURIComponent()` + `isFinite()` + `isNaN()` + `parseFloat()` + `parseInt()` Die folgenden globalen Funktionen von ES 6 werden unterstützt: + `atob()` + `btoa()` **Anmerkung** `atob()` und `btoa()` sind neu in JavaScript Runtime 2.0. Die folgenden globalen Konstanten werden unterstützt: + `NaN` + `Infinity` + `undefined` + `arguments` ## Integrierten Module Die folgenden integrierten Module werden unterstützt. **Topics** + [ ### Buffer ](#writing-functions-javascript-features-builtin-modules-buffer-20) + [ ### Abfragezeichenfolge ](#writing-functions-javascript-features-builtin-modules-query-string-20) + [ ### Crypto ](#writing-functions-javascript-features-builtin-modules-crypto-20) ### Buffer Das Modul bietet die folgenden Methoden: + `Buffer.alloc(size[, fill[, encoding]])` Weisen Sie einen `Buffer` zu. + `size`: Puffergröße. Geben Sie eine Ganzzahl ein. + `fill`: Optional. Geben Sie eine Zeichenfolge, `Buffer`, Uint8Array oder eine Ganzzahl ein. Der Standardwert ist `0`. + `encoding`: Optional. Wenn `fill` eine Zeichenfolge ist, geben Sie eine der folgenden Optionen ein: `utf8`, `hex`, `base64`, `base64url`. Der Standardwert ist `utf8`. + `Buffer.allocUnsafe(size)` Weisen Sie einen nicht initialisierten `Buffer` zu. + `size`: Geben Sie eine Ganzzahl ein. + `Buffer.byteLength(value[, encoding])` Gibt die Länge eines Werts in Byte zurück. + `value`: Eine Zeichenfolge, `Buffer`, TypedArray, Dataview oder Arraybuffer. + `encoding`: Optional. Wenn `value` eine Zeichenfolge ist, geben Sie eine der folgenden Optionen ein: `utf8`, `hex`, `base64`, `base64url`. Der Standardwert ist `utf8`. + `Buffer.compare(buffer1, buffer2)` Vergleichen Sie zwei `Buffer`, um Arrays besser sortieren zu können. Gibt `0` zurück, wenn sie identisch sind, `-1`, wenn `buffer1` an erster Stelle steht, oder `1`, wenn `buffer2` an erster Stelle steht. + `buffer1`: Geben Sie einen `Buffer` ein. + `buffer2`: Geben Sie einen anderen `Buffer` ein. + `Buffer.concat(list[, totalLength])` Verketten Sie mehrere `Buffer`. Gibt `0` zurück, wenn keiner vorhanden ist. Gibt bis zu `totalLength` zurück. + `list`: Geben Sie eine Liste von `Buffer`n ein. Beachten Sie, dass dies auf `totalLength` gekürzt wird. + `totalLength`: Optional. Geben Sie eine Ganzzahl ohne Vorzeichen ein. Wenn das Feld leer ist, wird die Summe der `Buffer`-Instances in der Liste verwendet. + `Buffer.from(array)` Erstellen Sie einen `Buffer` aus einem Array. + `array`: Geben Sie ein Byte-Array von `0` bis `255` ein. + `Buffer.from(arrayBuffer, byteOffset[, length]))` Erstellen Sie eine Ansicht von `arrayBuffer`, beginnend beim Versatz `byteOffset` mit der Länge `length`. + `arrayBuffer`: Geben Sie ein `Buffer`-Array ein. + `byteOffset`: Geben Sie eine Ganzzahl ein. + `length`: Optional. Geben Sie eine Ganzzahl ein. + `Buffer.from(buffer)` Erstellen Sie eine Kopie des `Buffer`s. + `buffer`: Geben Sie einen `Buffer` ein. + `Buffer.from(object[, offsetOrEncoding[, length]])` Erstellen Sie einen `Buffer` aus einem Objekt. Gibt `Buffer.from(object.valueOf(), offsetOrEncoding, length)` zurück, wenn `valueOf()` nicht dem Objekt entspricht. + `object`: Geben Sie ein Objekt ein. + `offsetOrEncoding`: Optional. Geben Sie eine Ganzzahl oder eine Kodierungszeichenfolge ein. + `length`: Optional. Geben Sie eine Ganzzahl ein. + `Buffer.from(string[, encoding])` Erstellen Sie einen `Buffer` aus einer Zeichenfolge. + `string`: Geben Sie eine Zeichenfolge ein. + `encoding`: Optional. Machen Sie eine der folgenden Eingaben: `utf8`, `hex`, `base64`, `base64url`. Der Standardwert ist `utf8`. + `Buffer.isBuffer(object)` Prüfen Sie, ob `object` ein Puffer ist. Gibt `true` oder `false` zurück. + `object`: Geben Sie ein Objekt ein. + `Buffer.isEncoding(encoding)` Prüfen Sie, ob `encoding` unterstützt wird. Gibt `true` oder `false` zurück. + `encoding`: Optional. Machen Sie eine der folgenden Eingaben: `utf8`, `hex`, `base64`, `base64url`. Der Standardwert ist `utf8`. Das Modul bietet die folgenden Puffer-Prototyp-Methoden: + `Buffer.prototype.compare(target[, targetStart[, targetEnd[, sourceStart[, sourceEnd]]]])` Vergleichen Sie `Buffer` mit dem Ziel. Gibt `0` zurück, wenn sie identisch sind, `1`, wenn `buffer` an erster Stelle steht, oder `-1`, wenn `target` an erster Stelle steht. + `target`: Geben Sie einen `Buffer` ein. + `targetStart`: Optional. Geben Sie eine Ganzzahl ein. Standard = 0. + `targetEnd`: Optional. Geben Sie eine Ganzzahl ein. Die Standardeinstellung ist die `target`-Länge. + `sourceStart`: Optional. Geben Sie eine Ganzzahl ein. Standard = 0. + `sourceEnd`: Optional. Geben Sie eine Ganzzahl ein. Die Standardeinstellung ist die `Buffer`-Länge. + `Buffer.prototype.copy(target[, targetStart[, sourceStart[, sourceEnd]]])` Kopieren Sie den Puffer nach `target`. + `target`: Geben Sie einen `Buffer` oder `Uint8Array` ein. + `targetStart`: Optional. Geben Sie eine Ganzzahl ein. Standard = 0. + `sourceStart`: Optional. Geben Sie eine Ganzzahl ein. Standard = 0. + `sourceEnd`: Optional. Geben Sie eine Ganzzahl ein. Die Standardeinstellung ist die `Buffer`-Länge. + `Buffer.prototype.equals(otherBuffer)` Vergleichen Sie `Buffer` mit `otherBuffer`. Gibt `true` oder `false` zurück. + `otherBuffer`: Geben Sie eine Zeichenfolge ein. + `Buffer.prototype.fill(value[, offset[, end][, encoding])` Geben Sie für den `Buffer` den Wert `value` ein. + `value`: Geben Sie eine Zeichenfolge, einen `Buffer` oder eine Ganzzahl ein. + `offset`: Optional. Geben Sie eine Ganzzahl ein. + `end`: Optional. Geben Sie eine Ganzzahl ein. + `encoding`: Optional. Machen Sie eine der folgenden Eingaben: `utf8`, `hex`, `base64`, `base64url`. Der Standardwert ist `utf8`. + `Buffer.prototype.includes(value[, byteOffset][, encoding])` Suchen Sie nach `value` im `Buffer`. Gibt `true` oder `false` zurück. + `value`: Geben Sie eine Zeichenfolge, einen `Buffer`, ein `Uint8Array` oder eine Ganzzahl ein. + `byteOffset`: Optional. Geben Sie eine Ganzzahl ein. + `encoding`: Optional. Machen Sie eine der folgenden Eingaben: `utf8`, `hex`, `base64`, `base64url`. Der Standardwert ist `utf8`. + `Buffer.prototype.indexOf(value[, byteOffset][, encoding])` Suchen Sie nach dem ersten `value` im `Buffer`. Gibt `index` zurück, wenn er gefunden wurde, oder gibt `-1` zurück, wenn er nicht gefunden wurde. + `value`: Geben Sie eine Zeichenfolge, einen `Buffer`, ein Unit8Array oder eine Ganzzahl von 0 bis 255 ein. + `byteOffset`: Optional. Geben Sie eine Ganzzahl ein. + `encoding`: Optional. Geben Sie eine der folgenden Optionen ein, wenn `value` eine Zeichenfolge ist: `utf8`, `hex`, `base64`, `base64url`. Der Standardwert ist `utf8`. + `Buffer.prototype.lastIndexOf(value[, byteOffset][, encoding])` Suchen Sie nach dem letzten `value` im `Buffer`. Gibt `index` zurück, wenn er gefunden wurde, oder gibt `-1` zurück, wenn er nicht gefunden wurde. + `value`: Geben Sie eine Zeichenfolge, einen `Buffer`, ein Unit8Array oder eine Ganzzahl von 0 bis 255 ein. + `byteOffset`: Optional. Geben Sie eine Ganzzahl ein. + `encoding`: Optional. Geben Sie eine der folgenden Optionen ein, wenn `value` eine Zeichenfolge ist: `utf8`, `hex`, `base64`, `base64url`. Der Standardwert ist `utf8`. + `Buffer.prototype.readInt8(offset)` Lesen Sie `Int8` beim `offset` vom `Buffer`. + `offset`: Geben Sie eine Ganzzahl ein. + `Buffer.prototype.readIntBE(offset, byteLength)` Lesen Sie `Int` als Big-Endian beim `offset` vom `Buffer`. + `offset`: Geben Sie eine Ganzzahl ein. + `byteLength`: Optional. Geben Sie eine Ganzzahl von `1` bis `6` ein. + `Buffer.prototype.readInt16BE(offset)` Lesen Sie `Int16` als Big-Endian beim `offset` vom `Buffer`. + `offset`: Geben Sie eine Ganzzahl ein. + `Buffer.prototype.readInt32BE(offset)` Lesen Sie `Int32` als Big-Endian beim `offset` vom `Buffer`. + `offset`: Geben Sie eine Ganzzahl ein. + `Buffer.prototype.readIntLE(offset, byteLength)` Lesen Sie `Int` als Little-Endian beim `offset` vom `Buffer`. + `offset`: Geben Sie eine Ganzzahl ein. + `byteLength`: Geben Sie eine Ganzzahl von `1` bis `6` ein. + `Buffer.prototype.readInt16LE(offset)` Lesen Sie `Int16` als Little-Endian beim `offset` vom `Buffer`. + `offset`: Geben Sie eine Ganzzahl ein. + `Buffer.prototype.readInt32LE(offset)` Lesen Sie `Int32` als Little-Endian beim `offset` vom `Buffer`. + `offset`: Geben Sie eine Ganzzahl ein. + `Buffer.prototype.readUInt8(offset)` Lesen Sie `UInt8` beim `offset` vom `Buffer`. + `offset`: Geben Sie eine Ganzzahl ein. + `Buffer.prototype.readUIntBE(offset, byteLength)` Lesen Sie `UInt` als Big-Endian beim `offset` vom `Buffer`. + `offset`: Geben Sie eine Ganzzahl ein. + `byteLength`: Geben Sie eine Ganzzahl von `1` bis `6` ein. + `Buffer.prototype.readUInt16BE(offset)` Lesen Sie `UInt16` als Big-Endian beim `offset` vom `Buffer`. + + `offset`: Geben Sie eine Ganzzahl ein. + `Buffer.prototype.readUInt32BE(offset)` Lesen Sie `UInt32` als Big-Endian beim `offset` vom `Buffer`. + `offset`: Geben Sie eine Ganzzahl ein. + `Buffer.prototype.readUIntLE(offset, byteLength)` Lesen Sie `UInt` als Little-Endian beim `offset` vom `Buffer`. + `offset`: Geben Sie eine Ganzzahl ein. + `byteLength`: Geben Sie eine Ganzzahl von `1` bis `6` ein. + `Buffer.prototype.readUInt16LE(offset)` Lesen Sie `UInt16` als Little-Endian beim `offset` vom `Buffer`. + `offset`: Geben Sie eine Ganzzahl ein. + `Buffer.prototype.readUInt32LE(offset)` Lesen Sie `UInt32` als Little-Endian beim `offset` vom `Buffer`. + `offset`: Geben Sie eine Ganzzahl ein. + `Buffer.prototype.readDoubleBE([offset])` Lesen Sie einen 64-Bit-Double-Wert als Big-Endian beim `offset` vom `Buffer`. + `offset`: Optional. Geben Sie eine Ganzzahl ein. + `Buffer.prototype.readDoubleLE([offset])` Lesen Sie einen 64-Bit-Double-Wert als Little-Endian beim `offset` vom `Buffer`. + `offset`: Optional. Geben Sie eine Ganzzahl ein. + `Buffer.prototype.readFloatBE([offset])` Lesen Sie einen 32-Bit-Float-Wert als Big-Endian beim `offset` vom `Buffer`. + `offset`: Optional. Geben Sie eine Ganzzahl ein. + `Buffer.prototype.readFloatLE([offset])` Lesen Sie einen 32-Bit-Float-Wert als Little-Endian beim `offset` vom `Buffer`. + `offset`: Optional. Geben Sie eine Ganzzahl ein. + `Buffer.prototype.subarray([start[, end]])` Gibt eine Kopie vom `Buffer` zurück, der versetzt und mit einem neuen `start` und `end` zugeschnitten wurde. + `start`: Optional. Geben Sie eine Ganzzahl ein. Standard = 0. + `end`: Optional. Geben Sie eine Ganzzahl ein. Die Standardeinstellung ist die Pufferlänge. + `Buffer.prototype.swap16()` Tauschen Sie die Byte-Reihenfolge des `Buffer`-Arrays aus und behandeln Sie es wie ein Array von 16-Bit-Zahlen. Die `Buffer`-Länge muss durch 2 teilbar sein, sonst erhalten Sie eine Fehlermeldung. + `Buffer.prototype.swap32()` Tauschen Sie die Byte-Reihenfolge des `Buffer`-Arrays aus und behandeln Sie es wie ein Array von 32-Bit-Zahlen. Die `Buffer`-Länge muss durch 4 teilbar sein, sonst erhalten Sie eine Fehlermeldung. + `Buffer.prototype.swap64()` Tauschen Sie die Byte-Reihenfolge des `Buffer`-Arrays aus und behandeln Sie es wie ein Array von 64-Bit-Zahlen. Die `Buffer`-Länge muss durch 8 teilbar sein, sonst erhalten Sie eine Fehlermeldung. + `Buffer.prototype.toJSON()` Gibt `Buffer` als JSON zurück. + `Buffer.prototype.toString([encoding[, start[, end]]])` Konvertieren Sie den `Buffer` von `start` bis `end` in eine kodierte Zeichenfolge. + `encoding`: Optional. Machen Sie eine der folgenden Eingaben: `utf8`, `hex`, `base64` oder `base64url`. Der Standardwert ist `utf8`. + `start`: Optional. Geben Sie eine Ganzzahl ein. Standard = 0. + `end`: Optional. Geben Sie eine Ganzzahl ein. Die Standardeinstellung ist die Pufferlänge. + `Buffer.prototype.write(string[, offset[, length]][, encoding])` Schreiben Sie die codierte `string` in den `Buffer`, wenn genügend Platz vorhanden ist, oder die gekürzte `string`, wenn nicht genügend Platz vorhanden ist. + `string`: Geben Sie eine Zeichenfolge ein. + `offset`: Optional. Geben Sie eine Ganzzahl ein. Standard = 0. + `length`: Optional. Geben Sie eine Ganzzahl ein. Die Standardeinstellung ist die Länge der Zeichenfolge. + `encoding`: Optional. Geben Sie optional eine der folgenden Optionen ein: `utf8`, `hex`, `base64` oder `base64url`. Der Standardwert ist `utf8`. + `Buffer.prototype.writeInt8(value, offset, byteLength)` Schreiben Sie den `Int8`-`value` der `byteLength` beim `offset` des `Buffer`s. + `value`: Geben Sie eine Ganzzahl ein. + `offset`: Geben Sie eine Ganzzahl ein + `byteLength`: Geben Sie eine Ganzzahl von `1` bis `6` ein. + `Buffer.prototype.writeIntBE(value, offset, byteLength)` Schreiben Sie den `value` beim `offset` des `Buffer`s mit Big-Endian. + `value`: Geben Sie eine Ganzzahl ein. + `offset`: Geben Sie eine Ganzzahl ein + `byteLength`: Geben Sie eine Ganzzahl von `1` bis `6` ein. + `Buffer.prototype.writeInt16BE(value, offset, byteLength)` Schreiben Sie den `value` beim `offset` des `Buffer`s mit Big-Endian. + `value`: Geben Sie eine Ganzzahl ein. + `offset`: Geben Sie eine Ganzzahl ein + `byteLength`: Geben Sie eine Ganzzahl von `1` bis `6` ein. + `Buffer.prototype.writeInt32BE(value, offset, byteLength)` Schreiben Sie den `value` beim `offset` des `Buffer`s mit Big-Endian. + `value`: Geben Sie eine Ganzzahl ein. + `offset`: Geben Sie eine Ganzzahl ein + `byteLength`: Geben Sie eine Ganzzahl von `1` bis `6` ein. + `Buffer.prototype.writeIntLE(offset, byteLength)` Schreiben Sie den `value` beim `offset` des `Buffer`s mit Little-Endian. + `offset`: Geben Sie eine Ganzzahl ein. + `byteLength`: Geben Sie eine Ganzzahl von `1` bis `6` ein. + `Buffer.prototype.writeInt16LE(offset, byteLength)` Schreiben Sie den `value` beim `offset` des `Buffer`s mit Little-Endian. + `offset`: Geben Sie eine Ganzzahl ein. + `byteLength`: Geben Sie eine Ganzzahl von `1` bis `6` ein. + `Buffer.prototype.writeInt32LE(offset, byteLength)` Schreiben Sie den `value` beim `offset` des `Buffer`s mit Little-Endian. + `offset`: Geben Sie eine Ganzzahl ein. + `byteLength`: Geben Sie eine Ganzzahl von `1` bis `6` ein. + `Buffer.prototype.writeUInt8(value, offset, byteLength)` Schreiben Sie den `UInt8`-`value` der `byteLength` beim `offset` des `Buffer`s. + `value`: Geben Sie eine Ganzzahl ein. + `offset`: Geben Sie eine Ganzzahl ein + `byteLength`: Geben Sie eine Ganzzahl von `1` bis `6` ein. + `Buffer.prototype.writeUIntBE(value, offset, byteLength)` Schreiben Sie den `value` beim `offset` des `Buffer`s mit Big-Endian. + `value`: Geben Sie eine Ganzzahl ein. + `offset`: Geben Sie eine Ganzzahl ein + `byteLength`: Geben Sie eine Ganzzahl von `1` bis `6` ein. + `Buffer.prototype.writeUInt16BE(value, offset, byteLength)` Schreiben Sie den `value` beim `offset` des `Buffer`s mit Big-Endian. + `value`: Geben Sie eine Ganzzahl ein. + `offset`: Geben Sie eine Ganzzahl ein + `byteLength`: Geben Sie eine Ganzzahl von `1` bis `6` ein. + `Buffer.prototype.writeUInt32BE(value, offset, byteLength)` Schreiben Sie den `value` beim `offset` des `Buffer`s mit Big-Endian. + `value`: Geben Sie eine Ganzzahl ein. + `offset`: Geben Sie eine Ganzzahl ein + `byteLength`: Geben Sie eine Ganzzahl von `1` bis `6` ein. + `Buffer.prototype.writeUIntLE(value, offset, byteLength)` Schreiben Sie den `value` beim `offset` des `Buffer`s mit Little-Endian. + `value`: Geben Sie eine Ganzzahl ein. + `offset`: Geben Sie eine Ganzzahl ein + `byteLength`: Geben Sie eine Ganzzahl von `1` bis `6` ein. + `Buffer.prototype.writeUInt16LE(value, offset, byteLength)` Schreiben Sie den `value` beim `offset` des `Buffer`s mit Little-Endian. + `value`: Geben Sie eine Ganzzahl ein. + `offset`: Geben Sie eine Ganzzahl ein + `byteLength`: Geben Sie eine Ganzzahl von `1` bis `6` ein. + `Buffer.prototype.writeUInt32LE(value, offset, byteLength)` Schreiben Sie den `value` beim `offset` des `Buffer`s mit Little-Endian. + `value`: Geben Sie eine Ganzzahl ein. + `offset`: Geben Sie eine Ganzzahl ein + `byteLength`: Geben Sie eine Ganzzahl von `1` bis `6` ein. + `Buffer.prototype.writeDoubleBE(value, [offset])` Schreiben Sie den `value` beim `offset` des `Buffer`s mit Big-Endian. + `value`: Geben Sie eine Ganzzahl ein. + `offset`: Optional. Geben Sie eine Ganzzahl ein. Standard = 0. + `Buffer.prototype.writeDoubleLE(value, [offset])` Schreiben Sie den `value` beim `offset` des `Buffer`s mit Little-Endian. + `value`: Geben Sie eine Ganzzahl ein. + `offset`: Optional. Geben Sie eine Ganzzahl ein. Standard = 0. + `Buffer.prototype.writeFloatBE(value, [offset])` Schreiben Sie den `value` beim `offset` des `Buffer`s mit Big-Endian. + `value`: Geben Sie eine Ganzzahl ein. + `offset`: Optional. Geben Sie eine Ganzzahl ein. Standard = 0. + `Buffer.prototype.writeFloatLE(value, [offset])` Schreiben Sie den `value` beim `offset` des `Buffer`s mit Little-Endian. + `value`: Geben Sie eine Ganzzahl ein. + `offset`: Optional. Geben Sie eine Ganzzahl ein. Standard = 0. Die folgenden Instanzmethoden werden unterstützt: + `buffer[index]` Rufen Sie Oktett (Byte) beim `index` im `Buffer` ab oder legen Sie es fest. + Rufen Sie eine Zahl von `0` bis `255` ab. Oder legen Sie eine Zahl von `0` bis `255` fest. Die folgenden Instanzeigenschaften werden unterstützt: + `buffer` Rufen Sie das `ArrayBuffer`-Objekt für den Puffer ab. + `byteOffset` Rufen Sie das `byteOffset` vom `Arraybuffer`-Objekt des Puffers ab. + `length` Rufen Sie die Byteanzahl des Puffers ab. **Anmerkung** Alle Puffermodul-Methoden sind neu in JavaScript Runtime 2.0. ### Abfragezeichenfolge **Anmerkung** Das [CloudFront Functions-Ereignisobjekt](functions-event-structure.md) parst automatisch URL-Abfragezeichenfolgen für Sie. Das bedeutet, dass Sie dieses Modul in den meisten Fällen nicht verwenden müssen. Das Modul für Abfragezeichenfolgen (`querystring`) bietet Methoden zum Analysieren und Formatieren von URL-Abfragezeichenfolgen. Sie können das Modul mit lade `require('querystring')`. Das Modul bietet die folgenden Methoden. `querystring.escape(string)` URL-kodiert die angegebene `string` und gibt eine entflohene Abfragezeichenfolge zurück. Die Methode wird von `querystring.stringify()` verwendet und sollte nicht direkt verwendet werden. `querystring.parse(string[, separator[, equal[, options]]])` Analysiert eine Abfragezeichenfolge (`string`) und gibt ein Objekt zurück. Der `separator`-Parameter ist eine Teilzeichenfolge zum Abgrenzen von Schlüssel- und Wertepaaren in der Abfragezeichenfolge. Standardmäßig ist dies `&`. Der `equal`-Parameter ist eine Teilzeichenfolge zum Abgrenzen von Schlüsseln und Werten in der Abfragezeichenfolge. Standardmäßig ist dies `=`. Der `options`-Parameter ist ein Objekt mit den folgenden Schlüsseln: `decodeURIComponent function` Eine Funktion zum Entschlüsseln von prozentkodierten Zeichen in der Abfragezeichenfolge. Standardmäßig ist dies `querystring.unescape()`. `maxKeys number` Die maximale Anzahl der Schlüssel zum Parsen. Standardmäßig ist dies `1000`. Verwenden Sie den Wert `0`, um die Beschränkungen für das Zählen von Schlüsseln aufzuheben. Standardmäßig wird davon ausgegangen, dass prozentcodierte Zeichen innerhalb der Abfragezeichenfolge die UTF-8-Codierung verwenden. Ungültige UTF-8-Sequenzen werden durch das Ersatzzeichen `U+FFFD` ersetzt. Zum Beispiel für die folgende Abfragezeichenfolge: ``` 'name=value&abc=xyz&abc=123' ``` Der Rückgabewert von `querystring.parse()` ist: ``` { name: 'value', abc: ['xyz', '123'] } ``` `querystring.decode()` ist ein Alias für `querystring.parse()`. `querystring.stringify(object[, separator[, equal[, options]]])` Serialisiert ein `object` und gibt eine Abfragezeichenfolge zurück. Der `separator`-Parameter ist eine Teilzeichenfolge zum Abgrenzen von Schlüssel- und Wertepaaren in der Abfragezeichenfolge. Standardmäßig ist dies `&`. Der `equal`-Parameter ist eine Teilzeichenfolge zum Abgrenzen von Schlüsseln und Werten in der Abfragezeichenfolge. Standardmäßig ist dies `=`. Der `options`-Parameter ist ein Objekt mit den folgenden Schlüsseln: `encodeURIComponent function` Die Funktion, die zum Konvertieren von URL-unsicheren Zeichen in die prozentuale Kodierung in der Abfragezeichenfolge verwendet wird. Standardmäßig ist dies `querystring.escape()`. Standardmäßig werden Zeichen, die eine prozentuale Kodierung innerhalb der Abfragezeichenfolge erfordern, als UTF-8 codiert. Um eine andere Codierung zu verwenden, geben Sie die Option `encodeURIComponent` an. Zum Beispiel für den folgenden Code: ``` querystring.stringify({ name: 'value', abc: ['xyz', '123'], anotherName: '' }); ``` Der Rückgabewert ist: ``` 'name=value&abc=xyz&abc=123&anotherName=' ``` `querystring.encode()` ist ein Alias für `querystring.stringify()`. `querystring.unescape(string)` Dekodiert die prozentualen Zeichen der URL in der angegebenen `string` und gibt eine nicht entdeckene Abfragezeichenfolge zurück. Diese Methode wird von `querystring.parse()` verwendet und sollte nicht direkt verwendet werden. ### Crypto Das kryptographische Modul (`crypto`) bietet standardmäßige Hashing- und HMAC-Helfer (Hash-basierter Nachrichtenauthentifizierungscode). Sie können das Modul mit lade `require('crypto')`. **Hashing-Methoden** `crypto.createHash(algorithm)` Erstellt und gibt ein Hash-Objekt zurück, mit dem Sie Hash-Digests mit dem angegebenen Algorithmus generieren können: `md5`, `sha1` oder `sha256`. `hash.update(data)` Aktualisiert den Hash-Inhalt mit dem angegebenen `data`. `hash.digest([encoding])` Berechnet den Digest aller mit übergebenen Date `hash.update()`. Die Codierung kann `hex`, `base64` oder `base64url` sein. **HMAC-Methoden** `crypto.createHmac(algorithm, secret key)` Erstellt und gibt ein HMAC-Objekt zurück, das das angegebene `algorithm` und `secret key` verwendet. Der Algorithmus kann `md5`, `sha1` oder `sha256` sein. `hmac.update(data)` Aktualisiert den HMAC-Inhalt mit den angegebenen `data`. `hmac.digest([encoding])` Berechnet den Digest aller mit übergebenen Date `hmac.update()`. Die Codierung kann `hex`, `base64` oder `base64url` sein. ## Eingeschränkte Features Die folgenden JavaScript-Sprach-Features werden aufgrund von Sicherheitsbedenken entweder nicht unterstützt oder eingeschränkt. **Dynamische Codeauswertung** Die dynamische Codeauswertung wird nicht unterstützt. Sowohl `eval()`- als auch `Function`-Konstruktoren geben einen Fehler aus, wenn sie versucht werden. Zum Beispiel gibt `const sum = new Function('a', 'b', 'return a + b')` einen Fehler aus. **Timer ** Die Funktionen `setTimeout()`, `setImmediate()` und `clearTimeout()` werden nicht unterstützt. Es gibt keine Bestimmung, innerhalb einer Funktionsausführung zu verschieben oder zu ergeben. Ihre Funktion muss synchron bis zum Abschluss ausgeführt werden. **Datum und Zeitstempel** Aus Sicherheitsgründen besteht kein Zugang zu hochauflösenden Timern. Alle `Date`-Methoden zum Abfragen der aktuellen Uhrzeit geben während der Lebensdauer einer einzelnen Funktionsausführung immer den gleichen Wert zurück. Der zurückgegebene Zeitstempel ist die Zeit, zu der die Funktion gestartet wurde. Folglich können Sie die verstrichene Zeit in Ihrer Funktion nicht messen. **Zugriff auf das Dateisystem** Es gibt keinen Zugriff auf das Dateisystem. Zum Beispiel gibt es kein `fs`-Modul für den Dateisystemzugriff wie in Node.js. **Prozesszugriff** Es gibt keinen Prozesszugriff. Zum Beispiel gibt es kein globales `process`-Objekt für die Verarbeitung von Informationszugriffen wie in Node.js. **Umgebungsvariablen** Es gibt keinen Zugriff auf Umgebungsvariablen. Stattdessen können Sie CloudFront KeyValueStore verwenden, um einen zentralen Datenspeicher mit Schlüssel-Wert-Paaren für CloudFront Functions zu erstellen. CloudFront KeyValueStore ermöglicht dynamische Updates Ihrer Konfigurationsdaten, ohne dass Codeänderungen implementiert werden müssen. Weitere Informationen finden Sie unter [Amazon CloudFront Schlüsselwertspeicher](kvs-with-functions.md). **Netzwerkzugriff** Es gibt keine Unterstützung für Netzwerkaufrufe. Zum Beispiel werden XHR, HTTP(S) und Socket nicht unterstützt.