> ## Documentation Index
> Fetch the complete documentation index at: https://devdocs.xbox.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Características de ES6 en CloudScript
> Use características de ECMAScript 6 como la interpolación de cadenas, las funciones de flecha y la desestructuración para escribir controladores de CloudScript de PlayFab más limpios en modo estricto.
El entorno de ejecución de CloudScript admite la mayoría de las características modernas de ECMAScript 6. Aunque la mayoría de estas características son trucos sintácticos, puede usarlas para mejorar y limpiar su código de CloudScript.
Hay disponible una descripción completa de las características de ES6 en esta [hoja de referencia rápida](https://devhints.io/es6).
Este tutorial muestra varios trucos que puede usar en su CloudScript.
Algunas de las características requieren el modo **strict**. Habilite este modo colocando el siguiente código como la primera línea de su archivo de CloudScript: `use strict;`
## Interpolación de cadenas
Al redactar mensajes para sus jugadores, es posible que quiera usar cadenas interpoladas de varias líneas. Use el *símbolo de acento grave* para crear una cadena interpolada. Después puede insertar datos directamente en la cadena mediante la sintaxis `${ variable }`.
Esto le permite evitar la concatenación de cadenas y mejora la legibilidad del código.
Las cadenas con acento grave son literales y pueden ocupar varias líneas. Esto significa que debe prestar atención a *toda la sangría*, ya que cualquier espacio o tabulación adicional se capturará en la cadena.
```javascript theme={null}
function sendPushNotification(playerName, prizeAmount, newLevel) {
let message = `Congratulations ${playerName}!
You have reached level ${newLevel}.
You get ${prizeAmount} coins for your efforts.`;
// Use message variable and send push notification
// ...
}
```
## Nuevos métodos y funciones de flecha
ES6 aporta una *nueva* sintaxis para definir funciones mediante el operador de flecha `=>`. El fragmento de código que se muestra a continuación presenta traducciones aproximadas de determinados usos del operador.
```javascript theme={null}
// The following snippets:
const add = (a,b) => a+b;
const add = (a,b) => {
return a+b;
}
// Both translate into something like
function add(a, b) {
return a+b;
}
```
Este operador, combinado con el nuevo método `Array.findIndex`, permite buscar por predicado con el siguiente código conciso y de buen aspecto.
```javascript theme={null}
const players = [...]; // Suppose this is an array of Player Profiles
// Search by predicate: find item in 'players' that has 'DisplayName' set to 'Bob':
const bobIndex = players.findIndex(p => p.DisplayName === 'Bob');
```
## Asignación de objetos
El método `Object.assign` le permite extender fácilmente cualquier objeto con un nuevo conjunto de propiedades y métodos.
Con una gran variedad de usos, este método resulta especialmente útil para extender un objeto de controladores y crear grupos de controladores.
```javascript theme={null}
let TestHandlers = {
TestLeaderboards : (args, ctx) => {
// Test leaderboards code
},
TestPrizes : (args, ctx) => {
// Test prizes code
}
// ...
}
let ProductionHandlers = {
CleanUp : (args, ctx) => {
// System clean up code
},
GrantTournamentAccess : (args, ctx) => {
// Another useful production code
}
// ...
}
// Install both handler groups:
Object.assign(handlers, TestHandlers);
Object.assign(handlers, ProductionHandlers);
// Comment out the group to disable it but keep the relevant code
// Object.assign(handlers, SomeOtherHandlers);
```
Esto no solo le permite habilitar y deshabilitar rápidamente grupos de controladores, sino que también le ofrece un punto para procesar sus controladores y envolverlos con código útil, como el control de excepciones.
El siguiente código extiende el fragmento anterior con el registro automático de excepciones. Como ejemplo, registramos el problema (lo que no siempre es útil), pero puede extender el comportamiento a su gusto.
```javascript theme={null}
// Handlers installer wraps the handler to catch error
function installHandlers(handlersObject) {
for (let property in handlersObject) {
handlersObject[property] = wrapHandler(handlersObject,property)
}
Object.assign(handlers, handlersObject);
}
// Utility
function wrapHandler(obj, key) {
if (obj.hasOwnProperty(key) && typeof obj[key] === 'function') {
let original = obj[key]; // Take the original function
return function() { // return a new function that
try { // Wraps the original invocation with try
return original.apply(null,arguments); // Do not forget to pass arguments
} catch (error) { // If error occurs
log.error(error); // We log it, but you may want to retry / do something else
throw error; // Rethrow to keep the original behaviour
}
}
} else { // If property is not a function, ignore it
return obj[key];
}
}
// Install handler groups:
installHandlers(TestHandlers);
installHandlers(ProductionHandlers);
```
## Captadores (getters)
Puede usar "captadores" (getters) para encapsular llamadas API comunes con una apariencia sintácticamente más agradable. Considere el siguiente estado de **Title Data**.
El siguiente fragmento de código muestra cómo recuperar los datos `Foo` y `Bar` de `TitleData` y luego usarlos de una manera muy sencilla.
```javascript theme={null}
'use strict'
// Define
let App = {
get TitleData() {
// Please, consider limiting the query by defining certain keys that you need
return server.GetTitleData({}).Data;
},
}
// Use
handlers.TestFooBar = () => {
// Client code is clean and does not show the fact of calling any functions / making api request
var titleData = App.TitleData; // Note that this implementation makes an API call every time it's accessed
log.debug(titleData.Foo);
log.debug(titleData.Bar);
}
```
## Related topics
- [Control de errores en CloudScript](/es/services/playfab/live-service-management/service-gateway/automation/cloudscript/handling-errors-in-cloudscript.md)
- [Depuración de CloudScript con Azure Functions en Azure Portal](/es/services/playfab/live-service-management/service-gateway/automation/cloudscript-af/debugging-with-CloudScript-AF-Azure.md)
- [Depuración de CloudScript con Azure Functions en Visual Studio](/es/services/playfab/live-service-management/service-gateway/automation/cloudscript-af/debugging-with-CloudScript-AF-VS.md)
- [Depuración de CloudScript con Azure Functions en Visual Studio Code](/es/services/playfab/live-service-management/service-gateway/automation/cloudscript-af/debugging-with-CloudScript-AF-VSCode.md)
- [CloudScript](/es/services/playfab/live-service-management/service-gateway/automation/cloudscript/index.md)