Fonction

Le bloc Fonction vous permet d'exécuter du code JavaScript 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.

Vue d'ensemble

Le bloc Fonction vous permet de :

Fonctionnement

Le bloc Fonction exécute votre code dans un isolat QuickJS neuf, avec des limites de mémoire et de temps. Le runtime expose uniquement les valeurs du workflow, les variables d'environnement configurées et console ; il n'expose aucune API hôte de Node.js ou du navigateur. En production, l'exécution exige également le backend isolé autorisé et échoue de manière fermée si ce backend est indisponible :

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

Requêtes externes et échecs

fetch() et l'accès réseau ne sont pas disponibles dans les blocs Fonction. Utilisez un bloc HTTP Request ou un bloc d'intégration pour chaque requête externe, puis transmettez son résultat à une Fonction pour le transformer. Une Fonction en échec reste une étape en échec ; elle n'est pas convertie en résultat vide réussi.

Les erreurs HTTP Request indiquent la méthode, l'hôte de destination et le statut HTTP. Les explications du fournisseur sont limitées en longueur et leurs secrets sont masqués ; les corps d'erreur bruts, paramètres de requête et en-têtes ne figurent pas dans le message. Un 401 Unauthorized générique ne prouve ni l'expiration d'un jeton ni l'absence d'une permission. Vérifiez le compte d'extension et les exigences d'accès du fournisseur sans présumer de la cause.

Langage

Un menu déroulant Langage vous permet de choisir entre JavaScript et Python. JavaScript est la valeur par défaut et le seul langage actuellement exécutable — Python est proposé mais n'est pas encore fonctionnel (suivi dans #1162).

Éditeur de code

Rédigez votre code JavaScript 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
• Aucun accès au système de fichiers, au réseau, aux processus, au chargeur de modules, au client de plateforme ou aux identifiants

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

Exécution synchrone

Le code Fonction s'exécute actuellement de manière synchrone. Utilisez les blocs d'intégration dédiés pour les appels réseau ou les autres opérations asynchrones, puis transformez leur sortie dans le bloc Fonction :

const data = <api.response>;
return data.map((item) => ({
  id: item.id,
  processed: true,
  timestamp: new Date().toISOString()
}));

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

Entrées et sorties

Exemples d'utilisation

Pipeline de traitement de données

Implémentation de logique métier

Validation et assainissement des données

Exemple : calculateur de score de fidélité

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