prüfen - javascript variable übergeben




Gibt es eine Standardfunktion, um in JavaScript auf leere, nicht definierte oder leere Variablen zu prüfen? (18)

Das ist sehr einfach.

if(data) {
  //Comes inside only if the data is not empty and not null 
}

Gibt es eine universelle JavaScript-Funktion, die überprüft, dass eine Variable einen Wert hat und sicherstellt, dass sie nicht undefined oder null ? Ich habe diesen Code, aber ich bin mir nicht sicher, ob er alle Fälle abdeckt:

function isEmpty(val){
    return (val === undefined || val == null || val.length <= 0) ? true : false;
}

Die erste Antwort mit der besten Bewertung ist falsch. Wenn der Wert nicht definiert ist, wird in modernen Browsern eine Ausnahme ausgelöst. Sie müssen Folgendes verwenden:

if (typeof(value) !== "undefined" && value)

oder

if (typeof value  !== "undefined" && value)

Diese Bedingungsprüfung

if (!!foo) {
    //foo is defined
}

ist alles, was du brauchst.


Diese Funktion prüft auf empty object {} , empty array [] , null , undefined und blank string ""

function isEmpty(val) {
  //check for empty object {}, array []
  if (val !== null && typeof val === 'object') {
    if (Object.keys(obj).length === 0) {
      return true;
    }
  }
  //check for undefined, null and "" 
  else if (val == null || val === "") {
    return true;
  }
  return false;
}

var val = {};
isEmpty (val) -> wahr
val = [];
isEmpty (val) -> wahr
isEmpty (undefiniert) -> true
isEmpty (null) -> wahr
isEmpty ("") -> true
isEmpty (falsch) -> falsch
isEmpty (0) -> false


Es kann nützlich sein.

[null, undefined, ''].indexOf(document.DocumentNumberLabel) > -1

Für alle, die hierher kommen, um ähnliche Fragen zu haben, funktioniert das Folgende großartig und ich habe es in meiner Bibliothek in den letzten Jahren:

(function(g3, $, window, document, undefined){
   g3.utils = g3.utils || {};
/********************************Function type()********************************
* Returns a lowercase string representation of an object's constructor.
* @module {g3.utils}
* @function {g3.utils.type}
* @public
* @param {Type} 'obj' is any type native, host or custom.
* @return {String} Returns a lowercase string representing the object's 
* constructor which is different from word 'object' if they are not custom.
* @reference http://perfectionkills.com/instanceof-considered-harmful-or-how-to-write-a-robust-isarray/
* http://.com/questions/3215046/differentiating-between-arrays-and-hashes-in-javascript
* http://javascript.info/tutorial/type-detection
*******************************************************************************/
g3.utils.type = function (obj){
   if(obj === null)
      return 'null';
   else if(typeof obj === 'undefined')
      return 'undefined';
   return Object.prototype.toString.call(obj).match(/^\[object\s(.*)\]$/)[1].toLowerCase();
};
}(window.g3 = window.g3 || {}, jQuery, window, document));

Hier ist meins - gibt true zurück, wenn value null, undefined usw. oder leer ist (dh nur Leerzeichen enthält):

function stringIsEmpty(value) {

    return value ? value.trim().length == 0 : true;

}

Ich denke mit dem? Betreiber ist etwas sauberer.

var ? function_if_exists() : function_if_doesnt_exist();

Im Falle von mehr als einem Wert, setzen Sie einfach '&&' zwischen alle Werte.

if( var1 && var2 && var3) {
  //to do...
}

Obwohl ein Oldie, was vergessen ist, dass sie ihren Codeblock wickeln sollten und dann den Fehler abfangen und dann testen ...

function checkup( t ){
  try{
    for(p in t){
      if( p.hasOwnProperty( t ) ){
        return true;
      }
    }
    return false;
  }catch(e){
    console.log("ERROR : "+e);
    return e;
  }
}

Sie müssen also nicht vorher nach einem möglichen Problem suchen, Sie fangen es einfach ein und gehen dann damit um, wie Sie wollen.


Sie können die folgende Funktion nützlich finden:

function typeOf(obj) {
  return {}.toString.call(obj).split(' ')[1].slice(0, -1).toLowerCase();
}

Oder in ES7 (Kommentar wenn weitere Verbesserungen)

function typeOf(obj) {
  const { toString } = Object.prototype;
  const stringified = obj::toString();
  const type = stringified.split(' ')[1].slice(0, -1);

  return type.toLowerCase();
}

Ergebnisse:

typeOf(); //undefined
typeOf(null); //null
typeOf(NaN); //number
typeOf(5); //number
typeOf({}); //object
typeOf([]); //array
typeOf(''); //string
typeOf(function () {}); //function
typeOf(/a/) //regexp
typeOf(new Date()) //date

"Beachten Sie, dass der Bindeoperator (: :) weder Teil von ES2016 (ES7) noch irgendeine spätere Ausgabe des ECMAScript-Standards ist. Es ist derzeit ein Vorschlag der Stufe 0 (Strohmann), um in die Sprache eingeführt zu werden." - Simon Kjellberg. der Autor möchte seine Unterstützung für diesen schönen Vorschlag hinzufügen, um königlichen Aufstieg zu erhalten.


Sie können einfach überprüfen, ob die Variable einen truthy Wert hat oder nicht. Das bedeutet

if( value ) {
}

wird als true ausgewertet, wenn der value nicht ist :

  • Null
  • nicht definiert
  • NaN
  • leerer String ("")
  • 0
  • falsch

Die obige Liste zeigt alle möglichen falsy Werte in ECMA- / Javascript. Finden Sie es in der specification im ToBoolean Abschnitt.

Wenn Sie nicht wissen, ob eine Variable existiert (dh wenn sie deklariert wurde ), sollten Sie dies mit dem Operator typeof überprüfen. Zum Beispiel

if( typeof foo !== 'undefined' ) {
    // foo could get resolved and it's defined
}

Wenn Sie sicher sein können, dass eine Variable mindestens deklariert ist, sollten Sie direkt prüfen, ob sie einen truthy Wert wie oben gezeigt hat.

Lesen Sie weiter: http://typeofnan.blogspot.com/2011/01/typeof-is-fast.html


Wenn Sie plain Javascript bevorzugen, versuchen Sie Folgendes:

  /**
   * Checks if `value` is empty. Arrays, strings, or `arguments` objects with a
   * length of `0` and objects with no own enumerable properties are considered
   * "empty".
   *
   * @static
   * @memberOf _
   * @category Objects
   * @param {Array|Object|string} value The value to inspect.
   * @returns {boolean} Returns `true` if the `value` is empty, else `false`.
   * @example
   *
   * _.isEmpty([1, 2, 3]);
   * // => false
   *
   * _.isEmpty([]);
   * // => true
   *
   * _.isEmpty({});
   * // => true
   *
   * _.isEmpty('');
   * // => true
   */

function isEmpty(value) {
    if (!value) {
      return true;
    }
    if (isArray(value) || isString(value)) {
      return !value.length;
    }
    for (var key in value) {
      if (hasOwnProperty.call(value, key)) {
        return false;
      }
    }
    return true;
  }

Andernfalls, wenn Sie bereits Unterstriche oder Lodash verwenden, versuchen Sie Folgendes:

_.isEmpty(value)

Wenn die Variable nicht deklariert wurde, können Sie nicht mit einer Funktion auf undefined testen, da Sie einen Fehler erhalten.

if (foo) {}
function (bar) {}(foo)

Beide erzeugen einen Fehler, wenn foo nicht deklariert wurde.

Wenn Sie testen möchten, ob eine Variable deklariert wurde, können Sie sie verwenden

typeof foo != "undefined"

Wenn Sie testen möchten, ob foo deklariert wurde und einen Wert hat, den Sie verwenden können

if (typeof foo != "undefined" && foo) {
    //code here
}

! Suche nach leeren Strings (""), null, undefined, false und die Zahl 0 und NaN. Angenommen, eine Zeichenkette ist leer var name = "" und console.log(!name) gibt true .

function isEmpty(val){
  return !val;
}

Diese Funktion gibt true zurück, wenn val leer ist, null, undefined, false, die Zahl 0 oder NaN .


// value is undefined or null
return value === undefined || value === null;

JavaScript-Ninjas könnten den Operator == :

return value == null;

function isEmpty(value){
  return (value == null || value.length === 0);
}

Dies wird für wahr zurückgegeben

undefined  // Because undefined == null

null

[]

""

und Null-Argument-Funktionen, da die length einer Funktion die Anzahl der deklarierten Parameter ist.

Um die letztere Kategorie zu verbieten, sollten Sie nur nach leeren Zeichenfolgen suchen

function isEmpty(value){
  return (value == null || value === '');
}

var myNewValue = myObject && myObject.child && myObject.child.myValue;

Dies wird niemals einen Fehler verursachen. Wenn myObject , child oder myValue null ist, ist myNewValue null. Es werden keine Fehler ausgegeben





undefined