Google Apps Script : introduction pour débutant (tutoriel)

Google Apps Script, qu’est-ce que c’est ?

Google Apps Script (GAS) est une plateforme de développement orientée cloud pour Google Workspace (Gmail, Drive, Sheets, Docs, etc.).

C’est en fait du JavaScript moderne qui vous permet de programmer des automatisations et de nouvelles fonctionnalités dans les applications Google. Vous écrivez votre code directement dans un éditeur Web (accessible depuis script.google.com ou via Extensions > Apps Script dans Google Sheets/Docs).

Avec Apps Script, on peut par exemple ajouter des menus personnalisés, créer des fonctions personnalisées dans Google Sheets, générer automatiquement des documents, envoyer des emails automatisés, ou même publier des mini-applications web ou APIs. Pour les utilisateurs habitués à l’environnement Microsoft, Power Automate est l’outil équivalent chez Microsoft en savoir plus sur Power Automate ou notre guide dédié.

Prise en main

Pour débuter, il suffit d’avoir un compte Google. Ouvrez un document (par exemple Google Sheets) et sélectionnez Extensions > Apps Script. Une nouvelle fenêtre s’ouvre avec l’éditeur Apps Script en ligne.

Ce projet contient par défaut un fichier Code.gs (javascript) vierge. Vous pouvez créer plusieurs fonctions dans ce fichier et les lancer directement depuis l’éditeur.

Google Apps Script fournit également des débogueurs et un journal d’exécution intégré : vous pouvez insérer des instructions comme Logger.log() ou console.log() dans votre code pour afficher des messages dans l’onglet « Historique des exécutions » de l’éditeur. Ces messages de log sont utiles pour suivre le déroulement du script et trouver d’éventuelles erreurs.

En plus du journal, l’éditeur propose un mode pas-à-pas (breakpoints) pour inspecter vos variables en détail.

Le JavaScript au cœur de Google Apps Script

Google Apps Script utilise JavaScript (JS) comme langage de programmation. Toutes vos fonctions et instructions sont écrites en JS (dernière version ECMAScript).

Ainsi, tout ce que vous apprenez ici est applicable au développement web en général.

À noter : JS n’est pas lié au langage Java malgré leur similarité de nom.

Dans Apps Script, on peut utiliser l’essentiel du JS moderne (variables, fonctions, objets, classes, etc.). Les fonctions que vous définissez sont exécutées sur les serveurs de Google et peuvent être déclenchées par des événements (par exemple à l’ouverture du document ou à une date/heure spécifiée).

Les bases du JavaScript

Pour écrire des scripts efficaces, il est utile de connaître les concepts fondamentaux de JavaScript. Voici les principaux :

Les commentaires

Les commentaires servent à expliquer votre code ou à désactiver temporairement des lignes de code.

En JavaScript, on écrit un commentaire sur une ligne avec //, ou un bloc de commentaires sur plusieurs lignes avec /* ... */. Par exemple :

// Ceci est un commentaire sur une seule ligne
/* Ceci est un commentaire
   sur plusieurs lignes */

Tout ce qui suit // (jusqu’à la fin de la ligne) n’est pas exécuté. Les commentaires ne modifient pas le comportement du script, ils sont simplement ignorés lors de l’exécution. C’est très pratique pour décrire ce que fait le code ou pour désactiver des morceaux de code pendant le débogage.

Les primitives

En JavaScript, une valeur primitive désigne une donnée de base qui n’est pas un objet et qui n’a pas de méthodes/propriétés. Il existe plusieurs types primitifs :

• les nombres (Number),
• les chaînes de caractères (String),
• les booléens (Boolean),
• ainsi que les valeurs spéciales null (aucune valeur) et undefined (valeur indéfinie).

Les types plus récents incluent le Symbol et le BigInt (entiers de grande taille). Ces primitives sont immuables (on ne peut pas modifier leur contenu une fois créées).

Par exemple, le résultat de l’opération "abc".toUpperCase() est une nouvelle chaîne, la chaîne d’origine reste inchangée. On peut cependant attribuer ces valeurs primitives à des variables pour les manipuler.

Les variables

On utilise des variables pour stocker des valeurs en mémoire. On peut imaginer qu’une variable est comme une boîte étiquetée qui contient une valeur (nombre, texte, boolean, etc.). Par exemple :

let nom = "Alice";
let age = 30;

Ici nom est une variable contenant la chaîne "Alice", et age contient le nombre 30.

Vous pouvez déclarer une variable sans la définir (let x; donne undefined) puis lui assigner une valeur plus tard (x = 5;).

En JavaScript, on déclare généralement les variables avec let (ou const pour une valeur fixe), et l’ancien mot-clé var existe aussi mais est moins utilisé maintenant (je ne vous conseille pas de l’utiliser car vous risquez d’obtenir des erreurs).

Les variables peuvent contenir n’importe quel type de valeur : primitives bien sûr, mais aussi des objets ou même des fonctions complètes.

On peut changer leur contenu en réassignant la variable (nom = "Bob"), à l’exception d’une variable déclarée avec const qui ne peut être modifiée.

Debugger (en JavaScript et en Apps Script)

Pour trouver des erreurs ou suivre l’exécution de votre code, vous pouvez utiliser les outils de debug.

Dans un navigateur web, on ouvre la console JavaScript (par exemple avec F12) pour voir les messages console.log ou les erreurs.

Dans Google Apps Script, l’éditeur propose lui aussi un Journal d’exécution et un débogueur. Comme l’explique la documentation, vous pouvez utiliser la classe Logger ou console.log() pour envoyer des messages au journal de debug. Par exemple :

function test() {
  let x = 10;
  Logger.log("Valeur initiale de x : " + x);
  x++;
  console.log("Nouvelle valeur de x : " + x);
}

Lorsque vous exécutez cette fonction dans l’éditeur, vous verrez les messages « Valeur initiale de x : 10 » et « Nouvelle valeur de x : 11 » dans l’onglet Historique des exécutions. Vous pouvez également lancer le mode débogage (step-by-step) depuis l’éditeur pour poser un point d’arrêt et inspecter la valeur des variables à chaque étape.

Les fonctions

Les fonctions sont des blocs de code réutilisables qui effectuent une tâche ou calculent une valeur.

En pratique, on définit une fonction avec le mot-clé function. Par exemple :

function carre(n) {
  return n * n;
}

Ici, la fonction carre prend un paramètre n et renvoie son carré. On peut ensuite l’appeler dans le code : let r = carre(5); // r vaut 25.

Les fonctions permettent de factoriser votre code et d’éviter les répétitions.

Elles peuvent prendre plusieurs paramètres, retourner des valeurs, et contiennent généralement un (ou plusieurs) return pour donner un résultat.

Les boucles

Les boucles permettent d’exécuter plusieurs fois un même bloc d’instructions. Par exemple, pour exécuter cinq fois une action, on peut écrire :

for (let i = 0; i < 5; i++) {
  console.log("Étape&nbsp;: " + i);
}

Cette boucle for affiche 0, 1, 2, 3, 4 dans la console (total 5 itérations).

Il existe aussi les boucles while (condition) { ... } qui s’exécutent tant que la condition est vraie, et do { ... } while(condition) qui fait un tour avant de tester la condition. Par exemple :

let x = 0;
while (x < 3) {
  console.log(x);
  x++;
}
// Affiche 0, puis 1, puis 2.

On veillera à éviter les boucles infinies (condition toujours vraie) sinon le script ne s’arrête jamais. Des instructions comme break (sortie de boucle) et continue (passer à l’itération suivante) permettent de mieux contrôler la boucle.

Les boucles sont très utiles pour parcourir des tableaux, traiter des lignes d’un tableur, ou répéter toute sorte de tâches jusqu’à ce qu’une condition soit atteinte.

Les tableaux, objets et JSON

Un tableau (Array) en JavaScript est une liste ordonnée d’éléments. Par exemple :

let tableau = ["pomme", "banane", "cerise"]

Ici tableau[0] vaut "pomme", tableau[1] vaut "banane", etc.

Les tableaux sont dynamiques : on peut les redimensionner et y mélanger différents types de données. Ils sont indexés à partir de 0.

Les objets (Object) sont des collections de paires clé–valeur. Un objet JavaScript peut ressembler à ceci :

let personne = {
	prenom: "Alice",
	age: 30,
	ville: "Paris"
}

Cet objet a trois propriétés (prenom, age, ville) avec leurs valeurs.

En pratique, les objets servent à regrouper des données et comportements sous un même nom (on parle de propriétés et de méthodes d’un objet).

Les tableaux et objets peuvent être imbriqués : un objet peut contenir un autre objet, un tableau, etc.

Le JSON (JavaScript Object Notation) est un format de texte très répandu pour échanger des données structurées. Par exemple :

{
	"nom": "Dupont", 
	"age": 45, 
	"projets": [
		"Alpha",
		"Beta"
	]
}

Ce format JSON représente un objet avec deux propriétés (nom, age) et un tableau (projets). En JavaScript, on utilise souvent JSON.stringify(objet) pour transformer un objet ou tableau JS en texte JSON, et JSON.parse(chaineJSON) pour faire l’inverse.

JSON est utile surtout pour communiquer avec des serveurs ou des APIs.

Les API

Google Apps Script offre deux types d’API : les services Google intégrés et les requêtes HTTP externes.

• Services Google : Apps Script fournit des classes prédéfinies comme SpreadsheetApp (pour Google Sheets), DocumentApp (pour Google Docs), GmailApp (pour Gmail), DriveApp (pour Google drive), etc. Par exemple, SpreadsheetApp.getActiveSpreadsheet() permet d’accéder au Google sheets actif (où le code est exécuté).
• Requêtes externes (URL Fetch) : pour communiquer avec d’autres applications Web (API externes), Apps Script utilise le service UrlFetchApp. Avec UrlFetchApp.fetch(url, options), vous pouvez faire des requêtes HTTP/HTTPS (GET, POST, PUT, etc.) vers n’importe quelle URL depuis votre script.

Quelques exemples

Génération de documents (Apps Script, Google Sheets et Google Docs)

Ici je te montre en vidéo comment générer un règlement intérieur automatiquement depuis un Google Sheets :

Voici le code généré :

/**
 * Ajoute le menu personnalisé « Règlement Intérieur » au classeur à l’ouverture.
 */
function onOpen() {
  SpreadsheetApp.getUi()
    .createMenu('Règlement Intérieur')
    .addItem('Générer les documents', 'creationDuReglementInterieur')
    .addToUi();
}

/**
 * Génère un document « règlement intérieur » pour chaque ligne de la feuille
 * « Liste », en se basant sur un Google Docs modèle.
 *
 * — Chaque copie est nommée « nom - prenom - règlement intérieur à signer »
 * — Les balises {{prenom}} et {{nom}} sont remplacées par les données de la ligne.
 * — La copie est déposée dans un dossier Drive donné.
 * — Le lien vers la copie est inscrit dans la colonne « lien vers ri ».
 *
 * ⚠️ Remplacez les constantes TEMPLATE_ID et FOLDER_ID ci‑dessous par l’ID du
 *    Doc modèle et l’ID du dossier de destination avant d’exécuter la fonction.
 */
function creationDuReglementInterieur() {
  const TEMPLATE_ID = 'TEMPLATE_ID';      // ← ID du template Docs
  const FOLDER_ID   = 'FOLDER_ID'; // ← ID du dossier Drive

  const ss    = SpreadsheetApp.getActiveSpreadsheet();
  const sheet = ss.getSheetByName('Liste');
  if (!sheet) {
    SpreadsheetApp.getUi().alert('La feuille "Liste" est introuvable.');
    return;
  }

  const data = sheet.getDataRange().getValues();
  if (data.length < 2) {
    SpreadsheetApp.getUi().alert('Aucune donnée à traiter dans la feuille "Liste".');
    return;
  }

  // Repère les index de colonnes depuis la première ligne (en‑têtes)
  const headers   = data[0];
  const idxPrenom = headers.indexOf('prenom');
  const idxNom    = headers.indexOf('nom');
  const idxLien   = headers.indexOf('lien vers ri');
  const idxAdresse   = headers.indexOf('adresse');
  if (idxPrenom === -1 || idxNom === -1 || idxLien === -1) {
    SpreadsheetApp.getUi().alert('Les colonnes "prenom", "nom" ou "lien vers ri" sont manquantes.');
    return;
  }

  const templateFile = DriveApp.getFileById(TEMPLATE_ID);
  const targetFolder = DriveApp.getFolderById(FOLDER_ID);
  const updates      = [];

  for (let i = 1; i < data.length; i++) { // commence à 1 pour ignorer l’en‑tête
    const row   = data[i];
    const prenom = row[idxPrenom];
    const nom    = row[idxNom];
    const lienRI = row[idxLien];
    const adresse = row[idxAdresse];

    // Ignore la ligne si nom/prenom manquants ou si le lien est déjà présent
    if (!prenom || !nom || lienRI) continue;

    // Copie du template dans le dossier cible
    const copyFile = templateFile.makeCopy(`${nom} - ${prenom} - règlement intérieur à signer`, targetFolder);

    // Remplace les balises dans la nouvelle copie
    const doc  = DocumentApp.openById(copyFile.getId());
    const body = doc.getBody();
    body.replaceText('{{prenom}}', prenom);
    body.replaceText('{{nom}}', nom);
    body.replaceText('{{adresse}}', adresse);
    doc.saveAndClose();

    // Stocke l’URL pour mise à jour en lot
    updates.push({ row: i + 1, url: doc.getUrl() }); // i+1 car les lignes Sheets sont 1‑based
  }

  // Écrit toutes les URL dans la feuille en une seule opération
  updates.forEach(u => sheet.getRange(u.row, idxLien + 1).setValue(u.url));
  SpreadsheetApp.flush();

  SpreadsheetApp.getUi().alert(`${updates.length} document(s) généré(s).`);
}

Ajouter un menu dans Google Sheets

Vous pouvez enrichir l’interface de Google Sheets en ajoutant un menu personnalisé. Pour cela, on écrit une fonction spéciale onOpen() dans un script lié à la feuille. Cette fonction utilise l’interface utilisateur (SpreadsheetApp.getUi()) pour créer un nouveau menu. Par exemple :

function onOpen() {
  let ui = SpreadsheetApp.getUi();
  ui.createMenu("Mon Menu")
    .addItem("Mettre à jour le rapport", "genererRapport")
    .addToUi();
}
function genererRapport() {
  SpreadsheetApp.getUi().alert("Génération lancée !");
  // Ici on lancerait une autre fonction pour faire le travail.
}

Lorsque la feuille est ouverte, ce code ajoute un menu Mon Menu dans la barre d’outils de Sheets. Cliquer sur « Mettre à jour le rapport » exécute la fonction genererRapport.

Quelques possibilités en vrac

• Automatisation de reporting périodique (mailing de rapports hebdomadaires, résumés statistiques, etc.).
• Création de formules personnalisées pour Google Sheets (fonctions sur mesure accessibles comme des formules normales).
• Développement d’applications web simples (Apps Script permet de publier un script en tant que Web App accessible via une URL).
• Création d’une mini-API interne (votre script peut exposer des fonctions via doGet(e)/doPost(e) pour être appelé depuis d’autres systèmes).

Résumé

Google Apps Script est un outil puissant et intuitif pour étendre Google Workspace et automatiser vos tâches quotidiennes. Il utilise le JavaScript standard, ce qui le rend accessible aux débutants tout en restant riche fonctionnellement.

En quelques lignes de code, vous pouvez créer des solutions sur-mesure : menus personnalisés, envois d’emails automatisés, génération de documents dynamiques, rapports automatisés, etc.

Les notions de base du langage (commentaires, variables, fonctions, boucles, tableaux, objets) suffisent pour démarrer. Une fois ces bases acquises, vous pouvez construire des scripts enchaînant les services Google (Sheets, Docs, Forms, Gmail, etc.) et même interagir avec des APIs externes via HTTP.

En résumé, Google Apps Script agit comme une boîte à outils scriptable pour Google Workspace, idéale pour gagner du temps et rendre votre environnement de travail plus intelligent. N’hésitez pas à explorer les ressources officielles (guide Google, tutoriels MDN, etc.) pour approfondir vos connaissances. Avec un peu de pratique, vous pourrez créer vous-même des automatisations sur-mesure et améliorer votre productivité.

FAQ

Q : Qu’est-ce que Google Apps Script ?

R : Google Apps Script est une plateforme de développement cloud de Google qui permet d’automatiser et d’étendre les applications Google (Sheets, Docs, Gmail, Calendar, etc.).

Q : Doit-on connaître JavaScript pour utiliser Google Apps Script ?

R : Apps Script utilise du JavaScript standard. Connaître les bases de JavaScript (variables, fonctions, boucles, objets…) est donc très utile pour écrire vos scripts.

Q : Que peut-on automatiser concrètement avec Google Apps Script ?

R : Presque tout ce qui concerne Google Workspace. Par exemple, vous pouvez automatiser l’envoi de rapports par email, créer des feuilles ou documents dynamiques, importer ou exporter des données vers d’autres services, répondre automatiquement à des formulaires, etc.

Q : Existe-t-il un équivalent de Google Apps Script chez Microsoft ?

R : Oui. L’outil équivalent dans l’univers Microsoft s’appelle Power Automate (qui fait partie de Power Platform).