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




null is-empty (20)

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

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

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


अंडरस्कोर जावास्क्रिप्ट लाइब्रेरी 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)


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

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

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


आप regexps के साथ भी जा सकते हैं:

if((/^\s*$/).test(str)) { }

तारों के लिए चेक जो खाली या सफेद जगह से भरे हुए हैं।


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

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

इसे इस्तेमाल करे

   str.value.length == 0

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

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

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


प्रयत्न:

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

मान लें कि आपके द्वारा चेक किए गए वेरिएबल एक स्ट्रिंग है। यह न मानें कि अगर इस 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 === '')
  ...


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

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

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

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

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

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);
}

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

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

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


मैंने कुछ शोध किया है यदि आप एक परीक्षक समारोह में एक गैर-स्ट्रिंग और गैर-खाली / शून्य मान पास करते हैं तो क्या होता है। जैसा कि कई जानते हैं, (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; } }]
];

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

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

यह जांचने के लिए कि कोई स्ट्रिंग खाली है या नहीं, शून्य या अपरिभाषित मैं इसका उपयोग करता हूं:

function isEmpty(str) {
    return (!str || 0 === str.length);
}

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

function isBlank(str) {
    return (!str || /^\s*$/.test(str));
}

यह जांचने के लिए कि कोई स्ट्रिंग खाली है या केवल सफेद-स्थान है:

String.prototype.isEmpty = function() {
    return (this.length === 0 || !this.trim());
};

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

लेकिन मैं यह सुनिश्चित नहीं कर सकता कि चर एक स्ट्रिंग है, इसमें केवल रिक्त स्थान नहीं हैं (यह मेरे लिए महत्वपूर्ण है), और इसमें '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 obj = {};
(!!obj.str) //returns false

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

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

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


समारोह:

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 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' />

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






is-empty