Как проверить нулевые значения в JavaScript? Я написал код ниже, но это не сработало.
if (pass == null || cpass == null || email == null || cemail == null || user == null) {
alert("fill all columns");
return false;
}
И как я могу найти ошибки в моих программах JavaScript?
Javascript очень гибкий в отношении проверки "нулевых" значений. Я предполагаю, что вы действительно ищете пустые строки, и в этом случае этот более простой код будет работать:
if(!pass || !cpass || !email || !cemail || !user){
Что будет проверять пустые строки (""), null, undefined, false и числа 0 и NaN
Обратите внимание, что если вы специально проверяете номера, это распространенная ошибка пропустить 0 с помощью этого метода, а num !== 0 является предпочтительным (или num !== -1 или ~num (хакерский код, который также проверяет на -1)) для функций, возвращающих -1, например indexOf)
Чтобы проверить значение null SPECIFICALLY, вы должны использовать это:
if(variable === null && typeof variable === "object")
... или проще:
if(variable === null)
Этот тест будет ТОЛЬКО проходить для null и не будет проходить для "", undefined, false, 0 или NaN.
В остальном это ответ на комментарий inorganik. Да, вы можете проверить каждый отдельно.
Вам необходимо реализовать функции absolutely equals: === и typeof, чтобы быть абсолютно уверенными в ваших проверках.
Я создал JSFiddle здесь, чтобы показать все индивидуальные тесты, работающие
Вот все результаты тестов:
Null Test:
if(variable === null && typeof variable === "object")
- 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 === "" && typeof variable === "string")
- 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(variable === undefined && typeof 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 && typeof variable === "boolean")
- 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 && typeof variable === "number")
- 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(!parseFloat(variable) && variable != 0 && typeof variable === "number")
- 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
Как вы можете видеть, немного сложнее протестировать NaN;
просто замените == на === во всех местах.
== это свободное или абстрактное сравнение на равенство
=== это строгое сравнение
См. Статью MDN о сравнениях и сходстве равенства для более подробной информации.
Строгий оператор равенства: -
Мы можем проверить значение null на ===
if ( value === null ){
}
Просто используя if
if( value ) {
}
будет оценивать значение true, если не:
Во-первых, у вас есть оператор return без тела функции. Скорее всего, это вызовет ошибку.
Более чистый способ сделать ваш чек - просто использовать! Оператор:
if (!pass || !cpass || !email || !cemail || !user) {
alert("fill all columns");
}
Улучшение по сравнению с принятым ответом путем явной проверки на null но с упрощенным синтаксисом:
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");
}вы можете использовать try catch finally
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 {}
вы также можете throw свои собственные ошибки. См. this.
для проверки undefined и null в javascript вам нужно просто написать следующее:
if (!var) {
console.log("var IS null or undefined");
} else {
console.log("var is NOT null or undefined");
}
Это комментарий к решению WebWanderer относительно проверки для NaN (у меня пока нет достаточного количества отзывов, чтобы оставить официальный комментарий). Решение читается как
if(!parseInt(variable) && variable != 0 && typeof variable === "number")
но это не удастся для рациональных чисел, которые будут округлены до 0, например variable = 0.1. Лучшим тестом будет:
if(isNaN(variable) && typeof variable === "number")
В JavaScript ни одна строка не равна null.
Возможно, вы ожидали, что pass == null будет истинным, если pass является пустой строкой, потому что вы знаете, что оператор свободного равенства == выполняет определенные виды принудительного типа.
Например, это выражение верно:
'' == 0
Напротив, оператор строгого равенства === говорит, что это неверно:
'' === 0
Учитывая, что '' и 0 слабо равны, вы можете разумно предположить, что '' и null являются равными. Однако это не так.
Это выражение ложно:
'' == null
Результатом сравнения любой строки с null является false. Поэтому pass == null и все ваши другие тесты всегда ложны, и пользователь никогда не получает предупреждение.
Чтобы исправить свой код, сравните каждое значение с пустой строкой:
pass === ''
Если вы уверены, что pass является строкой, pass == '' также будет работать, потому что только пустая строка свободно равна пустой строке. С другой стороны, некоторые эксперты говорят, что хорошая практика всегда использовать строгое равенство в JavaScript, если вы специально не хотите делать принуждение типа, которое выполняет оператор свободного равенства.
Если вы хотите знать, какие пары значений являются равными, см. таблицу "Сравнение сходства" в статье Mozilla по этому вопросу.
подчеркивание: _. isNull
_.isNull(null);
=> true
_.isNull(undefined);
=> false
jQuery: jQuery.type
jQuery.type( null ) === "null"
На самом деле, я думаю, вам может понадобиться использовать if (value !== null || value !== undefined) потому что если вы используете if (value) вы также можете фильтровать 0 или ложные значения.
Рассмотрим эти две функции:
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
В моей ситуации мне просто нужно было проверить, является ли значение нулевым и неопределенным, и я не хотел фильтровать 0 или false или '' значения. поэтому я использовал второй тест, но вам может понадобиться отфильтровать их, что может привести к использованию первого теста.
Я нашел другой способ проверить, если значение равно нулю:
if(variable >= 0 && typeof variable === "object")
null действует как number и object одновременно. Сравнение null >= 0 или null <= 0 приводит к true. Сравнение null === 0 или null > 0 или null < 0 приведет к ложному. Но поскольку null также является объектом, мы можем обнаружить его как ноль.
Я сделал более сложную функцию. Nature of witch будет работать лучше, чем typeof, и мне скажут, какие типы включать или сохранять сгруппированными.
/* 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"))
}Пожалуйста, просмотрите внимательно перед понижением.
AFAIK в JAVASCRIPT, когда переменная объявлена, но ей не присвоено значение, ее тип не undefined. поэтому мы можем проверить переменную, даже если это будет object содержащий некоторый экземпляр вместо значения.
создайте вспомогательный метод для проверки недействительности, который возвращает true и используйте его в своем API.
вспомогательная функция для проверки, если переменная пуста:
function isEmpty(item){
if(item){
return false;
}else{
return true;
}
}
попробуй поймать исключительный вызов 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;
}
}
некоторые тестовые случаи:
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));
Это не будет работать в случае логических значений, поступающих из БД для ex:
value = false
if(!value) {
// it will change all false values to not available
return "not available"
}
Я сделал эту очень простую функцию, которая творит чудеса:
function safeOrZero(route) {
try {
Function('return (${route})')();
} catch (error) {
return 0;
}
return Function('return (${route})')();
}
Маршрут - это любая цепочка ценностей, которая может взорваться. Я использую его для JQuery/Cheerio и объектов и тому подобное.
Примеры 1: простой объект, такой как этот const testObj = {items: [{ val: 'haya' }, { val: null }, { val: 'hum!' }];}; const testObj = {items: [{ val: 'haya' }, { val: null }, { val: 'hum!' }];}; ,
Но это может быть очень большой объект, который мы даже не сделали. Так что я передаю это через:
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
Конечно, если вы предпочитаете, вы можете использовать null или 'No value'... Все, что соответствует вашим потребностям.
Обычно запрос DOM или селектор jQuery могут выдать ошибку, если она не найдена. Но используя что-то вроде:
const bookLink = safeOrZero($('span.guidebook > a')[0].href);
if(bookLink){
[...]
}
Попробуйте следующее:
if (!variable && typeof variable === "object") {
// variable is null
}
Вы также можете использовать этот повторно используемый is-nil компонент с открытым исходным кодом, который определяет, является ли ссылка val нулевой или undefined и возвращает логическое.
Примеры:
isNil(null) // => true
isNil('') // => true
Он вернет false, даже если задана пустая строка, например.
Вы можете использовать модуль lodash, чтобы проверить, является ли значение пустым или неопределенным
_.isNil(value)
Example
country= "Abc"
_.isNil(country)
//false
state= null
_.isNil(state)
//true
city= undefined
_.isNil(state)
//true
pin= true
_.isNil(pin)
// false
Ссылочная ссылка: https://lodash.com/docs/#isNil