यदि सामग्री बहुत अधिक है तो HTML टैग में दीर्घवृत्त (…) डालें


148

मेरे पास एक लोचदार लेआउट वाला एक वेबपेज है जो ब्राउज़र विंडो के आकार बदलने पर इसकी चौड़ाई को बदल देता है।

इस लेआउट में हेडलाइंस ( h2) हैं जिनकी एक वैरिएबल लंबाई होगी (वास्तव में ब्लॉगपोस्ट्स से सुर्खियां बन रही हैं, जिन पर मेरा नियंत्रण नहीं है)। वर्तमान में - यदि वे खिड़की से व्यापक हैं - वे दो लाइनों में टूट गए हैं।

क्या jQuery के साथ उदाहरण के लिए एक सुरुचिपूर्ण, परीक्षण किया गया (क्रॉस-ब्राउज़र) समाधान है - जो उस शीर्षक टैग के आंतरिक HTML को छोटा करता है और "..." जोड़ता है, यदि पाठ वर्तमान स्क्रीन पर एक पंक्ति में फिट होने के लिए बहुत चौड़ा होगा / कंटेनर की चौड़ाई?


1
2014 अपडेट किया गया उत्तर: stackoverflow.com/a/22811590/759452
एड्रियन बनो

मैंने इस थ्रेड के आधार पर प्लगइन बनाया है जो पाठ को प्रारूपित करने के लिए सीएसएस गुण श्वेत-स्थान और वर्ड-रैप का उपयोग करता है। github.com/nothrem/jQuerySmartEllipsis
Radek Pech

जवाबों:


119

मुझे FF3, Safari और IE6 + में सिंगल और मल्टीलाइन टेक्स्ट के साथ काम करने का सॉल्यूशन मिला है

.ellipsis {
    white-space: nowrap;
    overflow: hidden;
}

.ellipsis.multiline {
    white-space: normal;
}

<div class="ellipsis" style="width: 100px; border: 1px solid black;">Lorem ipsum dolor sit amet, consectetur adipisicing elit</div>
<div class="ellipsis multiline" style="width: 100px; height: 40px; border: 1px solid black; margin-bottom: 100px">Lorem ipsum dolor sit amet, consectetur adipisicing elit</div>

<script type="text/javascript" src="/js/jquery.ellipsis.js"></script>
<script type="text/javascript">
$(".ellipsis").ellipsis();
</script>

jquery.ellipsis.js

(function($) {
    $.fn.ellipsis = function()
    {
        return this.each(function()
        {
            var el = $(this);

            if(el.css("overflow") == "hidden")
            {
                var text = el.html();
                var multiline = el.hasClass('multiline');
                var t = $(this.cloneNode(true))
                    .hide()
                    .css('position', 'absolute')
                    .css('overflow', 'visible')
                    .width(multiline ? el.width() : 'auto')
                    .height(multiline ? 'auto' : el.height())
                    ;

                el.after(t);

                function height() { return t.height() > el.height(); };
                function width() { return t.width() > el.width(); };

                var func = multiline ? height : width;

                while (text.length > 0 && func())
                {
                    text = text.substr(0, text.length - 1);
                    t.html(text + "...");
                }

                el.html(t.html());
                t.remove();
            }
        });
    };
})(jQuery);

22
अच्छा, मैं देख रहा हूँ कि कैसे कई लाइनों के साथ अतिप्रवाह को संभालना है। एक सुधार: तीन अवधियों को लागू करने के बजाय, एलिप्सिस वर्ण को जोड़ दें, '...'।
साइमन लेस्चके

4
यह बहुत अच्छा काम करता है। आपको इसे jQuery साइट पर प्रकाशित करना चाहिए।
एडगर

1
हालांकि IE में यदि ellipsis फ़ंक्शन एक div पर लागू होता है, जिसमें सिर्फ एक लिंक होता है, तो ellipsis के बाद लिंक गायब हो जाता है। इस पर कोई संकेत?

6
यदि आप इसे क्रिया में देखना चाहते हैं, तो आप इसे यहाँ देख सकते हैं (प्लगइन कोड पर खराब प्रारूपण के लिए खेद है) jsfiddle.net/danesparza/TF6Rb/1
Dan Esparza

22
प्रदर्शन में सुधार करने के लिए, "जबकि" लूप में एक बार में 1 चरित्र को हटाने के बजाय एक द्विआधारी खोज करें। यदि पाठ का 100% फिट नहीं होता है, तो पाठ का 50% प्रयास करें; यदि पाठ 50% फिट बैठता है, तो 25% या 50% फिट नहीं होने पर 25% पाठ इत्यादि
स्टैनलेह

182

निम्नलिखित सीएसएस एक लाइन पर पाठ को रौंदने के लिए केवल समाधान http://www.caniuse.com पर सूचीबद्ध सभी ब्राउज़रों के साथ काम करता है जैसा कि फ़ायरफ़ॉक्स 6.0 के अपवाद के साथ लिखा गया है। ध्यान दें कि जावास्क्रिप्ट पूरी तरह से अनावश्यक है जब तक कि आपको मल्टीलाइन पाठ या फ़ायरफ़ॉक्स के पुराने संस्करणों को लपेटने का समर्थन करने की आवश्यकता न हो।

.ellipsis {
    white-space: nowrap;
    overflow: hidden;
    text-overflow: ellipsis;
    -o-text-overflow: ellipsis;
}

यदि आपको फ़ायरफ़ॉक्स के पुराने संस्करणों के समर्थन की आवश्यकता है, तो इस अन्य प्रश्न पर मेरे उत्तर की जाँच करें ।


2
यह परिमाण के तेज और फिर jQuery के दृष्टिकोण के आदेश हैं। IE7 + और Chrome में ठीक काम करता है।
JDB अब भी मोनिका

3
यह प्राचीन ब्राउज़रों को भी अच्छी तरह से काम करता है। हम इसे Google में ~ 2004 में सफलतापूर्वक उपयोग कर रहे थे, जहाँ हमें कुछ सचमुच के कोने वाले ब्राउज़रों पर इनायत का समर्थन करने या नीचा दिखाने की आवश्यकता थी।
एल्बेल

2
जेएस फिडल उन लोगों के लिए जो इसे एक ब्राउज़र पर नमूना करना चाहते हैं - jsfiddle.net/r39Ad
दीपक बाला

@DilipRajkumar आपको अधिक विवरण प्रदान करने की आवश्यकता होगी जैसे एक JSFiddle उदाहरण यह प्रदर्शित करता है कि यह IE 8 में काम नहीं कर रहा है
साइमन लेस्चके

1
@SharpCoder आप नहीं। जहां टेक्स्ट कट ऑफ उस तत्व की चौड़ाई से तय होता है, यानी जब वह तत्व की चौड़ाई को ओवरफ्लो करता है तो यह छोटा हो जाता है।
साइमन लाइसेक

40

मैंने इस कोड को कई अन्य पदों का उपयोग करके बनाया है, निम्नलिखित संवर्द्धन के साथ:

  1. यह पाठ की लंबाई खोजने के लिए एक द्विआधारी खोज का उपयोग करता है जो कि सही है।
  2. यह उन मामलों को संभालता है जहां एलीपसिस तत्व (ओं) को शुरू में एक-शॉट शो ईवेंट सेट करके छिपाया जाता है जो आइटम के पहली बार प्रदर्शित होने पर एलिप्सिस कोड को फिर से चलाता है। यह मास्टर-डिटेल व्यूज़ या ट्री-व्यूज़ के लिए आसान है जहाँ कुछ आइटम शुरू में प्रदर्शित नहीं होते हैं।
  3. यह वैकल्पिक रूप से एक हॉवरओवर प्रभाव के लिए मूल पाठ के साथ एक शीर्षक विशेषता जोड़ता है।
  4. display: blockशैली में जोड़ा गया है, इसलिए स्पैन काम करते हैं
  5. यह 3 पीरियड के बजाय इलिप्सिस वर्ण का उपयोग करता है।
  6. यह .ellipsis वर्ग के साथ किसी भी चीज़ के लिए स्क्रिप्ट को ऑटो चलाता है

सीएसएस:

.ellipsis {
        white-space: nowrap;
        overflow: hidden;
        display: block;
}

.ellipsis.multiline {
        white-space: normal;
}

jquery.ellipsis.js

(function ($) {

    // this is a binary search that operates via a function
    // func should return < 0 if it should search smaller values
    // func should return > 0 if it should search larger values
    // func should return = 0 if the exact value is found
    // Note: this function handles multiple matches and will return the last match
    // this returns -1 if no match is found
    function binarySearch(length, func) {
        var low = 0;
        var high = length - 1;
        var best = -1;
        var mid;

        while (low <= high) {
            mid = ~ ~((low + high) / 2); //~~ is a fast way to convert something to an int
            var result = func(mid);
            if (result < 0) {
                high = mid - 1;
            } else if (result > 0) {
                low = mid + 1;
            } else {
                best = mid;
                low = mid + 1;
            }
        }

        return best;
    }

    // setup handlers for events for show/hide
    $.each(["show", "toggleClass", "addClass", "removeClass"], function () {

        //get the old function, e.g. $.fn.show   or $.fn.hide
        var oldFn = $.fn[this];
        $.fn[this] = function () {

            // get the items that are currently hidden
            var hidden = this.find(":hidden").add(this.filter(":hidden"));

            // run the original function
            var result = oldFn.apply(this, arguments);

            // for all of the hidden elements that are now visible
            hidden.filter(":visible").each(function () {
                // trigger the show msg
                $(this).triggerHandler("show");
            });

            return result;
        };
    });

    // create the ellipsis function
    // when addTooltip = true, add a title attribute with the original text
    $.fn.ellipsis = function (addTooltip) {

        return this.each(function () {
            var el = $(this);

            if (el.is(":visible")) {

                if (el.css("overflow") === "hidden") {
                    var content = el.html();
                    var multiline = el.hasClass('multiline');
                    var tempElement = $(this.cloneNode(true))
                        .hide()
                        .css('position', 'absolute')
                        .css('overflow', 'visible')
                        .width(multiline ? el.width() : 'auto')
                        .height(multiline ? 'auto' : el.height())
                    ;

                    el.after(tempElement);

                    var tooTallFunc = function () {
                        return tempElement.height() > el.height();
                    };

                    var tooWideFunc = function () {
                        return tempElement.width() > el.width();
                    };

                    var tooLongFunc = multiline ? tooTallFunc : tooWideFunc;

                    // if the element is too long...
                    if (tooLongFunc()) {

                        var tooltipText = null;
                        // if a tooltip was requested...
                        if (addTooltip) {
                            // trim leading/trailing whitespace
                            // and consolidate internal whitespace to a single space
                            tooltipText = $.trim(el.text()).replace(/\s\s+/g, ' ');
                        }

                        var originalContent = content;

                        var createContentFunc = function (i) {
                            content = originalContent.substr(0, i);
                            tempElement.html(content + "…");
                        };

                        var searchFunc = function (i) {
                            createContentFunc(i);
                            if (tooLongFunc()) {
                                return -1;
                            }
                            return 0;
                        };

                        var len = binarySearch(content.length - 1, searchFunc);

                        createContentFunc(len);

                        el.html(tempElement.html());

                        // add the tooltip if appropriate
                        if (tooltipText !== null) {
                            el.attr('title', tooltipText);
                        }
                    }

                    tempElement.remove();
                }
            }
            else {
                // if this isn't visible, then hook up the show event
                el.one('show', function () {
                    $(this).ellipsis(addTooltip);
                });
            }
        });
    };

    // ellipsification for items with an ellipsis
    $(document).ready(function () {
        $('.ellipsis').ellipsis(true);
    });

} (jQuery));

2
सुंदर। एक द्विआधारी खोज के मेरे सुझाव को लागू करने के लिए ब्रावो।
स्टैनलेह

2
बस एक त्वरित नोट ... यह टेम्पेमेंट वर्जन में .css ('अधिकतम-चौड़ाई', 'कोई नहीं') जोड़ने लायक है ... इस तरह से आप अपने css में अधिकतम-चौड़ाई की घोषणा का उपयोग कर सकते हैं, जिससे प्लगइन कहीं अधिक लचीला हो जाता है (कम से कम मेरे उपयोग के अधिकांश मामलों के लिए)। वैसे भी अच्छा काम। :)
गॉर्डियर

3
यह उपर्युक्त स्वीकृत उत्तर की तुलना में बहुत तेज कार्यान्वयन है। यदि आपके पास एकाधिक .ellipsis तत्व हैं, और उनके साथ कुछ भी गतिशील कर रहे हैं, तो यह बहुत बेहतर प्रदर्शन करता है।
मझवोटव

क्या आप एक उदाहरण प्रदान कर सकते हैं? मेरा सवाल यहाँ है: stackoverflow.com/questions/26344520/…
SearchForKnowledge

बाइनरी सर्च बेहतर है लेकिन बहुत छोटे डेटासेट्स के साथ नहीं है और इस मामले में यह एक सीधी रेखीय खोज जैसे कि indexOf () की तुलना में प्रदर्शन में बाधा डालता है ... जाहिरा तौर पर
user1360809

20

मेरा जवाब केवल सिंगल लाइन टेक्स्ट का समर्थन करता है। मल्टी लाइन कांटा के लिए नीचे gfullam की टिप्पणी देखें, यह बहुत आशाजनक लगता है।

मैंने पहले उत्तर से कोड को कुछ बार फिर से लिखा, और मुझे लगता है कि यह सबसे तेज़ होना चाहिए।

यह पहले एक "अनुमानित" पाठ की लंबाई पाता है, और फिर चौड़ाई सही होने तक एक चरित्र को जोड़ता या हटाता है।

इसका उपयोग करने वाला तर्क नीचे दिखाया गया है:

यहाँ छवि विवरण दर्ज करें

एक "अनुमानित" पाठ की लंबाई पाए जाने के बाद, वर्ण तब तक जोड़े या हटाए जाते हैं जब तक कि वांछित चौड़ाई नहीं मिल जाती।

मुझे यकीन है कि यह कुछ tweaking की जरूरत है, लेकिन यहाँ कोड है:

(function ($) {
    $.fn.ellipsis = function () {
        return this.each(function () {
            var el = $(this);

            if (el.css("overflow") == "hidden") {
                var text = el.html().trim();
                var t = $(this.cloneNode(true))
                                        .hide()
                                        .css('position', 'absolute')
                                        .css('overflow', 'visible')
                                        .width('auto')
                                        .height(el.height())
                                        ;
                el.after(t);

                function width() { return t.width() > el.width(); };

                if (width()) {

                    var myElipse = "....";

                    t.html(text);

                    var suggestedCharLength = (text.length * el.width() / t.width()) - myElipse.length;

                    t.html(text.substr(0, suggestedCharLength) + myElipse);

                    var x = 1;
                    if (width()) {
                        while (width()) {
                            t.html(text.substr(0, suggestedCharLength - x) + myElipse);
                            x++;
                        }
                    }
                    else {
                        while (!width()) {
                            t.html(text.substr(0, suggestedCharLength + x) + myElipse);
                            x++;
                        }
                        x--;
                        t.html(text.substr(0, suggestedCharLength + x) + myElipse);
                    }

                    el.html(t.html());
                    t.remove();
                }
            }
        });
    };
})(jQuery);

3
आपका समाधान सबसे अच्छा नहीं हो सकता है, लेकिन यह बहुत अच्छी तरह से समझाया गया है। और मुझे इस प्रकार के अनुमानित तर्क पसंद हैं। +1 :)
फ्लटर


19

बस के मामले में y'all 2013 में यहाँ समाप्त होता है - यहाँ एक शुद्ध सीएसएस दृष्टिकोण है जो मैंने यहां पाया है: http://css-tricks.com/snippets/css/truncate-string-with-ellipsis/

.truncate {
  width: 250px;
  white-space: nowrap;
  overflow: hidden;
  text-overflow: ellipsis;
}

यह अच्छा काम करता है।


1
FWIW, तत्वों के text-overflowसाथ काम नहीं करता है textarea(2015 तक)। यदि आपको इसके लिए समर्थन की आवश्यकता है, textareaतो आप स्वीकृत उत्तर को संशोधित करके या इस कांटे का उपयोग करके इसे प्राप्त कर सकते हैं ।
गुफलाम

18

मैंने टेक्स्ट की सभी प्रकार की इलिप्सिस से निपटने के लिए एक बहुत अच्छा jQuery प्लगइन बनाया है, जिसे थ्रीडॉट्स @ http://tpgblog.com/threedots कहा जाता है।

यह सीएसएस दृष्टिकोण की तुलना में बहुत अधिक लचीला है, और बहुत अधिक उन्नत, अनुकूलन योग्य व्यवहार और इंटरैक्शन का समर्थन करता है।

का आनंद लें।


8

एक और अधिक लचीला jQuery प्लगइन आपको एलिप्सिस के बाद एक तत्व रखने में सक्षम बनाता है (उदाहरण के लिए एक "अधिक पढ़ें" बटन) और onWindowResize को अपडेट करें। यह मार्कअप के साथ पाठ के आसपास भी काम करता है:

http://dotdotdot.frebsite.nl


मैंने अभी इस प्लगइन का परीक्षण किया है, लेकिन मैं इसे काम नहीं कर सका। ट्रंक 8 मेरे लिए बेहतर विकल्प था।
गिलहर्मे गार्नियर

8

trunk8 jQuery प्लगइन कई पंक्तियों का समर्थन करता है, और किसी भी html का उपयोग कर सकता है, न कि केवल दीर्घवृत्त वर्णों का, ट्रंकेशन प्रत्यय के लिए: https://github.com/rviscomi/trunk8

यहाँ डेमो: http://jrvis.com/trunk8/


हाँ, लेकिन यह अब प्राचीन है। ऐसा लगता है कि इसका समर्थन नहीं किया गया है?
user2513846 19

1
ऐसा लगता है कि इसका सक्रिय रूप से समर्थन किया गया है - लेखन के समय (मार्च 2016), मुद्दे और पीआरएस हाल ही में परियोजना निर्माता को शामिल करने वाली गतिविधि दिखाते हैं।
एलियट साइक्स

5

सीएसएस में ऐसा करने के लिए वास्तव में एक बहुत ही सरल तरीका है इस तथ्य का शोषण करना कि आईई इसे गैर-मानकों और एफएफ समर्थन के साथ विस्तारित करता है:after

आप इसे JS में भी कर सकते हैं यदि आप लक्ष्य के स्क्रॉलविद का निरीक्षण करके और इसकी तुलना माता-पिता की चौड़ाई से करना चाहते हैं, लेकिन यह कम मज़बूत है।

संपादित करें: यह स्पष्ट रूप से जितना मैंने सोचा था उससे अधिक विकसित है। CSS3 समर्थन जल्द ही मौजूद हो सकता है, और कुछ अपूर्ण विस्तार आपके लिए प्रयास करने के लिए उपलब्ध हैं।

कि पिछले एक अच्छा पढ़ना है।


वास्तव में मैं जेएस समाधान पसंद करता हूं - क्योंकि यह केवल "..." जोड़ता है यदि पाठ उपलब्ध स्थान से अधिक व्यापक है।
BlaM

3

मैंने हाल ही में एक ग्राहक के लिए कुछ ऐसा ही किया है। यहां मैंने उनके लिए जो किया है उसका एक संस्करण है (उदाहरण विस्टा पर सभी नवीनतम ब्राउज़र संस्करणों में परीक्षण किया गया)। बोर्ड के चारों ओर सही नहीं है, लेकिन बहुत आसानी से ट्विक किया जा सकता है।

डेमो: http://enobrev.info/ellipsis/

कोड:

<html>
    <head>
        <script src="http://www.google.com/jsapi"></script>
        <script>            
            google.load("jquery", "1.2.6");
            google.setOnLoadCallback(function() {
                $('.longtext').each(function() {
                    if ($(this).attr('scrollWidth') > $(this).width()) {
                        $more = $('<b class="more">&hellip;</b>');

                        // add it to the dom first, so it will have dimensions
                        $(this).append($more);

                        // now set the position
                        $more.css({
                            top: '-' + $(this).height() + 'px',
                            left: ($(this).attr('offsetWidth') - $more.attr('offsetWidth')) + 'px'
                        });
                    }
                });
            });
        </script>

        <style>
            .longtext {
                height: 20px;
                width: 300px;
                overflow: hidden;
                white-space: nowrap;
                border: 1px solid #f00;
            }

            .more {
                z-index: 10;
                position: relative;
                display: block;
                background-color: #fff;
                width: 18px;
                padding: 0 2px;
            }
        </style>
    </head>
    <body>
        <p class="longtext">This is some really long text.  This is some really long text.  This is some really long text.  This is some really long text.</p>
    </body>
</html>

3

ठीक है, एक सरल समाधान, जो "..." को काफी नहीं जोड़ता है, लेकिन <h2> को दो लाइनों में तोड़ने से रोकता है, इस बिट सीएसएस को जोड़ना होगा:

h2 {
    height:some_height_in_px; /* this is the height of the line */
    overflow:hidden; /* so that the second (or third, fourth, etc.)
                        line is not visible */
}

मैंने इसे कुछ और सोचा, और मैं इस समाधान के साथ आया, आपको अपने h2 टैग की पाठ्य सामग्री को दूसरे टैग (उदाहरण के लिए एक स्पैन) (या वैकल्पिक रूप से h2s को किसी ऐसी चीज से लपेटना है, जिसकी ऊंचाई दी गई है) और फिर आप इस तरह की जावास्क्रिप्ट का उपयोग अनावश्यक शब्दों को छानने के लिए कर सकते हैं:

var elems = document.getElementById('conainter_of_h2s').
                     getElementsByTagName('h2');

    for ( var i = 0, l = elems.length; i < l; i++) {
        var span = elems.item(i).getElementsByTagName('span')[0];
        if ( span.offsetHeight > elems.item(i).offsetHeight ) {
            var text_arr = span.innerHTML.split(' ');
            for ( var j = text_arr.length - 1; j>0 ; j--) {
                delete text_arr[j];
                span.innerHTML = text_arr.join(' ') + '...';
                if ( span.offsetHeight <= 
                                        elems.item(i).offsetHeight ){
                    break;
                }
            }
        }
    }

वास्तव में मैंने इसका उपयोग संभव समाधान के लिए एक आधार के रूप में करने के बारे में सोचा था, लेकिन मुझे इस बारे में कोई पता नहीं है कि क्या - इस पर आधारित है - यह पता लगाना संभव होगा, अगर पूरा पाठ अब प्रदर्शित किया जाता है या अगर मुझे इसे छोटा करना है और जोड़ना है " ... "। बस इसे काटने से अजीब लगेगा।
BlaM 14

3

यहाँ एक और जावास्क्रिप्ट समाधान है। बहुत अच्छा और बहुत तेज काम करता है।

https://github.com/dobiatowski/jQuery.FastEllipsis

विंडोज और मैक पर क्रोम, एफएफ, आईई पर परीक्षण किया गया।


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

3

शुद्ध सीएसएस के साथ बहु-पंक्ति पाठ के लिए एक समाधान है। इसे कहा जाता है line-clamp, लेकिन यह केवल वेबकिट ब्राउज़र में काम करता है। हालाँकि सभी आधुनिक ब्राउज़रों में यह नकल करने का एक तरीका है (IE8 से अधिक सब कुछ।) इसके अलावा, यह केवल ठोस पृष्ठभूमि पर काम करेगा क्योंकि आपको अंतिम पंक्ति के अंतिम शब्दों को छिपाने के लिए पृष्ठभूमि-छवि की आवश्यकता है। यहां बताया गया है:

इस HTML को देखते हुए:

<p class="example" id="example-1">
    Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
</p>

यहाँ सीएसएस है:

p {
    position:relative;
    line-height:1.4em;
    height:4.2em;      /* 3 times the line-height to show 3 lines */
}
p::after {
    content:"...";
    font-weight:bold;
    position:absolute;
    bottom:0;
    right:0;
    padding:0 20px 1px 45px;
    background:url(ellipsis_bg.png) repeat-y;
}

ellipsis_bg.png आपकी पृष्ठभूमि के एक ही रंग की एक छवि है, जो लगभग 100px चौड़ी होगी और आपकी रेखा-ऊंचाई जितनी ही होगी।

यह बहुत सुंदर नहीं है, क्योंकि आपका पाठ एक पत्र के बीच में काटा जा सकता है, लेकिन यह कुछ मामलों में उपयोगी हो सकता है।

संदर्भ: http://www.css-101.org/articles/line-clamp/line-clamp_for_non_webkit-based_browsers.php


यह अच्छा है, लेकिन आपको यह सुनिश्चित करने की आवश्यकता है कि आपका पाठ पर्याप्त लंबा है, क्योंकि यह सीएसएस "..." जोड़ देगा, भले ही पाठ उपलब्ध स्थान में फिट होने के लिए पर्याप्त छोटा हो। BTW: Apopii द्वारा एक महीने पहले लगभग एक ही जवाब दिया गया है;)
BlaM

@BlaM वास्तव में बहुत ज्यादा एक ही है। लेकिन मुझे लगता है कि ग्रेडिएंट ट्रिक साफ-सुथरी है और सीएसएस के बजाय सीएसएस में यह कोड है, इसलिए मुझे लगता है कि यह एक अलग उत्तर के योग्य है।
जूल्स कोल

3

पाठ सामग्री के लिए शुद्ध सीएसएस मल्टी-लाइन एलिप्सिस:

.container{
    position: relative;  /* Essential */
    background-color: #bbb;  /* Essential */
    padding: 20px; /* Arbritrary */
}
.text {
    overflow: hidden;  /* Essential */
    /*text-overflow: ellipsis; Not needed */
    line-height: 16px;  /* Essential */
    max-height: 48px; /* Multiples of line-height */
}
.ellipsis {
    position: absolute;/* Relies on relative container */
    bottom: 20px; /* Matches container padding */
    right: 20px; /* Matches container padding */
    height: 16px; /* Matches line height */
    width: 30px; /* Arbritrary */
    background-color: inherit; /* Essential...or specify a color */
    padding-left: 8px; /* Arbritrary */
}
<div class="container">
    <div class="text">
        Lorem ipsum dolor sit amet, consectetur eu in adipiscing elit. Aliquam consectetur venenatis blandit. Praesent vehicula, libero non pretium vulputate, lacus arcu facilisis lectus, sed feugiat tellus nulla eu dolor. Nulla porta bibendum lectus quis euismod. Aliquam volutpat ultricies porttitor. Cras risus nisi, accumsan vel cursus ut, sollicitudin vitae dolor. Fusce scelerisque eleifend lectus in bibendum. Suspendisse lacinia egestas felis a volutpat. Aliquam volutpat ultricies porttitor. Cras risus nisi, accumsan vel cursus ut, sollicitudin vitae dolor. Fusce scelerisque eleifend lectus in bibendum. Suspendisse lacinia egestas felis a volutpat.
    </div>
    <div class="ellipsis">...</div>
</div>

कृपया लाइव उदाहरण के लिए स्निपेट चेकआउट करें।


2

यह एलेक्स के समान है लेकिन यह रैखिक के बजाय लॉग टाइम में करता है, और एक मैक्सहाइट पैरामीटर लेता है।

jQuery.fn.ellipsis = function(text, maxHeight) {
  var element = $(this);
  var characters = text.length;
  var step = text.length / 2;
  var newText = text;
  while (step > 0) {
    element.html(newText);
    if (element.outerHeight() <= maxHeight) {
      if (text.length == newText.length) {
        step = 0;
      } else {
        characters += step;
        newText = text.substring(0, characters);
      }
    } else {
      characters -= step;
      newText = newText.substring(0, characters);
    }
    step = parseInt(step / 2);
  }
  if (text.length > newText.length) {
    element.html(newText + "...");
    while (element.outerHeight() > maxHeight && newText.length >= 1) {
      newText = newText.substring(0, newText.length - 1);
      element.html(newText + "...");
    }
  }
};

2

Devon Govett द्वारा एक सरल jQuery समाधान है :

https://gist.github.com/digulla/5796047

उपयोग करने के लिए, बस एक jQuery वस्तु पर दीर्घवृत्त () को कॉल करें। उदाहरण के लिए:

$ ( "काल") दीर्घवृत्त ()।


मैं उसी लिंक को पोस्ट करने वाला था। :)
गम्बू

इस पोस्ट में लिंक मृत है।
जस्टिन टान्नर

मैंने एक फॉलबैक लिंक जोड़ा
BlaM

1

मैं MooTools पुस्तकालय के लिए उपयोग करने के लिए एलेक्स के कार्य को फिर से लिखा है। मैंने इसे शब्द के बीच में दीर्घवृत्त जोड़ने के बजाय शब्द कूद में थोड़ा बदल दिया।

Element.implement({
ellipsis: function() {
    if(this.getStyle("overflow") == "hidden") {
        var text = this.get('html');
        var multiline = this.hasClass('multiline');
        var t = this.clone()
            .setStyle('display', 'none')
            .setStyle('position', 'absolute')
            .setStyle('overflow', 'visible')
            .setStyle('width', multiline ? this.getSize().x : 'auto')
            .setStyle('height', multiline ? 'auto' : this.getSize().y)
            .inject(this, 'after');

        function height() { return t.measure(t.getSize).y > this.getSize().y; };
        function width() { return t.measure(t.getSize().x > this.getSize().x; };

        var func = multiline ? height.bind(this) : width.bind(this);

        while (text.length > 0 && func()) {
            text = text.substr(0, text.lastIndexOf(' '));
            t.set('html', text + "...");
        }

        this.set('html', t.get('html'));
        t.dispose();
    }
}
});

1

मुझे एक स्क्रिप्ट नहीं मिली जो ठीक उसी तरह काम करती है जैसा मैं चाहता था कि यह jQuery के लिए मेरे खुद का हो - उनके अधिकांश पर अधिक के साथ सेट करने के लिए काफी कुछ विकल्प :)

https://github.com/rmorse/AutoEllipsis


1

मैं हालांकि सीएसएस के व्यवहार से थोड़ा हैरान था।

var cssEllipsis = 
{   "width": "100%","display": "inline-block", 
"vertical-align": "middle", "white-space": "nowrap", 
"overflow": "hidden", "text-overflow": "ellipsis" 
};

जब तक कि मैं नियंत्रण को चौड़ाई प्रदान करने के लिए जो मैं ellipsis बाँधने की जरूरत मेरे कारण नहीं था। क्या चौड़ाई एक संपत्ति जोड़ना होगी ??? कृपया अपने विचार रखें।


1

ELLIPSIS केवल CSS का उपयोग करें

<html>
<head>
<style type="text/css">
#ellipsisdiv {
    width:200px;
    white-space: nowrap;  
    overflow: hidden;  
    text-overflow: ellipsis;  
}  
</style>
</head>
<body>
<div id="ellipsisdiv">
This content is more than 200px and see how the the ellipsis comes at the end when the content width exceeds the div width.
</div>
</body>
</html>

* यह कोड अधिकांश वर्तमान ब्राउज़रों पर काम करता है। यदि आपको ओपेरा और IE (जो शायद आप नहीं करेंगे) के साथ किसी भी समस्या का अनुभव करते हैं, तो इन्हें स्टाइल में जोड़ें:

-o-text-overflow: ellipsis;  
-ms-text-overflow: ellipsis;

* यह सुविधा CSS3 का हिस्सा है। इसका पूरा सिंटैक्स है:

text-overflow: clip|ellipsis|string;

1

यहाँ एक अच्छा विजेट / प्लगइन लाइब्रेरी है, जिसमें निर्मित दीर्घवृत्त है: http://www.codeitbetter.co.uk/widgets/ellipsis/ आपको यह सब करने की आवश्यकता है कि आप पुस्तकालय का संदर्भ लें और निम्नलिखित पर कॉल करें:

<script type="text/javascript"> 
   $(document).ready(function () { 
      $(".ellipsis_10").Ellipsis({ 
         numberOfCharacters: 10, 
         showLessText: "less", 
         showMoreText: "more" 
      }); 
   }); 
</script> 
<div class="ellipsis_10"> 
   Some text here that's longer than 10 characters. 
</div>

1

आप इसे केवल css के साथ बहुत आसान कर सकते हैं, उदाहरण के लिए: sass मोड

.truncatedText {
   font-size: 0.875em;
   line-height: 1.2em;
   height: 2.4em; // 2 lines * line-height
   &:after {
      content: " ...";
   }
}

और आपको इलिप्सिस है;)


0

@AcSlater की तरह मुझे जो चाहिए उसके लिए मुझे कुछ नहीं मिला, इसलिए मैंने अपना रोल किया। यदि कोई और उपयोग कर सकता है तो साझा करना:

तरीका:
ellipsisIfNecessary(mystring,maxlength);
उपयोग:
trimmedString = ellipsisIfNecessary(mystring,50);
कोड और डेमो लिंक: https://gist.github.com/cemerson/10368014

दो एनोटेशन: ए) यह कोड एक HTML तत्व के वास्तविक आकार की जांच नहीं करता है। आपको दी गई लंबाई निर्दिष्ट करने की आवश्यकता है - जो आवश्यक कार्यक्षमता हो सकती है, लेकिन वास्तव में ऐसा करने के लिए तुच्छ है। b) आप स्ट्रिंग के अंत में "..." जोड़ते हैं। एक दीर्घवृत्त संकेत है "..." आप उपयोग कर सकते हैं / चाहिए।
ब्लॅम

हे @BlaM - कोड वास्तव में अधिकतम गति पैरामीटर के खिलाफ लंबाई की जांच करता है। यह मेरे लिए कम से कम काम कर रहा है। उस ने कहा - यह मेरी विशेष परिस्थिति के लिए सिर्फ एक विनम्र है। उपरोक्त किसी भी समाधान का उपयोग करने के लिए स्वतंत्र महसूस करें यदि यह आपकी स्थिति के लिए सही काम नहीं करता है।
क्रिस्टोफर डी। एमर्सन

हां, यह "लंबाई" के साथ काम करता है, लेकिन "चौड़ाई" (पिक्सेल आकार) के साथ नहीं।
BlaM

दिलचस्प विचार - उस के लिए एक अद्यतन संस्करण w / समर्थन बनाने के लिए स्वतंत्र महसूस करें। मुझे अब इसकी आवश्यकता नहीं है लेकिन भविष्य में उपयोगी हो सकता है।
क्रिस्टोफर डी। एमर्सन

0
<html>
<head>
    <!-- By Warren E. Downs, copyright 2016.  Based loosely on a single/multiline JQuery using example by Alex,
    but optimized to avoid JQuery, to use binary search, to use CSS text-overflow: ellipsis for end,
    and adding marquee option as well.
    Credit: Marquee: http://jsfiddle.net/jonathansampson/xxuxd/
            JQuery version: http://stackoverflow.com/questions/536814/insert-ellipsis-into-html-tag-if-content-too-wide
            (by Alex, http://stackoverflow.com/users/71953/alex)
            (Improved with Binary Search as suggested by StanleyH, http://stackoverflow.com/users/475848/stanleyh)
    -->
    <meta content="text/html;charset=utf-8" http-equiv="Content-Type">
    <meta content="utf-8" http-equiv="encoding">
    <style>

        .single {
            overflow:hidden;
            white-space: nowrap;
            width: 10em;
            padding: 10px;
            margin: 0 auto;
            border: solid 1px blue;
        }

        .multiline {
            overflow: hidden;
            white-space: wrap;
            width: 10em;
            height: 4.5em;
            padding: 10px;
            margin: 0 auto;
            border: solid 1px blue;
        }

        .marquee {
            overflow: hidden;
            width: 40em;
            padding: 10px;
            margin: 0 auto;
            border: solid 1px blue;
        }

</style>
    <script>
        var _marqueeNumber=0;
        // mode=start,end,middle
        function clipText(text, len, mode) {
            if(!mode) { mode="end"; }
            else { mode=mode.toLowerCase(); }
            if(mode == "start") { return "&hellip;"+clipText(text,len,"_start"); }
            if(mode == "_start") { return text.substr(text.length - len); }
            if(mode == "middle") { 
                return clipText(text, len/2, "end") + clipText(text, len/2, "_start");
            }
            return text.substr(0, len) + "&hellip;";
        }

        function generateKeyframes(clsName, start, end) {
            var sec=5;
            var totalLen=parseFloat(start)-parseFloat(end);
            if(start.indexOf('em') > -1)      { sec=Math.round(totalLen/3); }
            else if(start.indexOf('px') > -1) { sec=Math.round(totalLen/42); }

            var style = document.createElement('style');
            style.type = 'text/css';
            style.innerHTML = 'body {}';
            document.getElementsByTagName('head')[0].appendChild(style);
            this.stylesheet = document.styleSheets[document.styleSheets.length-1];
            try {
                this.stylesheet.insertRule('.'+clsName+' {\n'+
                    '    animation: '+clsName+' '+sec+'s linear infinite;\n'+
                    '}\n', this.stylesheet.rules.length);
                this.stylesheet.insertRule('.'+clsName+':hover {\n'+
                    '    animation-play-state: paused\n'+
                    '}\n', this.stylesheet.rules.length);
                this.stylesheet.insertRule('@keyframes '+clsName+' {\n'+
                    '    0%   { text-indent: '+start+' }\n'+
                    '    100% { text-indent: '+end+' }\n'+
                    '}', this.stylesheet.rules.length);
            } catch (e) {
                console.log(e.message);
            }
        }

        function addClone(el, multiline, estyle) {
            if(!estyle) { 
                try { estyle=window.getComputedStyle(el); }
                catch(e) { return null; }
            }
            var t = el.cloneNode(true);
            var s=t.style;
            //s.display='none';
            s.visibility='hidden'; // WARNING: Infinite loop if this is not hidden (e.g. while testing)
            s.display='inline-block';
            s.background='black';
            s.color='white';
            s.position='absolute';
            s.left=0;
            s.top=0;
            s.overflow='visible';
            s.width=(multiline ? parseFloat(estyle.width) : 'auto');
            s.height=(multiline ? 'auto' : parseFloat(estyle.height));

            el.parentNode.insertBefore(t, el.nextSibling);

            return t;
        }
        function getTextWidth(el, multiline) {
            var t=addClone(el, multiline);
            if(!t) { return null; }
            var ts=window.getComputedStyle(t);
            var w=ts.width;
            if(multiline) {
                var es=window.getComputedStyle(el);
                var lines=Math.round(parseInt(ts.height)/parseInt(es.height))*2+0.5;
                w=w+'';
                var unit=''; // Extract unit
                for(var xa=0; xa<w.length; xa++) {
                    var c=w[xa];
                    if(c <= '0' || c >= '9') { unit=w.substr(xa-1); }
                }
                w=parseFloat(w);
                w*=lines; // Multiply by lines
                w+=unit; // Append unit again
            }
            t.parentNode.removeChild(t);
            return w;
        }

        // cls=class of element to ellipsize
        // mode=start,end,middle,marq (scrolling marquee instead of clip)
        function ellipsis(cls, mode) {
            mode=mode.toLowerCase();
            var elems=document.getElementsByClassName(cls);
            for(xa in elems) {
                var el=elems[xa];
                var multiline = el.className ? el.className.indexOf('multiline') > -1 : true;
                if(mode == "marq") {       
                    var w=getTextWidth(el, multiline);
                    if(!w) { continue; }
                    var mCls="dsmarquee"+(_marqueeNumber++);
                    var es=window.getComputedStyle(el);
                    generateKeyframes(mCls,es.width, '-'+w);
                    el.className+=" "+mCls; 
                    continue; 
                }
                if(mode == "end" && !multiline) { el.style.textOverflow="ellipsis"; continue; }
                var estyle=null;
                try { estyle=window.getComputedStyle(el); }
                catch(e) { continue; }
                if(estyle.overflow == "hidden") {
                    var text = el.innerHTML;
                    var t=addClone(el, multiline, estyle);

                    function height() {
                        var ts=window.getComputedStyle(t);
                        var es=window.getComputedStyle(el);
                        return parseFloat(ts.height) - parseFloat(es.height); 
                    }
                    function width() { 
                        var ts=window.getComputedStyle(t);
                        var es=window.getComputedStyle(el);
                        return parseFloat(ts.width) - parseFloat(es.width); 
                    }

                    var tooLong = multiline ? height : width;

                    var len=text.length;
                    var diff=1;
                    var olen=0;
                    var jump=len/2;
                    while (len > 0) {
                        var diff=tooLong();
                        if(diff > 0) { len-=jump; jump/=2; }
                        else if(diff < 0) { len+=jump; }
                        len=Math.round(len);
                        //alert('len='+len+';olen='+olen+';diff='+diff+';jump='+jump+';t='+JSON.stringify(t.innerHTML));
                        t.innerHTML=clipText(text, len, mode);
                        if(olen == len) { break; }
                        olen=len;
                    }
                    el.innerHTML=t.innerHTML;
                    t.parentNode.removeChild(t);
                }           
                //break;
                t.style.visibility='hidden';
            }
        }

        function testHarness() {
            ellipsis('ellipsis1', 'start'); 
            ellipsis('ellipsis2', 'end'); 
            ellipsis('ellipsis3', 'middle'); 
            ellipsis('marquee', 'marq')
        }
    </script>
    </head>
    <body onload="testHarness()">
    <div class="single ellipsis1" style="float:left">some long text that should be clipped left</div>
    <div class="single ellipsis2" style="float:right">right clip long text that should be clipped</div>
    <div class="single ellipsis3" style="float:center">some long text that should be clipped in the middle</div>

    <br />

    <p class="single marquee">Windows 8 and Windows RT are focused on your lifeyour friends and family, your apps, and your stuff. With new things like the <a href="http://windows.microsoft.com/en-US/windows-8/start-screen">Start screen</a>, <a href="http://windows.microsoft.com/en-US/windows-8/charms">charms</a>, and a <a href="http://windows.microsoft.com/en-US/windows-8/microsoft-account">Microsoft account</a>, you can spend less time searching and more time doing.</p>
    &nbsp;

    <br />

    <div class="multiline ellipsis1" style="float:left">Test test test test test test, some more long text, such as asdasdasdasdasd, that should be multiline clipped left(*)</div>

    <div class="multiline ellipsis2" style="float:right">right clip multiline long text, such as Test test test test test test, and some more long text that should be multiline clipped right.</div>

    <div class="multiline ellipsis3" style="float:center">Test test test test test test, some more long text, such as asdasdasdasdasd, that should be multiline clipped in the middle(*)</div>

    <br />

    <p class="multiline marquee">Multiline Marquee: Windows 8 and Windows RT are focused on your lifeyour friends and family, your apps, and your stuff. With new things like the <a href="http://windows.microsoft.com/en-US/windows-8/start-screen">Start screen</a>, <a href="http://windows.microsoft.com/en-US/windows-8/charms">charms</a>, and a <a href="http://windows.microsoft.com/en-US/windows-8/microsoft-account">Microsoft account</a>, you can spend less time searching and more time doing.</p>
    &nbsp;

    </body>
</html>
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.