Как проверить, не является ли значение не нулевым и не пустой строкой в ​​JS

Есть ли какая-нибудь проверка, не является ли значение не нулевым и не пустой строкой в ​​Javascript? Я использую следующий:

var data; //get its value from db 
if(data != null && data != '') {
   // do something
}

Но мне интересно, есть ли другое лучшее решение. Благодарю.

Если вы действительно хотите подтвердить, что переменная не является нулем и конкретно не является пустой строкой, вы должны написать:

if(data !== null && data !== '') {
   // do something
}

Обратите внимание, что я изменил ваш код, чтобы проверить равенство типов ( !==| ===).

Однако, если вы просто хотите убедиться, что код будет работать только для «разумных» значений, вы можете, как уже заявляли другие, написать:

if (data) {
  // do something
}

Поскольку в javascript как нулевые значения, так и пустые строки равны false (т.е. null == false).

Разница между этими двумя частями кода заключается в том, что для первой каждое значение, которое не является конкретно нулевым или пустой строкой, будет входить в if. Но, на втором, каждый истинный иш значение введите if: false, 0, null, undefinedи пустые строки, не будет.

Оба nullи пустая строка являются ложными значениями в JS. Следовательно,

if (data) { ... }

вполне достаточно.

Однако примечание сбоку: я бы избегал наличия в моем коде переменной, которая могла бы проявляться в разных типах. Если данные в конечном итоге будут строкой, тогда я бы изначально определил свою переменную с пустой строкой, поэтому вы можете сделать это:

if (data !== '') { ... }

без ноля (или каких-либо странных вещей вроде data = "0"), мешающих.

Вместо того, чтобы использовать

if(data !== null && data !== ''  && data!==undefined) {

// do something
}

Вы можете использовать ниже простой код

if(Boolean(value)){ 
// do something 
}

• Значения, которые интуитивно «пусты», такие как 0, пустая строка, null, undefined и NaN, становятся ложными.
• Остальные ценности сбываются

Я часто проверяю истинное значение, а также пробелы в строке:

if(!(!data || data.trim().length === 0)) {
  // do something here
}

Если у вас есть строка, состоящая из одного или нескольких пустых пробелов, она будет иметь значение true.

if (data?.trim().length > 0) {
   //use data
}

?. по желанию оператор цепочки будет короткое замыкание и возврат , undefinedесли данные nullish( nullили undefined) , которые будут оценивать к ложному в ifвыражении.

Как null, так и empty можно проверить следующим образом:

<script>
function getName(){
    var myname = document.getElementById("Name").value;
    if(myname != '' && myname != null){
        alert("My name is "+myname);
    }else{
        alert("Please Enter Your Name");
    }       
}

попробуйте ----------

function myFun(){
var inputVal=document.getElementById("inputId").value;
if(inputVal){
document.getElementById("result").innerHTML="<span style='color:green'>The value is "+inputVal+'</span>';
}
else{
document.getElementById("result").innerHTML="<span style='color:red'>Something error happen! the input May be empty.</span>";
}
}

<input type="text" id="inputId">
<input type="button" onclick="myFun()" value="View Result">
<h1 id="result"></h1>

Когда мы кодируем пустой по сути, это может означать любое из следующих обстоятельств;

• 0 как в числовом значении
• 0,0 как в значении с плавающей точкой
• '0' как строковое значение
• '0,0' как в строковом значении
• null, как в значении Null, возможно, он также может захватить undefined или не может
• undefined как в undefined value
• ложь, как ложь, истинное значение, согласно шансу 0, также как истинное, но что, если мы хотим захватить ложь как есть
• 'пустое значение sting без пробела или табуляции
• '' строка с пробелом или табуляцией

В реальной жизненной ситуации, как заявил OP, мы можем захотеть протестировать их все, а иногда мы можем захотеть протестировать только ограниченный набор условий.

Обычно if(!a){return true;}служит своей цели большую часть времени, однако не охватывает более широкий набор условий.

Еще один популярный хак - это return (!value || value == undefined || value == "" || value.length == 0);

Но что, если нам нужен контроль над всем процессом?

В нативном ядре JavaScript нет простого решения для хлыстовой травмы, которое необходимо принять. Учитывая, что мы отказываемся от поддержки устаревшего IE11 (честно говоря, даже в Windows есть такая необходимость), приведенное ниже решение, рожденное разочарованием, работает во всех современных браузерах;

 function empty (a,b=[])
 {if(!Array.isArray(b)) return; 
 var conditions=[null,'0','0.0',false,undefined,''].filter(x => !b.includes(x));
 if(conditions.includes(a)|| (typeof a === 'string' && conditions.includes(a.toString().trim())))
 {return true;};
 return false;};`

Логика решения заключается в том, что функция имеет два параметра a и b , a - значение, которое нам нужно проверить, b - это массив с заданными условиями, которые нам нужно исключить из предопределенных условий, перечисленных выше. Значение по умолчанию для b устанавливается в пустой массив [].

Первый запуск функции - проверить, является ли b массивом или нет, в противном случае - досрочно выйти из функции.

Следующий шаг - вычислить разницу между массивом [null,'0','0.0',false,undefined,'']и массивом b. если b - пустой массив, будут стоять предопределенные условия, иначе он удалит совпадающие значения.

condition = [предопределенный набор] - [подлежащий исключению набор] функция фильтра делает именно это, используя его. Теперь, когда у нас есть условия в массиве, все, что нам нужно сделать, это проверить, находится ли значение в массиве условий. Функция includes делает именно то, что вам не нужно писать собственные неприятные циклы, пусть JS-движок сделает всю тяжелую работу.

Попался, если мы должны преобразовать a в строку для сравнения, тогда 0 и 0,0 будут работать нормально, однако Null и Undefined будут из-за ошибки, блокирующей весь скрипт. Нам нужно краевое решение. Ниже простой || покрывает крайний случай, если первое условие не выполняется. Выполнение еще одной ранней проверки включает в себя ранний выход, если не выполняется.

if(conditions.includes(a)||  (['string', 'number'].includes(typeof a) && conditions.includes(a.toString().trim())))

Функция trim () будет охватывать только более широкие пробелы и значения табуляции и вступает в игру только в сценарии крайнего случая.

Игровая площадка

function empty (a,b=[]){
if(!Array.isArray(b)) return;
conditions=[null,'0','0.0',false,undefined,''].filter(x => !b.includes(x));
if(conditions.includes(a)|| 
(['string', 'number'].includes(typeof a) && conditions.includes(a.toString().trim()))){
 return true;
} 
return false;
}

console.log('1 '+empty());
console.log('2 '+empty(''));
console.log('3 '+empty('      '));
console.log('4 '+empty(0));
console.log('5 '+empty('0'));
console.log('6 '+empty(0.0));
console.log('7 '+empty('0.0'));
console.log('8 '+empty(false));
console.log('9 '+empty(null));
console.log('10 '+empty(null,[null]));
console.log('11 dont check 0 as number '+empty(0,['0']));
console.log('12 dont check 0 as string '+empty('0',['0']));
console.log('13 as number for false as value'+empty(false,[false]));

Давайте усложним это - что, если наше значение для сравнения - это массив сам по себе, и он может быть настолько глубоко вложенным, насколько это возможно. что, если мы должны проверить, является ли какое-либо значение в массиве пустым, это может быть крайний бизнес-пример.

function empty (a,b=[]){
    if(!Array.isArray(b)) return;

    conditions=[null,'0','0.0',false,undefined,''].filter(x => !b.includes(x));
    if(Array.isArray(a) && a.length > 0){
    for (i = 0; i < a.length; i++) { if (empty(a[i],b))return true;} 
    } 
    
    if(conditions.includes(a)|| 
    (['string', 'number'].includes(typeof a) && conditions.includes(a.toString().trim()))){
     return true;
    } 
    return false;
    }

console.log('checking for all values '+empty([1,[0]]));
console.log('excluding for 0 from condition '+empty([1,[0]], ['0']));

это простая и более широкая функция варианта использования, которую я использовал в своей структуре;

• Дает контроль над тем, что именно является определением пустого в данной ситуации.
• Позволяет переопределить условия пустого
• Может сравнивать почти все: строки, числа, числа с плавающей запятой, правдивые, нулевые, неопределенные и глубокие массивы.
• Решение составлено с учетом возможности восстановления и гибкости. Все остальные ответы подходят в случае, если нужно разобраться в одном или двух простых случаях. Однако всегда есть случай, когда определение пустых изменений при кодировании вышеупомянутых фрагментов делает работу в этом случае безупречной.

Мне так надоела проверка на пустые и пустые строки, что теперь я обычно просто пишу и вызываю небольшую функцию, которая сделает это за меня.

/**
 * Test if the given value equals null or the empty string.
 * 
 * @param {string} value
**/
const isEmpty = (value) => value === null || value === '';

// Test:
isEmpty('');        // true
isEmpty(null);      // true
isEmpty(1);         // false
isEmpty(0);         // false
isEmpty(undefined); // false