JQuery සඳහා “පවතින” ශ්‍රිතයක් තිබේද?

JQuery හි මූලද්‍රව්‍යයක පැවැත්ම පරීක්ෂා කරන්නේ කෙසේද?

මා සතුව ඇති වර්තමාන කේතය මෙයයි:

if ($(selector).length > 0) {
    // Do something
}

මේ සඳහා ප්‍රවේශ වීමට වඩා අලංකාර ක්‍රමයක් තිබේද? සමහර විට ප්ලගිනයක් හෝ ශ්‍රිතයක්ද?

ජාවාස්ක්‍රිප්ට් හි සෑම දෙයක්ම 'සත්‍යවාදී' හෝ 'ව්‍යාජ' වන අතර සංඛ්‍යා සඳහා 0(සහ NaN) යන්නෙන් අදහස් වන්නේ falseඅන් සියල්ලම ය true. එබැවින් ඔබට ලිවිය හැකිය:

if ($(selector).length)

ඔබට එම >0කොටස අවශ්‍ය නොවේ .

ඔව්!

jQuery.fn.exists = function(){ return this.length > 0; }

if ($(selector).exists()) {
    // Do something
}

මෙය ප්‍රතිචාරයක් ලෙස: ජෙෆ් ඇට්වුඩ් සමඟ හර්ඩින් කෝඩ් පොඩ්කාස්ට්

ඔබ භාවිතා කළේ නම්

jQuery.fn.exists = function(){return ($(this).length > 0);}
if ($(selector).exists()) { }

ඔබ අදහස් කරන්නේ දම්වැල නොමැති විට එය කළ හැකි බවයි.

මෙය වඩා හොඳ වනු ඇත:

jQuery.exists = function(selector) {return ($(selector).length > 0);}
if ($.exists(selector)) { }

විකල්පයක් ලෙස, නිතර අසනු ලබන ප්‍රශ්න වලින් :

if ( $('#myDiv').length ) { /* Do something */ }

ඔබට පහත සඳහන් දෑ ද භාවිතා කළ හැකිය. JQuery වස්තු අරාවෙහි කිසිදු අගයක් නොමැති නම්, අරාවෙහි පළමු අයිතමය ලබා ගැනීම නිර්වචනය නොකෙරේ.

if ( $('#myDiv')[0] ) { /* Do something */ }

ඔබට මෙය භාවිතා කළ හැකිය:

// if element exists
if($('selector').length){ /* do something */ }

// if element does not exist
if(!$('selector').length){ /* do something */ }

පැවැත්ම පරීක්ෂා කිරීම සඳහා වේගවත්ම හා අර්ථාන්විතව ස්වයං පැහැදිලි කිරීමේ ක්‍රමය සැබවින්ම සරල භාවිතා කිරීමෙනි JavaScript:

if (document.getElementById('element_id')) {
    // Do something
}

එය jQuery දිග විකල්පයට වඩා ලිවීමට ටිකක් දිගු වේ, නමුත් එය ස්වදේශීය JS ක්‍රමයක් බැවින් වේගයෙන් ක්‍රියාත්මක වේ.

ඔබේම jQueryශ්‍රිතයක් ලිවීමේ විකල්පයට වඩා එය හොඳය . ස්නෝවර් ප්‍රකාශ කළ හේතු නිසා එම විකල්පය මන්දගාමී වේ. නමුත් එය වෙනත් ක්‍රමලේඛකයන්ට එම exists()ශ්‍රිතය jQuery වලට ආවේණික දෙයක් බවට හැඟීමක් ලබා දෙනු ඇත. JavaScriptදැනුම ණය වැඩි නොකර ඔබේ කේතය සංස්කරණය කරන වෙනත් අය විසින් තේරුම් ගත යුතුය.

සැ.යු: මීට පෙර '#' හි lack නතාවක් ඇති බව සැලකිල්ලට ගන්න element_id(මෙය සරල JS බැවින් නොවේ jQuery).

ලිවීමෙන් ඔබට බයිට් කිහිපයක් ඉතිරි කළ හැකිය:

if ($(selector)[0]) { ... }

මෙම ක්රියා අපි සිට පළමු අයිතමය ලබා ගැනීමට අරාව dereferencing ක්රියාකරු භාවිතා කළ හැකි නිසා එක් එක් jQuery වස්තුව ද, රැසක් වෙස් ගනියි නිසා මාලාවක් . undefinedනිශ්චිත දර්ශකයේ අයිතමයක් නොමැති නම් එය නැවත පැමිණේ .

ඔයාට පාවිච්චි කරන්න පුළුවන්:

if ($(selector).is('*')) {
  // Do something
}

ඒ කුඩා වැඩි අලංකාර, සමහර විට.

මෙම ප්ලගිනය කෝල්බැක් ifවැනි ප්‍රකාශයක if ($(ele).exist()) { /* DO WORK */ }භාවිතා කළ හැකිය.

ප්ලගිනය

;;(function($) {
    if (!$.exist) {
        $.extend({
            exist: function() {
                var ele, cbmExist, cbmNotExist;
                if (arguments.length) {
                    for (x in arguments) {
                        switch (typeof arguments[x]) {
                            case 'function':
                                if (typeof cbmExist == "undefined") cbmExist = arguments[x];
                                else cbmNotExist = arguments[x];
                                break;
                            case 'object':
                                if (arguments[x] instanceof jQuery) ele = arguments[x];
                                else {
                                    var obj = arguments[x];
                                    for (y in obj) {
                                        if (typeof obj[y] == 'function') {
                                            if (typeof cbmExist == "undefined") cbmExist = obj[y];
                                            else cbmNotExist = obj[y];
                                        }
                                        if (typeof obj[y] == 'object' && obj[y] instanceof jQuery) ele = obj[y];
                                        if (typeof obj[y] == 'string') ele = $(obj[y]);
                                    }
                                }
                                break;
                            case 'string':
                                ele = $(arguments[x]);
                                break;
                        }
                    }
                }

                if (typeof cbmExist == 'function') {
                    var exist =  ele.length > 0 ? true : false;
                    if (exist) {
                        return ele.each(function(i) { cbmExist.apply(this, [exist, ele, i]); });
                    }
                    else if (typeof cbmNotExist == 'function') {
                        cbmNotExist.apply(ele, [exist, ele]);
                        return ele;
                    }
                    else {
                        if (ele.length <= 1) return ele.length > 0 ? true : false;
                        else return ele.length;
                    }
                }
                else {
                    if (ele.length <= 1) return ele.length > 0 ? true : false;
                    else return ele.length;
                }

                return false;
            }
        });
        $.fn.extend({
            exist: function() {
                var args = [$(this)];
                if (arguments.length) for (x in arguments) args.push(arguments[x]);
                return $.exist.apply($, args);
            }
        });
    }
})(jQuery);

jsFiddle

ඔබට ඇමතුම් එකක් හෝ දෙකක් නියම කළ හැකිය. එම මූලද්රව්යය කරන්නේ නම් දෙවන එක් වෙඩි ඇත අංගයක් පවතී නම්, පළමු එක වෙඩි ඇත, නැත පවතී. කෙසේ වෙතත්, ඔබ එක් ශ්‍රිතයක් පමණක් සම්මත කිරීමට තෝරා ගන්නේ නම්, එය වෙඩි තබන්නේ මූලද්‍රව්‍යය පවතින විට පමණි. මේ අනුව, තෝරාගත් අංගයක් වන්නේ නම් දාම මිය යනු ඇත නොහැකි පවතී. ඇත්ත වශයෙන්ම, එය පවතින්නේ නම්, පළමු කාර්යය ගිනි ගන්නා අතර දාමය දිගටම පවතිනු ඇත.

කෝල්බැක් ප්‍රභේදය භාවිතා කිරීම දාමයේ හැකියාව පවත්වා ගැනීමට උපකාරී වන බව මතක තබා ගන්න - මූලද්‍රව්‍යය නැවත ලබා දෙන අතර වෙනත් ඕනෑම jQuery ක්‍රමයක් මෙන් ඔබට දම්වැල් විධාන දිගටම කරගෙන යා හැකිය!

උදාහරණ භාවිතයන්

if ($.exist('#eleID')) {    /*    DO WORK    */ }        //    param as STRING
if ($.exist($('#eleID'))) { /*    DO WORK    */ }        //    param as jQuery OBJECT
if ($('#eleID').exist()) {  /*    DO WORK    */ }        //    enduced on jQuery OBJECT

$.exist('#eleID', function() {            //    param is STRING && CALLBACK METHOD
    /*    DO WORK    */
    /*    This will ONLY fire if the element EXIST    */
}, function() {            //    param is STRING && CALLBACK METHOD
    /*    DO WORK    */
    /*    This will ONLY fire if the element DOES NOT EXIST    */
})

$('#eleID').exist(function() {            //    enduced on jQuery OBJECT with CALLBACK METHOD
    /*    DO WORK    */
    /*    This will ONLY fire if the element EXIST    */
})

$.exist({                        //    param is OBJECT containing 2 key|value pairs: element = STRING, callback = METHOD
    element: '#eleID',
    callback: function() {
        /*    DO WORK    */
        /*    This will ONLY fire if the element EXIST    */
    }
})

මෙහි ඇති පිළිතුරු බොහොමයක් නිවැරදි නොවන බව මට පෙනේ , ඒවා මූලද්‍රව්‍ය දිග පරීක්ෂා කරයි, එය බොහෝ අවස්ථාවන්හිදී හරි විය හැකිය , නමුත් 100% ක් නොවේ , ඒ වෙනුවට ශ්‍රිතය වෙත අංකය ගමන් කරයිදැයි සිතන්න, එබැවින් මම සියල්ල පරීක්ෂා කරන ශ්‍රිතයක් මූලාකෘති කරමි කොන්දේසි සහ පිළිතුර තිබිය යුතු ආකාරයට ආපසු එවන්න:

$.fn.exists = $.fn.exists || function() { 
  return !!(this.length && (this[0] instanceof HTMLDocument || this[0] instanceof HTMLElement)); 
}

මෙය දිග සහ වර්ගය යන දෙකම පරීක්ෂා කරනු ඇත, දැන් ඔබට එය මේ ආකාරයෙන් පරීක්ෂා කළ හැකිය:

$(1980).exists(); //return false
$([1,2,3]).exists(); //return false
$({name: 'stackoverflow', url: 'http://www.stackoverflow.com'}).exists(); //return false
$([{nodeName: 'foo'}]).exists() // returns false
$('div').exists(); //return true
$('.header').exists(); //return true
$(document).exists(); //return true
$('body').exists(); //return true

ඇත්ත වශයෙන්ම jQuery අවශ්‍ය නොවේ. සරල ජාවාස්ක්‍රිප්ට් සමඟ පරීක්ෂා කිරීම පහසු සහ අර්ථාන්විතව නිවැරදි ය:

if(document.getElementById("myElement")) {
    //Do something...
}

කිසියම් හේතුවක් නිසා මූලද්‍රව්‍යයට හැඳුනුම්පතක් දැමීමට ඔබට අවශ්‍ය නැතිනම්, ඔබට තවමත් DOM වෙත ප්‍රවේශ වීම සඳහා නිර්මාණය කර ඇති වෙනත් ජාවාස්ක්‍රිප්ට් ක්‍රමයක් භාවිතා කළ හැකිය.

jQuery ඇත්තෙන්ම සිසිල් ය, නමුත් පිරිසිදු ජාවාස්ක්‍රිප්ට් අමතක වීමට ඉඩ නොදෙන්න ...

ඔබට මෙය භාවිතා කළ හැකිය:

jQuery.fn.extend({
    exists: function() { return this.length }
});

if($(selector).exists()){/*do something*/}

පෙර පිළිතුරු සියල්ලටම .lengthපරාමිතිය අවශ්‍ය වීමට හේතුව ඔවුන් වැඩිපුරම භාවිතා කරන්නේ jquery හි $()තේරීම වන අතර එය තිරය පිටුපස විමසුම් සෙලෙක්ටර් ඇත (නැතහොත් ඔවුන් එය කෙලින්ම භාවිතා කරයි). මෙම ක්‍රමය තරමක් මන්දගාමී වන්නේ එයට තේරීම් කාරකයට සියලු ගැලපීම් සොයන මුළු DOM ගස විග්‍රහ කිරීමට අවශ්‍ය වන අතර ඔවුන් සමඟ අරාවක් ජනනය කළ යුතු බැවිනි.

['දිග'] පරාමිතිය අවශ්‍ය හෝ ප්‍රයෝජනවත් නොවන අතර ඔබ document.querySelector(selector)ඒ වෙනුවට කෙලින්ම භාවිතා කරන්නේ නම් කේතය වඩා වේගවත් වනු ඇත , මන්ද එය ගැලපෙන පළමු අංගය නැවත ලබා දෙන නිසා හෝ සොයාගත නොහැකි නම් එය ශුන්‍ය වේ.

function elementIfExists(selector){  //named this way on purpose, see below
    return document.querySelector(selector);
}
/* usage: */
var myelement = elementIfExists("#myid") || myfallbackelement;

කෙසේ වෙතත් මෙම ක්‍රමය මඟින් සත්‍ය වස්තුව ආපසු ලබා දෙනු ඇත. එය විචල්‍ය ලෙස සුරැකීමට සහ නැවත නැවත භාවිතා කිරීමට නොයන්නේ නම් එය හොඳයි (මේ අනුව අපට අමතක වුවහොත් එම සඳහන තබා ගන්න).

var myel=elementIfExists("#myid");
// now we are using a reference to the element which will linger after removal
myel.getParentNode.removeChild(myel);
console.log(elementIfExists("#myid")); /* null */
console.log(myel); /* giant table lingering around detached from document */
myel=null; /* now it can be garbage collected */

සමහර අවස්ථාවල මෙය අපේක්ෂා කළ හැකිය. මෙය for for loop එකක භාවිතා කළ හැකිය:

/* locally scoped myel gets garbage collected even with the break; */
for (var myel; myel = elementIfExist(sel); myel.getParentNode.removeChild(myel))
    if (myel == myblacklistedel) break;

ඔබට ඇත්ත වශයෙන්ම මූලද්‍රව්‍යය අවශ්‍ය නැතිනම් සත්‍ය / අසත්‍යය ලබා ගැනීමට / ගබඩා කිරීමට අවශ්‍ය නම්, එය දෙගුණයක් නොවේ !! එය ක්‍රියා විරහිත සපත්තු සඳහා ක්‍රියා කරයි, එබැවින් මෙහි ගැටගැසෙන්නේ ඇයි?

function elementExists(selector){
    return !!document.querySelector(selector);
}
/* usage: */
var hastables = elementExists("table");  /* will be true or false */
if (hastables){
    /* insert css style sheet for our pretty tables */
}
setTimeOut(function (){if (hastables && !elementExists("#mytablecss"))
                           alert("bad table layouts");},3000);

වන $.contains()ඔබට අවශ්ය දේ?

jQuery.contains( container, contained )

$.contains()දෙවන තර්කය මඟින් සපයන ලද DOM මූලද්‍රව්‍යය පළමු තර්කය මඟින් සපයන ලද DOM මූලද්‍රව්‍යයෙන් පැවත එන්නෙකු නම්, එය සෘජු දරුවෙකු හෝ වඩාත් ගැඹුරින් කැදැල්ල කර තිබේ නම් මෙම ක්‍රමය සත්‍ය වේ. එසේ නොමැති නම්, එය සාවද්‍ය ය. සහාය දක්වන්නේ මූලද්‍රව්‍ය නෝඩ් පමණි; දෙවන තර්කය පෙළ හෝ අදහස් දැක්වීමේ නෝඩයක් නම්, $.contains()අසත්‍යය නැවත ලබා දෙනු ඇත.

සටහන : පළමු තර්කය DOM අංගයක් විය යුතුය, jQuery වස්තුවක් හෝ සරල ජාවාස්ක්‍රිප්ට් වස්තුවක් නොවේ.

මම if ($(selector).length) {}ප්රමාණවත් නොවන බව සොයාගෙන ඇත. selectorහිස් වස්තුවක් වන විට එය ඔබගේ යෙදුම නිහ ly ව බිඳ දමනු ඇත {}.

var $target = $({});        
console.log($target, $target.length);

// Console output:
// -------------------------------------
// [▼ Object              ] 1
//    ► __proto__: Object

මගේ එකම යෝජනාව වන්නේ අතිරේක පරීක්‍ෂණයක් සිදු කිරීමයි {}.

if ($.isEmptyObject(selector) || !$(selector).length) {
    throw new Error('Unable to work with the given selector.');
}

මම තවමත් වඩා හොඳ විසඳුමක් සොයමින් සිටියද මෙය ටිකක් බරයි.

සංස්කරණය කරන්න: අවවාදයයි! selectorනූලක් වන විට මෙය IE හි ක්‍රියා නොකරයි .

$.isEmptyObject('hello') // FALSE in Chrome and TRUE in IE

ජාවා ස්ක්‍රිප්ටයේ දිග භාවිතා නොකිරීම හෝ මූලද්‍රව්‍යය තිබේදැයි ඔබට පරීක්ෂා කළ හැකිය. දිග ශුන්‍යයට වඩා වැඩි නම් මූලද්‍රව්‍යය පවතින්නේ දිග ශුන්‍ය නම් මූලද්‍රව්‍යය නොපවතී

// These by Id
if ($("#elementid").length > 0) {
  // Element is Present
} else {
  // Element is not Present
}

// These by Class
if ($(".elementClass").length > 0) {
  // Element is Present
} else {
  // Element is not Present
}

මූලද්‍රව්‍යයක පැවැත්ම පරීක්ෂා කිරීම නිල jQuery වෙබ් අඩවියේම පිළිවෙලට ලේඛනගත කර ඇත!

ඔබේ තේරීම්කරු විසින් ආපසු ලබා දුන් jQuery එකතුවෙහි .length දේපල භාවිතා කරන්න :

if ($("#myDiv").length) {
    $("#myDiv").show();
}

මූලද්‍රව්‍යයක් තිබේද යන්න පරීක්ෂා කිරීම සැමවිටම අවශ්‍ය නොවන බව සලකන්න. පහත කේතය මඟින් මූලද්රව්යය තිබේ නම් එය පෙන්වනු ඇති අතර එය නොමැති නම් කිසිවක් නොකරන්න (දෝෂ නොමැතිව):

$("#myDiv").show();

මෙය සියලු පිළිතුරු වලට බෙහෙවින් සමාන ය, නමුත් !ඔබට බූලියන් ලබා ගත හැකි වන පරිදි දෙවරක් ක්‍රියාකරු භාවිතා නොකරන්නේ මන්ද :

jQuery.fn.exists = function(){return !!this.length};

if ($(selector).exists()) {
    // the element exists, now what?...
}

$(selector).length && //Do something

DOMමූලද්රව්යය සඳහා පරීක්ෂා කිරීමට උත්සාහ කරන්න

if (!!$(selector)[0]) // do stuff

විසින් ජාතිය hiway පිළිතුර මම පහත දැක්වෙන සමග පැමිණි:

$.fn.exists = function() {
    return $.contains( document.documentElement, this[0] );
}

jQuery.contains විසින් DOM මූලද්‍රව්‍ය දෙකක් ගෙන පළමු එක දෙවැන්න අඩංගු දැයි පරීක්ෂා කරයි.

භාවිතා document.documentElementපළමු තර්කය ලෙස ඇති semantics ඉටු existsඅපි වත්මන් ලේඛනයේ මූලද්රව්යයක පැවැත්ම පරීක්ෂා කිරීමට පමණක් එය අයදුම් කිරීමට අවශ්ය වන විට ක්රමය.

පහත බලන්න, මම එකට සමාන කරන තැනට දානවා jQuery.exists()එරෙහිව $(sel)[0]හා $(sel).lengthනැවත දෙකම ප්රවේශයන් truthyසඳහා අගයන් $(4)අතර $(4).exists()ප්රතිලාභ false. DOM හි මූලද්‍රව්‍යයක පැවැත්ම පරීක්ෂා කිරීමේ සන්දර්භය තුළ මෙය අපේක්ෂිත ප්‍රති .ලය ලෙස පෙනේ .

$.fn.exists = function() {
    return $.contains(document.documentElement, this[0]); 
  }
  
  var testFuncs = [
    function(jq) { return !!jq[0]; },
    function(jq) { return !!jq.length; },
    function(jq) { return jq.exists(); },
  ];
    
  var inputs = [
    ["$()",$()],
    ["$(4)",$(4)],
    ["$('#idoexist')",$('#idoexist')],
    ["$('#idontexist')",$('#idontexist')]
  ];
  
  for( var i = 0, l = inputs.length, tr, input; i < l; i++ ) {
    input = inputs[i][1];
    tr = "<tr><td>" + inputs[i][0] + "</td><td>"
          + testFuncs[0](input) + "</td><td>"
          + testFuncs[1](input) + "</td><td>"
          + testFuncs[2](input) + "</td></tr>";
    $("table").append(tr);
  }

td { border: 1px solid black }

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<div id="idoexist">#idoexist</div>
<table style>
<tr>
  <td>Input</td><td>!!$(sel)[0]</td><td>!!$(sel).length</td><td>$(sel).exists()</td>
</tr>
</table>
<script>
  
  $.fn.exists = function() {
    return $.contains(document.documentElement, this[0]); 
  }
  
</script>

JQuery (මූලික විසඳුම) අවශ්‍ය නොවේ

if(document.querySelector('.a-class')) {
  // do something
}

පහත බොහෝ ක්‍රියාකාරී විකල්පය (පන්තියකට පෙර තිතක් නොමැති බව සැලකිල්ලට ගන්න).

if(document.getElementsByClassName('a-class')[0]) {
  // do something
}

querySelector jQuery හි matching () (sizzle) වැනි නිසි ගැලපෙන එන්ජිමක් භාවිතා කරන අතර වැඩි පරිගණක බලයක් භාවිතා කරයි, නමුත් 99% ක්ම හොඳ වනු ඇත. දෙවන විකල්පය වඩාත් පැහැදිලිව පෙනෙන අතර කළ යුතු දේ හරියටම කේතයට කියයි. Jsperf https://jsperf.com/getelementsbyclassname-vs-queryselectorall/25 අනුව එය වඩා වේගවත්ය

මෙය කිරීමට සරල වැනිලා ජාවාස්ක්‍රිප්ට් භාවිතා කිරීමට මම කැමතියි.

function isExists(selector){
  return document.querySelectorAll(selector).length>0;
}

මම මෙම ප්‍රශ්නයට බාධා කළ අතර මම දැනට භාවිතා කරන කේතයේ කොටසක් බෙදා ගැනීමට කැමතියි:

$.fn.exists = function(callback) {
    var self = this;
    var wrapper = (function(){
            function notExists () {}

            notExists.prototype.otherwise = function(fallback){
                if (!self.length) {                    
                    fallback.call();
                }
            };

            return new notExists;
        })();

    if(self.length) {
        callback.call();    
    }

    return wrapper;
}

දැන් මට මේ වගේ කේත ලිවිය හැකිය -

$("#elem").exists(function(){
    alert ("it exists");
}).otherwise(function(){
    alert ("it doesn't exist");
});

එය බොහෝ කේත ලෙස පෙනේ, නමුත් කෝපි ස්ක්‍රිප්ට් හි ලියා ඇති විට එය තරමක් කුඩා ය:

$.fn.exists = (callback) ->
    exists = @length
    callback.call() if exists        
    new class
       otherwise: (fallback) ->            
            fallback.call() if not exists

මට වෙනත් නඩුවක් ඇතුළත වස්තුවක් තිබේදැයි බැලීමට අවශ්‍ය නඩුවක් මා සතුව ඇති බැවින් තේරීම් කාරකය තුළ තේරීම් කාරකයක් පරීක්ෂා කිරීම සඳහා පළමු පිළිතුරට යමක් එකතු කළෙමි ..

// Checks if an object exists.
// Usage:
//
//     $(selector).exists()
//
// Or:
// 
//     $(selector).exists(anotherSelector);
jQuery.fn.exists = function(selector) {
    return selector ? this.find(selector).length : this.length;
};

කොහොමද:

function exists(selector) {
    return $(selector).length;
}

if (exists(selector)) {
    // do something
}

එය ඉතා අවම වන අතර $()සෑම විටම තේරීම් කාරකය කොටු කර ගැනීමට ඔබට ඉතිරි වේ.

මම මෙය භාවිතා කරමි:

    $.fn.ifExists = function(fn) {
      if (this.length) {
        $(fn(this));
      }
    };
    $("#element").ifExists( 
      function($this){
        $this.addClass('someClass').animate({marginTop:20},function(){alert('ok')});               
      }
    ); 

JQuery අංගයක් තිබේ නම් පමණක් දාමය ක්‍රියාත්මක කරන්න - http://jsfiddle.net/andres_314/vbNM3/2/

මෙන්න existjQuery හි මගේ ප්‍රියතම ක්‍රමය

$.fn.exist = function(callback) {
    return $(this).each(function () {
        var target = $(this);

        if (this.length > 0 && typeof callback === 'function') {
            callback.call(target);
        }
    });
};

සහ තේරීම් කාරකය නොපවතින විට ඇමතුම් ලබා ගැනීමට සහාය වන වෙනත් අනුවාදය

$.fn.exist = function(onExist, onNotExist) {
    return $(this).each(function() {
        var target = $(this);

        if (this.length > 0) {
            if (typeof onExist === 'function') {
                onExist.call(target);
            }
        } else {
            if (typeof onNotExist === 'function') {
                onNotExist.call(target);
            }
        }
    });
};

උදාහරණයක්:

$('#foo .bar').exist(
    function () {
        // Stuff when '#foo .bar' exists
    },
    function () {
        // Stuff when '#foo .bar' does not exist
    }
);

$("selector") lengthදේපල ඇති වස්තුවක් ආපසු ලබා දෙයි . තේරීම්කරු කිසියම් මූලද්‍රව්‍යයක් සොයා ගන්නේ නම්, ඒවා වස්තුවට ඇතුළත් වේ. එබැවින් ඔබ එහි දිග පරීක්ෂා කළහොත් ඔබට කිසියම් මූලද්‍රව්‍යයක් තිබේදැයි බැලීමට හැකිය. JavaScript හි 0 == false, එබැවින් ඔබට නොලැබුනේ නම් 0ඔබේ කේතය ක්‍රියාත්මක වේ.

if($("selector").length){
   //code in the case
} 

විවිධ තත්වයන් පිළිබඳ සම්පූර්ණ උදාහරණය මෙයයි. JQuery තේරීම් කාරකයේ සෘජු භාවිතයෙන් මූලද්‍රව්‍යය පවතින්නේ දැයි පරීක්ෂා කර බැලිය හැකි අතර එය අරාව හෝ මූලද්‍රව්‍ය නැවත ලබා දෙන නිසා ක්‍රියා නොකරනු ඇත.

var a = null;

var b = []

var c = undefined ;

if(a) { console.log(" a exist")} else { console.log("a doesn't exit")}
// output: a doesn't exit

if(b) { console.log(" b exist")} else { console.log("b doesn't exit")}
// output: b exist

if(c) { console.log(" c exist")} else { console.log("c doesn't exit")}
// output: c doesn't exit

අවසාන විසඳුම

if($("#xysyxxs").length){ console.log("xusyxxs exist")} else { console.log("xusyxxs doesnn't exist") }
//output : xusyxxs doesnn't exist

if($(".xysyxxs").length){ console.log("xusyxxs exist")} else { console.log("xusyxxs doesnn't exist") }
    //output : xusyxxs doesnn't exist

ඔබ එය ට වඩා වැඩි වේ නම්, පරීක්ෂා කිරීමට අවශ්ය නැත 0වගේ $(selector).length > 0, $(selector).lengthඑය ප්රමාණවත් හා මූලද්රව්ය පැවැත්ම පරීක්ෂා කිරීමට අලංකාර ක්රමයක්. මේ සඳහා පමණක් ශ්‍රිතයක් ලිවීම වටී යැයි මම නොසිතමි, ඔබට තවත් අමතර දේවල් කිරීමට අවශ්‍ය නම්, ඔව්.

if($(selector).length){
  // true if length is not 0
} else {
  // false if length is 0
}