Czy istnieje uniwersalna funkcja JavaScript, która sprawdza, że zmienna ma wartość i zapewnia, że nie jest undefined lub null? Mam ten kod, ale nie jestem pewien, czy obejmuje wszystkie przypadki:

function isEmpty(val){
    return (val === undefined || val == null || val.length <= 0) ? true : false;
}
2719
Alex 1 kwiecień 2011, 19:14

27 odpowiedzi

const isEmpty = value => (
  (!value && value !== 0 && value !== false)
  || (Array.isArray(value) && value.length === 0)
  || (isObject(value) && Object.keys(value).length === 0)
  || (typeof value.size === 'number' && value.size === 0)

  // `WeekMap.length` is supposed to exist!?
  || (typeof value.length === 'number'
      && typeof value !== 'function' && value.length === 0)
);

// Source: https://levelup.gitconnected.com/javascript-check-if-a-variable-is-an-object-and-nothing-else-not-an-array-a-set-etc-a3987ea08fd7
const isObject = value =>
  Object.prototype.toString.call(value) === '[object Object]';

testów biednych 😁

const test = () => {
  const run = (label, values, expected) => {
    const length = values.length;
    console.group(`${label} (${length} tests)`);
    values.map((v, i) => {
      console.assert(isEmpty(v) === expected, `${i}: ${v}`);
    });
    console.groupEnd();
  };

  const empty = [
    null, undefined, NaN, '', {}, [],
    new Set(), new Set([]), new Map(), new Map([]),
  ];
  const notEmpty = [
    ' ', 'a', 0, 1, -1, false, true, {a: 1}, [0],
    new Set([0]), new Map([['a', 1]]),
    new WeakMap().set({}, 1),
    new Date(), /a/, new RegExp(), () => {},
  ];
  const shouldBeEmpty = [
    {undefined: undefined}, new Map([[]]),
  ];

  run('EMPTY', empty, true);
  run('NOT EMPTY', notEmpty, false);
  run('SHOULD BE EMPTY', shouldBeEmpty, true);
};

Wyniki testu:

EMPTY (10 tests)
NOT EMPTY (16 tests)
SHOULD BE EMPTY (2 tests)
  Assertion failed: 0: [object Object]
  Assertion failed: 1: [object Map]
2
Pascal Polleunus 23 kwiecień 2020, 08:06

Myślę, że używam? Operator jest nieco czyszczący.

var ? function_if_exists() : function_if_doesnt_exist();
0
Pedro Pereira 30 czerwiec 2016, 09:31

Chociaż Oldie, co zapomnieć, że powinni ciąć blok kodu, a następnie złapać błąd, a następnie przetestować ...

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

Więc naprawdę nie musisz sprawdzać potencjalnego problemu przed ręką, po prostu go złapiesz, a następnie radzić sobie z tym, jak chcesz.

0
Mark Giblin 10 marzec 2017, 09:57

Możesz bezpośrednio korzystać z operatora równości

<script>
    var firstName;
    var lastName = null;
    /* Since null == undefined is true, the following statements will catch both null and undefined */
        if(firstName == null){
            alert('Variable "firstName" is undefined.');
        }    
        if(lastName == null){
           alert('Variable "lastName" is null.');
        }
</script>

Demo @ Jak określić Jeśli zmienna jest niezdefiniowana lub null przy użyciu javascript

0
jonathan klevin 29 marzec 2018, 07:50
try{

     let vari = obj.propTest; // obj may be don't have propTest property

        ...
} catch(NullException){
    // do something here
}

Myślę, że przy użyciu Catch można uniknąć błędu kontroli NULL, także w kątowym lub JavaScript, przyciągając w nim wyjątek NULL i proces.

0
nobjta_9x_tq 1 październik 2018, 10:25

To obejmuje również pustą tablicę i pusty obiekt

null, niezdefiniowany, ", 0, [], {}

isEmpty = (value) => (!value  || (typeof v === 'object' &&
   Object.keys(value).length < 1));
0
Narasimha Reddy - Geeker 9 styczeń 2020, 11:13

Doskonałą metodę sprawdzenia, czy wartość jest niezdefiniowana lub null to:

return value === undefined || value === null;

Możesz także użyć operatora ==, ale spodziewa się to z Znajdź wszystkie zasady:

return value == null; // also returns true if value is undefined
251
Salman A 18 lipiec 2018, 12:26
function isEmpty(value){
  return (value == null || value.length === 0);
}

Spowoduje to powrót prawdą

undefined  // Because undefined == null

null

[]

""

I funkcje zero argumentów ponieważ funkcja length jest liczbą zadeklarowanych parametrów, które wymagają.

Aby zezwolić tej ostatniej kategorii, możesz po prostu sprawdzić dla pustych ciągów

function isEmpty(value){
  return (value == null || value === '');
}
90
Mike Samuel 16 luty 2015, 17:04

Możesz znaleźć następującą funkcję Przydatne:

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

Lub w ES7 (komentarz, jeśli dalsze ulepszenia)

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

  return type.toLowerCase();
}

Wyniki:

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
typeOf(new WeakMap()) //weakmap
typeOf(new Map()) //map

"Należy zauważyć, że operator wiązania (: :) nie jest częścią ES2016 (ES7), ani żadnej późniejszej edycji Norma ECMASCRIPT w ogóle. Jest obecnie propozycję etapu 0 (Strawman), aby wprowadzić język". - Simon Kjellberg. Autor pragnie dodać jego wsparcie dla tej pięknej propozycji otrzymywania Royal Wniebowstąpienie.

30
Vix 14 sierpień 2018, 19:42

Pierwsza odpowiedź z najlepszą oceną jest błędna. Jeśli wartość jest niezdefiniowana, rzuci to wyjątek w nowoczesnych przeglądarkach. Musisz użyć:

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

Lub

if (typeof value  !== "undefined" && value)
27
krupar 19 marzec 2014, 13:23

Ten błąd

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

To wszystko, czego potrzebujesz.

19
Aryeh Beitz 3 czerwiec 2017, 19:51

! Sprawdź puste struny (""), null, niezdefiniowane, false i numer 0 i Nan. Powiedz, jeśli ciąg jest pusty var name = "" Następnie var name = "" {X1}} zwraca true.

function isEmpty(val){
  return !val;
}

Ta funkcja powróci true, jeśli val jest pusty, null, niezdefiniowany, false, numer 0 lub NAN .

LUB

Zgodnie z domenem problemy możesz wystarczyć jak !val lub !!val.

19
Arif 8 maj 2019, 07:40

Jesteś trochę przesadzony. Aby sprawdzić, czy zmienna nie otrzymuje wartości, konieczne byłoby tylko sprawdzić niepokonaty i null.

function isEmpty(value){
    return (typeof value === "undefined" || value === null);
}

Obejmuje 0, "", a obiekty (nawet pusty obiekt i tablicę) są prawidłowe "wartości".

15
tcooc 1 kwiecień 2011, 15:21

Oto moje - zwraca prawdziwe, jeśli wartość jest null, niezdefiniowana, etc lub pusta (np. Zawiera tylko puste miejsca):

function stringIsEmpty(value) {

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

}
11
DavidWainwright 12 luty 2014, 15:45

Jeśli wolisz prosty JavaScript, spróbuj spróbuj tego:

  /**
   * 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;
  }

W przeciwnym razie, jeśli już używasz podkreślenia lub Lodash, spróbuj:

_.isEmpty(value)
11
l3x 21 sierpień 2015, 13:39
return val || 'Handle empty variable'

Jest naprawdę ładny i czysty sposób, aby obsłużyć go w wielu miejscach, może być również używany do przypisywania zmiennych

const res = val || 'default value'
7
cubefox 4 grudzień 2018, 12:44

Jeśli zmienna nie została zadeklarowana, nie będziesz w stanie przetestować niezdefiniowanych za pomocą funkcji, ponieważ otrzymasz błąd.

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

Oba wygenerują błąd, jeśli foo nie został zadeklarowany.

Jeśli chcesz przetestować, czy zmienna została zadeklarowana, możesz użyć

typeof foo != "undefined"

Jeśli chcesz przetestować, czy foo zostało zadeklarowane i ma wartość, której możesz użyć

if (typeof foo != "undefined" && foo) {
    //code here
}
6
herostwist 1 kwiecień 2011, 15:25

, aby sprawdzić wartość domyślną

function typeOfVar (obj) {
      return {}.toString.call(obj).split(' ')[1].slice(0, -1).toLowerCase();
}
function isVariableHaveDefaltVal(variable) {
    if ( typeof(variable) === 'string' ) {  // number, boolean, string, object 
        console.log(' Any data Between single/double Quotes is treated as String ');        
        return (variable.trim().length === 0) ? true : false;
    }else if ( typeof(variable) === 'boolean' ) {
      console.log('boolean value with default value \'false\'');
        return (variable === false) ? true : false;
    }else if ( typeof(variable) === 'undefined' ) {
        console.log('EX: var a; variable is created, but has the default value of undefined.'); 
        return true;
    }else if ( typeof(variable) === 'number' ) { 
        console.log('number : '+variable);
        return (variable === 0 ) ? true : false;
    }else if ( typeof(variable) === 'object' ) {
   //   -----Object-----
        if (typeOfVar(variable) === 'array' && variable.length === 0) {
            console.log('\t Object Array with length = ' + [].length); // Object.keys(variable)
            return true;
        }else if (typeOfVar(variable) === 'string' && variable.length === 0 ) {
            console.log('\t Object String with length = ' + variable.length);
            return true;
        }else if (typeOfVar(variable) === 'boolean' ) {
            console.log('\t Object Boolean = ' + variable);
            return (variable === false) ? true : false;
        }else if (typeOfVar(variable) === 'number' ) {
            console.log('\t Object Number = ' + variable);
            return (variable === 0 ) ? true : false;
        }else if (typeOfVar(variable) === 'regexp' && variable.source.trim().length === 0 ) {
       console.log('\t Object Regular Expression : ');
        return true;
        }else if (variable === null) {
       console.log('\t Object null value');
        return true;
        }
    }
    return false;
}
var str = "A Basket For Every Occasion";
str = str.replace(/\s/g, "-");
//The "g" flag in the regex will cause all spaces to get replaced.

Sprawdź wynik:

isVariableHaveDefaltVal(' '); // string          
isVariableHaveDefaltVal(false); // boolean       
var a;           
isVariableHaveDefaltVal(a);               
isVariableHaveDefaltVal(0); // number             
isVariableHaveDefaltVal(parseInt('')); // NAN isNAN(' '); - true         
isVariableHaveDefaltVal(null);              
isVariableHaveDefaltVal([]);               
isVariableHaveDefaltVal(/ /);              
isVariableHaveDefaltVal(new Object(''));               
isVariableHaveDefaltVal(new Object(false));            
isVariableHaveDefaltVal(new Object(0)); 
typeOfVar( function() {} );

Użyłem funkcji @vix (), aby sprawdzić obiekt tego typu.

Za pomocą instanceof «

var prototypes_or_Literals = function (obj) {
    switch (typeof(obj)) {
        // object prototypes
        case 'object':
            if (obj instanceof Array)
                return '[object Array]';
            else if (obj instanceof Date)
                return '[object Date]';
            else if (obj instanceof RegExp)
                return '[object regexp]';
            else if (obj instanceof String)
                return '[object String]';
            else if (obj instanceof Number)
                return '[object Number]';

            else
                return 'object';
        // object literals
        default:
            return typeof(obj);
    }   
};
output test «
prototypes_or_Literals( '' ) // "string"
prototypes_or_Literals( new String('') ) // "[object String]"
Object.prototype.toString.call("foo bar") //"[object String]"        
5
Yash 9 kwiecień 2017, 05:39
function isEmpty(obj) {
    if (typeof obj == 'number') return false;
    else if (typeof obj == 'string') return obj.length == 0;
    else if (Array.isArray(obj)) return obj.length == 0;
    else if (typeof obj == 'object') return obj == null || Object.keys(obj).length == 0;
    else if (typeof obj == 'boolean') return false;
    else return !obj;
}

W ES6 z wykończeniem do radzenia sobie ze strunami białek:

const isEmpty = value => {
    if (typeof value === 'number') return false
    else if (typeof value === 'string') return value.trim().length === 0
    else if (Array.isArray(value)) return value.length === 0
    else if (typeof value === 'object') return value == null || Object.keys(value).length === 0
    else if (typeof value === 'boolean') return false
    else return !value
}
5
Fabian von Ellerts 5 październik 2018, 14:37

Może być przydatny.

Wszystkie wartości w tablicy reprezentują to, co chcesz być (null, niezdefiniowane lub inne rzeczy) i szukasz tego, co chcesz.

var variablesWhatILookFor = [null, undefined, ''];
variablesWhatILookFor.indexOf(document.DocumentNumberLabel) > -1
5
ddagsan 14 czerwiec 2019, 10:36

Jeśli używasz TypeScript} i nie chcesz uwzględnić wartości "To są false" , to jest to rozwiązanie dla Ciebie:

Po pierwsze: import { isNullOrUndefined } from 'util';

Następnie: isNullOrUndefined(this.yourVariableName)

Uwaga: Jak wspomniano Poniżej Jest to teraz przestarzały, użyj {x0}}}. Ref.

4
BlackBeard 5 październik 2018, 02:48

spróbuj z inną logiką . Możesz użyć innego kodu do sprawdzenia wszystkich czterech (4) warunku walidacji, jak nie pusty, nie pusty, nie bezdefiniowany, a nie zero Używaj tylko tego kodu (! (! (Zmienna))) w JavaScript i jQuery.

function myFunction() {
    var data;  //The Values can be like as null, blank, undefined, zero you can test

    if(!(!(data)))
    {
        alert("data "+data);
    } 
    else 
    {
        alert("data is "+data);
    }
}
3
Ravikant 2 styczeń 2020, 10:18
function isEmpty(val){
    return !val;
}

Ale to rozwiązanie jest przeciążone, jeśli nie możesz zmodyfikować funkcji później w przypadku potrzeb biznesowych, jest czystsze, aby używać go bezpośrednio w kodzie:

if(!val)...
2
Luca C. 2 czerwiec 2017, 08:30
var myNewValue = myObject && myObject.child && myObject.child.myValue;

To nigdy nie rzuci błędu. Jeśli myObject , dziecko , albo myvalue jest null, a następnie mynewValue będzie null. Nie zostaną rzucone żadne błędy

2
Sᴀᴍ Onᴇᴌᴀ 20 czerwiec 2017, 20:46

Dla wszystkich przyjeżdżających tutaj za podobne pytanie, następujące prace świetne i mam to w mojej bibliotece w ostatnich latach:

(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://stackoverflow.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));
2
centurian 2 grudzień 2017, 09:27

Spowoduje to sprawdzenie, czy zmienna zagnieżdżania nieokreślona jest niezdefiniowana

function Undef(str) 
{
  var ary = str.split('.');
  var w = window;
  for (i in ary) {
    try      { if (typeof(w = w[ary[i]]) === "undefined") return true; }
    catch(e) { return true; }
  }
  return false;
}

if (!Undef("google.translate.TranslateElement")) {

Powyższe sprawdza, czy istnieje translistyment funkcji Google Translate. Jest to odpowiednik:

if (!(typeof google === "undefined" 
 || typeof google.translate === "undefined" 
 || typeof google.translate.TranslateElement === "undefined")) {
1
rickdog 3 wrzesień 2016, 21:49

Spójrz na nowy ECMascript Nulish Coalescing Operator .

Możesz myśleć o tej funkcji - operator ?? - jako sposób na "upadku" do wartości domyślnej podczas radzenia sobie z null lub undefined.

let x = foo ?? bar();

Ponownie, powyższy kod jest równoważny następujących.

let x = (foo !== null && foo !== undefined) ? foo : bar();
11
Daniel Eduardo Delgado Diaz 17 marzec 2020, 17:32