> ## 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. # Fonctionnalités ES6 dans CloudScript > Utilisez des fonctionnalités ECMAScript 6 comme l'interpolation de chaînes, les fonctions fléchées et la déstructuration pour écrire des gestionnaires PlayFab CloudScript plus clairs en mode strict. L'environnement d'exécution de CloudScript prend en charge la plupart des fonctionnalités modernes d'ECMAScript 6. Bien que la majorité de ces fonctionnalités soient des astuces syntaxiques, vous pouvez les utiliser pour améliorer et clarifier votre code CloudScript. Une vue d'ensemble complète des fonctionnalités ES6 est disponible dans cet [aide-mémoire](https://devhints.io/es6). Ce tutoriel présente plusieurs astuces que vous pouvez utiliser dans votre CloudScript. Certaines fonctionnalités nécessitent le mode **strict**. Activez ce mode en plaçant le code suivant sur la toute première ligne de votre fichier CloudScript : `use strict;` ## Interpolation de chaînes Lorsque vous composez des messages pour vos joueurs, vous pouvez utiliser des chaînes interpolées sur plusieurs lignes. Utilisez l'*accent grave* (back-tick) pour créer une chaîne interpolée. Vous pouvez ensuite insérer des données directement dans la chaîne à l'aide de la syntaxe `${ variable }`. Cela vous permet d'éviter la concaténation de chaînes et améliore la lisibilité du code. Les chaînes délimitées par des accents graves sont littérales et peuvent s'étendre sur plusieurs lignes. Vous devez donc surveiller *toute l'indentation*, car tout espace ou toute tabulation supplémentaire sera capturé dans la chaîne. ```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 // ... } ``` ## Nouvelles méthodes et fonctions fléchées ES6 apporte une *nouvelle* syntaxe de définition des fonctions à l'aide de l'opérateur flèche `=>`. L'extrait ci-dessous présente des équivalents approximatifs pour certaines utilisations de l'opérateur. ```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; } ``` Cet opérateur, combiné à la nouvelle méthode `Array.findIndex`, permet d'effectuer une recherche par prédicat avec le code élégant et concis suivant. ```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'); ``` ## Affectation d'objets La méthode `Object.assign` vous permet d'étendre facilement n'importe quel objet avec un nouvel ensemble de propriétés et de méthodes. Offrant une grande variété d'utilisations, cette méthode est particulièrement utile pour étendre un objet de gestionnaires et créer des groupes de gestionnaires. ```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); ``` Cela vous permet non seulement d'activer et de désactiver rapidement des groupes de gestionnaires, mais vous offre également un point d'entrée pour traiter vos gestionnaires et les envelopper dans du code utile, comme la gestion des exceptions. Le code suivant étend l'extrait précédent avec une journalisation automatique des exceptions. À titre d'exemple, nous journalisons le problème (ce qui n'est pas toujours utile), mais vous pouvez étendre ce comportement selon vos besoins. ```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); ``` ## Accesseurs (getters) Vous pouvez utiliser des « getters » pour encapsuler des appels d'API courants dans une syntaxe plus agréable. Considérez l'état suivant des **Title Data**. Game Manager : données de titre L'extrait suivant montre comment récupérer les données `Foo` et `Bar` depuis `TitleData`, puis les utiliser de manière très simple. ```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 - [Gestion des erreurs dans CloudScript](/fr/services/playfab/live-service-management/service-gateway/automation/cloudscript/handling-errors-in-cloudscript.md) - [Déboguer CloudScript avec Azure Functions dans Visual Studio](/fr/services/playfab/live-service-management/service-gateway/automation/cloudscript-af/debugging-with-CloudScript-AF-VS.md) - [Déboguer CloudScript avec Azure Functions dans Visual Studio Code](/fr/services/playfab/live-service-management/service-gateway/automation/cloudscript-af/debugging-with-CloudScript-AF-VSCode.md) - [Déboguer CloudScript avec Azure Functions dans le portail Azure](/fr/services/playfab/live-service-management/service-gateway/automation/cloudscript-af/debugging-with-CloudScript-AF-Azure.md) - [CloudScript](/fr/services/playfab/live-service-management/service-gateway/automation/cloudscript/index.md)