À quoi sert "var _gaq = _gaq || [];"?
Le code de suivi Async dans Google Analytics ressemble à ceci:
var _gaq = _gaq || [];
_gaq.Push(['_setAccount', 'UA-XXXXX-X']);
_gaq.Push(['_trackPageview']);
(function() {
var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
})();
À propos de la première ligne:
var _gaq = _gaq || [];
Je pense que cela garantit que si _gaq est déjà défini, nous devons l'utiliser sinon nous devrions un tableau.
Quelqu'un peut-il expliquer à quoi cela sert?
Est-ce aussi important si _gaq est renommé? En d'autres termes, Google Analytics s'appuie-t-il sur un objet global nommé _gaq?
Oui, il garantit que _gaq Est défini, de sorte que _gaq.Push() n'échoue jamais.
Je ne jouerais pas avec le nom des variables dans le code de GA ... avez-vous une raison de le faire? Est-ce en conflit avec l'une de vos variables? (Alors je changerais le mien ...)
Cette ligne est là pour autoriser plusieurs extraits GA dans la même page. Elle garantit que le deuxième extrait n'écrase pas un _gaq défini par le premier.
Le suivi asynchrone GA fonctionne en définissant d'abord _gaq comme un tableau. Ce tableau agit comme une file d'attente, ce qui vous permet de pousser (ajouter) la configuration et de suivre les "commandes" (comme _trackPageview) à la fin de la file d'attente. Vos commandes sont stockées dans ce tableau jusqu'à ce que ga.js soit entièrement téléchargé.
Lorsque ga.js est prêt, il exécute toutes les commandes du tableau _gaq et remplace _gaq par un objet. Cet objet a également une méthode Push, mais au lieu de mettre les commandes en file d'attente, il les exécute immédiatement, car ga.js est disponible pour les traiter.
Ce mécanisme vous permet d'effectuer des commandes de configuration et de suivi sans savoir si le navigateur a fini de télécharger ga.js. Cela est nécessaire car l'extrait async télécharge ga.js sans empêcher l'exécution d'un autre code sur la page. Les choses deviendraient poilues si cet autre code (vos commandes de configuration) avait besoin de connaître l'état de ga.js en cours de téléchargement.
Tout cela absolument est-ce que dépend de l'utilisation du nom _gaq. Vous ne devriez pas essayer de le nommer si vous voulez que le suivi asynchrone fonctionne.
En utilisant || dans l'affectation est une astuce de programmation courante qui tire parti de la direction d'évaluation de l'opérateur, qui est de gauche à droite. Cela signifie qu'il évalue d'abord le côté gauche. Ensuite, et seulement si c'est faux (ou un faux équivalent), évalue-t-il le côté droit.
Vous pouvez également profiter des || ou && opérateurs dans une simple instruction if, de sorte que
if (a > 5) {
do_a();
}
if (!some_boolean) {
do_b();
}
devenir
a > 5 && do_a();
some_boolean || do_b(); // Note that the negation operator `!` is gone!
qui sont à la fois plus agréables à regarder.
La raison pour laquelle les langues le permettent, c'est parce que c'est une perte de temps d'évaluer le côté droit si le côté gauche fera de toute façon échouer la ligne entière. Il l'ignore donc à moins qu'il ne soit nécessaire.
ÉDITER:
j'ajouterai plus de détails
_gaq est simplement un tableau javascript, tel que défini initialement. vous y ajoutez des événements, tels que les rappels de suivi des événements
cependant, lorsque le script ga.js est chargé, google prend ce tableau et le transforme en objet, que ga utilise.
c'est pourquoi vous poussez les fonctions dans le tableau _gaq, puis appelez le script ga.js après vous; vous avez fini de construire le tableau.
gaq est la file d'attente Google Analytics. c'est une pile pour les méthodes GA, comme le suivi des événements, l'attribution des pages, etc. vous utilisez la méthode Push () pour y placer des éléments GA. interférence, tout le monde devrait le faire, ou au moins apprendre le concept.
Désolé de répondre tard, mais j'ai lu la réponse acceptée et je pense qu'elle manque la chose la plus importante. Je vais donc essayer d'expliquer ce que j'ai compris:
Tout d'abord, il a été expliqué mais la réponse doit être complète, donc je l'explique aussi, le code commence par:
var _gaq = _gaq || [];
Il garantit que _gaq est défini. S'il n'est pas défini, il est initialisé dans un tableau vide.
Pensez-le comme l'équivalent:
var _gaq;
/* ... */
if(!_gaq)
_gaq = [];
La valeur javascript undefined est "falsish"/"falsy", c'est-à-dire qu'elle a la valeur false lorsqu'elle est convertie en booléen, donc _gaq est initialisé avec [] Dans ce cas.
Ce qui est important à noter, c'est que:
- si _gaq contient un tableau à ce stade, _gaq est "trueish", donc il gardera sa valeur (et ne sera pas vidé)
- si _gaq contient un autre type d'objet à ce stade, _gaq peut également conserver sa valeur
Eh bien, j'ai ré-expliqué, du mieux que je peux, quelque chose de déjà expliqué. La plupart des gens expérimentés avec javascript l'ont déjà compris. Cependant, la partie intéressante n'est pas seulement le début!
_gaq.Push(['command', 'argument']); // is very interesting too
Si _gaq est un tableau, vous devinerez tous que l'élément ['command', 'argument'] Est ajouté au tableau. Google Analytics stocke ces informations dans sa file d'attente pour un traitement ultérieur. Le tableau _gaq est utilisé comme file d'attente.
Mais la partie vraiment intéressante est que_gaq.Push(/*...*/) peut être fait sans avoir un tableau nommé _gaq. Il s'agit simplement d'un appel de méthode, et les tableaux non peuvent également avoir une méthode "Push".
Il "ouvre de nouvelles possibilités". En voici un résumé:
- Tant que le fichier javascript externe n'est pas chargé de manière asynchrone, _gaq est un tableau utilisé comme file d'attente.
- Le ga.js externe traite ensuite la file d'attente.
- ga.js remplace ensuite _gaq par un objet qui fournit une méthode Push.
- Une fois que _gaq est remplacé par un objet, les commandes
_gaq.Push(/*...*/)n'ont plus besoin d'être différées, elles peuvent être exécutées.
Pour ceux qui ont raté la partie de chargement du script asynchrone, c'est:
(function() {
var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
})();
Utiliser temporairement un tableau comme file d'attente et la méthode Push est un excellent code. C'est une manière très intéressante de gérer le fait que lorsque _gaq.Push(/*...*/) est exécuté, nous ne savons pas toujours si la dépendance a été chargée de manière asynchrone ou pas.
Une autre façon intéressante de gérer ce type de problèmes est le nouvel extrait de "isogramme" de Google Analytics : ga(/*...*/) semble encore plus intuitif pour les appels qui _gaq.Push(/*...*/), mais il fait toujours face aux joies liées au chargement des dépendances de manière asynchrone.
Quelqu'un peut-il expliquer à quoi cela sert?
J'espère que ma réponse ci-dessus l'a fait. Ce que je voulais partager ici, c'est que la première ligne est faite d'une manière particulière pour s'adapter à l'ensemble: initialisation qui ne nuit jamais si elle est faite deux fois, utilisation intelligente de la méthode Push ...
google Analytics s'appuie-t-il sur un objet global nommé _gaq?
Oui, lors de l'utilisation de cet extrait ga.js.
Oui, il fait exactement ce que vous pensez qu'il fait :) C'est un raccourci pour
if(!_gaq){ var _gaq = [] }
Cela signifie que si _gaq est déjà défini, il utilise sinon qu'il déclare un tableau vide. Avec Push, vous pouvez remplacer les paramètres. Si l'objet _gaq n'était pas défini, les 2 "lignes" après cela entraîneraient une erreur.
Oui, l'objet _gaq est attendu dans le script que vous incluez dans le code (ga.js).