Fonctionnalités ES6 dans CloudScript

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. 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.

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.

// 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.

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.

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.

// 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.

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.

'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);
}

XBOX Services

PlayFab

Interpolation de chaînes

Nouvelles méthodes et fonctions fléchées

Affectation d’objets

Accesseurs (getters)

​Interpolation de chaînes

​Nouvelles méthodes et fonctions fléchées

​Affectation d’objets

​Accesseurs (getters)

Interpolation de chaînes

Nouvelles méthodes et fonctions fléchées

Affectation d’objets

Accesseurs (getters)