JavaScriptでnull、未定義、または空白の変数をチェックするための標準関数はありますか？
変数に値があることを確認し、それがundefinedまたはnullではないことを確認する汎用のJavaScript関数はありますか。私はこのコードを持っています、しかしそれがすべての場合をカバーするかどうかはわかりません：
function isEmpty(val){
return (val === undefined || val == null || val.length <= 0) ? true : false;
}
variableがtruthyの値を持っているかどうかをチェックするだけです。つまり
if( value ) {
}
trueが ではない の場合、valueと評価されます。
- ヌル
- undefined
- NaN
- 空の文字列（ ""）
- false
上記のリストはECMA// Javascriptで可能性のあるすべてのfalsy値を表しています。 specification のToBooleanセクションにあります。
さらに、変数が存在しないかどうか 知っている （それが宣言されたであれば）typeof演算子を使ってチェックするべきです。例えば
if( typeof foo !== 'undefined' ) {
// foo could get resolved and it's defined
}
あなたがvariableが少なくとも宣言されていることを確認することができるならば、あなたはそれが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'
};
value が定義されていない場合、およびこれらのいずれかがカバーされます。
- ヌル
- 未定義（undefinedの値は、定義されたことがないパラメーターと同じではありません）
- ""（空の文字列）
- false
- NaN
P.S 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規格のそれ以降のエディションでもありません。現在、この言語に導入されることはステージ0（strawman）の提案です。」 - Simon Kjellberg。作者は王室の昇天を受けるためにこの美しい提案への彼の支持を加えたいです。
最高の評価を持つ最初の答えは間違っています。値が未定義の場合、最近のブラウザでは例外が発生します。あなたが使用する必要があります：
if (typeof(value) !== "undefined" && value)
または
if (typeof value !== "undefined" && value)
！空の文字列（ ""）、null、未定義、false、および数字0とNaNを確認します。例えば、文字列が空の場合var name = ""はconsole.log(!name)がtrueを返します。
function isEmpty(val){
return !val;
}
valがempty、null、未定義、false、数値0、またはNaNの場合、この関数はtrueを返します。
または
あなたの問題領域に応じて、あなたは!valまたは!!valのように使うことができます。
あなたは少しやり過ぎです。変数に値が与えられていないかどうかを確認するには、未定義値とnullに対してのみ確認する必要があります。
function isEmpty(value){
return (typeof value === "undefined" || value === null);
}
これは0、""、およびオブジェクト（空のオブジェクトや配列であっても）が有効な「値」であると想定しています。
これが私のものです - valueがnull、undefinedなどのように空白の場合、trueを返します。
function stringIsEmpty(value) {
return value ? value.trim().length == 0 : true;
}
あなたが普通の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)
この状態チェック
if (!!foo) {
//foo is defined
}
は、あなたが必要とすることすべてです。
私はとても気に入った登録済みの解決策を残します。
最初に、空白変数がnull、undefined、または長さがある場合はゼロ、オブジェクトの場合はキーがないことを定義しましょう。
function isEmpty (value) {
return (
// null or undefined
(value == null) ||
// has length and it's zero
(value.hasOwnProperty('length') && value.length === 0) ||
// is an Object and has no keys
(value.constructor === Object && Object.keys(value).length === 0)
)
}
戻り値：
- true：
undefined、null、""、[]、{} - false：
true、false、1、0、-1、"foo"、[1, 2, 3]、{ foo: 1 }
return val || 'Handle empty variable'
それは多くの場所でそれを扱うための本当に素晴らしくてきれいな方法です、また変数を割り当てるのに使用することができます
const res = val || 'default value'
デフォルト値を確認するには
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 function（）を使用しました。
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]"
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
}
役に立つかもしれません。
配列内のすべての値は、必要なもの（ヌル、未定義、またはその他のもの）を表し、その中から必要なものを検索します。
var variablesWhatILookFor = [null, undefined, ''];
variablesWhatILookFor.indexOf(document.DocumentNumberLabel) > -1
変数が宣言されていない場合は、エラーが発生するため、関数を使用して未定義をテストすることはできません。
if (foo) {}
function (bar) {}(foo)
Fooが宣言されていないと、両方ともエラーを生成します。
変数が宣言されているかどうかをテストしたい場合は、
typeof foo != "undefined"
fooが宣言されていて、それが値を持っているかどうかをテストしたい場合
if (typeof foo != "undefined" && foo) {
//code here
}
Null、null、未定義、0以外の検証用の4つすべての条件をチェックするための以下のコードを使用できます。このコード（！（！（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);
}
}
似たような質問をするためにここにやってくるすべての人にとって、次のものは素晴らしい仕事をしています。
(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));
var myNewValue = myObject && myObject.child && myObject.child.myValue;
これは決してエラーをスローしません。 myObject 、 child 、または myValue がnullの場合、 myNewValue はnullになります。エラーはスローされません
function isEmpty(val){
return !val;
}
しかし、このソリューションは過剰に設計されています。後でビジネスモデルのニーズに合わせて関数を変更したくない場合は、コードで直接使用する方がきれいです。
if(!val)...
不定ネスティングの変数が未定義かどうかチェックします
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")) {
昔のことですが、忘れているのは、コードブロックをラップしてからエラーを捕捉してからテストすることです。
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を使用すると、AngularやJavaScriptでもnullチェックのエラーを回避できると思います。ただnull例外をキャッチして処理します。
私は使うと思う？オペレータは少しきれいです。
var ? function_if_exists() : function_if_doesnt_exist();