Ik wil een tekst of regel met ellips afkappen met JavaScript

Ik ben op zoek naar een eenvoudig script dat een string kan afkappen met ellips (…)

Ik wil iets als 'this is a very long string'afkappen tot 'this is a ve...'

Ik wil geen CSS of PHP gebruiken.


Antwoord 1, autoriteit 100%

function truncate(input) {
   if (input.length > 5) {
      return input.substring(0, 5) + '...';
   }
   return input;
};

of in ES6

const truncate = (input) => input.length > 5 ? `${input.substring(0, 5)}...` : input;

Antwoord 2, autoriteit 27%

KooiInc heeft hier een goed antwoord op. Samenvattend:

String.prototype.trunc = 
      function(n){
          return this.substr(0,n-1)+(this.length>n?'…':'');
      };

Je kunt nu het volgende doen:

var s = 'not very long';
s.trunc(25); //=> not very long
s.trunc(5); //=> not...

En als je er de voorkeur aan geeft als een functie, volgens de opmerking van @AlienLifeForm:

function truncateWithEllipses(text, max) 
{
    return text.substr(0,max-1)+(text.length>max?'…':''); 
}

Het volledige tegoed gaat hiervoor naar KooiInc.


Antwoord 3, autoriteit 8%

Dit beperkt het tot het aantal regels dat u wilt beperken en is responsief

Een idee dat niemand heeft gesuggereerd, het doen op basis van de hoogte van het element en het dan vanaf daar verwijderen.

Fiddle – https://jsfiddle.net/hutber/u5mtLznf/<- ES6-versie

Maar eigenlijk wil je de regelhoogte van het element pakken, door alle tekst heen lopen en stoppen wanneer het op een bepaalde regelhoogte is:

'use strict';
var linesElement = 3; //it will truncate at 3 lines.
var truncateElement = document.getElementById('truncateme');
var truncateText = truncateElement.textContent;
var getLineHeight = function getLineHeight(element) {
  var lineHeight = window.getComputedStyle(truncateElement)['line-height'];
  if (lineHeight === 'normal') {
    // sucky chrome
    return 1.16 * parseFloat(window.getComputedStyle(truncateElement)['font-size']);
  } else {
    return parseFloat(lineHeight);
  }
};
linesElement.addEventListener('change', function () {
  truncateElement.innerHTML = truncateText;
  var truncateTextParts = truncateText.split(' ');
  var lineHeight = getLineHeight(truncateElement);
  var lines = parseInt(linesElement.value);
  while (lines * lineHeight < truncateElement.clientHeight) {
    console.log(truncateTextParts.length, lines * lineHeight, truncateElement.clientHeight);
    truncateTextParts.pop();
    truncateElement.innerHTML = truncateTextParts.join(' ') + '...';
  }
});

CSS

#truncateme {
   width: auto; This will be completely dynamic to the height of the element, its just restricted by how many lines you want it to clip to
}

Antwoord 4, autoriteit 6%

Zoiets als:

var line = "foo bar lol";
line.substring(0, 5) + '...' // gives "foo b..."

Antwoord 5, autoriteit 4%

Om de punten in het midden van een woord of na een leesteken te voorkomen.

let parseText = function(text, limit){
  if (text.length > limit){
      for (let i = limit; i > 0; i--){
          if(text.charAt(i) === ' ' && (text.charAt(i-1) != ','||text.charAt(i-1) != '.'||text.charAt(i-1) != ';')) {
              return text.substring(0, i) + '...';
          }
      }
       return text.substring(0, limit) + '...';
  }
  else
      return text;
};
console.log(parseText("1234567 890",5))  // >> 12345...
console.log(parseText("1234567 890",8))  // >> 1234567...
console.log(parseText("1234567 890",15)) // >> 1234567 890

Snippet uitvouwen


Antwoord 6, autoriteit 2%

Hierdoor wordt de ellips in het midden van de regel geplaatst:

function truncate( str, max, sep ) {
    // Default to 10 characters
    max = max || 10;
    var len = str.length;
    if(len > max){
        // Default to elipsis
        sep = sep || "...";
        var seplen = sep.length;
        // If seperator is larger than character limit,
        // well then we don't want to just show the seperator,
        // so just show right hand side of the string.
        if(seplen > max) {
            return str.substr(len - max);
        }
        // Half the difference between max and string length.
        // Multiply negative because small minus big.
        // Must account for length of separator too.
        var n = -0.5 * (max - len - seplen);
        // This gives us the centerline.
        var center = len/2;
        var front = str.substr(0, center - n);
        var back = str.substr(len - center + n); // without second arg, will automatically go to end of line.
        return front + sep + back;
    }
    return str;
}
console.log( truncate("123456789abcde") ); // 123...bcde (using built-in defaults) 
console.log( truncate("123456789abcde", 8) ); // 12...cde (max of 8 characters) 
console.log( truncate("123456789abcde", 12, "_") ); // 12345_9abcde (customize the separator) 

Bijvoorbeeld:

1234567890 --> 1234...8910

En:

A really long string --> A real...string

Niet perfect, maar functioneel. Vergeef de overcommentaar… voor de noobs.


Antwoord 7, autoriteit 2%

Gemakkelijkste en flexibele manier: JSnippet DEMO

Functiestijl:

function truncString(str, max, add){
   add = add || '...';
   return (typeof str === 'string' && str.length > max ? str.substring(0,max)+add : str);
};

Prototype:

String.prototype.truncString = function(max, add){
   add = add || '...';
   return (this.length > max ? this.substring(0,max)+add : this);
};

Gebruik:

str = "testing with some string see console output";
//By prototype:
console.log(  str.truncString(15,'...')  );
//By function call:
console.log(  truncString(str,15,'...')  );

Antwoord 8

function truncate(string, length, delimiter) {
   delimiter = delimiter || "&hellip;";
   return string.length > length ? string.substr(0, length) + delimiter : string;
};
var long = "Very long text here and here",
    short = "Short";
truncate(long, 10); // -> "Very long ..."
truncate(long, 10, ">>"); // -> "Very long >>"
truncate(short, 10); // -> "Short"

Antwoord 9

Probeer dit

function shorten(text, maxLength, delimiter, overflow) {
  delimiter = delimiter || "&hellip;";
  overflow = overflow || false;
  var ret = text;
  if (ret.length > maxLength) {
    var breakpoint = overflow ? maxLength + ret.substr(maxLength).indexOf(" ") : ret.substr(0, maxLength).lastIndexOf(" ");
    ret = ret.substr(0, breakpoint) + delimiter;
  }
  return ret;
}
$(document).ready(function() {
  var $editedText = $("#edited_text");
  var text = $editedText.text();
  $editedText.text(shorten(text, 33, "...", false));
});

Bekijk een werkend voorbeeld op Codepen
http://codepen.io/Izaias/pen/QbBwwE


Antwoord 10

HTML met JavaScript:

<p id="myid">My long long looooong text cut cut cut cut cut</p>
<script type="text/javascript">
var myid=document.getElementById('myid');
myid.innerHTML=myid.innerHTML.substring(0,10)+'...';
</script>

Het resultaat is:

My long lo...

Proost

G.


Antwoord 11

Als je een snaar wilt knippen voor een bepaalde lengte en punten wilt toevoegen, gebruik dan

// Length to cut
var lengthToCut = 20;
// Sample text
var text = "The quick brown fox jumps over the lazy dog";
// We are getting 50 letters (0-50) from sample text
var cutted = text.substr(0, lengthToCut );
document.write(cutted+"...");

Of als u niet op lengte wilt knippen maar met woordentelling, gebruik dan:

// Number of words to cut
var wordsToCut = 3;
// Sample text
var text = "The quick brown fox jumps over the lazy dog";
// We are splitting sample text in array of words
var wordsArray = text.split(" ");
// This will keep our generated text
var cutted = "";
for(i = 0; i < wordsToCut; i++)
 cutted += wordsArray[i] + " "; // Add to cutted word with space
document.write(cutted+"...");

Veel succes…

Other episodes