Jak sprawdzić wartości zerowe w JavaScript?

Jak mogę sprawdzić wartości zerowe w JavaScript? Napisałem poniższy kod, ale nie działał.

if (pass == null || cpass == null || email == null || cemail == null || user == null) {      

    alert("fill all columns");
    return false;  

}   

Jak mogę znaleźć błędy w moich programach JavaScript?

JavaScript jest bardzo elastyczny w zakresie sprawdzania wartości „zerowych”. Zgaduję, że faktycznie szukasz pustych ciągów, w takim przypadku ten prostszy kod będzie działał:

if(!pass || !cpass || !email || !cemail || !user){

Który sprawdzi pustych strunach ( ""), null, undefined, falseoraz numery 0iNaN

Należy pamiętać, że jeśli konkretnie sprawdza się liczby, często pomija się 0tę metodę i num !== 0jest preferowane ( num !== -1lub ~num(hacky kod, który sprawdza również -1)) dla funkcji, które zwracają -1, np. indexOf)

Aby sprawdzić, czy nie ma wartości SZCZEGÓŁOWE , użyłbyś tego:

if (variable === null)

Ten test będzie tylko udawać nulli nie przejdzie do "", undefined, false, 0, lub NaN.

Dodatkowo podałem bezwzględne kontrole dla każdej „fałszywej” wartości (tej, która zwróciłaby wartość true !variable).

Uwaga: w przypadku niektórych kontroli bezwzględnych konieczne będzie wdrożenie funkcji absolutely equals: ===i typeof.

Utworzyłem JSFiddle tutaj aby pokazać wszystkie z poszczególnych testów pracy

Oto wynik każdej kontroli:

Null Test:

if (variable === null)

- variable = ""; (false) typeof variable = string

- variable = null; (true) typeof variable = object

- variable = undefined; (false) typeof variable = undefined

- variable = false; (false) typeof variable = boolean

- variable = 0; (false) typeof variable = number

- variable = NaN; (false) typeof variable = number



Empty String Test:

if (variable === '')

- variable = ''; (true) typeof variable = string

- variable = null; (false) typeof variable = object

- variable = undefined; (false) typeof variable = undefined

- variable = false; (false) typeof variable = boolean

- variable = 0; (false) typeof variable = number

- variable = NaN; (false) typeof variable = number




Undefined Test:

if (typeof variable == "undefined")

-- or --

if (variable === undefined)

- variable = ''; (false) typeof variable = string

- variable = null; (false) typeof variable = object

- variable = undefined; (true) typeof variable = undefined

- variable = false; (false) typeof variable = boolean

- variable = 0; (false) typeof variable = number

- variable = NaN; (false) typeof variable = number



False Test:

if (variable === false)

- variable = ''; (false) typeof variable = string

- variable = null; (false) typeof variable = object

- variable = undefined; (false) typeof variable = undefined

- variable = false; (true) typeof variable = boolean

- variable = 0; (false) typeof variable = number

- variable = NaN; (false) typeof variable = number



Zero Test:

if (variable === 0)

- variable = ''; (false) typeof variable = string

- variable = null; (false) typeof variable = object

- variable = undefined; (false) typeof variable = undefined

- variable = false; (false) typeof variable = boolean

- variable = 0; (true) typeof variable = number

- variable = NaN; (false) typeof variable = number



NaN Test:

if (typeof variable == 'number' && !parseFloat(variable) && variable !== 0)

-- or --

if (isNaN(variable))

- variable = ''; (false) typeof variable = string

- variable = null; (false) typeof variable = object

- variable = undefined; (false) typeof variable = undefined

- variable = false; (false) typeof variable = boolean

- variable = 0; (false) typeof variable = number

- variable = NaN; (true) typeof variable = number

Jak widać, testowanie przeciwko jest nieco trudniejsze NaN;

po prostu wymienić ==się ===we wszystkich miejscach.

== to luźne lub abstrakcyjne porównanie równości

=== jest ścisłym porównaniem równości

Aby uzyskać więcej informacji, zobacz artykuł MDN na temat porównań i identyczności równości .

Operator ścisłej równości:

Możemy sprawdzić wartość null przez ===

if ( value === null ){

}

Tylko za pomocą if

if( value ) {

}

oceni prawdę, jeśli wartość nie jest :

• zero
• nieokreślony
• NaN
• pusta struna ("")
• fałszywe
• 0

Ulepszenie w stosunku do zaakceptowanej odpowiedzi poprzez jawne sprawdzenie, nullale z uproszczoną składnią:

if ([pass, cpass, email, cemail, user].every(x=>x!==null)) {
    // your code here ...
}

// Test
let pass=1, cpass=1, email=1, cemail=1, user=1; // just to test

if ([pass, cpass, email, cemail, user].every(x=>x!==null)) {
    // your code here ...
    console.log ("Yayy! None of them are null");
} else {
    console.log ("Oops! At-lease one of them is null");
}

Po pierwsze, masz instrukcję return bez treści funkcji. Są szanse, że spowoduje to błąd.

Bardziej czystym sposobem na sprawdzenie byłoby po prostu użycie! operator:

if (!pass || !cpass || !email || !cemail || !user) {

    alert("fill all columns");

}

możesz wreszcie spróbować złapać

 try {
     document.getElementById("mydiv").innerHTML = 'Success' //assuming "mydiv" is undefined
 } catch (e) {

     if (e.name.toString() == "TypeError") //evals to true in this case
     //do something

 } finally {}   

możesz także throwwłasne błędy. Zobacz to .

W JavaScript żaden ciąg znaków nie jest równy null.

Być może spodziewałeś się, że pass == nullto prawda, gdy passpusty ciąg znaków, ponieważ masz świadomość, że operator luźnej równości ==dokonuje pewnego rodzaju przymusu typu.

Na przykład to wyrażenie jest prawdziwe:

'' == 0

Natomiast operator ścisłej równości ===mówi, że jest to fałsz:

'' === 0

Biorąc to pod uwagę ''i 0są luźno równe, możesz rozsądnie przypuszczać, że ''i nullsą luźno równe. Jednak nie są.

To wyrażenie jest fałszywe:

'' == null

Wynik porównania dowolnego ciągu znaków nulljest fałszywy. Dlatego pass == nullwszystkie pozostałe testy są zawsze fałszywe, a użytkownik nigdy nie otrzymuje ostrzeżenia.

Aby naprawić kod, porównaj każdą wartość z pustym ciągiem:

pass === ''

Jeśli masz pewność, że passjest to ciąg, pass == ''zadziała również, ponieważ tylko pusty ciąg jest luźno równy pustemu ciągowi. Z drugiej strony niektórzy eksperci twierdzą, że dobrą praktyką jest zawsze stosowanie ścisłej równości w JavaScript, chyba że specjalnie chcesz zastosować przymus typu, który wykonuje operator luźnej równości.

Jeśli chcesz wiedzieć, które pary wartości są luźno równe, zobacz tabelę „Porównania podobieństwa” w artykule Mozilli na ten temat .

aby sprawdzić, czy w javascript jest niezdefiniowana i pusta , wystarczy napisać:

if (!var) {
        console.log("var IS null or undefined");
} else {
        console.log("var is NOT null or undefined");
}

To jest komentarz dotyczący rozwiązania WebWanderer dotyczącego sprawdzania NaN (nie mam jeszcze wystarczającej liczby przedstawicieli, aby zostawić formalny komentarz). Rozwiązanie brzmi jak

if(!parseInt(variable) && variable != 0 && typeof variable === "number")

ale to się nie powiedzie w przypadku liczb wymiernych, które zaokrągliby do 0, takich jak variable = 0.1. Lepszym testem byłoby:

if(isNaN(variable) && typeof variable === "number")

Właściwie myślę, że możesz potrzebować użyć, if (value !== null || value !== undefined) ponieważ jeśli użyjesz if (value), możesz również odfiltrować 0 lub fałszywe wartości.

Rozważ te dwie funkcje:

const firstTest = value => {
    if (value) {
        console.log('passed');
    } else {
        console.log('failed');
    }
}
const secondTest = value => {
    if (value !== null && value !== undefined) {
        console.log('passed');
    } else {
        console.log('failed');
    }
}

firstTest(0);            // result: failed
secondTest(0);           // result: passed

firstTest(false);        // result: failed
secondTest(false);       // result: passed

firstTest('');           // result: failed
secondTest('');          // result: passed

firstTest(null);         // result: failed
secondTest(null);        // result: failed

firstTest(undefined);    // result: failed
secondTest(undefined);   // result: failed

W mojej sytuacji, po prostu potrzebne, aby sprawdzić, czy wartość jest null i niezdefiniowana i nie chcę aby filtrować 0albo falseczy ''wartości. więc użyłem drugiego testu, ale może być konieczne ich też odfiltrowanie, co może spowodować, że użyjesz pierwszego testu.

Znalazłem inny sposób na sprawdzenie, czy wartość jest pusta:

if(variable >= 0 && typeof variable === "object")

nullDziała jak numberi objectw tym samym czasie. Porównywanie null >= 0lub null <= 0wyniki w true. Porównując null === 0lub null > 0czy null < 0spowoduje fałszywy. Ale podobnie jak nullobiekt możemy go wykryć jako zerowy.

Zrobiłem bardziej złożoną funkcję, że czarownica poradzi sobie lepiej niż typeof i można powiedzieć, jakie typy należy uwzględnić lub zachować w grupie

/* function natureof(variable, [included types])
included types are 
    null - null will result in "undefined" or if included, will result in "null"
    NaN - NaN will result in "undefined" or if included, will result in "NaN"
    -infinity - will separate negative -Inifity from "Infinity"
    number - will split number into "int" or "double"
    array - will separate "array" from "object"
    empty - empty "string" will result in "empty" or
    empty=undefined - empty "string" will result in "undefined"
*/
function natureof(v, ...types){
/*null*/            if(v === null) return types.includes('null') ? "null" : "undefined";
/*NaN*/             if(typeof v == "number") return (isNaN(v)) ? types.includes('NaN') ? "NaN" : "undefined" : 
/*-infinity*/       (v+1 === v) ? (types.includes('-infinity') && v === Number.NEGATIVE_INFINITY) ? "-infinity" : "infinity" : 
/*number*/          (types.includes('number')) ? (Number.isInteger(v)) ? "int" : "double" : "number";
/*array*/           if(typeof v == "object") return (types.includes('array') && Array.isArray(v)) ? "array" : "object";
/*empty*/           if(typeof v == "string") return (v == "") ? types.includes('empty') ? "empty" : 
/*empty=undefined*/ types.includes('empty=undefined') ? "undefined" : "string" : "string";
                    else return typeof v
}

// DEMO
let types = [null, "", "string", undefined, NaN, Infinity, -Infinity, false, "false", true, "true", 0, 1, -1, 0.1, "test", {var:1}, [1,2], {0: 1, 1: 2, length: 2}]

for(i in types){
console.log("natureof ", types[i], " = ", natureof(types[i], "null", "NaN", "-infinity", "number", "array", "empty=undefined")) 
}

Zrobiłem tę bardzo prostą funkcję, która działa cuda:

function safeOrZero(route) {
  try {
    Function(`return (${route})`)();
  } catch (error) {
    return 0;
  }
  return Function(`return (${route})`)();
}

Trasa to dowolny łańcuch wartości, który może wybuchnąć. Używam go do jQuery / cheerio i obiektów i tym podobnych.

Przykłady 1: obiekt prosty, jak to const testObj = {items: [{ val: 'haya' }, { val: null }, { val: 'hum!' }];};.

Ale może to być bardzo duży przedmiot, którego nawet nie stworzyliśmy. Więc przekazuję to przez:

let value1 = testobj.items[2].val;  // "hum!"
let value2 = testobj.items[3].val;  // Uncaught TypeError: Cannot read property 'val' of undefined

let svalue1 = safeOrZero(`testobj.items[2].val`)  // "hum!"
let svalue2 = safeOrZero(`testobj.items[3].val`)  // 0

Oczywiście jeśli wolisz, możesz użyć nullalbo 'No value'... Niezależnie od własnych potrzeb.

Zwykle zapytanie DOM lub selektor jQuery może zgłosić błąd, jeśli nie zostanie znaleziony. Ale używając czegoś takiego:

const bookLink = safeOrZero($('span.guidebook > a')[0].href);
if(bookLink){
  [...]
}

Możesz użyć modułu lodash, aby sprawdzić, czy wartość jest pusta lub niezdefiniowana

_.isNil(value)
Example 

 country= "Abc"
    _.isNil(country)
    //false

   state= null
    _.isNil(state)
    //true

city= undefined
    _.isNil(state)
    //true

   pin= true
    _.isNil(pin)
    // false   

LINK: https://lodash.com/docs/#isNil

To nie zadziała w przypadku wartości logicznych pochodzących z DB np.

 value = false

 if(!value) {
   // it will change all false values to not available
   return "not available"
 }

AFAIK w JAVASCRIPT, gdy zmienna jest zadeklarowana, ale nie ma przypisanej wartości, jej typ to undefined. więc możemy sprawdzić zmienną, nawet jeśli byłaby to instancjaobject trzymająca miejsce zamiast wartości .

utwórz metodę pomocniczą do sprawdzania zwracanej wartości null truei użyj jej w interfejsie API.

funkcja pomocnicza, aby sprawdzić, czy zmienna jest pusta:

function isEmpty(item){
    if(item){
        return false;
    }else{
        return true;
    }
}

try-catch wyjątkowe wywołanie API:

try {

    var pass, cpass, email, cemail, user; // only declared but contains nothing.

    // parametrs checking
    if(isEmpty(pass) || isEmpty(cpass) || isEmpty(email) || isEmpty(cemail) || isEmpty(user)){
        console.log("One or More of these parameter contains no vlaue. [pass] and-or [cpass] and-or [email] and-or [cemail] and-or [user]");
    }else{
        // do stuff
    }

} catch (e) {
    if (e instanceof ReferenceError) {
        console.log(e.message); // debugging purpose
        return true;
    } else {
        console.log(e.message); // debugging purpose
        return true;
    }
}

niektóre przypadki testowe:

var item = ""; // isEmpty? true
var item = " "; // isEmpty? false
var item; // isEmpty? true
var item = 0; // isEmpty? true
var item = 1; // isEmpty? false
var item = "AAAAA"; // isEmpty? false
var item = NaN; // isEmpty? true
var item = null; // isEmpty? true
var item = undefined; // isEmpty? true

console.log("isEmpty? "+isEmpty(item));

Sprawdzanie warunków błędu:

// Typical API response data
let data = {
  status: true,
  user: [],
  total: 0,
  activity: {sports: 1}
}

// A flag that checks whether all conditions were met or not
var passed = true;

// Boolean check
if (data['status'] === undefined || data['status'] == false){
  console.log("Undefined / no `status` data");
  passed = false;
}

// Array/dict check
if (data['user'] === undefined || !data['user'].length){
  console.log("Undefined / no `user` data");
  passed = false;
}

// Checking a key in a dictionary
if (data['activity'] === undefined || data['activity']['time'] === undefined){
   console.log("Undefined / no `time` data");
   passed = false;
}

// Other values check
if (data['total'] === undefined || !data['total']){
  console.log("Undefined / no `total` data");
  passed = false;
}

// Passed all tests?
if (passed){
  console.log("Passed all tests");
}

Spróbuj tego:

if (!variable && typeof variable === "object") {
    // variable is null
}