Vérifier si l'objet existe en JavaScript
Comment vérifier l'existence d'un objet en JavaScript?
Les oeuvres suivantes:
if (!null)
alert("GOT HERE");
Mais cela jette une erreur:
if (!maybeObject)
alert("GOT HERE");
L'erreur:
maybeObjectn'est pas défini.
Vous pouvez utiliser en toute sécurité l'opérateur typeof sur des variables non définies.
Si une valeur quelconque, y compris null, lui a été attribuée, typeof renverra autre chose que non défini. typeof retourne toujours une chaîne.
Donc
if (typeof maybeObject != "undefined") {
alert("GOT THERE");
}
Il y a beaucoup de demi-vérités ici, alors j'ai pensé rendre certaines choses plus claires.
En réalité, vous ne pouvez pas savoir avec précision si une variable existe (à moins que vous ne vouliez insérer une ligne sur deux dans un bloc try-catch).
La raison est que Javascript a cette valeur notoire de undefined qui ne signifie pas que la variable n'est pas définie, ou qu'elle n'existe pas undefined !== not defined
var a;
alert(typeof a); // undefined (declared without a value)
alert(typeof b); // undefined (not declared)
Donc, une variable qui existe et une autre qui ne peut pas vous signaler le type undefined.
En ce qui concerne l'idée fausse de @ Kevin, null == undefined. C’est en raison de la contrainte exercée sur les types, et c’est la raison principale pour laquelle Crockford continue de demander à tous les utilisateurs qui ne sont pas certains de ce type de choses de toujours utiliser l’opérateur d’égalité stricte === pour tester les valeurs éventuellement fausses. null !== undefined vous donne ce à quoi vous pouvez vous attendre. Veuillez également noter que 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 améliorer la lisibilité.
Si vous restreignez la question pour vérifier si un objet existe, typeof o == "object" peut être une bonne idée, sauf si vous ne considérez pas les objets de 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 vous donnera également object qui est tout simplement faux.
La zone primale où vous devriez vraiment faire attention à typeof, undefined, null, unknown et aux autres mystères sont des objets hôtes. On ne peut pas leur faire confiance. Ils sont libres de faire presque n'importe quelle chose sale qu'ils veulent. Alors, soyez 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 peut même ne pas exister.
Vous pouvez utiliser:
if (typeof objectName == 'object') {
//do something
}
Deux manières.
typeof pour les variables locales
Vous pouvez tester un objet local en utilisant typeof:
if (object !== "undefined") {}
fenêtre pour les variables globales
Vous pouvez tester un objet global (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)
Vous pouvez utiliser "typeof".
if(typeof maybeObject != "undefined")
alert("GOT HERE");
J'avais l'habitude de faire un if(maybeObject) comme contrôle nul dans mes javascripts.
if(maybeObject){
alert("GOT HERE");
}
Donc, seulement si maybeObject - est un objet, l'alerte serait affichée . J'ai un exemple sur mon site.
https://sites.google.com/site/javaerrorsandsolutions/home/javascript-dynamic-checkboxes
Je viens de tester les exemples typeOf ci-dessus et aucun ne fonctionnait pour moi, alors j'ai plutôt utilisé ceci:
btnAdd = document.getElementById("elementNotLoadedYet");
if (btnAdd != null) {
btnAdd.textContent = "Some text here";
} else {
alert("not detected!");
}pour moi cela fonctionnait pour un objet DOM:
if(document.getElementsById('IDname').length != 0 ){
alert("object exist");
}
En plus de vérifier l'existence de l'objet/de la variable, vous pouvez vouloir fournir une sortie "pire des cas" ou au moins la capturer dans une alerte pour qu'elle ne passe pas inaperçue.
Exemple de fonction qui vérifie, fournit des erreurs de remplacement et des 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 passais pourrait être x, x.m, x.m [z] et que typeof x.m [z] échouerait avec une erreur si x.m 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-il été déclaré?), La réponse approuvée suffit:
if (typeof maybeObject != "undefined") {
alert("GOT THERE");
}
Si cela vous intéresse d'avoir une valeur réelle, vous devriez 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 ne s'agit ni de null ni de undefined, et que typeof ne commet pas d'erreur si la valeur n'existe pas plus && court-circuit, vous n'obtiendrez jamais une exécution. erreur de temps.
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!");
}
définissez la valeur de la zone de texte sur un cadre à un autre en utilisant le panneau à onglets div alignmnt . Donc, avant de définir la valeur, nous devons vérifier si le cadre de panneaux à onglets est disponible ou n'utilise pas 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>
Le fil a été ouvert il y a un certain temps. Je pense qu'entre-temps, l'utilisation d'un opérateur ternaire est l'option la plus simple:
maybeObject ? console.log(maybeObject.id) : ""
if (n === Object(n)) {
// code
}
Vous pouvez utiliser l'opérateur ! deux fois !!:
if (!!maybeObject)
alert("maybeObject exists");
Ou une seule fois ! pour n'existe pas:
if (!maybeObject)
alert("maybeObject does not exist");
zéro et null sont des pointeurs implicites. Si vous ne faites pas d'arithmétique, comparez ou n'imprimez pas '0' sur l'écran, il n'est pas nécessaire de le saisir. C'est implicite. Comme implicite. Typeof n'est pas non plus requis pour la même raison. Regarder.
if (obj) console.log ("existe");
Je n'ai pas vu la demande d'un non ou sinon car il n'est pas inclus comme. Autant que j'aime le contenu supplémentaire qui ne rentre pas dans la question. Permet de garder les choses simples.