Intelligent String Abbreviation

Core points

• The abbreviate() function in JavaScript intelligently shortens the string to the specified maximum length, ensuring that it does not break in the middle of the word and removing unnecessary spaces.
• This function takes three parameters: the original input string, the maximum output length, and an optional suffix, added to the end of the abbreviation string. If the suffix is ​​not defined, the default is "...", indicating the abbreviation.
• This function can be used in any scenario where string lengths need to be limited, such as processing form input, creating custom tooltips, displaying mail topics in web-based email lists, or preprocessing data to be sent through Ajax.
• The effectiveness of this function is that it is able to split the input string into a single word and then recombine as many words as possible to fit the maximum length. It also preprocesses the input to remove excess spaces.

This article will introduce a simple and efficient JavaScript function called abbreviate(), whose main function is as its name: intelligently shortens the string to a specified length. It ensures that it is not truncated in the middle of the word and preprocesses the string to remove excess spaces. The following is the code of the abbreviate function:

function abbreviate(str, max, suffix) {
  if ((str = str.replace(/^\s+|\s+$/g, '').replace(/[\r\n]*\s*[\r\n]+/g, ' ').replace(/[ \t]+/g, ' ')).length <= max) {
    return str;
  }

  var
    abbr = '',
    str = str.split(' '),
    suffix = (typeof suffix !== 'undefined' ? suffix : ' ...'),
    max = (max - suffix.length);

  for (var len = str.length, i = 0; i < len; i++) {
    if ((abbr + str[i]).length <= max) {
      abbr += str[i] + ' ';
    } else {
      break;
    }
  }

  return abbr.replace(/[ ]$/g, '') + suffix;
}

This function takes three parameters: the original input string, the maximum output length, and an optional suffix, added to the end of the abbreviation string. If the suffix is ​​not defined, the default is "..." (one space followed by three dots), a common and easily recognizable abbreviation indication.

Function usage

This function can be used in any scenario where string lengths need to be limited, as a smarter alternative to simple substr expressions. There are many possible applications, such as processing form input, creating custom tooltips, displaying mail topics in web-based email lists, or preprocessing data to be sent through Ajax. For example, to limit the string to 100 characters and add the default suffix, we can call it like this:

str = abbreviate(str, 100);

This is conceptually equivalent to this substrExpression:

str = str.substr(0, 96) + " ...";

But this is a very rough approach, as it often causes the output string to break in the middle of the word. The abbreviate function is designed to not do this, it splits the string before the last word instead of splitting it in the middle of the word. Therefore, the output string generated by will usually be abbreviate() shorter than the maximum length specified by , but will never be longer than it. The function also takes into account the spaces required for the abbreviation suffix, that is, if the specified maximum length is 100, but the suffix itself is 4 characters, then we can only use up to 96 characters of the main input string. You can specify that there is no suffix at all by passing an empty string, or if you want to abbreviate the tag string, you can define it as an HTML close tag. For example, the following input:

abbreviate("<p>One two three four five</p>", 15, "");

will produce this output:

function abbreviate(str, max, suffix) {
  if ((str = str.replace(/^\s+|\s+$/g, '').replace(/[\r\n]*\s*[\r\n]+/g, ' ').replace(/[ \t]+/g, ' ')).length <= max) {
    return str;
  }

  var
    abbr = '',
    str = str.split(' '),
    suffix = (typeof suffix !== 'undefined' ? suffix : ' ...'),
    max = (max - suffix.length);

  for (var len = str.length, i = 0; i < len; i++) {
    if ((abbr + str[i]).length <= max) {
      abbr += str[i] + ' ';
    } else {
      break;
    }
  }

  return abbr.replace(/[ ]$/g, '') + suffix;
}

How the function works

The key to the

abbreviate function is the ability to split the input string into a single word and then recombine as many words as possible to fit the maximum length. To be more efficient, we need to make sure that the separators between words are predictable, the easiest way is to minimize internal spaces - convert newlines and tabs into spaces, and then reduce successive spaces so that each internal space is The blocks become a space. Of course, there are other ways to deal with this – for example, we can define a more flexible regular expression for segmentation that takes into account all the different types of characters we might find between words. There is even a word boundary character ("b") for regular expressions, so we can use it as well. But I found space preprocessing itself useful, especially when processing user input. And splitting by word boundary does not produce the expected results, because dashes, dots, commas, and most special characters are actually considered word boundaries. But I think it is inappropriate to split words by punctuation unless the characters are followed by spaces, so that hyphen words and code snippets are not split in the middle. So the first job of the function is to do space preprocessing, and then if the result is already shorter than the maximum specified by , we can return it directly:

str = abbreviate(str, 100);

If we don't do this, we may encounter situations where strings are abbreviated when they don't have to be abbreviated, for example:

str = str.substr(0, 96) + " ...";

If there is no first condition, we will get the output of the abbreviation, because the specified maximum value must take into account the length of the suffix:

abbreviate("<p>One two three four five</p>", 15, "");

Adding the first condition will produce unmodified output:

<p>One two>

So unless we return at this point, we will continue to compile the abbreviated string - split the input string by space to create a single word, and then iteratively regroup each word-space pair as long as the abbreviation The string is shorter than the specified maximum length. Once we compile what we need, we can break the iteration and then trim the remaining spaces from the end of the abbreviation string, then add the suffix and finally return the result. Trim the remaining spaces from the right end and then add it with the default suffix seems a bit wasteful, but this allows inputting the suffix without spaces at all.

Conclusion

This is a simple but smart string abbreviation function that also preprocesses input to remove excess spaces. In my experience, both requirements usually appear at the same time, which is why I developed this function to work this way.

(The FAQ part is omitted here due to space limitations. If necessary, a pseudo-original version of the FAQ part can be provided separately.)

The above is the detailed content of Intelligent String Abbreviation. For more information, please follow other related articles on the PHP Chinese website!