Réponses:
Vous pouvez utiliser en toute sécurité l' typeof
opérateur sur des variables non définies.
Si une valeur lui a été affectée, y compris null, typeof renverra autre chose qu'undefined. typeof renvoie toujours une chaîne.
Par conséquent
if (typeof maybeObject != "undefined") {
alert("GOT THERE");
}
Il y a beaucoup de demi-vérités ici, alors j'ai pensé clarifier certaines choses.
En fait, vous ne pouvez pas dire avec précision si une variable existe (sauf si vous voulez encapsuler toutes les deux lignes dans un bloc try-catch).
La raison en est que Javascript a cette valeur notoire undefined
qui, de façon frappante, ne signifie pas que la variable n'est pas définie ou qu'elle n'existe pasundefined !== not defined
var a;
alert(typeof a); // undefined (declared without a value)
alert(typeof b); // undefined (not declared)
Donc, à la fois une variable qui existe et une autre qui ne peut pas vous signaler le undefined
type.
Quant à l'idée fausse @ Kevin, null == undefined
. Cela est dû à la coercition de type, et c'est la principale raison pour laquelle Crockford continue de dire à tous ceux qui ne sont pas sûrs de ce genre de chose de toujours utiliser un opérateur d'égalité stricte ===
pour tester les valeurs éventuellement fausses. null !== undefined
vous donne ce que vous attendez. Veuillez également noter que cela foo != null
peut être un moyen efficace de vérifier si une variable n'est ni undefined
ni null
. Bien sûr, vous pouvez être explicite, car cela peut aider à la lisibilité.
Si vous limitez la question pour vérifier si un objet existe, cela typeof o == "object"
peut être une bonne idée, sauf si vous ne considérez pas les objets tableaux, car cela sera également signalé comme étant le type de object
ce qui peut vous laisser un peu confus. Sans oublier que typeof null
cela vous donnera également ce object
qui est tout simplement faux.
La zone primaire où vous devriez vraiment faire attention typeof
, undefined
, null
, unknown
et d' autres sont des objets mystères hôtes. On ne peut pas leur faire confiance. Ils sont libres de faire presque n'importe quelle chose sale qu'ils veulent. Soyez donc prudent avec eux, vérifiez les fonctionnalités si vous le pouvez, car c'est le seul moyen sécurisé d'utiliser une fonctionnalité qui n'existe peut-être même pas.
foo!=null
produira une ReferenceError si elle foo
n'est pas définie. Il est donc préférable de l'utiliser typeof
, sauf si vous prévoyez d'attraper l'exception.
undefined !== not defined
&&foo != null can be an effective way to check if a variable is neither 'undefined' nor 'null'
. Je n'ai pas dit qu'il != null
est bon de vérifier s'il existe. Vous le sortez de son contexte. (J'ai également mentionné qu'il s'agit d'un sidenote, pas strictement lié au sujet de la question du PO)
undefined
. Ils ne sont pas les mêmes. (note) it can be used !== you should use
. Faites preuve de bon sens pendant la lecture. Lorsque la variable est déclarée (liste de paramètres ou ailleurs) et que vous voulez vérifier si elle a une valeur, !=
null est complètement sûr. C'est un cas d'utilisation différent de ce que le PO a demandé, c'est pourquoi je l'ai introduit comme une note. Le paragraphe entier concerne le poste de @ Kevin et le type coercition btw. Comme vous pouvez le constater si vous lisez attentivement.
!= null
lorsque vous savez que la variable a été déclarée. Ceci est très utile pour vérifier les arguments des fonctions, considérez:var hasValue = function(foo) {return foo != null}
Deux manières.
Vous pouvez tester un objet local en utilisant typeof:
if (typeof object !== "undefined") {}
Vous pouvez tester un objet global (celui défini sur la portée globale) en inspectant l'objet window:
if (window.FormData) {}
Si c'est un objet global, vous pouvez utiliser if (!window.maybeObject)
window.hasOwnProperty('maybeObject')
c'est un peu plus lisible, si c'est un objet global
Vous pouvez utiliser "typeof".
if(typeof maybeObject != "undefined")
alert("GOT HERE");
Le fil a été ouvert il y a un certain temps. Je pense que dans l'intervalle, l'utilisation d'un opérateur ternaire est l'option la plus simple:
maybeObject ? console.log(maybeObject.id) : ""
var maybeObject = typeof maybeObject !== "undefined" ? Chart:false;
et vérifiez si non false
.
J'avais l'habitude de faire une if(maybeObject)
vérification nulle dans mes javascripts.
if(maybeObject){
alert("GOT HERE");
}
Donc, seulement si maybeObject
- est un objet, l'alerte sera affichée. J'ai un exemple sur mon site.
https://sites.google.com/site/javaerrorsandsolutions/home/javascript-dynamic-checkboxes
maybeObject
c'est le cas 0, 0.0, or ""
, il vérifie faux
Je viens de tester les exemples de typeOf ci-dessus et aucun n'a fonctionné pour moi, donc j'ai plutôt utilisé ceci:
btnAdd = document.getElementById("elementNotLoadedYet");
if (btnAdd) {
btnAdd.textContent = "Some text here";
} else {
alert("not detected!");
}
En plus de vérifier l'existence de l'objet / de la variable, vous souhaiterez peut-être fournir une sortie "pire des cas" ou au moins la piéger dans une alerte afin qu'elle ne passe pas inaperçue.
Exemple de fonction qui vérifie, fournit une alternative et intercepte les erreurs.
function fillForm(obj) {
try {
var output;
output = (typeof obj !== 'undefined') ? obj : '';
return (output);
}
catch (err) {
// If an error was thrown, sent it as an alert
// to help with debugging any problems
alert(err.toString());
// If the obj doesn't exist or it's empty
// I want to fill the form with ""
return ('');
} // catch End
} // fillForm End
J'ai créé cela aussi parce que l'objet que je lui passais pouvait être x, xm, xm [z] et typeof xm [z] échouerait avec une erreur si xm n'existait pas.
J'espère que ça aide. (BTW, je suis novice avec JS)
Si vous ne vous souciez que de son existence (a-t-elle été déclarée?), La réponse approuvée suffit:
if (typeof maybeObject != "undefined") {
alert("GOT THERE");
}
Si vous vous souciez qu'il ait une valeur réelle, vous devez ajouter:
if (typeof maybeObject != "undefined" && maybeObject != null ) {
alert("GOT THERE");
}
Comme typeof( null ) == "object"
par exemple bar = { x: 1, y: 2, z: null}
typeof( bar.z ) == "object"
typeof( bar.not_present ) == "undefined"
De cette façon vous vérifiez qu'il est ni null
ou undefined
, et depuis typeof
ne pas d' erreur si la valeur n'existe pas , plus &&
courts circuits, vous ne serez jamais obtenir une erreur d' exécution.
Personnellement, je suggérerais d'ajouter un assistant fn quelque part (et ne faisons pas confiance typeof()
):
function exists(data){
data !== null && data !== undefined
}
if( exists( maybeObject ) ){
alert("Got here!");
}
if (n === Object(n)) {
// code
}
définissez la valeur de la zone de texte sur un cadre pour le cadre en ligne à l'aide du panneau à onglets div alignmnt. Donc, tout d'abord, avant de définir la valeur, nous devons vérifier que le cadre des panneaux à onglets sélectionné est disponible ou non en utilisant les codes suivants:
Code Javascript:
/////////////////////////////////////////
<script>
function set_TextID()
{
try
{
if(!parent.frames["entry"])
{
alert("Frame object not found");
}
else
{
var setText=document.getElementById("formx").value;
parent.frames["entry"].document.getElementById("form_id").value=setText;
}
if(!parent.frames["education"])
{
alert("Frame object not found");
}
else
{
var setText=document.getElementById("formx").value;
parent.frames["education"].document.getElementById("form_id").value=setText;
}
if(!parent.frames["contact"])
{
alert("Frame object not found");
}
else
{
var setText=document.getElementById("formx").value;
parent.frames["contact"].document.getElementById("form_id").value=setText;
}
}catch(exception){}
}
</script>
zéro et null sont des pointeurs implicites. Si vous ne faites pas d'arithmétique, ne comparez pas ou n'imprimez pas `` 0 '' à l'écran, il n'est pas nécessaire de le taper. C'est implicite. Comme implicite. Typeof n'est également pas requis pour la même raison. Regarder.
if (obj) console.log ("existe");
Je n'ai pas vu de demande de non ou bien car il n'est pas inclus en tant que. Autant j'aime le contenu supplémentaire qui ne rentre pas dans la question. Permet de rester simple.
if (!maybeObject)
- mais en effet, le titre demande le contraire.
Ou, vous pouvez tous commencer à utiliser ma méthode exclusive exclusive () à la place et pouvoir faire des choses considérées comme impossibles. c'est à dire:
Des choses comme:, exists("blabla")
ou même: exists("foreignObject.guessedProperty.guessNext.propertyNeeded")
sont également possibles ...
!==
pour la comparaison.