# Attributs et méthodes tC.\*

*Les méthodes « tC. » sont **dans un espace de noms\*** . Elles sont très utiles lorsqu’il faut réaliser des actions techniquement avancées, comme afficher dans la console du navigateur le tableau des tags lancés au sein d’un conteneur. Veuillez noter que la disponibilité et le comportement de ces fonctions dépendent de plusieurs éléments, notamment de la configuration de votre conteneur. Il suffit de saisir « tC. » dans la console de votre navigateur pour que la liste des fonctions disponibles sur un site donné et pour un conteneur donné apparaisse.*

*\* « **namespacing** est une technique utilisée pour éviter les collisions avec d’autres objets ou variables dans le **namespace**global. Elles sont également extrêmement utiles pour aider à organiser des blocs de fonctionnalités de 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 conteneur publiée. Si vous utilisez l’un de nos outils de test (Bookmarklet ou l’extension Chrome TagAssistant) et simulez la présence d’une autre version du conteneur, la fonction affichera les tags de la version du conteneur en cours de test*                                                                                        |
| *tC.array\_launched\_tags\_keys*                                             | *Affiche une liste d’identifiants de tag correspondant aux tags de la version du conteneur 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 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 qu’à propos des tags qu’ils contiennent (id, name)*                                                                                                                                                       |
| *tC.dedup*                                                                   | <p><em>LA DÉDUPLICATION DOIT ÊTRE ACTIVÉE POUR QUE CETTE FONCTION FONCTIONNE</em></p><p><em>Affiche un objet JavaScript contenant tous les 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>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 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 – lié 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.domReady*                                                                | *Indique si tout le contenu du Document Object Model (DOM) a fini de se charger ou non (c.-à-d. les conteneurs)*                                                                                                                                                                                                                                                                          |
| *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 des conteneurs*                                                                                                                                                                                                                                                                                                                               |
| *tC.getCookie*                                                               | *Affiche la valeur d’un cookie donné. Vous devez écrire la fonction et le nom du cookie à côté, entre parenthèses et guillemets : tC.getCookie(“nom du cookie”).*                                                                                                                                                                                                                         |
| *tC.getParamURL*                                                             | *Affiche un paramètre donné de l’URL de la page*                                                                                                                                                                                                                                                                                                                                          |
| *tC.hitCounter*                                                              | *Fonction interne utilisée pour obtenir des statistiques liées aux invoicing 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 est placé dans un tableau*                                                                                                                                                                                                                                                                                                         |
| *tC.inclusion\_oct\_1*                                                       | *Spécifique à chaque conteneur (inclusion JS)*                                                                                                                                                                                                                                                                                                                                            |
| *tC.internalFunctions*                                                       | *namespace des fonctions internes de TagCommander*                                                                                                                                                                                                                                                                                                                                        |
| *tC.internalvars*                                                            | *namespace des variables internes de TagCommander*                                                                                                                                                                                                                                                                                                                                        |
| *tC.isArray*                                                                 | *Méthode permettant de vérifier si une variable est placée dans un tableau*                                                                                                                                                                                                                                                                                                               |
| *tC.isCurrentVersion*                                                        | *Confirme si la version actuellement déployée dans l’interface est la version actuelle sur le site*                                                                                                                                                                                                                                                                                       |
| *tC.isDOMReady*                                                              | *Confirme si le Document Object Model (DOM) est prêt*                                                                                                                                                                                                                                                                                                                                     |
| *tC.isFunction*                                                              | *Méthode permettant de vérifier si le type d’une variable est une fonction*                                                                                                                                                                                                                                                                                                               |
| *tC.isNumeric*                                                               | *Méthode permettant de vérifier si la valeur d’une variable est un nombre*                                                                                                                                                                                                                                                                                                                |
| *tC.isPrototypeOf*                                                           | *Méthode permettant de vérifier si une variable est un prototype*                                                                                                                                                                                                                                                                                                                         |
| *tC.isWindow*                                                                | *Méthode permettant de vérifier si une variable est une window*                                                                                                                                                                                                                                                                                                                           |
| *tC.launchTag*                                                               | *Méthode interne utilisée pour l’extension Google Chrome de TagCommander*                                                                                                                                                                                                                                                                                                                 |
| *tC.length*                                                                  | *Variable interne*                                                                                                                                                                                                                                                                                                                                                                        |
| *tC.log*                                                                     | *Méthode remplaçant la commande console.log()*                                                                                                                                                                                                                                                                                                                                            |
| *tC.maindomain*                                                              | *Affiche le domaine principal sur lequel les conteneurs sont déployés*                                                                                                                                                                                                                                                                                                                    |
| *tC.name*                                                                    | *Affiche un « c » pour container*                                                                                                                                                                                                                                                                                                                                                         |
| *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*                                                                 | *namespace 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 regexp*                                                                                                                                                                                                                                                                                                                                                    |
| *tC.removeCookie*                                                            | *Cette fonction vous permet de supprimer un cookie. Vous devez écrire la fonction et le nom du cookie à côté, entre parenthèses et guillemets : tC.removeCookie(“nom du cookie”)*                                                                                                                                                                                                         |
| *tC.script*                                                                  | *Renvoie un objet JavaScript que vous pouvez « déplier » pour trouver l’emplacement du conteneur (lien vers le script)*                                                                                                                                                                                                                                                                   |
| *tC.setCookie*                                                               | <p><em>Cette fonction vous permet de créer un cookie.</em><br><em>Voici l’interface de la fonction :  tC.setCookie(name, value, lifetime, path, domain, secure, sameSite).</em><br><em>Ex : tC.setCookie(“My\_cookie”, “1”, 365,”/”,”.mysite.com”, true, "Lax")</em></p>                                                                                                                  |
| *tC.ssl*                                                                     | *Affiche le certificat SSL : indique si le protocole de la page est https ou http*                                                                                                                                                                                                                                                                                                        |
| *tC.tagPatterns*                                                             | *Variable interne contenant les regex (patterns) permettant de détecter les hits des tags pour le module TagPerformance*                                                                                                                                                                                                                                                                  |
| *tC.tagPerf*                                                                 | *Variable interne pour le module TagPerformance*                                                                                                                                                                                                                                                                                                                                          |
| *tC.tagPerfAnalyzer*                                                         | *Fonction interne qui analyse une page pour calculer le temps de réponse des tags (pour le module TagPerformance)*                                                                                                                                                                                                                                                                        |
| *tC.tagPerfE*                                                                | *Variable encore inutilisée qui contrôle les taux d’échantillonnage des appels de TagPerformance*                                                                                                                                                                                                                                                                                         |
| *tC.script.add(location.protocol + “//manager.tagcommander.com/utils/IP/”);* | *Cette fonction vous permet de récupérer l’adresse IP*                                                                                                                                                                                                                                                                                                                                    |


---

# Agent Instructions: 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:

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

The question should be specific, self-contained, and written in natural language.
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.