Sat. Dec 14th, 2024

Tabla RegEx easy para Google Tag Supervisor


Cuando nuestros buenos amigos en el Administrador de etiquetas de Google El equipo de desarrolladores presentó por primera vez el Macro de tabla de búsquedaestábamos emocionados. Para muchos de nosotros, pronto se convirtió en el arma preferida, especialmente cuando se utiliza como herramienta de gestión y optimización del propio contenedor.

Sin embargo, la macro no se consideró perfecta. De hecho, la petición escuchada con más frecuencia tenía que ver con la funcionalidad principal de la función en sí: la macro debería admitir operacioneseso es, lógica de predicados. No basta con realizar búsquedas de coincidencias iguales; la gente quería soporte para operaciones como “es x mayor que y” o “y contiene x”.

La cuestión es que no estoy de acuerdo con cambiar la macro de la tabla de búsqueda para admitir este tipo de operaciones. Claro, una tabla cuyos valores se puedan consultar con operaciones más complejas que las simples búsquedas sería increíble, pero no sería una tabla de búsqueda ya no. Necesitaríamos un tipo de variable diferente para esos casos de uso.

En esta publicación, analizaré qué hace que una tabla de búsqueda sea una tabla de búsqueda y también le brindaré una ingeniosa variable JavaScript personalizada que le permite crear una tabla de expresiones regulares usted mismo. Esta tabla le permite consultar una variable de entrada (por ejemplo, {{Ruta de la página}}) frente a varias expresiones regulares (filas). Si se realiza una coincidencia, se devuelve algún valor. Entonces, es esencialmente una variación de la tabla de búsqueda, pero con expresiones regulares en lugar de búsquedas de coincidencias exactas.


incógnita


El boletín a fuego lento

Suscríbete al Boletín a fuego lento para recibir las últimas noticias y contenido de Simo Ahava en su bandeja de entrada de correo electrónico.

¡Búscalo!

Aunque soy producto del insuperable sistema educativo finlandés, soy un desastre en ornitología. Así que me disculparán por la siguiente y torpe metáfora.

Consideremos la paloma mensajera. Tiene un conocimiento íntimo de un lugar y vuela a ese lugar. Si no hay nada allí, se confunde y hace caca. Si encuentra un destinatario o un mensaje, hace lo suyo y arrulla felizmente.

Bueno, cuando tienes una tabla de búsqueda, es lo mismo. Utilice una referencia de variable para señalar una celda específica en una tabla. Si esta celda existe, se devuelve cualquier valor almacenado en ella. Si la celda no existe, el script se confunde y muestra un mensaje indefinido o un error.

Esto es lo que hace que las tablas de búsqueda sean tan increíblemente eficientes. Todo está basado en lógica binaria.

No hay operaciones complejas ni predicados que evaluar. Es sólo una cuestión de “¿la tabla X tiene un valor bajo la etiqueta Y?”.

En JavaScript, una tabla de búsqueda puede ser un objeto easy (el más común), una matriz o incluso una cadena. Básicamente, puede ser cualquier estructura related a una matriz.

Si utiliza un objeto easy como tabla de búsqueda, es común llamarlo matriz asociativa o un tabla hashpero aquí las llamaremos tablas de búsqueda para mayor claridad.

Por lo tanto, puede realizar búsquedas en todas las estructuras tipo matriz. Los tres ejemplos enumerados anteriormente se pueden utilizar para búsquedas como esta:

// Plain object
var newValue = objectTable('key');
// Array
var anotherValue = arrayTable(3);
// String
var newestValue = 'String'(5);

Con el objeto easy, también puedes usar la notación de puntos en algunos casos.

Como puede ver, está solicitando directamente un valor específicamente etiquetado en la tabla y, si existe, se le devuelve sin realizar más operaciones.

Ahora, si introdujeras la lógica de predicados en la mezcla, con algo como desk('(Kk)ey') (ejemplo ficticio), significaría que la búsqueda debería verificar cada celda hasta que se haga una coincidencia en la tabla para ver si tienen ‘Clave’ o ‘clave’ como etiqueta.

Esto se debe a que con las estructuras de datos de JavaScript, una etiqueta solo puede ser una cosa. Con las tablas de búsqueda, solicita una etiqueta determinada sin variaciones, por ejemplo, ‘Clave’, y solo esa etiqueta se consulta así en la tabla. Esto se debe a que la lógica de programación dicta que solo puede existir una celda en la tabla con esa etiqueta.

Tan pronto como agrega lógica de predicado a la mezcla, obliga a la búsqueda a verificar cada celda hasta que se logra una coincidencia, porque no puede etiquetar celdas con expresiones regulares o valores dinámicos (por ejemplo, ‘Clave/clave’).

La diferencia entre la verificación binaria de la búsqueda y el recorrido de una operación más compleja se vuelve más clara cuando se piensa en términos de rendimiento.

Se cube que las consultas en una tabla de búsqueda funcionan en tiempo constante. Dado que estás consultando una etiqueta específica en una tabla de tamaño arbitrario, la complejidad de la operación siempre será la misma. O la etiqueta existe o no. La mesa puede ser enorme o minúscula, el rendimiento es siempre el mismo.

El rendimiento suele indicarse con O grande notación. La notación para tiempo constante (es decir, la búsqueda) sería O(1).

Al utilizar la lógica de predicados, se logra O(1) solo si coincide la consulta con la primera celda marcada. Cada celda posterior que se verifica para detectar una coincidencia incurre en una disminución lineal en el rendimiento. Por lo tanto, se cube que la lógica de comparación funciona en tiempo lineal.

Describir operaciones de tiempo lineal con O(1) sería bastante optimista. Por esta razón, la notación O grande tiende a describir el peor de los casos. El peor de los casos de tiempo lineal sería que el valor esté en la última celda que se consulta. Por tanto, la notación sería En)dónde norte es el número de celdas de la tabla.

Esto también significa que cuanto más grande sea la mesa, más cara será la operación en términos de rendimiento.

Con tablas pequeñas, esta diferencia es bastante trivial, pero con tablas grandes y multitudes de variables encadenadas, el impacto en el rendimiento puede ser significativo, especialmente si lleva tiempo hacer la coincidencia y las etiquetas son lo suficientemente arbitrarias como para que no se puedan usar datos facilitadores. estructuras o algoritmos de búsqueda.

Entonces, si le preocupa el rendimiento, y debería estarlo si se trata de una página net, utilice siempre la variable Tabla de búsqueda.

Tabla de búsqueda de expresiones regulares con JavaScript personalizado

Bueno, sé que no estás satisfecho con mi explicación y todavía anhelas una forma más versatile de obtener valores de una tabla.

Espero que los desarrolladores de GTM, en algún momento, introduzcan otro tipo de variable que sea esencialmente una tabla de búsqueda, pero donde se pueda especificar la lógica de predicado utilizada fila por fila.

Hasta entonces, puede conformarse con soluciones como la siguiente secuencia de comandos.

Copie el siguiente código en una nueva variable JavaScript personalizada:

perform() {
    // Set inputVariable to the enter you wish to assess
    var inputVariable = {{Web page URL}};

    // Set defaultVal to what you wish to return if no match is made
    var defaultVal = undefined;
    
    // Add rows as two-cell Arrays inside the Array 'desk'.
    // The primary cell comprises the RegExp you wish to match
    // the inputVariable with, the second cell comprises the
    // return worth if a match is made. The third cell (optionally available),
    // comprises any RegEx flags you wish to use. 
    //
    // The return worth will be one other GTM variable or any 
    // supported JavaScript kind.
    //
    // Bear in mind, no comma after the final row within the desk Array,
    // and keep in mind to double escape reserved characters: ?
    var desk = (
        ('/house/?$', 'House Web page'), // Row 1
        ('?location=', 'Contact Us Web page'), // Row 2
        ('/merchandise/(123)(0-9)', 'Merchandise 10-39', 'i') // Row n (final)
    );
    
    // Undergo all of the rows within the desk, do the checks,
    // and return the return worth of the FIRST profitable
    // match.
    for (var i = 0, len = desk.size; i < len; i += 1) {
        var regex = new RegExp(desk(i)(0), desk(i)(2));
        if (regex.check(inputVariable)) {
            return desk(i)(1);
        }
    }
    return defaultVal;
}

Así es como funciona la variable:

  1. Primero, le das la entrada: alguna variable o valor que quieras evaluar en las filas de la tabla.

  2. A continuación, insertas las filas.

  3. Las filas son en realidad matrices dentro del desk Formación

1. The primary cell comprises the common expression you wish to consider towards the enter (word, you will want to _double_ escape reserved characters!)

2. The second cell comprises the worth that's returned if a match is made

3. The third cell is optionally available, and might include any common expression flags (e.g. 'g', 'i') you may wish to use
  1. Finalmente, hay un pequeño bucle que recorre cada fila del desk Matriz, comparando la expresión common con la variable de entrada. Si se realiza una coincidencia, la función devuelve el valor de retorno especificado.

  2. Si no se realiza ninguna coincidencia, se devuelve el valor predeterminado especificado

Recuerde editar las filas para que coincidan con su tabla. Dado que es JavaScript de texto sin formato, también puede crear la tabla en Excel (formateándola con corchetes y todo) y luego simplemente copiarla y pegarla como texto sin formato en el cuerpo de la macro de JavaScript.

Resumen

Como siempre, esta solución es primero educativa, luego una prueba de concepto y, por último, una solución alternativa utilizable y lista para usar. Así que siéntete libre de modificarlo según tus propios fines o simplemente deshacerte de él por completo.

La conclusión clave de este artículo debería ser comprender cómo funcionan las tablas de búsqueda y cuánto más complicadas se volverían si también se introdujera la lógica operativa. Por esa razón, mi solicitud de función sigue siendo que la tabla de búsqueda se mantenga como está, pero se introducirá un nuevo tipo de variable, donde se puede especificar la operación fila por fila. De esta manera todos ganan.

Por cierto, si estás interesado en el rendimiento, JavaScript y otras estructuras de datos y algoritmos de búsqueda, echa un vistazo a este libro:

Michael McMillan: estructuras de datos y algoritmos con JavaScript

El libro tiene los conceptos básicos muy bien resumidos. El siguiente paso sería adquirir un libro sobre patrones de diseño y estructuras de datos más complejas. Es todo muy educativo.

Related Post

Leave a Reply

Your email address will not be published. Required fields are marked *