> 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 dans la console du navigateur le tableau des tags lancés dans un container. Veuillez noter que la disponibilité et le comportement de ces fonctions dépendent de plusieurs éléments, notamment de la configuration de votre container. Tapez simplement « tC. » dans la console de votre navigateur et la liste des fonctions disponibles pour un site donné et pour un container donné s’affichera.*

*\* « **namespacing** est une technique utilisée pour éviter les collisions avec d’autres objets ou variables dans le **namespace**global. Elles sont aussi extrêmement utiles pour aider à organiser des blocs de fonctionnalités dans votre application en groupes 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 une liste de tags 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 de container, la fonction affichera les tags de la version du container en cours de test*                                                                                          |
| *tC.array\_launched\_tags\_keys*                                             | *Affiche une liste des identifiants de tags correspondant aux tags de la version du container publiée ou en cours de test*                                                                                                                                                                                                                                                                |
| *tC.call*                                                                    | *Fonction interne utilisée pour les callbacks*                                                                                                                                                                                                                                                                                                                                            |
| *tC.clear*                                                                   | *Méthode remplaçant la commande console.clear()*                                                                                                                                                                                                                                                                                                                                          |
| *tC.containerVersion*                                                        | *Affiche le numéro de version du container 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 que sur les tags qu’ils contiennent (id, name)*                                                                                                                                                           |
| *tC.debug*                                                                   | *Méthode remplaçant 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 channels 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 du 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 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 channel 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 channel 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 channel 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 channel 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 channel 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 channel 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 channel 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 channel 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 channel 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 channel 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 channels 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 channels 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 channels reconnus à mi-parcours du customer journey (pour les vues)</em></p>                                                                                                                                                                                                      |
| *tC.dir*                                                                     | *affiche la liste des propriétés de l’objet JavaScript spécifié (remplace console.dir)*                                                                                                                                                                                                                                                                                                   |
| *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*                                                                  | *Retourne le domaine de la page (.tagcommander.com par exemple)*                                                                                                                                                                                                                                                                                                                          |
| *tC.each*                                                                    | *Itérateur interne*                                                                                                                                                                                                                                                                                                                                                                       |
| *tC.error*                                                                   | *Méthode remplaçant la commande console.error()*                                                                                                                                                                                                                                                                                                                                          |
| *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 entre guillemets : tC.getCookie(“cookie’s name”).*                                                                                                                                                                                                                   |
| *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 container*                                                                                                                                                                                                                                                                                                                                                               |
| *tC.id\_site*                                                                | *Affiche l’ID du site TagCommander*                                                                                                                                                                                                                                                                                                                                                       |
| *tC.inArray*                                                                 | *Fonction interne pour vérifier si un élément se trouve dans un array*                                                                                                                                                                                                                                                                                                                    |
| *tC.inclusion\_oct\_1*                                                       | *Spécifique à chaque container (inclusion JS)*                                                                                                                                                                                                                                                                                                                                            |
| *tC.internalFunctions*                                                       | *namespace des fonctions internes de TagCommander*                                                                                                                                                                                                                                                                                                                                        |
| *tC.info*                                                                    | *Méthode remplaçant la commande console.info()*                                                                                                                                                                                                                                                                                                                                           |
| *tC.internalvars*                                                            | *namespace des variables internes de TagCommander*                                                                                                                                                                                                                                                                                                                                        |
| *tC.isArray*                                                                 | *Méthode pour vérifier si une variable se trouve dans un array*                                                                                                                                                                                                                                                                                                                           |
| *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*                                                                 | *namespace 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 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 entre guillemets : tC.removeCookie(“cookie’s name”)*                                                                                                                                                                                                   |
| *tC.script*                                                                  | *Retourne 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 https ou http*                                                                                                                                                                                                                                                                                                        |
| *tC.tagPatterns*                                                             | *Variable interne contenant les regexp (patterns) pour détecter les hits de 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 TagPerformance*                                                                                                                                                                                                                                                                                            |
| *tC.trace*                                                                   | *Méthode remplaçant la commande console.trace()*                                                                                                                                                                                                                                                                                                                                          |
| *tC.script.add(location.protocol + “//manager.tagcommander.com/utils/IP/”);* | *Cette fonction vous 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 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.