javascript आप जावास्क्रिप्ट में खाली स्ट्रिंग की जांच कैसे करते हैं?




null is-empty (24)

मैं संयोजन का उपयोग करता हूं, सबसे तेज़ चेक पहले होते हैं।

function isBlank(pString){
    if (!pString || pString.length == 0) {
        return true;
    }
    // checks for a non-white space character 
    // which I think [citation needed] is faster 
    // than removing all the whitespace and checking 
    // against an empty string
    return !/[^\s]+/.test(pString);
}

मैंने यह thread देखा, लेकिन मुझे एक जावास्क्रिप्ट विशिष्ट उदाहरण नहीं मिला। क्या कोई साधारण string.Empty है। जावास्क्रिप्ट में उपलब्ध string.Empty , या यह सिर्फ "" जांचने का मामला है?


प्रयत्न:

if (str && str.trim().length) {  
    //...
}

यदि आप सिर्फ यह जांचना चाहते हैं कि कोई मूल्य है या नहीं, तो आप कर सकते हैं

if (strValue) {
    //do something
}

यदि आपको विशेष रूप से शून्य पर खाली स्ट्रिंग के लिए जांच करने की आवश्यकता है, तो मुझे लगता है कि === ऑपरेटर का उपयोग करके, "" खिलाफ जांच करना आपकी सबसे अच्छी शर्त है (ताकि आप जानते हैं कि यह वास्तव में एक स्ट्रिंग है जिसके खिलाफ आप तुलना कर रहे हैं )।

if (strValue === "") {
    //...
}

मैंने कुछ शोध किया है यदि आप एक परीक्षक समारोह में एक गैर-स्ट्रिंग और गैर-खाली / शून्य मान पास करते हैं तो क्या होता है। जैसा कि कई जानते हैं, (0 == "") जावास्क्रिप्ट में सत्य है, लेकिन चूंकि 0 एक मान है और खाली या शून्य नहीं है, तो आप इसके लिए परीक्षण करना चाहेंगे।

निम्नलिखित दो कार्य केवल अपरिभाषित, शून्य, खाली / सफेद स्थान मूल्यों और अन्य सभी चीज़ों के लिए झूठे हैं, जैसे कि संख्या, बूलियन, ऑब्जेक्ट्स, एक्सप्रेशन इत्यादि।

function IsNullOrEmpty(value)
{
    return (value == null || value === "");
}
function IsNullOrWhiteSpace(value)
{
    return (value == null || !/\S/.test(value));
}

अधिक जटिल उदाहरण मौजूद हैं, लेकिन ये सरल हैं और लगातार परिणाम देते हैं। अपरिभाषित के लिए परीक्षण करने की कोई आवश्यकता नहीं है, क्योंकि इसमें शामिल है (value == null) चेक। आप उन्हें इस तरह स्ट्रिंग में जोड़कर सी # व्यवहार की नकल भी कर सकते हैं:

String.IsNullOrEmpty = function (value) { ... }

आप इसे स्ट्रिंग्स प्रोटोटाइप में नहीं रखना चाहते हैं, क्योंकि यदि स्ट्रिंग-क्लास का उदाहरण शून्य है, तो यह त्रुटि होगी:

String.prototype.IsNullOrEmpty = function (value) { ... }
var myvar = null;
if (1 == 2) { myvar = "OK"; } // could be set
myvar.IsNullOrEmpty(); // throws error

मैंने निम्न मान सरणी के साथ परीक्षण किया। संदेह में यदि आप अपने कार्यों का परीक्षण करने के लिए इसे लूप कर सकते हैं।

// Helper items
var MyClass = function (b) { this.a = "Hello World!"; this.b = b; };
MyClass.prototype.hello = function () { if (this.b == null) { alert(this.a); } else { alert(this.b); } };
var z;
var arr = [
// 0: Explanation for printing, 1: actual value
    ['undefined', undefined],
    ['(var) z', z],
    ['null', null],
    ['empty', ''],
    ['space', ' '],
    ['tab', '\t'],
    ['newline', '\n'],
    ['carriage return', '\r'],
    ['"\\r\\n"', '\r\n'],
    ['"\\n\\r"', '\n\r'],
    ['" \\t \\n "', ' \t \n '],
    ['" txt \\t test \\n"', ' txt \t test \n'],
    ['"txt"', "txt"],
    ['"undefined"', 'undefined'],
    ['"null"', 'null'],
    ['"0"', '0'],
    ['"1"', '1'],
    ['"1.5"', '1.5'],
    ['"1,5"', '1,5'], // valid number in some locales, not in js
    ['comma', ','],
    ['dot', '.'],
    ['".5"', '.5'],
    ['0', 0],
    ['0.0', 0.0],
    ['1', 1],
    ['1.5', 1.5],
    ['NaN', NaN],
    ['/\S/', /\S/],
    ['true', true],
    ['false', false],
    ['function, returns true', function () { return true; } ],
    ['function, returns false', function () { return false; } ],
    ['function, returns null', function () { return null; } ],
    ['function, returns string', function () { return "test"; } ],
    ['function, returns undefined', function () { } ],
    ['MyClass', MyClass],
    ['new MyClass', new MyClass()],
    ['empty object', {}],
    ['non-empty object', { a: "a", match: "bogus", test: "bogus"}],
    ['object with toString: string', { a: "a", match: "bogus", test: "bogus", toString: function () { return "test"; } }],
    ['object with toString: null', { a: "a", match: "bogus", test: "bogus", toString: function () { return null; } }]
];

function tell()
{
var pass = document.getElementById('pasword').value;
var plen = pass.length;

now you can check if your string is empty as like 
if(plen==0)
{
         alert('empty');
}
else
{
   alert('you entered something');
}
}


<input type='text' id='pasword' />

यह जांचने का एक सामान्य तरीका है कि क्या फ़ील्ड खाली है या नहीं।


मान लें कि आपके द्वारा चेक किए गए वेरिएबल एक स्ट्रिंग है। यह न मानें कि अगर इस var की लंबाई है, तो यह एक स्ट्रिंग है।

बात यह है कि सावधानी से सोचें कि आपके ऐप को क्या करना चाहिए और स्वीकार कर सकते हैं। कुछ मजबूत बनाएँ।

यदि आपकी विधि / फ़ंक्शन को केवल एक खाली खाली स्ट्रिंग को संसाधित करना चाहिए, तो जांच करें कि तर्क एक खाली खाली स्ट्रिंग है और कुछ 'चाल' न करें।

कुछ ऐसी चीज के उदाहरण के रूप में जो विस्फोट कर देगी यदि आप कुछ सलाहों का पालन करते हैं तो ध्यान से नहीं।


var getLastChar = function (str) {
 if (str.length > 0)
   return str.charAt(str.length - 1)
}

getLastChar('hello')
=> "o"

getLastChar([0,1,2,3])
=> TypeError: Object [object Array] has no method 'charAt'

तो, मैं साथ रहना होगा


if (myVar === '')
  ...


कोई isEmpty() नहीं है isEmpty() विधि, आपको प्रकार और लंबाई की जांच करनी है:

if (typeof test === 'string' && test.length === 0){
  ...

test undefined या null होने पर रनटाइम त्रुटियों से बचने के लिए प्रकार की जांच की आवश्यकता होती है।


मैं सबसे कुशल विधि के बारे में ज्यादा चिंता नहीं करता। अपने इरादे के लिए सबसे स्पष्ट क्या है इसका प्रयोग करें। मेरे लिए आमतौर पर strVar == ""

संपादित करें: Constantin से प्रति टिप्पणी, अगर strVar कुछ पूर्णांक 0 मान को समाप्त कर सकता है, तो यह वास्तव में उन इरादे-स्पष्टीकरण स्थितियों में से एक होगा।


समारोह:

function Is_Empty_or_Undefined (MyVar)
{
   return 
   ( 
        (typeof MyVar== 'undefined')
                    ||
        (MyVar == null) 
                    ||
        (MyVar == false)  //same as: !MyVariable
                    ||
        (MyVar.length == 0)
                    ||
        (MyVar == "")
                    ||
        (MyVar.replace(/\s/g,"") == "")
                    ||
        (!/[^\s]/.test(MyVar))
                    ||
        (/^\s*$/.test(MyVar))
  );
}

मैं उपयोग करता हूं :

function empty(e) {
  switch (e) {
    case "":
    case 0:
    case "0":
    case null:
    case false:
    case typeof this == "undefined":
      return true;
    default:
      return false;
  }
}

empty(null) // true
empty(0) // true
empty(7) // false
empty("") // true
empty((function() {
    return ""
  })) // false

आप lodash : _.isEmpty (मान) का उपयोग कर सकते हैं।

इसमें कई मामलों जैसे {} , '' , null , undefined इत्यादि शामिल हैं।

लेकिन यह हमेशा प्रकार के जावास्क्रिप्ट आदिम डेटा प्रकार जैसे _.isEmpty(10) या _.isEmpty(Number.MAX_VALUE) true लौटाता true दोनों true लौटते true


ये सभी जवाब अच्छे हैं।

लेकिन मैं यह सुनिश्चित नहीं कर सकता कि चर एक स्ट्रिंग है, इसमें केवल रिक्त स्थान नहीं हैं (यह मेरे लिए महत्वपूर्ण है), और इसमें '0' (स्ट्रिंग) हो सकती है।

मेरा संस्करण:

function empty(str){
    return !str || !/[^\s]+/.test(str);
}

empty(null); // true
empty(0); // true
empty(7); // false
empty(""); // true
empty("0"); // false
empty("  "); // true

jsfiddle पर नमूना।


मैंने एक ऐसा जवाब नहीं देखा है जो एक स्ट्रिंग में शून्य वर्णों की संभावना को ध्यान में रखता है। उदाहरण के लिए, यदि हमारे पास शून्य वर्ण स्ट्रिंग है:

var y = "\0"; // an empty string, but has a null character
(y === "") // false, testing against an empty string does not work
(y.length === 0) // false
(y) // true, this is also not expected
(y.match(/^[\s]*$/)) // false, again not wanted

इसकी नीचता का परीक्षण करने के लिए कोई ऐसा कुछ कर सकता है:

String.prototype.isNull = function(){ 
  return Boolean(this.match(/^[\0]*$/)); 
}
...
"\0".isNull() // true

यह एक शून्य स्ट्रिंग पर और खाली स्ट्रिंग पर काम करता है और यह सभी तारों के लिए सुलभ है। इसके अलावा, इसे अन्य जावास्क्रिप्ट खाली या सफेद स्थान वर्ण (यानी गैर-ब्रेकिंग स्पेस, बाइट ऑर्डर मार्क, लाइन / पैराग्राफ सेपरेटर इत्यादि) रखने के लिए विस्तारित किया जा सकता है।


मैं आमतौर पर इस तरह की कुछ चीज का उपयोग करता हूं,

if (!str.length) {
//do some thing
}

यदि आपको यह सुनिश्चित करने की ज़रूरत है कि स्ट्रिंग केवल खाली रिक्त स्थान का समूह नहीं है (मुझे लगता है कि यह फ़ॉर्म सत्यापन के लिए है) तो आपको रिक्त स्थान पर प्रतिस्थापन करने की आवश्यकता है।

if(str.replace(/\s/g,"") == ""){
}

अगर किसी को न केवल खाली बल्कि खाली तारों का पता लगाने की जरूरत है, तो मैं गोरल के जवाब में जोड़ूंगा:

function isEmpty(s){
    return !s.length;    
}

function isBlank(s){
    return isEmpty(s.trim());    
}

इस बीच हमारे पास एक ऐसा कार्य हो सकता है जो सभी 'खाली' जैसे शून्य, अपरिभाषित, '', '', {}, [] के लिए जांच करता है । तो मैंने अभी यह लिखा है।

var isEmpty = function(data) {
    if(typeof(data) === 'object'){
        if(JSON.stringify(data) === '{}' || JSON.stringify(data) === '[]'){
            return true;
        }else if(!data){
            return true;
        }
        return false;
    }else if(typeof(data) === 'string'){
        if(!data.trim()){
            return true;
        }
        return false;
    }else if(typeof(data) === 'undefined'){
        return true;
    }else{
        return false;
    }
}

मामलों और परिणामों का प्रयोग करें।

console.log(isEmpty()); // true
console.log(isEmpty(null)); // true
console.log(isEmpty('')); // true
console.log(isEmpty('  ')); // true
console.log(isEmpty(undefined)); // true
console.log(isEmpty({})); // true
console.log(isEmpty([])); // true
console.log(isEmpty(0)); // false
console.log(isEmpty('Hey')); // false

इसके अलावा, यदि आप एक सफेद जगह भरने वाली स्ट्रिंग को "खाली" मानते हैं। आप इस रेगेक्स के साथ इसका परीक्षण कर सकते हैं:

!/\S/.test(string); // Returns true if blank.

यह जांचने के लिए कि वास्तव में एक खाली स्ट्रिंग है या नहीं:

if(val==="")...

यह जांचने के लिए कि क्या यह एक खाली स्ट्रिंग है या कोई वैल्यू (शून्य, अपरिभाषित, 0, NaN, false, ...) के लिए तार्किक समकक्ष है:

if(!val)...

मैं आमतौर पर कुछ ऐसा उपयोग करता हूं:

if (str == "") {
     //Do Something
}
else {
     //Do Something Else
}

अंडरस्कोर जावास्क्रिप्ट लाइब्रेरी http://underscorejs.org/ खाली तारों और अन्य खाली वस्तुओं की जांच के लिए एक बहुत ही उपयोगी _.isEmpty() फ़ंक्शन प्रदान करती है।

संदर्भ: http://underscorejs.org/#isEmpty

_.isEmpty(object)
यदि कोई गणना करने योग्य ऑब्जेक्ट में कोई मान नहीं है (कोई संख्यात्मक स्वयं-गुण नहीं) तो सत्य वापस आता है। तारों और सरणी जैसी वस्तुओं के लिए _.is लक्षण जांचता है कि लंबाई की संपत्ति 0 है या नहीं।

_.isEmpty([1, 2, 3]);
=> झूठी

_.isEmpty({});
=> सच है

अन्य बहुत उपयोगी अंडरस्कोर कार्यों में शामिल हैं:
http://underscorejs.org/#isNull _.isNull(object)
http://underscorejs.org/#isUndefined _.isUndefined(value)
http://underscorejs.org/#has _.has(object, key)


व्हाइटस्पेस तारों को अनदेखा करते हुए, आप इसका उपयोग शून्य, खाली और अपरिभाषित करने के लिए कर सकते हैं:

var obj = {};
(!!obj.str) //returns false

obj.str = "";
(!!obj.str) //returns false

obj.str = null;
(!!obj.str) //returns false

संक्षिप्त और यह अपरिभाषित गुणों के लिए काम करता है, हालांकि यह सबसे अधिक पठनीय नहीं है।


बहुत सारे जवाब, और कई अलग-अलग संभावनाएं!

त्वरित और सरल कार्यान्वयन के लिए संदेह के बिना विजेता है: if (!str.length) {...}

हालांकि, कई अन्य उदाहरण उपलब्ध हैं। इसके बारे में जाने के लिए सबसे अच्छा कार्यात्मक तरीका, मैं सुझाव दूंगा:

function empty(str)
{
    if (typeof str == 'undefined' || !str || str.length === 0 || str === "" || !/[^\s]/.test(str) || /^\s*$/.test(str) || str.replace(/\s/g,"") === "")
    {
        return true;
    }
    else
    {
        return false;
    }
}

थोड़ा अधिक, मुझे पता है।


  1. उस var a; जांच करें var a; मौजूद
  2. मूल्य में false spaces को ट्रिम करें, फिर emptiness लिए परीक्षण करें

    if ((a)&&(a.trim()!=''))
    {
      // if variable a is not empty do this 
    }
    




is-empty