Se usó la API de Cloud Translation para traducir esta página.

Servicio HTML: HTML basado en plantillas

Puedes combinar código de Apps Script y HTML para producir páginas dinámicas con un esfuerzo mínimo. Si usaste un lenguaje de plantillas que combina código y HTML, como PHP, ASP o JSP, la sintaxis debería resultarte familiar.

Secuencias de comandos

Las plantillas de Apps Script pueden contener tres etiquetas especiales, llamadas secuencias de comandos. Dentro de un secuencia de comandos, puedes escribir cualquier código que funcione en un archivo normal de Apps Script: las secuencias de comandos pueden llamar a funciones definidas en otros archivos de código, hacer referencia a variables globales o usar cualquiera de las APIs de Apps Script. Incluso puedes definir funciones y variables dentro de secuencias de comandos, con la salvedad de que las funciones definidas en archivos de código o en otras plantillas no pueden llamarlas.

Si pegas el siguiente ejemplo en el editor de secuencia de comandos, el contenido de la etiqueta <?= ... ?> (un subprograma de impresión) aparecerá en itálicas. Ese código en cursiva se ejecuta en el servidor antes de que se entregue la página al usuario. Debido a que el código de secuencia de comandos se ejecuta antes de que se publique la página, solo se puede ejecutar una vez por página. A diferencia de las funciones de JavaScript o Apps Script del cliente a las que llamas a través de google.script.run, las secuencias de comandos no se pueden volver a ejecutar después de que se carga la página.

Code.gs

function doGet() {
  return HtmlService
      .createTemplateFromFile('Index')
      .evaluate();
}

Index.html

<!DOCTYPE html>
<html>
  <head>
    <base target="_top">
  </head>
  <body>
    Hello, World! The time is <?= new Date() ?>.
  </body>
</html>

Ten en cuenta que la función doGet() para HTML con plantillas difiere de los ejemplos para crear y publicar HTML básico. La función que se muestra aquí genera un objeto HtmlTemplate a partir del archivo HTML y, luego, llama a su método evaluate() para ejecutar los subprogramas y convertir la plantilla en un objeto HtmlOutput que la secuencia de comandos puede entregar al usuario.

Secuencias de comandos estándar

Las secuencias de comandos estándar, que usan la sintaxis <? ... ?>, ejecutan código sin mostrar contenido de forma explícita en la página. Sin embargo, como se muestra en este ejemplo, el resultado del código dentro de un secuencia de comandos puede afectar el contenido HTML fuera de la secuencia de comandos:

Code.gs

function doGet() {
  return HtmlService
      .createTemplateFromFile('Index')
      .evaluate();
}

Index.html

<!DOCTYPE html>
<html>
  <head>
    <base target="_top">
  </head>
  <body>
    <? if (true) { ?>
      <p>This will always be served!</p>
    <? } else  { ?>
      <p>This will never be served.</p>
    <? } ?>
  </body>
</html>

Cómo imprimir secuencias de comandos

Las secuencias de comandos de impresión, que usan la sintaxis <?= ... ?>, muestran los resultados de su código en la página mediante escape contextual.

La evasión contextual significa que Apps Script realiza un seguimiento del contexto del resultado en la página (dentro de un atributo HTML, dentro de una etiqueta script del cliente o en cualquier otro lugar) y agrega automáticamente caracteres de escape para proteger contra ataques de secuencias de comandos entre sitios (XSS).

En este ejemplo, la primera secuencia de comandos de impresión genera una cadena directamente, a la que le sigue una secuencia de comandos estándar que configura un array y un bucle, y luego otra secuencia de comandos de impresión para generar el contenido del array.

Code.gs

function doGet() {
  return HtmlService
      .createTemplateFromFile('Index')
      .evaluate();
}

Index.html

<!DOCTYPE html>
<html>
  <head>
    <base target="_top">
  </head>
  <body>
    <?= 'My favorite Google products:' ?>
    <? var data = ['Gmail', 'Docs', 'Android'];
      for (var i = 0; i < data.length; i++) { ?>
        <b><?= data[i] ?></b>
    <? } ?>
  </body>
</html>

Ten en cuenta que una secuencia de comandos de impresión solo muestra el valor de su primera sentencia. Cualquier sentencia restante se comporta como si estuviera contenida en una secuencia de comandos estándar. Por ejemplo, el secuenciador de comandos <?= 'Hello, world!'; 'abc' ?> solo imprime "Hello, world!".

Cómo forzar la impresión de secuencias de comandos

Las secuencias de comandos de impresión forzada, que usan la sintaxis <?!= ... ?>, son como las secuencias de comandos de impresión, excepto que evitan la evasión contextual.

La evasión contextual es importante si tu secuencia de comandos permite entradas de usuario no confiables. Por el contrario, deberás forzar la impresión si el resultado de tu secuencia de comandos contiene HTML o secuencias de comandos que deseas insertar exactamente como se especifica.

Como regla general, usa secuencias de comandos de impresión en lugar de secuencias de comandos de impresión forzosa, a menos que sepas que necesitas imprimir HTML o JavaScript sin cambios.

Código de Apps Script en secuencias de comandos

Los subprogramas no se limitan a ejecutar JavaScript normal. También puedes usar cualquiera de las siguientes tres técnicas para permitir que tus plantillas accedan a los datos de Apps Script.

Sin embargo, recuerda que, como el código de plantilla se ejecuta antes de que se entregue la página al usuario, estas técnicas solo pueden enviar contenido inicial a una página. Para acceder a los datos de Apps Script desde una página de forma interactiva, usa la API de google.script.run.

Cómo llamar a funciones de Apps Script desde una plantilla

Los subprogramas pueden llamar a cualquier función definida en un archivo o biblioteca de código de Apps Script. En este ejemplo, se muestra una forma de extraer datos de una hoja de cálculo a una plantilla y, luego, construir una tabla HTML a partir de los datos.

Code.gs

function doGet() {
  return HtmlService
      .createTemplateFromFile('Index')
      .evaluate();
}

function getData() {
  return SpreadsheetApp
      .openById('1234567890abcdefghijklmnopqrstuvwxyz')
      .getActiveSheet()
      .getDataRange()
      .getValues();
}

Index.html

<!DOCTYPE html>
<html>
  <head>
    <base target="_top">
  </head>
  <body>
    <? var data = getData(); ?>
    <table>
      <? for (var i = 0; i < data.length; i++) { ?>
        <tr>
          <? for (var j = 0; j < data[i].length; j++) { ?>
            <td><?= data[i][j] ?></td>
          <? } ?>
        </tr>
      <? } ?>
    </table>
  </body>
</html>

Cómo llamar a las APIs de Apps Script directamente

También puedes usar el código de Apps Script directamente en los subprogramas. En este ejemplo, se logra el mismo resultado que en el ejemplo anterior cargando los datos en la plantilla en lugar de hacerlo a través de una función independiente.

Code.gs

function doGet() {
  return HtmlService
      .createTemplateFromFile('Index')
      .evaluate();
}

Index.html

<!DOCTYPE html>
<html>
  <head>
    <base target="_top">
  </head>
  <body>
    <? var data = SpreadsheetApp
        .openById('1234567890abcdefghijklmnopqrstuvwxyz')
        .getActiveSheet()
        .getDataRange()
        .getValues(); ?>
    <table>
      <? for (var i = 0; i < data.length; i++) { ?>
        <tr>
          <? for (var j = 0; j < data[i].length; j++) { ?>
            <td><?= data[i][j] ?></td>
          <? } ?>
        </tr>
      <? } ?>
    </table>
  </body>
</html>

Cómo enviar variables a plantillas

Por último, puedes enviar variables a una plantilla asignándolas como propiedades del objeto HtmlTemplate. Una vez más, este ejemplo logra el mismo resultado que los ejemplos anteriores.

Code.gs

function doGet() {
  var t = HtmlService.createTemplateFromFile('Index');
  t.data = SpreadsheetApp
      .openById('1234567890abcdefghijklmnopqrstuvwxyz')
      .getActiveSheet()
      .getDataRange()
      .getValues();
  return t.evaluate();
}

Index.html

<!DOCTYPE html>
<html>
  <head>
    <base target="_top">
  </head>
  <body>
    <table>
      <? for (var i = 0; i < data.length; i++) { ?>
        <tr>
          <? for (var j = 0; j < data[i].length; j++) { ?>
            <td><?= data[i][j] ?></td>
          <? } ?>
        </tr>
      <? } ?>
    </table>
  </body>
</html>

Plantillas de depuración

Las plantillas pueden ser difíciles de depurar porque el código que escribes no se ejecuta directamente. En su lugar, el servidor transforma tu plantilla en código y, luego, ejecuta ese código resultante.

Si no es obvio cómo la plantilla interpreta tus secuencias de comandos, dos métodos de depuración en la clase HtmlTemplate pueden ayudarte a comprender mejor lo que sucede.

getCode()

getCode() muestra una cadena que contiene el código que el servidor crea a partir de la plantilla. Si registras el código y, luego, lo pegas en el editor de secuencia de comandos, puedes ejecutarlo y depurar como un código normal de Apps Script.

Esta es la plantilla simple que vuelve a mostrar una lista de productos de Google, seguida del resultado de getCode():

Code.gs

function myFunction() {
  Logger.log(HtmlService
      .createTemplateFromFile('Index')
      .getCode());
}

Index.html

<!DOCTYPE html>
<html>
  <head>
    <base target="_top">
  </head>
  <body>
    <?= 'My favorite Google products:' ?>
    <? var data = ['Gmail', 'Docs', 'Android'];
      for (var i = 0; i < data.length; i++) { ?>
        <b><?= data[i] ?></b>
    <? } ?>
  </body>
</html>

REGISTRO (EVALUADO)

(function() { var output = HtmlService.initTemplate(); output._ =  '<!DOCTYPE html>\n';
  output._ =  '<html>\n' +
    '  <head>\n' +
    '    <base target=\"_top\">\n' +
    '  </head>\n' +
    '  <body>\n' +
    '    '; output._$ =  'My favorite Google products:' ;
  output._ =  '    ';  var data = ['Gmail', 'Docs', 'Android'];
        for (var i = 0; i < data.length; i++) { ;
  output._ =  '        <b>'; output._$ =  data[i] ; output._ =  '</b>\n';
  output._ =  '    ';  } ;
  output._ =  '  </body>\n';
  output._ =  '</html>';
  /* End of user code */
  return output.$out.append('');
})();

getCodeWithComments()

getCodeWithComments() es similar a getCode(), pero muestra el código evaluado como comentarios que aparecen junto con la plantilla original.

Explicación del código evaluado

Lo primero que notarás en cualquiera de los ejemplos de código evaluado es el objeto output implícito que crea el método HtmlService.initTemplate(). Este método no está documentado porque solo las plantillas deben usarlo. output es un objeto HtmlOutput especial con dos propiedades con nombres inusuales, _ y _$, que son abreviaturas para llamar a append() y appendUntrusted().

output tiene una propiedad especial más, $out, que hace referencia a un objeto HtmlOutput normal que no posee estas propiedades especiales. La plantilla muestra ese objeto normal al final del código.

Ahora que comprendes esta sintaxis, el resto del código debería ser bastante fácil de seguir. El contenido HTML fuera de los subprogramas (como la etiqueta b) se agrega con output._ = (sin escape contextual) y los subprogramas se agregan como JavaScript (con o sin escape contextual, según el tipo de subprograma).

Ten en cuenta que el código evaluado conserva los números de línea de la plantilla. Si obtienes un error mientras ejecutas el código evaluado, la línea corresponderá al contenido equivalente en la plantilla.

Jerarquía de comentarios

Debido a que el código evaluado conserva los números de línea, es posible que los comentarios dentro de los subprogramas anulen otros subprogramas y hasta el código HTML. En estos ejemplos, se muestran algunos efectos sorprendentes de los comentarios:

<? var x; // a comment ?> This sentence won't print because a comment begins inside a scriptlet on the same line.

<? var y; // ?> <?= "This sentence won't print because a comment begins inside a scriptlet on the same line.";
output.append("This sentence will print because it's on the next line, even though it's in the same scriptlet.”) ?>

<? doSomething(); /* ?>
This entire block is commented out,
even if you add a */ in the HTML
or in a <script> */ </script> tag,
<? until you end the comment inside a scriptlet. */ ?>