Существует ли универсальная функция JavaScript, которая проверяет, что переменная имеет значение и гарантирует, что она не undefined или null? У меня есть этот код, но я не уверен, что он охватывает все случаи:
function isEmpty(val){
return (val === undefined || val == null || val.length <= 0) ? true : false;
}
Вы можете просто проверить, имеет ли переменная значение truthy или нет. Это значит
if( value ) {
}
оценивает true, если value не:
Приведенный выше список представляет все возможные значения falsy в ECMA-/Javascript. Найдите его в спецификации в разделе ToBoolean.
Кроме того, если вы не знаете, существует ли переменная (то есть, если она была объявлена), вы должны проверить с помощью оператора typeof. Например,
if( typeof foo !== 'undefined' ) {
// foo could get resolved and it defined
}
Если вы можете быть уверены, что хотя бы переменная объявлена, вам следует непосредственно проверить, имеет ли она значение truthy, как показано выше.
Далее читайте: http://typeofnan.blogspot.com/2011/01/typeof-is-fast.html
Подробный метод проверки того, является ли значение неопределенным или null:
return value === undefined || value === null;
Вы также можете использовать оператор == но это позволяет узнать все правила:
return value == null; // also returns true if value is undefined
function isEmpty(value){
return (value == null || value.length === 0);
}
Это вернет true для
undefined // Because undefined == null
null
[]
""
и функции нулевого аргумента, так как функция length - это количество объявленных параметров, которое требуется.
Чтобы запретить последнюю категорию, вы можете просто проверить пустые строки
function isEmpty(value){
return (value == null || value === '');
}
Это самая безопасная проверка, и я не видел, чтобы она была опубликована здесь в точности так:
if (typeof value != 'undefined' && value) {
//deal with value'
};
Он будет охватывать случаи, когда значение никогда не определялось, а также любой из них:
PS нет необходимости строгого равенства в значении typeof! = 'Undefined'
Вы можете найти следующую полезную функцию:
function typeOf(obj) {
return {}.toString.call(obj).split(' ')[1].slice(0, -1).toLowerCase();
}
Или в ES7 (прокомментируйте, если последующие улучшения)
function typeOf(obj) {
const { toString } = Object.prototype;
const stringified = obj::toString();
const type = stringified.split(' ')[1].slice(0, -1);
return type.toLowerCase();
}
Результаты:
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
"Обратите внимание, что оператор связывания (: :) не является частью ES2016 (ES7) или какой-либо более поздней версии стандарта ECMAScript вообще. В настоящее время это предложение этапа (strawman) для введения в язык". - Симон Кьелберг. автор хочет добавить свою поддержку этому прекрасному предложению получить королевское вознесение.
Первый ответ с лучшим рейтингом неверен. Если значение undefined, это вызовет исключение в современных браузерах. Вы должны использовать:
if (typeof(value) !== "undefined" && value)
или
if (typeof value !== "undefined" && value)
! проверьте наличие пустых строк (""), нулевых, неопределенных, ложных и числа 0 и NaN. Скажем, если строка пустая var name = "" тогда console.log(!name) возвращает true.
function isEmpty(val){
return !val;
}
эта функция вернет true, если val пуст, null, undefined, false, число 0 или NaN.
ИЛИ ЖЕ
В зависимости от вашей проблемной области вы можете просто использовать как !val или !!val.
Вы немного переусердствовали. Чтобы проверить, не указана ли переменной значение, вам нужно будет проверить только undefined и null.
function isEmpty(value){
return (typeof value === "undefined" || value === null);
}
Это предполагает 0, "", а объекты (даже пустой объект и массив) являются допустимыми "значениями".
Это условие проверки
if (!!foo) {
//foo is defined
}
- это все, что вам нужно.
Если вы предпочитаете простой javascript, попробуйте это:
/**
* 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;
}
В противном случае, если вы уже используете подчеркивание или lodash, попробуйте:
_.isEmpty(value)
Здесь my - возвращает true, если значение равно null, undefined и т.д. или пустое (т.е. содержит только пробелы):
function stringIsEmpty(value) {
return value ? value.trim().length == 0 : true;
}
Решение, которое мне очень нравится:
Давайте определим, что пустой переменной является null, или undefined, или если она имеет длину, она равна нулю, или если это объект, у нее нет ключей:
function isEmpty (value) {
return (
// null or undefined
(value == null) ||
// has length and it zero
(value.hasOwnProperty('length') && value.length === 0) ||
// is an Object and has no keys
(value.constructor === Object && Object.keys(value).length === 0)
)
}
Returns:
undefined, null, "", [], {}true, false, 1, 0, -1, "foo", [1, 2, 3], { foo: 1 }Если переменная не была объявлена, вы не сможете проверить для undefined функцию, потому что вы получите сообщение об ошибке.
if (foo) {}
function (bar) {}(foo)
Оба будут генерировать ошибку, если foo не был объявлен.
Если вы хотите проверить, была ли указана переменная, вы можете использовать
typeof foo != "undefined"
если вы хотите проверить, объявлено ли foo и имеет значение, которое вы можете использовать
if (typeof foo != "undefined" && foo) {
//code here
}
Это очень простой.
if(data) {
//Comes inside only if the data is not empty and not null
}
Чтобы проверить значение по умолчанию
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.
проверить Результат:
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() {} );
Я использовал функцию @Vix(), чтобы проверить объект этого типа.
используя instansof "
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]"
return val || 'Handle empty variable'
это действительно хороший и чистый способ справиться с этим во многих местах, также может использоваться для назначения переменных
const res = val || 'default value'
вы можете использовать:
Если условие, чтобы проверить, не является ли строка или значение пустой. например:
if (someVar.value)
{
//its not emppty
}
else
{
//Its empty
}
Это может быть полезно.
Все значения в массиве представляют собой то, что вы хотите (ноль, неопределенное или другое), и вы ищете в нем то, что хотите.
var variablesWhatILookFor = [null, undefined, ''];
variablesWhatILookFor.indexOf(document.DocumentNumberLabel) > -1
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;
}
В ES6 с отделкой для обработки строк с пробелами:
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
}
Вы можете использовать следующий код для проверки всех четырех (4) условий для проверки, таких как не null, не пустые, не неопределенные и не ноль, только используйте этот код (! (! (Variable))) в javascript и 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);
}
}
Если вы используете TypeScript и не хотите учитывать "значения, которые являются false ", то это решение для вас:
Во-первых: import { isNullOrUndefined } from 'util';
Затем: isNullOrUndefined(this.yourVariableName)
Обратите внимание: как упоминалось ниже, это теперь устарело, используйте value === undefined || value === null value === undefined || value === null. ref.
function isEmpty(val){
return !val;
}
но это решение чрезмерно спроектировано, если вы не хотите изменять функцию позже для потребностей модели на машинах, тогда чище использовать ее непосредственно в коде:
if(!val)...
var myNewValue = myObject && myObject.child && myObject.child.myValue;
Это никогда не вызовет ошибку. Если myObject, child или myValue равно null, myNewValue будет null. Ошибок не будет.
Для всех, кто приехал сюда за аналогичным вопросом, следующие работы великолепны, и у меня есть это в моей библиотеке последние годы:
(function(g3, $, window, document, undefined){
g3.utils = g3.utils || {};
/********************************Function type()********************************
* Returns a lowercase string representation of an object 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
* 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));
Это проверит, является ли переменная неопределенной вложенности undefined
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")) {
Вышеописанная проверка, существует ли функция перевода Google TranslateElement. Это эквивалентно:
if (!(typeof google === "undefined"
|| typeof google.translate === "undefined"
|| typeof google.translate.TranslateElement === "undefined")) {
Я не рекомендую пытаться определить или использовать функцию, которая вычисляет, является ли какое-либо значение во всем мире пустым. Что на самом деле означает быть "пустым"? Если у меня есть let human = { name: 'bob', stomach: 'empty' }, должен ли isEmpty(human) возвращать true? Если у меня есть let reg = new RegExp('');, должен ли isEmpty(reg) возвращать true? Как насчет isEmpty([ null, null, null, null ]) - этот список содержит только пустоту, поэтому сам список пуст? Я хочу выдвинуть здесь некоторые примечания о "пустотности" (намеренно неясное слово, чтобы избежать ранее существовавших ассоциаций) в javascript - и я хочу доказать, что "пустотность" в значениях javascript никогда не должна рассматриваться в общем.
Для принятия решения о том, как определить "пустоту" значений, нам необходимо учесть встроенный JavaScript, присущий смысл того, являются ли значения "правдивыми" или "ложными". Естественно, и null, и undefined являются "ложными". Менее естественно, число 0 (и никакое другое число кроме NaN) также является "ложным". Наименее естественно: '' является ложью, но [] и {} (и new Set(), и new Map()) правдивы - хотя все они кажутся одинаково пустыми!
Существует также некоторая дискуссия относительно null против undefined - действительно ли нам нужно и то, и другое, чтобы выразить пустоту в наших программах? Лично я избегаю, чтобы буквы u, n, d, e, f, i, n, e, d появлялись в моем коде в таком порядке. Я всегда использую null для обозначения "пустотности". Опять же, тем не менее, нам нужно учесть присущий Javascript смысл различия между null и undefined:
undefinedundefined:
let f = a => a;
console.log(f('hi'));
console.log(f());Я думаю, используя? оператор немного чист.
var ? function_if_exists() : function_if_doesnt_exist();
Хотя старое, что забыли, что они должны обернуть свой блок кода, а затем поймать ошибку, а затем проверить...
function checkup( t ){
try{
for(p in t){
if( p.hasOwnProperty( t ) ){
return true;
}
}
return false;
}catch(e){
console.log("ERROR : "+e);
return e;
}
}
Поэтому вам действительно не нужно проверять потенциальную проблему перед рукой, вы просто ее поймаете, а затем справляетесь с ней, как хотите.
try{
let vari = obj.propTest; // obj may be don't have propTest property
...
} catch(NullException){
// do something here
}
Я думаю, что использование try catch позволит избежать ошибки null check, также в Angular или JavaScript. Просто улавливает нулевое исключение и обрабатывает его.
Вместо того, чтобы использовать
if(data !== null && data !== '' && data!==undefined) {
// do something
}
Вы можете использовать ниже простой код
if(Boolean(value)){
// do something
}