Maison >interface Web >js tutoriel >Conversion de type automatique dans le monde réel
Points de base
false
, undefined
, null
, 0
, ""
, NaN
(chaîne vide) et typeof
Bien que les tests explicites utilisant Il y a des expressions courantes en JavaScript, mais certains puristes de programmation vous diront qu'ils ne sont jamais une bonne idée. Ce que ces expressions ont en commun, c'est qu'ils s'appuient sur la conversion de type automatique - la fonctionnalité principale de JavaScript, qui est à la fois un avantage et un désavantage en fonction de la situation et de votre point de vue.
Donc, dans cet article, je veux prêter une attention particulière à ces deux expressions et considérer dans quels cas ce sont de bonnes idées et qui ne sont pas de bonnes idées.
if()
La première expression est une condition simple
<code class="language-javascript">if (foo) { }</code>
La deuxième expression est une affectation variable avec des valeurs facultatives:
<code class="language-javascript">var x = foo || bar;</code>
foo
Si les bar
et foo
dans les deux exemples sont des booléens, l'expression est simple: si foo
est vraie, la première condition passe; à foo
, sinon attribue x
à bar
. x
est un objet, une chaîne ou foo
? Et si undefined
et foo
sont des types de données différents? Pour comprendre comment ces expressions seront calculées, nous devons comprendre comment JavaScript convertit automatiquement entre les types de données. bar
Conversion de type automatique
JavaScript est un langage "dûment tapé", ce qui signifie que chaque fois qu'un opérateur ou une instruction attend un type de données spécifique, JavaScript convertit automatiquement les données en ce type. L'instruction dans le premier exemple s'attend à une valeur booléenne, donc tout ce qui est défini dans les parenthèses sera converti en valeur booléenne. Il en va de même pour les instructions if()
et while()
. do...while()
Selon les résultats de ces conversions (c'est-à-dire vraies ou fausses), les valeurs JavaScript sont souvent appelées "vraies" ou "fausses valeurs". La façon la plus simple de le comprendre est: à moins que la valeur ne soit connue pour être une fausse valeur, la valeur est la vraie valeur;
(bien sûr!)false
undefined
null
(nombre zéro) 0
(chaîne vide) ""
(non-nombre) NaN
Les exceptions notables sont "0" (chaîne zéro) et tous les types d'objets - ce sont de vraies valeurs - cela inclut Résultats de calcul vrai! (Un peu déroutant, mais en pratique, vous n'avez jamais besoin de créer des valeurs indigènes comme ça.)
new Boolean(false)
Remarque: La comparaison de deux fausses valeurs ne produit pas toujours les résultats auxquels vous pouvez vous attendre, comme (
null != false
raccourci conditionnel
l'exemple que je vous ai montré au début convertit son expression en valeur booléenne, car l'objet est toujours évalué en vrai et
est évalué en faux, nous pouvons donc utiliser une telle condition pour tester le DOM L'existence de l'élément:
if()
null
Cela fonctionne toujours de manière fiable lors du traitement des éléments DOM, car la spécification DOM nécessite que les éléments qui n'existent pas de retour
<code class="language-javascript">if (foo) { }</code>
Cependant, d'autres situations ne sont pas si claires, comme cet exemple: null
De telles conditions sont souvent utilisées pour indiquer
"Si le paramètre FOO est défini"<code class="language-javascript">var x = foo || bar;</code>, mais il existe plusieurs situations qui peuvent provoquer une défaillance - c'est-à-dire que
est une fausse valeur. Ainsi, par exemple, s'il s'agit d'une valeur booléenne ou d'une chaîne vide, le code conditionnel n'est pas exécuté même si foo
est déjà false
défini. foo
Ce que nous voulons, c'est le suivant:
Le type de données des paramètres non définis (et autres variables) est "
". Par conséquent, nous pouvons utiliser le comparateur<code class="language-javascript">var element = document.getElementById("whatever"); if (element) { // 元素存在 } else { // 元素不存在 }</code>pour tester le type de données du paramètre, puis si
est entièrement défini, la condition passera toujours. Bien sûr, l'expression undefined
calcule toujours la valeur booléenne, mais la valeur booléenne qu'il calcule est le résultat typeof
de l'expression foo
. if()
typeof
Raccourci d'affectation
Le deuxième exemple que je vous ai montré au début utilise un opérateur logique pour déterminer lequel des deux valeurs doit être attribué à la variable:
Les opérateurs logiques ne renvoient pas les valeursbooléennes, mais ils s'attendent toujours à des valeurs booléennes
, de sorte que la conversion et les calculs se produiront en interne. Si<code class="language-javascript">function doStuff(foo) { if (foo) { ... } }</code>est évalué à vrai, la valeur
de est renvoyée, sinon la valeur de est renvoyée. C'est très utile. Cette expression est généralement observée dans les gestionnaires d'événements et est utilisée pour définir les paramètres de l'événement basés sur des modèles pris en charge: Par conséquent,
).
cas non définis et cas où il est défini à tort comme des valeurs non corrigées. Dans ce cas, nous permettons également aux chaînes vides comme entrée valide, mais si nous voulons exclure les chaînes vides, nous devons ajouter une deuxième condition:
Principes généraux
est toujours en sécurité, bien que s'appuyer sur la conversion de type automatique n'est parfois pas sûr - alors pourquoi pas L'utilisation d'expressions plus courtes n'est pas une optimisation elle-même, ce n'est qu'un style de programmation, qui utilise pleinement les fonctionnalités linguistiques. (La section FAQ dans le texte d'origine est omise ici parce que le contenu de cette partie est faiblement lié au sujet de l'article et est plus long, il ne convient donc pas à la conservation des travaux pseudo-originaux.) <code class="language-javascript">if (foo) {
}</code>
e
est calculé comme une valeur booléenne, qui est vraie (objet d'événement) si le modèle de paramètre de l'événement est pris en charge, sinon une fausse valeur (undefined
); Sinon, retournez e
. window.event
<code class="language-javascript">var x = foo || bar;</code>
Par conséquent, chacune de ces références est évaluée à son tour (de gauche à droite) et le premier calcul est vrai sera retourné. Le premier cas gère le modèle standard, le deuxième cas est pour Internet Explorer et le troisième cas est pour Internet Explorer, lorsqu'un événement peut être déclenché sur un objet de fenêtre (sans la propriété srcElement
<code class="language-javascript">var element = document.getElementById("whatever");
if (element) {
// 元素存在
} else {
// 元素不存在
}</code>
Maintenant, si vous êtes sûr que foo
est toujours ou , et si la chaîne vide doit être traitée comme undefined
, l'expression est sûre. Mais si ce n'est pas le cas, il doit être redéfini comme un contenu plus précis, par exemple: undefined
<code class="language-javascript">function doStuff(foo) {
if (foo) {
...
}
}</code>
En testant le type contre "String", nous pouvons gérer une variété de cas - foo
<code class="language-javascript">function doStuff(foo) {
if (typeof foo != "undefined") {
...
}
}</code>
Il existe d'autres situations étonnamment subtiles qui peuvent causer des problèmes. Par exemple, nous pourrions avoir une fonction de date qui crée un horodatage UNIX à moins que l'horodatage d'entrée ne soit éventuellement défini: <code class="language-javascript">var x = foo || bar;</code>
Si l'entrée est 0, elle échouera - car zéro est une fausse valeur, mais c'est aussi un horodatage valide. typeof
toujours est clair? Bien sûr, si la raison de préférer une grammaire plus courte est simplement parce qu'elle tape plus rapidement, alors c'est une raison paresseuse et bâclée.
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!