Scrydon
Blocs

Fonction

Exécuter du code JavaScript ou TypeScript personnalisé dans vos workflows

Le bloc Fonction vous permet d'exécuter du code JavaScript ou TypeScript personnalisé dans votre workflow. Utilisez-le pour transformer des données, effectuer des calculs ou implémenter une logique métier non disponible dans d'autres blocs.

Function Block with Code Editor

Vue d'ensemble

Le bloc Fonction vous permet de :

Transformer des données : convertir des formats, analyser du texte, manipuler des tableaux et des objets

Effectuer des calculs : opérations mathématiques, statistiques, calculs financiers

Implémenter une logique personnalisée : conditions complexes, boucles et algorithmes

Traiter des données externes : analyser des réponses, formater des requêtes, gérer l'authentification

Fonctionnement

Le bloc Fonction exécute votre code dans un environnement sécurisé et isolé :

  1. Réception des entrées : accédez aux données des blocs précédents via l'objet input
  2. Exécution du code : exécutez votre code JavaScript/TypeScript
  3. Renvoi des résultats : utilisez return pour transmettre les données au bloc suivant
  4. Gestion des erreurs : gestion des erreurs et journalisation intégrées

Options de configuration

Éditeur de code

Rédigez votre code JavaScript/TypeScript dans un éditeur complet proposant :

  • Coloration syntaxique et vérification des erreurs
  • Numéros de ligne et correspondance des accolades
  • Prise en charge des fonctionnalités JavaScript modernes
  • Support natif de fetch

Accès aux données d'entrée

Utilisez l'objet input pour accéder aux données des blocs précédents :

// Accès aux données des blocs connectés
const userData = <agent.userData>;
const orderData = <agent.orderData>;

// Accès à des champs spécifiques
const customerName = <agent.customer.name>;
const total = <agent.order.total>;

Exemples courants

Transformation de données :

// Conversion et mise en forme des données
const formatted = {
  name: <agent.user.firstName> + ' ' + <agent.user.lastName>,
  email: <agent.user.email>.toLowerCase(),
  joinDate: new Date(<agent.user.created>).toLocaleDateString()
};
return formatted;

Calculs :

// Calcul de remises et totaux
const subtotal = <agent.items>.reduce((sum, item) => sum + item.price, 0);
const discount = subtotal > 100 ? 0.1 : 0;
const total = subtotal * (1 - discount);

return { subtotal, discount, total };

Validation des données :

// Validation du format d'un e-mail
const email = <agent.email>;
const isValid = /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email);

if (!isValid) {
  throw new Error('Invalid email format');
}
return { email, isValid };

Accès aux résultats

Après l'exécution d'une fonction, vous pouvez accéder à ses sorties :

  • <function.result> : la valeur retournée par votre fonction
  • <function.stdout> : la sortie de toute instruction console.log() de votre code

Fonctionnalités avancées

Support de l'async/await

Utilisez des fonctions asynchrones pour les opérations complexes :

// Exemple de fonction asynchrone
const processData = async () => {
  const data = <api.response>;
  
  // Traitement des données avec des opérations asynchrones
  const processed = await Promise.all(
    data.map(async (item) => {
      return {
        id: item.id,
        processed: true,
        timestamp: new Date().toISOString()
      };
    })
  );
  
  return processed;
};

return await processData();

Gestion des erreurs

Implémentez une gestion robuste des erreurs :

try {
  const result = <api.data>;
  
  if (!result || !result.length) {
    throw new Error('No data received');
  }
  
  return result.map(item => ({
    id: item.id,
    name: item.name.trim(),
    valid: true
  }));
} catch (error) {
  console.error('Processing failed:', error.message);
  return { error: error.message, valid: false };
}

Optimisation des performances

Optimisez le traitement pour les grands ensembles de données :

// Traitement efficace des données
const data = <api.large_dataset>;

// Utilisation de méthodes de tableau efficaces
const processed = data
  .filter(item => item.status === 'active')
  .map(item => ({
    id: item.id,
    summary: item.description.substring(0, 100)
  }))
  .slice(0, 1000); // Limiter les résultats

return processed;

Sécurité et limitations

Les fonctions s'exécutent dans un environnement sécurisé soumis aux restrictions suivantes :

  • Délai d'exécution : 30 secondes maximum pour éviter les boucles infinies
  • Limites de mémoire : mémoire limitée pour prévenir l'épuisement des ressources
  • Pas d'accès réseau : les requêtes HTTP ne sont pas autorisées (utilisez des blocs API à la place)
  • API limitées : seules les API JavaScript sûres sont disponibles

Entrées et sorties

  • Code : votre code JavaScript/TypeScript à exécuter

  • Timeout : durée maximale d'exécution (30 secondes par défaut)

  • Données d'entrée : toutes les sorties des blocs connectés disponibles via les variables

  • function.result : la valeur retournée par votre fonction

  • function.stdout : sortie des instructions Console.log() de votre code

  • function.error : détails de l'erreur si la fonction a échoué

  • function.execution_time : durée d'exécution

  • Résultat de la fonction : sortie principale de votre code

  • Informations de débogage : journaux et détails d'exécution

  • Accès : disponible dans les blocs suivant la fonction

Exemples d'utilisation

Pipeline de traitement de données

Scénario : transformer une réponse API en données structurées

  1. Le bloc API récupère les données brutes des clients
  2. Le bloc Fonction traite et valide les données
  3. Le bloc Fonction calcule les métriques dérivées
  4. Le bloc de réponse renvoie les résultats mis en forme

Implémentation de logique métier

Scénario : calculer les scores et niveaux de fidélité

  1. L'agent récupère l'historique d'achats du client
  2. Le bloc Fonction calcule les métriques de fidélité
  3. Le bloc Fonction détermine le niveau du client
  4. Le bloc Condition route en fonction du niveau

Validation et assainissement des données

Scénario : valider et nettoyer les saisies utilisateur

  1. Saisie utilisateur reçue depuis un formulaire
  2. Le bloc Fonction valide le format de l'e-mail et des numéros de téléphone
  3. Le bloc Fonction assainit et normalise les données
  4. Le bloc API enregistre les données validées en base

Exemple : calculateur de score de fidélité

loyalty-calculator.js
// Traitement des données client et calcul du score de fidélité
const { purchaseHistory, accountAge, supportTickets } = <agent>;

// Calcul des métriques
const totalSpent = purchaseHistory.reduce((sum, purchase) => sum + purchase.amount, 0);
const purchaseFrequency = purchaseHistory.length / (accountAge / 365);
const ticketRatio = supportTickets.resolved / supportTickets.total;

// Calcul du score de fidélité (0-100)
const spendScore = Math.min(totalSpent / 1000 * 30, 30);
const frequencyScore = Math.min(purchaseFrequency * 20, 40);
const supportScore = ticketRatio * 30;

const loyaltyScore = Math.round(spendScore + frequencyScore + supportScore);

return {
  customer: <agent.name>,
  loyaltyScore,
  loyaltyTier: loyaltyScore >= 80 ? "Platinum" : loyaltyScore >= 60 ? "Gold" : "Silver",
  metrics: { spendScore, frequencyScore, supportScore }
};

Bonnes pratiques

  • Garder les fonctions focalisées : écrivez des fonctions qui font une seule chose pour faciliter la maintenabilité et le débogage
  • Gérer les erreurs de façon élégante : utilisez des blocs try/catch pour gérer les erreurs potentielles et fournir des messages d'erreur explicites
  • Tester les cas limites : assurez-vous que votre code gère correctement les entrées inhabituelles, les valeurs null et les cas aux limites
  • Optimiser les performances : soyez attentif à la complexité calculatoire et à l'utilisation mémoire pour les grands ensembles de données
  • Utiliser console.log() pour le débogage : exploitez la sortie stdout pour déboguer et surveiller l'exécution de la fonction
Sur cette page

Sur cette page

Vue d'ensembleFonctionnementOptions de configurationÉditeur de codeAccès aux données d'entréeExemples courantsAccès aux résultatsFonctionnalités avancéesSupport de l'async/awaitGestion des erreursOptimisation des performancesSécurité et limitationsEntrées et sortiesExemples d'utilisationPipeline de traitement de donnéesImplémentation de logique métierValidation et assainissement des donnéesExemple : calculateur de score de fidélitéBonnes pratiques
Edit on GitHubCréer un ticket de documentation