> 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 **namespaced\*** . Elles sont très utiles lorsqu’il faut effectuer des actions techniquement avancées, comme afficher le tableau des tag lancés dans un container dans la console du navigateur. Veuillez noter que la disponibilité et le comportement de ces fonctions dépendent de plusieurs éléments, comme la configuration de votre container, entre autres. Tapez simplement « tC. » dans la console de votre navigateur et la liste des fonctions disponibles sur un site donné et pour un container donné apparaîtra.*

*\* “**namespacing** est une technique utilisée pour éviter les collisions avec d’autres objets ou variables dans l’espace de noms global **espace de noms**. Elles sont également extrêmement utiles pour aider à organiser les blocs de fonctionnalités de votre application en समूहes facilement gérables 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 la liste des tag présents dans la version du container 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 du container, la fonction affichera les tag présents dans la version du container qui est testée*                                                                               |
| *tC.array\_launched\_tags\_keys*                                             | *Affiche la liste des identifiants de tag correspondant aux tag présents dans la version du container publiée ou en cours de test*                                                                                                                                                                                                                                                             |
| *tC.call*                                                                    | *Fonction interne utilisée pour les callbacks*                                                                                                                                                                                                                                                                                                                                                 |
| *tC.containerVersion*                                                        | *Affiche le numéro de version du container qui est publié ou en cours de test*                                                                                                                                                                                                                                                                                                                 |
|                                                                              |                                                                                                                                                                                                                                                                                                                                                                                                |
| *tC.containersLaunched*                                                      | *Affiche un objet JavaScript contenant d’autres objets. Ces derniers correspondent aux containers lancés sur une page donnée et fournissent des informations à leur sujet ainsi qu’au sujet des tag 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 non 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 les cookies customer journey (CJ). Vous pouvez ajuster le nombre de touchpoints dans l’interface. Pour cela, 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 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 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 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 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 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 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.domReady*                                                                | *Affiche si tout le contenu du Document Object Model (DOM) a fini de se charger ou non (c.-à-d. les containers)*                                                                                                                                                                                                                                                                               |
| *tC.domain*                                                                  | *Renvoie le domaine de la page (.tagcommander.com par exemple)*                                                                                                                                                                                                                                                                                                                                |
| *tC.each*                                                                    | *Itérateur interne*                                                                                                                                                                                                                                                                                                                                                                            |
| *tC.generatorVersion*                                                        | *Affiche la version du moteur de génération du container*                                                                                                                                                                                                                                                                                                                                      |
| *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 les statistiques liées aux hits de facturation*                                                                                                                                                                                                                                                                                                        |
| *tC.id\_container*                                                           | *Affiche l’ID du container*                                                                                                                                                                                                                                                                                                                                                                    |
| *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 container (inclusion JS)*                                                                                                                                                                                                                                                                                                                                                 |
| *tC.internalFunctions*                                                       | *Espace de noms des fonctions internes de TagCommander*                                                                                                                                                                                                                                                                                                                                        |
| *tC.internalvars*                                                            | *Espace de noms des variables internes de TagCommander*                                                                                                                                                                                                                                                                                                                                        |
| *tC.isArray*                                                                 | *Méthode pour 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 pour vérifier si le type d’une variable est une fonction*                                                                                                                                                                                                                                                                                                                             |
| *tC.isNumeric*                                                               | *Méthode pour vérifier si la valeur d’une variable est un nombre*                                                                                                                                                                                                                                                                                                                              |
| *tC.isPrototypeOf*                                                           | *Méthode pour vérifier si une variable est un prototype*                                                                                                                                                                                                                                                                                                                                       |
| *tC.isWindow*                                                                | *Méthode pour 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 containers sont déployés*                                                                                                                                                                                                                                                                                                                         |
| *tC.name*                                                                    | *Affiche un « c » pour container*                                                                                                                                                                                                                                                                                                                                                              |
| *tC.nodeNames*                                                               | *Affiche la liste des éléments du Document Object Model (DOM)*                                                                                                                                                                                                                                                                                                                                 |
| *tC.onDomReady*                                                              | *Méthode pour exécuter du code lors de l’événement Dom Ready*                                                                                                                                                                                                                                                                                                                                  |
| *tC.pixelTrack*                                                              | *Méthode interne injectant des pixels*                                                                                                                                                                                                                                                                                                                                                         |
| *tC.privacy*                                                                 | *Espace de noms des 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 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 container (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 en https ou en http*                                                                                                                                                                                                                                                                                                       |
| *tC.tagPatterns*                                                             | *Variable interne contenant les regex (motifs) pour détecter les hits des tag pour le module TagPerformance*                                                                                                                                                                                                                                                                                   |
| *tC.tagPerf*                                                                 | *Variable interne du module TagPerformance*                                                                                                                                                                                                                                                                                                                                                    |
| *tC.tagPerfAnalyzer*                                                         | *Fonction interne qui analyse une page afin de calculer le temps de réponse des tag (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.