Quelqu'un peut-il expliquer ce que cet énoncé signifie? Spécialement, P> e = e || window.event
10 Réponses :
Il n'attribuait pas em> à "e", juste celui qui n'est pas non plus non supérieur à C'est fait parce que Internet Explorer n'a pas transmis la référence d'événement comme paramètre, simplement reliant simplement un symbole global. Les gestionnaires d'événements ont été très souvent écrits: p> Cela aurait probablement été plus rigoureusement "correct" pour écrire: P> non défini code>,
null code>,
0 ,
nan code>,
"" code> ou
false code>. Il préfère la valeur d'origine de "E" à
window.event code> parce que "E" est à gauche de
|| code>, mais s'il est vide (une de ces valeurs i listé) alors "e" sera attribué à "code> window.event" code>.
function pedanticHandler(e) {
if (e === undefined) // or arguments.length == 0 perhaps
e = window.event;
// ...
}
Spécifiquement, si e a une valeur, il conserve sa valeur. Si cela est indéfini, nous regardons ailleurs pour une valeur.
@Jonkiparsky oui, étendu :)
@VivinpaliaIth Oui, c'est! (... mais seulement si quelqu'un de votre équipe déclare vraiment la variable non définie code>;)).
@Crazytrain je pense qu'il (y compris moi) comparé typeof e === "indéfini" code> à
e === non défini code>, pas sur
si (e) code> en général.
Veuillez prendre toutes les discussions prolongées pour discuter. Ce n'est pas un bon endroit pour eux. Si vous avez des éclaircissements pour la question ou une réponse, veuillez éditer cet article avec les informations pertinentes.
@Crazytrain
Il est redondant d'assigner La déclaration vérifie si en particulier, si J'utiliserai personnellement un Edit: Je pense que le code d'origine est buggy. Clairement, l'intention est de vérifier si
Alors pourquoi pensez-vous que c'est redondant? Avez-vous conduit un vieil IE dernièrement?
Il n'y a pas de malentendu du code, cela semble simplement de la manière dont la réponse est formulée. Il aurait dû être écrit comme ceci: "Bien sûr, il est redondant d'assigner
Le phrasé de cette réponse est médiocre. Je suis sûr que Akonsu sait ce que ça fait, mais répondant ne concerne pas seulement la connaissance. Il s'agit de communiquer. Fondamentalement, la première phrase n'a aucun sens. Si c'est redondant, comment remplace-t-il le code?
@Crazytrain très vrai. Ce n'est pas une bonne réponse par aucun moyen. J'espère que je suis édité. Je voulais juste partager ce que j'ai découvert après une décollation pendant quelques minutes, car ce n'était pas évident même après plusieurs lectures. :)
Je pense que cette réponse est précieuse car elle décrit le but derrière le code OPS.
@akonsu mais je ne pense pas que ce code est buggy ou inattendu. C'est en effet une technique très utile imho. Les grands projets font l'utiliser aussi, jQuery utilise par exemple dans ce fichier .
votes
e = e code>, ils le font dans le cadre de cette instruction car c'est un idiome. P>
E code> est défini et s'il n'est pas alors, il l'initialise avec l'expression qui suit
|| code>. Cela fonctionne parce que lorsque
|| code> expression est évalué que l'interprète arrête l'évaluation lorsque le premier
true code> partie (à gauche) est trouvé. P>
E code> est évalué vers
true code> puis l'évaluation s'arrête à droite puis et efficacement, vous avez
E = E code>, qui est redondant. Mais si
E code> est indéfini ou évalue vers
false code>, la partie droite du
|| code> est évaluée et attribuée à
E code >. p>
si code> est au lieu d'être intelligent. Ou restructurer le code encore plus pour éviter
si code> complètement. P>
E code> est déjà initialisé. Mais ici, il peut être réaffecté à lui-même s'il est déjà initialisé et évalue à
vrai code>. Cela peut avoir des effets secondaires indésirables. P>
E code> à
E code>; ce n'est pas ce que ce code fait. Au lieu de cela, le programmateur fait autre chose: Nommerez une valeur à
E code> uniquement si
E code> est FALSY. Cet idiome enregistre le code sur plus long
si (! E) e = x code> style.
Si E est défini, l'évaluation s'arrête correctement puis et efficacement, vous avez E = E code> qui est faux! Il doit dire:
si e est défini ** et ** évalue vers true code>.
Vous êtes des opérateurs malentendants. P>
Cette ligne attribue l'expression la valeur de e || x code> à la variable
E code>. p>
e || x code> est la première valeur de la vérité.
Si E code> est une vérité, qui sera
e code>; Si
E code> est FALSY, il sera
x code>. p>
Ceci est identique à: p> < Pre> xxx pré> Voici une table qui montre quelles valeurs évaluent false em>: https : //stackoverflow.com/a/7615236/603003 p> Les valeurs les plus importantes sont les suivantes: null em> et non défini em>. P > p>
Qu'est-ce que cela signifie dans votre contexte?
Vous avez probablement une sorte de ce code: p> où e = e || x code> attribue
x code> à
E code> si
E code> est évaluée sur false.
gestionnaire code> est un auditeur d'événement attaché à un élément DOM. Étant donné que les anciennes versions de IE n'ont pas passé l'objet événement sous forme de paramètre, il a dû vérifier si le paramètre était indéfini em>. Si ce dernier était le cas, on attribue l'objet global
window.event code> (qui est fourni) à
E code>. P> p>
Yikes! Je me sens stupide, j'aurais dû me rappeler ça. C'est tellement simple. Merci!
si Il est implicitement: p> E code> est
non défini code> (ou
null code> ou tout autre
false code> valeur), il est initialisé avec
x code>.
Il est égal à l'égal à lui-même (s'il n'est pas nul, non défini ou faux) sinon window.event.
C'est comme dire P>
if (!e) e = window.event;
Il n'attribuait pas les deux valeurs à Fondamentalement, c'est une forme abrégée pour: p> E code>. C'est juste une façon d'attribuer
x code> à
E code> si la valeur d'origine de
E code> est
null code>,
non défini code>,
0 code>,
false code>,
nan code> ou une chaîne vide (
"" code>). Si la valeur d'origine de
E code> ne correspond à aucune des conditions susmentionnées, il conserve la valeur d'origine.
@ Virus721 merci! Ajouté que à la réponse.
dans votre exemple e = e || window.event; code> est équivalent à:
Lorsque vous ajoutez un événementHandler à un élément dans la plupart des navigateurs, il transmet l'événement comme premier paramètre. P> handler=function(e){// e is the event in some browsers
e=e||window.event; // but in some old browsers the event is window.event
// so you check if e(event) exists else you use window.event.
// '||' means or...
// e is already defined as a placeholder in the handler function
// so you don't need to put var infront of it
}
La réponse ci-dessus (COMFREEK) est correcte. La raison em> Cela fait ceci est dû à l'évaluation paresseuse. Le booléen Ceci est le code intelligent. Clever est stupide. (avis)
En tant que mainteneur, je préfère voir p> x || y code>, évalué paresseusement vérifiera
x code> d'abord. Si elle évalue à
true code> (c'est-à-dire, non nulle, non null), alors l'expression arrête et retourne vrai. Si
x code> évalue vers
false code>, il retournera
y code>.
D'accord. C # a une notation légèrement meilleure avec e = e ?? X; Le double point d'interrogation donne clairement clairement que votre vérification si quelque chose existe, plutôt que d'assigner un booléen.
N'est pas
|| code> un opérateur booléen? Donc,
E code> devrait être soit
true code> ou
false code> après cela?
C'est «Utilisez E s'il est déjà défini / disponible, utilisez sinon X». C'est un peu de sucre syntaxiste dans JavaScript, en pseudo-code, "si (existe e), puis renvoie e d'autre retour x".
@Cobra_fast
|| code> ne renvoie pas vrai / faux dans JavaScript, il renvoie le premier objet "Truthy".
C'est-à-dire ne pas transmettre l'argument de l'événement au gestionnaire
Dupliqué possible de JavaScript ou (||) Affectation de la variable Explication
Dupliquer possible de En JavaScript, qu'est-ce que cela signifie quand il y a un opérateur logique dans une déclaration de variable? (la dupe possible était elle-même une dupe possible!)