> For the complete documentation index, see [llms.txt](https://doc.commandersact.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://doc.commandersact.com/fr/fonctionnalites/sources/sources-catalog/web/containers/best-practices/tc.-attributes-and-methods.md).

# Attributs et méthodes tC.\*

*Les méthodes “tC.” sont **avec espace de noms\*** . Elles sont très utiles lorsqu’il faut effectuer des actions techniquement avancées, comme afficher dans la console du navigateur le tableau des tags lancés au sein d’un conteneur. Veuillez noter que la disponibilité et le comportement de ces fonctions dépendent de plusieurs éléments, comme la configuration de votre conteneur, entre autres. Tapez simplement “tC.” dans la console de votre navigateur et la liste des fonctions disponibles sur un site donné et pour un conteneur donné s’affichera.*

*\* “**espace de noms** est une technique utilisée pour éviter les collisions avec d’autres objets ou variables dans le **espace de noms**. Elles sont aussi extrêmement utiles pour aider à organiser des blocs de fonctionnalité dans votre application en groupes facilement gérables qui peuvent être identifiés de manière unique.”*

| *tC.\_R*                                                                     | *Objet interne utilisé pour les statistiques*                                                                                                                                                                                                                                                                                                                                                      |
| ---------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| *tC.ams*                                                                     | *Objet interne utilisé pour le produit Measure*                                                                                                                                                                                                                                                                                                                                                    |
| *tC.array\_launched\_tags*                                                   | *Affiche une liste de tags dans la version du conteneur publiée. Si vous utilisez l’un de nos outils de test (Bookmarklet ou extension Chrome TagAssistant) et simulez la présence d’une autre version de conteneur, la fonction affichera les tags dans la version de conteneur qui est testée*                                                                                                   |
| *tC.array\_launched\_tags\_keys*                                             | *Affiche une liste d’identifiants de tag correspondant aux tags dans la version du conteneur publiée ou testée*                                                                                                                                                                                                                                                                                    |
| *tC.call*                                                                    | *Fonction interne utilisée pour les callbacks*                                                                                                                                                                                                                                                                                                                                                     |
| *tC.containerVersion*                                                        | *Affiche le numéro de version du conteneur publié ou testé*                                                                                                                                                                                                                                                                                                                                        |
|                                                                              |                                                                                                                                                                                                                                                                                                                                                                                                    |
| *tC.containersLaunched*                                                      | *Affiche un objet JavaScript contenant d’autres objets. Ces derniers correspondent aux conteneurs lancés sur une page donnée et fournissent des informations à leur sujet ainsi que sur les tags qu’ils contiennent (id, name)*                                                                                                                                                                    |
| *tC.dedup*                                                                   | <p><em>LA DÉDUPLICATION DOIT ÊTRE ACTIVÉE POUR QUE CETTE FONCTION FONCTIONNE</em></p><p><em>Affiche un objet JavaScript contenant tous les canaux et sources définis et indiquant s’ils sont actifs ou non</em></p>                                                                                                                                                                                |
| *tC.dedup\_done*                                                             | <p><em>LA DÉDUPLICATION DOIT ÊTRE ACTIVÉE</em> POUR QUE CETTE FONCTION FONCTIONNE</p><p><em>Affiche si le module de déduplication est activé ou désactivé sur un site donné</em></p>                                                                                                                                                                                                               |
| *tC.dedup.cj*                                                                | <p><em>LA DÉDUPLICATION DOIT ÊTRE ACTIVÉE</em> POUR QUE CETTE FONCTION FONCTIONNE</p><p><em>Affiche les 10 derniers touchpoints dans le customer journey d’un utilisateur. Ils sont collectés avec des cookies customer journey (CJ). Vous pouvez ajuster le nombre de touchpoints dans l’interface. Pour ce faire, veuillez aller dans l’onglet Options > Channel and sources definition</em></p> |
| *tC.dedup.LeA*                                                               | <p><em>LA DÉDUPLICATION DOIT ÊTRE ACTIVÉE</em> POUR QUE CETTE FONCTION FONCTIONNE</p><p><em>Affiche le dernier canal reconnu dans le customer journey</em></p>                                                                                                                                                                                                                                     |
| *tC.dedup.LeAD*                                                              | <p><em>LA DÉDUPLICATION DOIT ÊTRE ACTIVÉE</em> POUR QUE CETTE FONCTION FONCTIONNE</p><p><em>Affiche la source associée au dernier canal reconnu dans le cookie de customer journey</em></p>                                                                                                                                                                                                        |
| *tC.dedup.LeC*                                                               | <p><em>LA DÉDUPLICATION DOIT ÊTRE ACTIVÉE</em> POUR QUE CETTE FONCTION FONCTIONNE</p><p><em>Affiche le dernier canal reconnu – lié aux clics – dans le cookie de customer journey</em></p>                                                                                                                                                                                                         |
| *tC.dedup.LeCD*                                                              | <p><em>LA DÉDUPLICATION DOIT ÊTRE ACTIVÉE</em> POUR QUE CETTE FONCTION FONCTIONNE</p><p><em>Affiche la source associée au dernier canal reconnu – associé aux clics – dans le cookie de customer journey</em></p>                                                                                                                                                                                  |
| *tC.dedup.LeV*                                                               | <p><em>LA DÉDUPLICATION DOIT ÊTRE ACTIVÉE</em> POUR QUE CETTE FONCTION FONCTIONNE</p><p><em>Affiche le dernier canal reconnu – lié aux vues – dans le cookie de customer journey</em></p>                                                                                                                                                                                                          |
| *tC.dedup.LeVD*                                                              | <p><em>LA DÉDUPLICATION DOIT ÊTRE ACTIVÉE</em> POUR QUE CETTE FONCTION FONCTIONNE</p><p><em>Affiche la source associée au dernier canal reconnu – liée aux vues – dans le cookie de customer journey</em></p>                                                                                                                                                                                      |
| *tC.dedup.FeC*                                                               | <p><em>LA DÉDUPLICATION DOIT ÊTRE ACTIVÉE</em> POUR QUE CETTE FONCTION FONCTIONNE</p><p><em>Affiche le premier canal reconnu – lié aux clics – dans le customer journey</em></p>                                                                                                                                                                                                                   |
| *tC.dedup.FeCD*                                                              | <p><em>LA DÉDUPLICATION DOIT ÊTRE ACTIVE POUR QUE CETTE FONCTION FONCTIONNE</em></p><p><em>Affiche la source associée au premier canal reconnu – lié aux clics – dans le cookie de customer journey</em></p>                                                                                                                                                                                       |
| *tC.dedup.FeV*                                                               | <p><em>LA DÉDUPLICATION DOIT ÊTRE ACTIVÉE</em> POUR QUE CETTE FONCTION FONCTIONNE</p><p><em>Affiche la source associée au premier canal reconnu – lié aux vues – dans le cookie de customer journey</em></p>                                                                                                                                                                                       |
| *tC.dedup.FeVD*                                                              | <p><em>LA DÉDUPLICATION DOIT ÊTRE ACTIVÉE</em> POUR QUE CETTE FONCTION FONCTIONNE</p><p><em>Affiche la source associée au premier canal reconnu – liée aux vues – dans le cookie de customer journey</em></p>                                                                                                                                                                                      |
| *tC.dedup.AeA*                                                               | <p><em>LA DÉDUPLICATION DOIT ÊTRE ACTIVÉE</em> POUR QUE CETTE FONCTION FONCTIONNE</p><p><em>Affiche les canaux reconnus à mi-parcours du customer journey</em></p>                                                                                                                                                                                                                                 |
| *tC.dedup.AeC*                                                               | <p><em>LA DÉDUPLICATION DOIT ÊTRE ACTIVÉE</em> POUR QUE CETTE FONCTION FONCTIONNE</p><p><em>Affiche les canaux reconnus à mi-parcours du customer journey (pour les clics)</em></p>                                                                                                                                                                                                                |
| *tC.dedup.AeV*                                                               | <p><em>LA DÉDUPLICATION DOIT ÊTRE ACTIVÉE</em> POUR QUE CETTE FONCTION FONCTIONNE</p><p><em>Affiche les canaux reconnus à mi-parcours du customer journey (pour les vues)</em></p>                                                                                                                                                                                                                 |
| *tC.domReady*                                                                | *Affiche si tout le contenu du Document Object Model (DOM) a terminé le chargement ou non (c.-à-d. les conteneurs)*                                                                                                                                                                                                                                                                                |
| *tC.domain*                                                                  | *Renvoie le domaine de la page (par exemple .tagcommander.com)*                                                                                                                                                                                                                                                                                                                                    |
| *tC.each*                                                                    | *Itérateur interne*                                                                                                                                                                                                                                                                                                                                                                                |
| *tC.generatorVersion*                                                        | *Affiche la version du moteur de génération du conteneur*                                                                                                                                                                                                                                                                                                                                          |
| *tC.getCookie*                                                               | *Affiche la valeur d’un cookie donné. Vous devez écrire la fonction et le nom du cookie à côté, entre parenthèses et guillemets : tC.getCookie(“nom du cookie”).*                                                                                                                                                                                                                                  |
| *tC.getParamURL*                                                             | *Affiche un paramètre donné de l’URL de la page*                                                                                                                                                                                                                                                                                                                                                   |
| *tC.hitCounter*                                                              | *Fonction interne utilisée pour obtenir des statistiques liées aux hits de facturation*                                                                                                                                                                                                                                                                                                            |
| *tC.id\_container*                                                           | *Affiche l’ID du conteneur*                                                                                                                                                                                                                                                                                                                                                                        |
| *tC.id\_site*                                                                | *Affiche l’ID du site TagCommander*                                                                                                                                                                                                                                                                                                                                                                |
| *tC.inArray*                                                                 | *Fonction interne permettant de vérifier si un élément se trouve dans un tableau*                                                                                                                                                                                                                                                                                                                  |
| *tC.inclusion\_oct\_1*                                                       | *Spécifique à chaque conteneur (inclusion JS)*                                                                                                                                                                                                                                                                                                                                                     |
| *tC.internalFunctions*                                                       | *Espace de noms pour les fonctions internes de TagCommander*                                                                                                                                                                                                                                                                                                                                       |
| *tC.internalvars*                                                            | *Espace de noms pour les variables internes de TagCommander*                                                                                                                                                                                                                                                                                                                                       |
| *tC.isArray*                                                                 | *Méthode permettant de vérifier si une variable se trouve dans un tableau*                                                                                                                                                                                                                                                                                                                         |
| *tC.isCurrentVersion*                                                        | *Confirme si la version actuellement déployée dans l’interface est la version actuelle sur le site*                                                                                                                                                                                                                                                                                                |
| *tC.isDOMReady*                                                              | *Confirme si le Document Object Model (DOM) est prêt*                                                                                                                                                                                                                                                                                                                                              |
| *tC.isFunction*                                                              | *Méthode permettant de vérifier si le type d’une variable est une fonction*                                                                                                                                                                                                                                                                                                                        |
| *tC.isNumeric*                                                               | *Méthode permettant de vérifier si la valeur d’une variable est un nombre*                                                                                                                                                                                                                                                                                                                         |
| *tC.isPrototypeOf*                                                           | *Méthode permettant de vérifier si une variable est un prototype*                                                                                                                                                                                                                                                                                                                                  |
| *tC.isWindow*                                                                | *Méthode permettant de vérifier si une variable est window*                                                                                                                                                                                                                                                                                                                                        |
| *tC.launchTag*                                                               | *Méthode interne utilisée pour l’extension Google Chrome de TagCommander*                                                                                                                                                                                                                                                                                                                          |
| *tC.length*                                                                  | *Variable interne*                                                                                                                                                                                                                                                                                                                                                                                 |
| *tC.log*                                                                     | *Méthode remplaçant la commande console.log()*                                                                                                                                                                                                                                                                                                                                                     |
| *tC.maindomain*                                                              | *Affiche le domaine principal sur lequel les conteneurs sont déployés*                                                                                                                                                                                                                                                                                                                             |
| *tC.name*                                                                    | *Affiche un “c” pour conteneur*                                                                                                                                                                                                                                                                                                                                                                    |
| *tC.nodeNames*                                                               | *Affiche la liste des éléments du Document Object Model (DOM)*                                                                                                                                                                                                                                                                                                                                     |
| *tC.onDomReady*                                                              | *Méthode permettant d’exécuter du code lors de l’événement Dom Ready*                                                                                                                                                                                                                                                                                                                              |
| *tC.pixelTrack*                                                              | *Méthode interne injectant des pixels*                                                                                                                                                                                                                                                                                                                                                             |
| *tC.privacy*                                                                 | *Espace de noms pour les variables liées au module Privacy*                                                                                                                                                                                                                                                                                                                                        |
| *tC.privacyVersion*                                                          | *Affiche le numéro de version de la bannière et des paramètres Privacy publiés*                                                                                                                                                                                                                                                                                                                    |
| *tC.rchecked*                                                                | *Variable interne stockant une regexp*                                                                                                                                                                                                                                                                                                                                                             |
| *tC.removeCookie*                                                            | *Cette fonction vous permet de supprimer un cookie. Vous devez écrire la fonction et le nom du cookie à côté, entre parenthèses et guillemets : tC.removeCookie(“nom du cookie”)*                                                                                                                                                                                                                  |
| *tC.script*                                                                  | *Renvoie un objet JavaScript que vous pouvez « déplier » pour trouver l’emplacement du conteneur (lien vers le script)*                                                                                                                                                                                                                                                                            |
| *tC.setCookie*                                                               | <p><em>Cette fonction vous permet de créer un cookie.</em><br><em>Voici l’interface de la fonction :  tC.setCookie(name, value, lifetime, path, domain, secure, sameSite).</em><br><em>Ex. : tC.setCookie(“My\_cookie”, “1”, 365,”/”,”.mysite.com”, true, "Lax")</em></p>                                                                                                                          |
| *tC.ssl*                                                                     | *Affiche le certificat SSL : indique si le protocole de la page est https ou http*                                                                                                                                                                                                                                                                                                                 |
| *tC.tagPatterns*                                                             | *Variable interne contenant les expressions régulières (patterns) permettant de détecter les hits des tags pour le module TagPerformance*                                                                                                                                                                                                                                                          |
| *tC.tagPerf*                                                                 | *Variable interne pour le module TagPerformance*                                                                                                                                                                                                                                                                                                                                                   |
| *tC.tagPerfAnalyzer*                                                         | *Fonction interne qui analyse une page pour calculer le temps de réponse des tags (pour le module TagPerformance)*                                                                                                                                                                                                                                                                                 |
| *tC.tagPerfE*                                                                | *Variable encore inutilisée qui contrôle les taux d’échantillonnage des appels de TagPerformance*                                                                                                                                                                                                                                                                                                  |
| *tC.script.add(location.protocol + “//manager.tagcommander.com/utils/IP/”);* | *Cette fonction vous permet de récupérer l’adresse IP*                                                                                                                                                                                                                                                                                                                                             |


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://doc.commandersact.com/fr/fonctionnalites/sources/sources-catalog/web/containers/best-practices/tc.-attributes-and-methods.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.