स्क्रॉलबार दिखाई देने पर मैं कैसे जांच कर सकता हूं?


277

क्या overflow:autoडिव की जाँच संभव है ?

उदाहरण के लिए:

एचटीएमएल

<div id="my_div" style="width: 100px; height:100px; overflow:auto;" class="my_class"> 
  * content
</div>

jQuery

$('.my_class').live('hover', function (event)
{
    if (event.type == 'mouseenter')
    {
         if( ...  if scrollbar visible ? ... )
         {
            alert('true'):
         }
         else
         {
            alert('false'):
         }
    }

});

कभी-कभी सामग्री छोटी होती है (कोई स्क्रॉलबार नहीं) और कभी-कभी लंबी (स्क्रॉलबार दिखाई देती है)।

जवाबों:


376

इसके लिए थोड़ा प्लगइन।

(function($) {
    $.fn.hasScrollBar = function() {
        return this.get(0).scrollHeight > this.height();
    }
})(jQuery);

इसे इस तरह से उपयोग करें,

$('#my_div1').hasScrollBar(); // returns true if there's a `vertical` scrollbar, false otherwise..

फ़ायरफ़ॉक्स, क्रोम, IE6,7,8 पर काम कर रहा है

लेकिन bodyटैग चयनकर्ता पर ठीक से काम नहीं कर रहा है

डेमो


संपादित करें

मुझे पता चला कि जब आपके पास क्षैतिज स्क्रॉलबार होता है जिसके कारण ऊर्ध्वाधर स्क्रॉलबार दिखाई देता है, तो यह फ़ंक्शन काम नहीं करता है ...।

मुझे एक और उपाय पता चला ... उपयोग clientHeight

return this.get(0).scrollHeight > this.get(0).clientHeight;

22
यदि आपके पास पैडिंग है तो आपको > this.innerHeight(); jsfiddle.net/p3FFL/210
jcubic

2
इस के साथ एक समस्या है, अगर एक क्षैतिज स्क्रॉल बार भी मौजूद है, तो यह तब भी गलत वापस आ जाएगा, जब तक कि एक ऊर्ध्वाधर स्क्रॉल बार मौजूद न हो, जब तक कि ऊंचाई क्षैतिज स्क्रॉल बार की ऊंचाई से सिकुड़ गई हो।
सहयोगी

आपने एक ही फ़ंक्शन को दो बार क्यों परिभाषित किया है? @ जुबिक
नितिन सावंत

8
ध्यान दें कि Mac पर स्क्रॉलबार सामग्री पर तैरता है और उपयोग में न होने पर गायब हो जाता है। विंडोज पर यह हमेशा दिखाई देता है और क्षैतिज स्थान लेता है। इसके लिए, सिर्फ इसलिए कि सामग्री को स्क्रॉल किया जा सकता है (जो इस फ़ंक्शन का पता लगाता है) इसका मतलब यह नहीं है कि स्क्रॉलबार आवश्यक रूप से मौजूद है।
एंड्रयू

2
(फ़ंक्शन ($) {$ .fn.hasScrollBar = function () {यह वापसी करें। (0) .scrollWidth> this.width); }}) (jQuery); यह क्षैतिज ओवरफ्लो के लिए काम करता है। आइफ्रेम में वेबसाइटों पर मोबाइल जवाबदेही की जाँच के लिए अच्छा है।
अलेक्जेंडर निकोलस पोपा

56

शायद एक अधिक सरल उपाय।

if ($(document).height() > $(window).height()) {
    // scrollbar
}

यह जवाब मेरे लिए काम करता है कि जाँच करने के बाद कि डोम JQuery.ready()
सरल सैंडमैन

4
यह मान लेता है कि स्क्रॉलबार खिड़की पर है और एक दिव्य तत्व नहीं है। सुझाव देने के लिए संदर्भ बदलने का प्रस्ताव: "यदि आपको केवल मुख्य विंडो पर स्क्रॉलबार का परीक्षण करने की आवश्यकता है, तो आप कोशिश कर सकते हैं:"
justdan23

43

आप Element.scrollHeightऔर Element.clientHeightविशेषताओं के संयोजन का उपयोग करके ऐसा कर सकते हैं ।

एमडीएन के अनुसार:

Element.scrollHeight केवल पढ़ने के लिए विशेषता एक तत्व की सामग्री की ऊंचाई का माप सामग्री अतिप्रवाह के कारण स्क्रीन पर दिखाई नहीं भी शामिल है। स्क्रॉलहाइट मान न्यूनतम क्लाइंटहाइट के बराबर है तत्व को ऊर्ध्वाधर स्क्रॉलबार का उपयोग किए बिना सभी सामग्री को व्यूपॉइंट में फिट करने के लिए आवश्यक होगा। इसमें तत्व पैडिंग शामिल है लेकिन इसका मार्जिन नहीं है।

तथा:

Element.clientHeight गद्दी नहीं बल्कि क्षैतिज स्क्रॉलबार ऊंचाई, सीमा, या मार्जिन सहित पिक्सल, में केवल पढ़ने के लिए संपत्ति विवरणी एक तत्व के भीतरी ऊंचाई।

क्लाइंटहाइट की गणना सीएसएस ऊंचाई + सीएसएस पैडिंग - क्षैतिज स्क्रॉलबार की ऊंचाई (यदि मौजूद है) के रूप में की जा सकती है।

इसलिए, तत्व स्क्रॉलबार प्रदर्शित करेगा यदि स्क्रॉल ऊंचाई क्लाइंट ऊंचाई से अधिक है, तो आपके प्रश्न का उत्तर है:

function scrollbarVisible(element) {
  return element.scrollHeight > element.clientHeight;
}

2
उदाहरण: MDN बोली और स्पष्टीकरण के लिए github.com/twbs/bootstrap/blob/master/js/modal.js#L242 और +1!
लोटेकसून

क्रोम में अगर सामग्री की सीमा है तो वह स्क्रॉलहाइट में शामिल नहीं है
एटी

1
फ्रेमवर्क / लाइब्रेरी का उपयोग नहीं करने और उसका उपयोग न करने के लिए मतदान किया गया।
जॉन

सावधान - यह एक रिफ्लो का कारण बनता है, जो एक प्रदर्शन नाली है। gist.github.com/paulirish/5d52fb081b3570c81e3a
टोड सेजोलैंडर

43

मुझे एक छोटी सी बात बदलनी चाहिए जो रीगेल ने कही है:

(function($) {
    $.fn.hasScrollBar = function() {
        return this[0] ? this[0].scrollHeight > this.innerHeight() : false;
    }
})(jQuery);

इनरहाइट नियंत्रण की ऊंचाई और इसके शीर्ष और निचले पैडिंग को गिनता है


वापसी (यह.गेट (0)); यह.गेट (0) .scrollHeight> this.innerHeight (): गलत;
आम

3
मुझे लगता है कि इसे सही जवाब के रूप में सौंपा जाना चाहिए। इसने FF35, IE11 और Chrome39 पर काम किया।
लुकासब्र

यह 'ओवरफ्लो' मान की जांच नहीं करता है कि स्क्रॉलहॉल की स्थिति पूरी होने पर स्क्रॉल बार दिखाई देगा।
बीटी

1
@BT लेकिन अगर मैं अपनी css में ऑटो को ओवरफ्लो कर देता हूं, तो मुझे इस अतिरिक्त जांच की आवश्यकता नहीं है? यह आकार की तुलना करता है और यह पर्याप्त है ...?
एंड्रयू

एक उत्तर जो केवल आपके लिए काम करता है, वह उत्तर नहीं है .. आप कैसे जानते हैं कि अन्य लोगों के पास क्या है? आपके उत्तर में उस सीमा का उल्लेख नहीं है। यदि कोई आपके उत्तर में नहीं गिर सकता है और उसके पास काम है, तो यह एक अच्छा उत्तर नहीं है।
बीटी

27

यह @ रेइगेल के उत्तर पर फैलता है। यह क्षैतिज या ऊर्ध्वाधर स्क्रॉलबार के लिए एक उत्तर देगा।

(function($) {
    $.fn.hasScrollBar = function() {
        var e = this.get(0);
        return {
            vertical: e.scrollHeight > e.clientHeight,
            horizontal: e.scrollWidth > e.clientWidth
        };
    }
})(jQuery);

उदाहरण:

element.hasScrollBar()             // Returns { vertical: true/false, horizontal: true/false }
element.hasScrollBar().vertical    // Returns true/false
element.hasScrollBar().horizontal  // Returns true/false


8

मैंने एक नया रिवाज बनाया: jQuery के लिए छद्म चयनकर्ता यह जांचने के लिए कि क्या किसी आइटम में निम्नलिखित सीएसएस गुण हैं:

  1. अतिप्रवाह: [स्क्रॉल | ऑटो]
  2. अतिप्रवाह-एक्स: [स्क्रॉल | ऑटो]
  3. अतिप्रवाह-y: [स्क्रॉल | ऑटो]

मैं किसी अन्य तत्व के निकटतम स्क्रॉल करने योग्य माता-पिता को ढूंढना चाहता था, इसलिए मैंने अतिप्रवाह के साथ निकटतम माता-पिता को खोजने के लिए एक और छोटा jQuery प्लगइन भी लिखा।

यह समाधान शायद सर्वश्रेष्ठ प्रदर्शन नहीं करता है, लेकिन यह काम करता है। मैंने इसे $ .scrollTo प्लगइन के साथ संयोजन में उपयोग किया। कभी-कभी मुझे यह जानने की आवश्यकता होती है कि क्या कोई तत्व किसी अन्य स्क्रॉल करने योग्य कंटेनर के अंदर है। उस मामले में मैं मूल स्क्रॉल करने योग्य तत्व बनाम विंडो को स्क्रॉल करना चाहता हूं।

मुझे संभवतः इसे एक ही प्लगइन में लपेटना चाहिए था और प्लगइन के एक भाग के रूप में psuedo चयनकर्ता को जोड़ा, साथ ही निकटतम (मूल) स्क्रॉल करने योग्य कंटेनर को खोजने के लिए एक 'निकटतम' विधि को उजागर किया।

Anywho .... यहाँ यह है।

$ .isScrollable jQuery प्लगइन:

$.fn.isScrollable = function(){
    var elem = $(this);
    return (
    elem.css('overflow') == 'scroll'
        || elem.css('overflow') == 'auto'
        || elem.css('overflow-x') == 'scroll'
        || elem.css('overflow-x') == 'auto'
        || elem.css('overflow-y') == 'scroll'
        || elem.css('overflow-y') == 'auto'
    );
};

$ (': स्क्रॉल करने योग्य') jQuery का छद्म चयनकर्ता:

$.expr[":"].scrollable = function(a) {
    var elem = $(a);
    return elem.isScrollable();
};

$ .scrollableparent () jQuery प्लगइन:

$.fn.scrollableparent = function(){
    return $(this).closest(':scrollable') || $(window); //default to $('html') instead?
};

कार्यान्वयन बहुत सरल है

//does a specific element have overflow scroll?
var somedivIsScrollable = $(this).isScrollable();
//use :scrollable psuedo selector to find a collection of child scrollable elements
var scrollableChildren = $(this).find(':scrollable');
//use $.scrollableparent to find closest scrollable container
var scrollableparent = $(this).scrollableparent();

अद्यतन करें: मैंने पाया कि रॉबर्ट कोरिटनिक पहले से ही बहुत अधिक शक्तिशाली हैं: स्क्रॉल करने योग्य छद्म चयनकर्ता जो स्क्रॉल करने योग्य कुल्हाड़ियों और स्क्रॉल करने योग्य कंटेनरों की ऊंचाई की पहचान करेंगे, उनके $ .scrollintoview () jQuery प्लगइन के एक भाग के रूप में। स्क्रोलिनव्यू प्लगइन

यहाँ उनके फैंसी छद्म चयनकर्ता (प्रॉप्स) हैं:

    $.extend($.expr[":"], {

    scrollable: function (element, index, meta, stack) {

        var direction = converter[typeof (meta[3]) === "string" && meta[3].toLowerCase()] || converter.both;

        var styles = (document.defaultView && document.defaultView.getComputedStyle ? document.defaultView.getComputedStyle(element, null) : element.currentStyle);

        var overflow = {

            x: scrollValue[styles.overflowX.toLowerCase()] || false,

            y: scrollValue[styles.overflowY.toLowerCase()] || false,

            isRoot: rootrx.test(element.nodeName)

        };



        // check if completely unscrollable (exclude HTML element because it's special)

        if (!overflow.x && !overflow.y && !overflow.isRoot)

        {

            return false;

        }



        var size = {

            height: {

                scroll: element.scrollHeight,

                client: element.clientHeight

            },

            width: {

                scroll: element.scrollWidth,

                client: element.clientWidth

            },

            // check overflow.x/y because iPad (and possibly other tablets) don't dislay scrollbars

            scrollableX: function () {

                return (overflow.x || overflow.isRoot) && this.width.scroll > this.width.client;

            },

            scrollableY: function () {

                return (overflow.y || overflow.isRoot) && this.height.scroll > this.height.client;

            }

        };

        return direction.y && size.scrollableY() || direction.x && size.scrollableX();

    }

});

6

उपरोक्त पहला समाधान केवल IE में काम करता है ऊपर का दूसरा समाधान केवल FF में काम करता है

दोनों फ़ंक्शंस का यह संयोजन दोनों ब्राउज़रों में काम करता है:

//Firefox Only!!
if ($(document).height() > $(window).height()) {
    // has scrollbar
    $("#mtc").addClass("AdjustOverflowWidth");
    alert('scrollbar present - Firefox');
} else {
    $("#mtc").removeClass("AdjustOverflowWidth");
}

//Internet Explorer Only!!
(function($) {
    $.fn.hasScrollBar = function() {
        return this.get(0).scrollHeight > this.innerHeight();
    }
})(jQuery);
if ($('#monitorWidth1').hasScrollBar()) {
    // has scrollbar
    $("#mtc").addClass("AdjustOverflowWidth");
    alert('scrollbar present - Internet Exploder');
} else {
    $("#mtc").removeClass("AdjustOverflowWidth");
}​
  • तैयार दस्तावेज़ में लपेटें
  • MonitorWidth1: div जहां ओवरफ्लो ऑटो पर सेट है
  • mtc: MonitorWidth1 के अंदर एक कंटेनर div
  • AdjustOverflowWidth: स्क्रॉलबार सक्रिय होने पर #mtc div पर लागू css क्लास * क्रॉस ब्राउजर का परीक्षण करने के लिए अलर्ट का उपयोग करें, और फिर अंतिम उत्पादन कोड के लिए टिप्पणी करें।

HTH


6

(स्क्रॉलविद / हाइट - क्लाइंटविद / हाइट) स्क्रॉलबार की उपस्थिति के लिए एक अच्छा संकेतक है, लेकिन यह आपको कई मौकों पर "गलत सकारात्मक" उत्तर देगा। यदि आपको सटीक होने की आवश्यकता है, तो मैं निम्नलिखित फ़ंक्शन का उपयोग करने का सुझाव दूंगा। तत्व स्क्रॉल करने योग्य है, यह अनुमान लगाने की कोशिश करने के बजाय - आप इसे स्क्रॉल कर सकते हैं ...

function isScrollable( el ){
  var y1 = el.scrollTop;
  el.scrollTop  += 1;
  var y2 = el.scrollTop;
  el.scrollTop  -= 1;
  var y3 = el.scrollTop;
  el.scrollTop   = y1;
  var x1 = el.scrollLeft;
  el.scrollLeft += 1;
  var x2 = el.scrollLeft;
  el.scrollLeft -= 1;
  var x3 = el.scrollLeft;
  el.scrollLeft  = x1;
  return {
    horizontallyScrollable: x1 !== x2 || x2 !== x3,
    verticallyScrollable: y1 !== y2 || y2 !== y3
  }
}
function check( id ){
  alert( JSON.stringify( isScrollable( document.getElementById( id ))));
}
#outer1, #outer2, #outer3 {
  background-color: pink;
  overflow: auto;
  float: left;
}
#inner {
  width:  150px;
  height: 150px;
}
button {  margin: 2em 0 0 1em; }
<div id="outer1" style="width: 100px; height: 100px;">
  <div id="inner">
    <button onclick="check('outer1')">check if<br>scrollable</button>
  </div>
</div>
<div id="outer2" style="width: 200px; height: 100px;">
  <div id="inner">
    <button onclick="check('outer2')">check if<br>scrollable</button>
  </div>
</div>
<div id="outer3" style="width: 100px; height: 180px;">
  <div id="inner">
    <button onclick="check('outer3')">check if<br>scrollable</button>
  </div>
</div>


किन अवसरों पर यह एक झूठी सकारात्मक देगा?
गैलोजगर्ल

5

यहाँ पर हर किसी के उत्तर अधूरे हैं, और एसओ जवाब में jquery का उपयोग करना बंद कर देते हैं। यदि आप jquery के बारे में जानकारी चाहते हैं, तो jquery के दस्तावेज़ देखें।

यहां परीक्षण के लिए सामान्यीकृत शुद्ध-जावास्क्रिप्ट फ़ंक्शन है कि किसी तत्व में स्क्रॉलबार पूरी तरह से है या नहीं:

// dimension - Either 'y' or 'x'
// computedStyles - (Optional) Pass in the domNodes computed styles if you already have it (since I hear its somewhat expensive)
function hasScrollBars(domNode, dimension, computedStyles) {
    dimension = dimension.toUpperCase()
    if(dimension === 'Y') {
        var length = 'Height'
    } else {
        var length = 'Width'
    }

    var scrollLength = 'scroll'+length
    var clientLength = 'client'+length
    var overflowDimension = 'overflow'+dimension

    var hasVScroll = domNode[scrollLength] > domNode[clientLength]


    // Check the overflow and overflowY properties for "auto" and "visible" values
    var cStyle = computedStyles || getComputedStyle(domNode)
    return hasVScroll && (cStyle[overflowDimension] == "visible"
                         || cStyle[overflowDimension] == "auto"
                         )
          || cStyle[overflowDimension] == "scroll"
}

4
क्यों एक प्रश्न पर jquery का उपयोग करने से बचें jquery के रूप में भड़काया? कृपया आपके द्वारा उल्लिखित jquery प्रलेखन के भाग में लिंक जोड़ें।
kpull1 11

6
@ kpull1 बहुत से लोग jQuery के हर एक जावास्क्रिप्ट प्रश्न पर टैग करते हैं जो उनके पास है। इस प्रश्न का jQuery से 0 संबंध है। वहाँ है jQuery प्रलेखन, जिसका उत्तर क्योंकि jQuery ऐसा नहीं करती है का कोई हिस्सा नहीं है, न ही यह होना चाहिए।
बीटी

4

मैं उन गरीब आत्माओं के लिए इस पर और भी विस्तार करने जा रहा हूं, जो मेरी तरह, आधुनिक जेएस फ्रेमवर्क में से एक का उपयोग करते हैं और JQuery का नहीं और इस धागे के लोगों द्वारा पूरी तरह से छोड़ दिया गया है:

यह कोणीय 6 में लिखा गया था, लेकिन यदि आप रिएक्ट 16, वीयू 2, पॉलिमर, आयोनिक, रिएक्ट-नेटिव लिखते हैं, तो आपको पता चल जाएगा कि इसे अनुकूलित करने के लिए क्या करना चाहिए। और यह पूरा घटक है इसलिए यह आसान होना चाहिए।

import {ElementRef, AfterViewInit} from '@angular/core';

@Component({
  selector: 'app',
  templateUrl: './app.html',
  styleUrls: ['./app.scss']
})
export class App implements AfterViewInit {
scrollAmount;

constructor(
  private fb: FormBuilder,
  private element: ElementRef 
) {}

ngAfterViewInit(){
  this.scrollAmount = this.element.nativeElement.querySelector('.elem-list');
  this.scrollAmount.addEventListener('wheel', e => { //you can put () instead of e
  // but e is usefull if you require the deltaY amount.
    if(this.scrollAmount.scrollHeight > this.scrollAmount.offsetHeight){
       // there is a scroll bar, do something!
    }else{
       // there is NO scroll bar, do something!
    }
  });
}
}

html में वर्ग "elem-list" के साथ एक div होगा जो कि css या scss में स्टाइल किया गया है heightऔर एक overflowमान जो नहीं है hidden। (तो autoया sroll)

मैं इस ईवेंट को एक स्क्रॉल ईवेंट पर ट्रिगर करता हूं क्योंकि मेरा अंतिम लक्ष्य "स्वचालित फ़ोकस स्क्रॉल" था, जो यह तय करता है कि क्या वे घटकों के पूरे सेट को क्षैतिज रूप से स्क्रॉल कर रहे हैं यदि कहा जाता है कि घटकों में कोई ऊर्ध्वाधर स्क्रॉल उपलब्ध नहीं है और अन्यथा केवल एक में से एक के स्क्रॉल को स्क्रॉल करें घटक लंबवत हैं।

लेकिन आप इसे कहीं और ले जा सकते हैं ताकि इसे किसी और चीज़ से ट्रिगर किया जा सके।

यहां याद रखने वाली महत्वपूर्ण बात यह है कि क्या आप कभी भी JQuery का उपयोग करने के लिए मजबूर नहीं होते हैं , हमेशा एक ही कार्यक्षमता का उपयोग करने का एक तरीका है जो इसे उपयोग करने से बचता है।


1
उत्सुक है कि आप यह देखने के लिए पहिया घटनाओं के लिए क्यों सुन रहे हैं कि कोई स्क्रॉलबार है या नहीं।
मिश्रण

3
इसके अलावा, चूंकि आप एरो फ़ंक्शंस का उपयोग कर रहे हैं, thisइसलिए पेरेंट स्कोप बना रहता है; th = this;अनावश्यक है।
मिश्रण

1
@ मिक्स 3 डी मैं व्यक्तिगत रूप से क्षैतिज और ऊर्ध्वाधर स्क्रॉलिंग के बीच स्वचालित रूप से स्विच करने के लिए इस कोड का उपयोग करता हूं, जिसके आधार पर दिए गए तत्व पर स्क्रॉल दिशा है जो गतिशील है
tatsu

1
पुन: यह; यह मूल रूप से function(){}.bind(this)
सिंथेटिक

1

यहां इवान के उत्तर का एक उन्नत संस्करण है जो अतिप्रवाह तर्क के लिए ठीक से खाता है।

            function element_scrollbars(node) {
                var element = $(node);
                var overflow_x = element.css("overflow-x");
                var overflow_y = element.css("overflow-y");
                var overflow = element.css("overflow");
                if (overflow_x == "undefined") overflow_x == "";
                if (overflow_y == "undefined") overflow_y == "";
                if (overflow == "undefined") overflow == "";
                if (overflow_x == "") overflow_x = overflow;
                if (overflow_y == "") overflow_y = overflow;
                var scrollbar_vertical = (
                    (overflow_y == "scroll")
                    || (
                        (
                            (overflow_y == "hidden")
                            || (overflow_y == "visible")
                        )
                        && (
                            (node.scrollHeight > node.clientHeight)
                        )
                    )
                );
                var scrollbar_horizontal = (
                    (overflow_x == "scroll")
                    || (
                        (
                            (overflow_x == "hidden")
                            || (overflow_x == "visible")
                        )
                        && (
                            (node.scrollWidth > node.clientWidth)
                        )
                    )
                );
                return {
                    vertical: scrollbar_vertical,
                    horizontal: scrollbar_horizontal
                };
            }

1

ऊपर दिए गए समाधान अधिकांश मामलों में काम करेंगे, लेकिन स्क्रॉलहाइट और अतिप्रवाह की जांच करना कभी-कभी पर्याप्त नहीं होता है और शरीर और HTML तत्वों के लिए विफल हो सकता है जैसा कि यहां देखा गया है: https://codepen.io/anon/pen/EvzXZw

1. समाधान - जांचें कि क्या तत्व स्क्रॉल करने योग्य है:

function isScrollableY (element) {
  return !!(element.scrollTop || (++element.scrollTop && element.scrollTop--));
}

नोट: तत्वों overflow: hiddenको भी स्क्रॉल करने योग्य ( अधिक जानकारी ) के रूप में माना जाता है , इसलिए आप जरूरत पड़ने पर इसके खिलाफ एक शर्त जोड़ सकते हैं:

function isScrollableY (element) {
    let style = window.getComputedStyle(element);
    return !!(element.scrollTop || (++element.scrollTop && element.scrollTop--)) 
           && style["overflow"] !== "hidden" && style["overflow-y"] !== "hidden";
}

जहाँ तक मुझे पता है कि यह विधि केवल तभी विफल होती है जब तत्व में है scroll-behavior: smooth

स्पष्टीकरण: चाल यह है, कि नीचे स्क्रॉल करने और इसे वापस करने का प्रयास ब्राउज़र द्वारा प्रदान नहीं किया जाएगा। सबसे ऊपरी फ़ंक्शन को निम्नलिखित की तरह भी लिखा जा सकता है:

2. समाधान - सभी आवश्यक जाँच करें:

function isScrollableY (element) {
  const style = window.getComputedStyle(element);
  
  if (element.scrollHeight > element.clientHeight &&
      style["overflow"] !== "hidden" && style["overflow-y"] !== "hidden" &&
      style["overflow"] !== "clip" && style["overflow-y"] !== "clip"
  ) {
    if (element === document.documentElement) return true;
    else if (style["overflow"] !== "visible" && style["overflow-y"] !== "visible") {
      // special check for body element (https://drafts.csswg.org/cssom-view/#potentially-scrollable)
      if (element === document.body) {
        const parentStyle = window.getComputedStyle(element.parentElement);
        if (parentStyle["overflow"] !== "visible" && parentStyle["overflow-y"] !== "visible" &&
            parentStyle["overflow"] !== "clip" && parentStyle["overflow-y"] !== "clip"
        ) {
          return true;
        }
      }
      else return true;
    }
  }
  
  return false;
}

0

यहाँ मेरा सुधार है: जोड़ा गया parseInt। कुछ अजीब कारण के लिए यह इसके बिना काम नहीं किया।

// usage: jQuery('#my_div1').hasVerticalScrollBar();
// Credit: http://stackoverflow.com/questions/4814398/how-can-i-check-if-a-scrollbar-is-visible
(function($) {
    $.fn.hasVerticalScrollBar = function() {
        return this.get(0) ? parseInt( this.get(0).scrollHeight ) > parseInt( this.innerHeight() ) : false;
    };
})(jQuery);

0

कम से कम नए संस्करणों में क्रोम , एज , फ़ायरफ़ॉक्स और ओपेरा पर काम करता है ।

JQuery का उपयोग कर रहा है ...

पाद को ठीक करने के लिए इस फ़ंक्शन को सेट करें:

function fixFooterCaller()
{
    const body = $('body');
    const footer = $('body footer');

    return function ()
    {
        // If the scroll bar is visible
        if ($(document).height() > $(window).height())
        {
            // Reset
            footer.css('position', 'inherit');
            // Erase the padding added in the above code
            body.css('padding-bottom', '0');
        }
        // If the scrollbar is NOT visible
        else
        {
            // Make it fixed at the bottom
            footer.css('position', 'fixed');
            // And put a padding to the body as the size of the footer
            // This makes the footer do not cover the content and when
            // it does, this event fix it
            body.css('padding-bottom', footer.outerHeight());
        }
    }
}

यह एक फ़ंक्शन देता है। सिर्फ शरीर और पाद को एक बार सेट करने के लिए इस तरह से बनाया गया है।

और फिर, दस्तावेज़ तैयार होने पर इसे सेट करें।

$(document).ready(function ()
{
    const fixFooter = fixFooterCaller();

    // Put in a timeout call instead of just call the fixFooter function
    // to prevent the page elements needed don't be ready at this time
    setTimeout(fixFooter, 0);
    // The function must be called every time the window is resized
    $(window).resize(fixFooter);
});

इसे अपने पाद लेख में जोड़ें:

footer {
    bottom: 0;
}

0

प्रस्तुत किए गए अधिकांश उत्तरों ने मुझे पास कर दिया जहां मुझे होने की आवश्यकता थी, लेकिन वहां नहीं।

हम मूल रूप से यह आकलन करना चाहते थे कि स्क्रोल बार -वॉल्ड-सामान्य स्थिति में दिखाई दे या नहीं, इस परिभाषा से यह अर्थ निकलता है कि बॉडी एलिमेंट का आकार व्यू पोर्ट से बड़ा है। यह एक प्रस्तुत समाधान नहीं था, यही वजह है कि मैं इसे प्रस्तुत कर रहा हूं।

उम्मीद है कि यह किसी की मदद करता है!

(function($) {
    $.fn.hasScrollBar = function() {
        return this.get(0).scrollHeight > $(window).height();
    }
})(jQuery);

अनिवार्य रूप से, हमारे पास hasScrollbarफ़ंक्शन है, लेकिन यदि अनुरोध किया गया तत्व रिटर्न पोर्ट से बड़ा है तो वापस लौटना होगा। पोर्ट आकार को देखने के लिए, हमने अभी उपयोग किया है $(window).height()। तत्व आकार के खिलाफ एक त्वरित तुलना, सही परिणाम और वांछनीय व्यवहार प्राप्त करता है।


0

वर्तमान तत्व का एक अभिभावक खोजें जिसमें लंबवत स्क्रॉलिंग या बॉडी हो।

$.fn.scrollableParent = function() {
    var $parents = this.parents();

    var $scrollable = $parents.filter(function(idx) {
        return this.scrollHeight > this.offsetHeight && this.offsetWidth !== this.clientWidth;
    }).first();

    if ($scrollable.length === 0) {
        $scrollable = $('html, body');
    }
    return $scrollable;
};

इसका उपयोग वर्तमान तत्व के लिए ऑटोस्कोप करने के लिए किया जा सकता है:

var $scrollable = $elem.scrollableParent();
$scrollable.scrollTop($elem.position().top);

0

एक फ्रेमवर्क जावास्क्रिप्ट दृष्टिकोण, ऊर्ध्वाधर और क्षैतिज दोनों के लिए जाँच करता है

 /*
 * hasScrollBars
 * 
 * Checks to see if an element has scrollbars
 * 
 * @returns {object}
 */
Element.prototype.hasScrollBars = function() {
    return {"vertical": this.scrollHeight > this.style.height, "horizontal": this.scrollWidth > this.style.width};
}

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

if(document.getElementsByTagName("body")[0].hasScrollBars().vertical){
            alert("vertical");
}

        if(document.getElementsByTagName("body")[0].hasScrollBars().horizontal){
            alert("horizontal");
}
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.