> 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 **encapsulées dans un espace de noms\*** . Elles sont utiles pour effectuer des opérations techniquement avancées, comme afficher dans la console du navigateur le tableau des tags lancés dans un conteneur. Veuillez noter que la disponibilité et le comportement de ces fonctions dépendent de plusieurs éléments, notamment de la configuration de votre conteneur. Saisissez simplement « tC. » dans la console de votre navigateur pour afficher la liste des fonctions disponibles sur un site donné et pour un conteneur donné.*

*\* Le «**namespacing** est une technique utilisée pour éviter les conflits avec d’autres objets ou variables dans l’espace de noms global. Elle permet également d’organiser des blocs de fonctionnalités de votre application en groupes faciles à gérer et pouvant être identifiés de manière unique. » **espace de noms**. Ils sont également très utiles pour organiser les blocs de fonctionnalités de votre application en groupes faciles à gérer et pouvant ê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 des tags du conteneur publié. Si vous utilisez l’un de nos outils de test (Bookmarklet ou extension Chrome TagAssistant) et simulez la présence d’une autre version du conteneur, la fonction affichera les tags de la version du conteneur testée*                                                                                                                 |
| *tC.array\_launched\_tags\_keys*                                             | *Affiche une liste des identifiants de tags correspondant aux tags du conteneur publié ou en cours de test*                                                                                                                                                                                                                                                                            |
| *tC.call*                                                                    | *Fonction interne utilisée pour les callbacks*                                                                                                                                                                                                                                                                                                                                         |
| *tC.clear*                                                                   | *Méthode qui remplace la commande console.clear()*                                                                                                                                                                                                                                                                                                                                     |
| *tC.containerVersion*                                                        | *Affiche le numéro de version du conteneur publié ou en cours de 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, nom)*                                                                                                                                                         |
| *tC.debug*                                                                   | *Méthode qui remplace la commande console.debug()*                                                                                                                                                                                                                                                                                                                                     |
| *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>Indique 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 du Customer journey d’un utilisateur. Ils sont collectés à l’aide des cookies de Customer journey (CJ). Vous pouvez ajuster le nombre de Touchpoints dans l’interface. Pour cela, accédez à 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 associé 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 lié 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 associé 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é 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 associé aux clics dans le Customer journey</em></p>                                                                                                                                                                                                       |
| *tC.dedup.FeCD*                                                              | <p><em>LA DÉDUPLICATION DOIT ÊTRE ACTIVE POUR QUE CETTE FONCTIONNALITÉ FONCTIONNE</em></p><p><em>Affiche la source associée au premier canal reconnu — lié aux clics — dans le cookie 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 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é aux vues — dans le cookie 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.dir*                                                                     | *affiche une liste des propriétés de l’objet JavaScript spécifié (remplace console.dir)*                                                                                                                                                                                                                                                                                               |
| *tC.domReady*                                                                | *Indique si le chargement de tout le contenu du Document Object Model (DOM) est terminé ou non (c’est-à-dire les conteneurs)*                                                                                                                                                                                                                                                          |
| *tC.domain*                                                                  | *Renvoie le domaine de la page (par exemple, .tagcommander.com)*                                                                                                                                                                                                                                                                                                                       |
| *tC.each*                                                                    | *Itérateur interne*                                                                                                                                                                                                                                                                                                                                                                    |
| *tC.error*                                                                   | *Méthode qui remplace la commande console.error()*                                                                                                                                                                                                                                                                                                                                     |
| *tC.generatorVersion*                                                        | *Affiche la version du moteur de génération des conteneurs*                                                                                                                                                                                                                                                                                                                            |
| *tC.getCookie*                                                               | *Affiche la valeur d’un cookie donné. Vous devez écrire la fonction, puis le nom du cookie entre parenthèses et entre 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 à la facturation des hits*                                                                                                                                                                                                                                                                                              |
| *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 des fonctions internes de TagCommander*                                                                                                                                                                                                                                                                                                                                |
| *tC.info*                                                                    | *Méthode qui remplace la commande console.info()*                                                                                                                                                                                                                                                                                                                                      |
| *tC.internalvars*                                                            | *Espace de noms des variables internes de TagCommander*                                                                                                                                                                                                                                                                                                                                |
| *tC.isArray*                                                                 | *Méthode permettant de vérifier si une variable se trouve dans un tableau*                                                                                                                                                                                                                                                                                                             |
| *tC.isCurrentVersion*                                                        | *Confirme que la version actuellement déployée dans l’interface est bien la version en cours sur le site*                                                                                                                                                                                                                                                                              |
| *tC.isDOMReady*                                                              | *Confirme que 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 une fenêtre*                                                                                                                                                                                                                                                                                                                       |
| *tC.launchTag*                                                               | *Méthode interne utilisée par 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 Privacy et des paramètres publiés*                                                                                                                                                                                                                                                                                                        |
| *tC.rchecked*                                                                | *Variable interne stockant une expression régulière*                                                                                                                                                                                                                                                                                                                                   |
| *tC.removeCookie*                                                            | *Cette fonction permet de supprimer un cookie. Vous devez écrire la fonction suivie du nom du cookie entre parenthèses et guillemets : tC.removeCookie(“cookie’s name”)*                                                                                                                                                                                                               |
| *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 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 du 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.trace*                                                                   | *Méthode remplaçant la commande console.trace()*                                                                                                                                                                                                                                                                                                                                       |
| *tC.script.add(location.protocol + “//manager.tagcommander.com/utils/IP/”);* | *Cette fonction permet de récupérer l’adresse IP*                                                                                                                                                                                                                                                                                                                                      |
| tC.warn                                                                      | *Méthode remplaçant la commande console.warn()*                                                                                                                                                                                                                                                                                                                                        |


---

# 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 by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

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

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

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.
