> ## 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.
# Recursos do ES6 no CloudScript
> Use recursos do ECMAScript 6, como interpolação de cadeias de caracteres, funções de seta e desestruturação, para escrever manipuladores do CloudScript do PlayFab mais limpos no modo estrito.
O ambiente de runtime do CloudScript oferece suporte à maioria dos recursos modernos do ECMAScript 6. Embora a maioria desses recursos seja composta de truques sintáticos, você pode usá-los para melhorar e limpar seu código do CloudScript.
Uma visão geral completa dos recursos do ES6 está disponível nesta [folha de referência](https://devhints.io/es6).
Este tutorial mostra vários truques que você pode usar no seu CloudScript.
Alguns dos recursos exigem o modo **strict**. Habilite esse modo colocando o código a seguir na primeira linha do seu arquivo do CloudScript: `use strict;`
## Interpolação de cadeias de caracteres
Ao compor mensagens para seus jogadores, talvez você queira usar cadeias de caracteres interpoladas de várias linhas. Use o *símbolo de acento grave* para criar uma cadeia de caracteres interpolada. Em seguida, você pode inserir dados diretamente na cadeia de caracteres usando a sintaxe `${ variable }`.
Isso permite evitar a concatenação de cadeias de caracteres e melhora a legibilidade do código.
As cadeias de caracteres com acento grave são literais e podem ter várias linhas. Isso significa que você precisa ficar atento a *todo o recuo*, pois qualquer espaço/tabulação extra será capturado na cadeia de caracteres.
```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
// ...
}
```
## Novos métodos e funções de seta
O ES6 traz uma *nova* sintaxe para definir funções usando o operador de seta `=>`. O trecho exibido abaixo mostra traduções aproximadas para determinados usos do 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;
}
```
Esse operador, combinado com o novo método `Array.findIndex`, permite pesquisar por predicado com o seguinte código elegante e sucinto.
```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');
```
## Atribuição de objetos
O método `Object.assign` permite estender facilmente qualquer objeto com um novo conjunto de propriedades e métodos.
Com uma grande variedade de usos, esse método é particularmente útil para estender um objeto de manipuladores e criar grupos de manipuladores.
```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);
```
Isso não só permite habilitar e desabilitar rapidamente grupos de manipuladores, como também oferece um ponto para processar seus manipuladores e envolvê-los com código útil, como o tratamento de exceções.
O código a seguir estende o trecho anterior com o registro automático de exceções. Como exemplo, registramos o problema (o que nem sempre é útil), mas você pode estender o comportamento como preferir.
```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);
```
## Getters
É possível usar "getters" para encapsular chamadas de API comuns em uma aparência sintaticamente mais agradável. Considere o seguinte estado de **Title Data**.
O trecho a seguir mostra como recuperar os dados `Foo` e `Bar` de `TitleData` e usá-los de forma muito simples.
```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
- [Depurar Azure Functions do CloudScript no portal do Azure](/pt-BR/services/playfab/live-service-management/service-gateway/automation/cloudscript-af/debugging-with-CloudScript-AF-Azure.md)
- [CloudScript](/pt-BR/services/playfab/live-service-management/service-gateway/automation/cloudscript/index.md)
- [Escrever CloudScript personalizado](/pt-BR/services/playfab/live-service-management/service-gateway/automation/cloudscript/writing-custom-cloudscript.md)
- [CloudScript do PlayFab usando Azure Functions](/pt-BR/services/playfab/live-service-management/service-gateway/automation/cloudscript-af/index.md)
- [Depuração local do CloudScript usando Azure Functions](/pt-BR/services/playfab/live-service-management/service-gateway/automation/cloudscript-af/local-debugging-for-cloudscript-using-azure-functions.md)