Se você já se perguntou por que raios pessoas usam emojis como nomes de [tags](https://metricasboss.com.br/artigos/dissecando-o-google-tag-manager-tags), variáveis e acionadores no Google Tag Manager e por que isso pode gerar problemas técnicos significativos (e não apenas uma questão de preferência estética), vamos entender isso a fundo.

### Por que as pessoas usam emojis no GTM?

Ao perguntar na comunidade da Métricas Boss, descobri que os principais motivos são:

1. **Organização visual**: "Eu utilizo porque facilita a identificação das tags, acionadores e variáveis. Tenho um modelo padrão, tudo que for laranja é GA4, tudo que for azul é Facebook e amarelo uso para o Google Ads."

2. **Navegação rápida**: "Eu usaria para direcionar melhor a visão, como se fosse as pastas."

Embora esses argumentos pareçam fazer sentido do ponto de vista da experiência do usuário, vamos entender por que tecnicamente essa não é uma boa prática.

## O que é Unicode (Sem Enrolação)

[Unicode](https://www.devlingo.com.br/termos/unicode) é um padrão que atribui um código numérico único para cada caractere, independente da plataforma, programa ou idioma. Antes do Unicode, tínhamos vários padrões de codificação diferentes (ASCII, ISO-8859, etc) que não conseguiam representar todos os caracteres de todos os idiomas ao mesmo tempo - e muito menos emojis.

O Unicode resolve isso com um espaço de código enorme: capacidade para mais de 1 milhão de caracteres diferentes, onde cada um tem um "code point" único, geralmente representado como U+XXXX (um número hexadecimal).

## Como o JavaScript Lida com Unicode (e Porque Isso Importa)

JavaScript utiliza [UTF-16](https://www.devlingo.com.br/termos/utf-16) para representar strings internamente. Isso é fundamental de entender quando lidamos com emojis, porque aqui está o primeiro problema técnico:

```javascript
// Alguns emojis ocupam 2 unidades de código (surrogate pairs)
const emoji = '🚀';
console.log(emoji.length); // Retorna 2, não 1!
```

Emojis mais complexos podem ocupar até 4 unidades de código (dois "surrogate pairs"):

```javascript
const emojiComplexa = '👨‍👩‍👧‍👦';
console.log(emojiComplexa.length); // Retorna 11 (!!)
```

Isso significa que operações simples como `substring()`, `charAt()` e até mesmo o acesso por índice `string[i]` podem quebrar quando lidam com emojis, potencialmente corrompendo o valor.

## Implicações Práticas no GTM

Quando você usa emojis no Google Tag Manager, está essencialmente criando uma bomba-relógio para diversos problemas:

### 1. Falhas de [Serialização/Deserialização](https://metricasboss.com.br/artigos/como-evitar-problemas-de-performance-e-recursividade-em-tags-do-google-tag-manager)

O GTM armazena e transmite dados no formato [JSON](https://www.devlingo.com.br/termos/json). Quando emojis são incluídos, podem ocorrer problemas durante a serialização e deserialização:

```javascript
// O que acontece por baixo dos panos quando o GTM processa dados
try {
  const tagConfig = JSON.parse(tagConfigString);
  // Se o emoji quebrar aqui, sua tag simplesmente para de funcionar
} catch (e) {
  console.error("Falha ao processar configuração da tag");
}
```

### 2. Manipulação Incorreta de Strings

Dentro de [variáveis customizadas JavaScript](https://metricasboss.com.br/artigos/como-funciona-as-variaveis-no-google-tag-manager) no GTM:

```javascript
function getEmojiTagValue(tagName) {
  // Tentativa de buscar o valor de uma tag usando um emoji no nome
  // Se o emoji for processado incorretamente, isso retornará undefined
  return getTagValue(tagName);
}
```

### 3. Problemas de Regex

[Regex](https://www.devlingo.com.br/termos/regex) no JavaScript não lida bem com caracteres Unicode mais complexos:

```javascript
// Tentativa de validar string que contém emoji
const regexPattern = /^[A-Za-z0-9_\-🚀]+$/;  // Isso pode não funcionar como esperado
```

### 4. Inconsistências de Rendering

Como mencionado, o mesmo emoji pode ter aparências drasticamente diferentes em sistemas operacionais e navegadores diferentes:

```javascript
// O que você vê:
// Windows 11: 🙂 (Aparência Windows)
// macOS: 🙂 (Aparência Apple)
// Android: 🙂 (Aparência Google)
```

Isso torna a colaboração em equipe um pesadelo, especialmente em empresas que usam diferentes sistemas operacionais.

## A Questão de [Desempenho](https://metricasboss.com.br/artigos/google-tag-manager-vai-deixar-o-meu-site-lento)

Comparado com caracteres ASCII simples, processar emojis é mais intensivo computacionalmente:

```javascript
// Teste simples de desempenho
console.time('ascii');
let asciiStr = '';
for (let i = 0; i < 100000; i++) {
  asciiStr += 'a';
}
console.timeEnd('ascii');

console.time('emoji');
let emojiStr = '';
for (let i = 0; i < 100000; i++) {
  emojiStr += '🚀';
}
console.timeEnd('emoji');
// O processamento de emoji é consistentemente mais lento
```

Em um cenário onde o GTM precisa processar múltiplas tags rapidamente, isso pode contribuir para uma degradação de desempenho.

## Alternativas Sólidas

Em vez de usar emojis, adote convenções de nomenclatura profissionais:

```javascript
// Ruim
const 🚀_event = 'purchase';

// Bom
const PURCHASE_EVENT = 'purchase';
// ou
const purchaseEvent = 'purchase';
```

## Alternativas Melhores para Organização Visual

Entendo que a motivação principal para usar emojis é organização visual e facilidade de identificação. Felizmente, existem alternativas melhores e tecnicamente seguras:

1. **Prefixos consistentes**: Use prefixos padronizados como `GA4_`, `FB_`, `GADS_` para identificar facilmente a que plataforma pertence cada tag.

2. **[Estrutura de pastas do GTM](https://metricasboss.com.br/artigos/google-tag-manager-guia-para-iniciantes)**: Utilize a funcionalidade nativa de pastas do GTM para organizar suas tags, acionadores e variáveis por plataforma ou funcionalidade.

3. **Esquema de nomenclatura**: Desenvolva um esquema de nomenclatura claro e consistente, como:
   ```
   [Plataforma]_[Tipo]_[Função]
   ```
   Exemplo: `GA4_EV_Compra_Concluida` é muito mais seguro e tão claro quanto usar um emoji.

4. **Tags de cores no nível de documentação**: Mantenha um documento de referência com um esquema de cores para as diferentes plataformas, em vez de incorporar isso diretamente nos nomes.

Emojis no código não são apenas uma "preferência estética" - são uma decisão técnica que pode ter consequências reais. No contexto do [GTM](https://metricasboss.com.br/artigos/o-que-e-google-tag-manager), onde estabilidade, desempenho e colaboração são essenciais, é recomendável evitá-los.

Os benefícios aparentes de organização visual não superam os riscos técnicos potenciais. Se quiser trabalhar profissionalmente com GTM, adote práticas de nomenclatura padronizadas.

Se você ainda prefere usar emojis nos seus contêineres do GTM, lembre-se que isso pode colocar em risco a integridade da sua implementação de analytics e, potencialmente, criar horas de debugging desnecessário para você mesmo e sua equipe no futuro.

O código limpo não é apenas sobre estética - é sobre engenharia sólida que resiste ao teste do tempo.


Se você já se perguntou por que raios pessoas usam emojis como nomes de tags, variáveis e acionadores no Google Tag Manager e por que isso pode gerar problemas técnicos significativos (e não apenas uma questão de preferência estética), vamos entender isso a fundo.

thumbnail_image.png

image.png

Por que não devemos usar emojis no Google Tag Manager: Análise técnica

A Métricas Boss é uma agência de Web Analytics e usabilidade. Conte com uma empresa certificada Google Analytics para sua gestão de web analytics.

O que você irá aprender?