如何从字符串中提取符号、数字和单词并将它们存储到相应分类的数组中？

Question

如何从字符串中提取符号、数字、最多 3 个单词和至少 4 个字母的单词，并将它们分别存储到相应分类的数组中？

给定的字符串是：

const string = 'There are usually 100 to 200 words + in a paragraph'; 

预期的响应是：

const numbers = ['200', '100'];

const wordsMoreThanThreeLetters = ['There', 'words ', 'paragraph', 'usually'];

const symbols = ['+'];

const words = ['are', 'to', 'in', 'a'];

Answer 1

一种有效的方法是split 任何空白序列处的字符串，然后在split 方法的结果数组上运行reduce 方法。

reducer 函数的实现方式是，它根据 OP 的类别收集和聚合特定数组中的字符串项（令牌），由辅助方法支持，例如数字和单词测试...

function collectWordsDigitsAndRest(collector, token) {
  const isDigitsOnly = value => (/^\d+$/).test(token);
  const isWord = value => (/^\w+$/).test(token);

  const listName = isDigitsOnly(token)
    ? 'digits'
    : (
        isWord(token)
        ? (token.length <= 3) && 'shortWords' || 'longWords'
        : 'rest'
    );
  (collector[listName] ??= []).push(token);

  return collector;
}
const {

  longWords: wordsMoreThanThreeLetters = [],
  shortWords: words = [],
  digits: numbers = [],
  rest: symbols = [],

} = 'There are usually 100 to 200 words + in a paragraph'

  .split(/\s+/)
  .reduce(collectWordsDigitsAndRest, {});

console.log({
  wordsMoreThanThreeLetters,
  words,
  numbers,
  symbols,
});

.as-console-wrapper { min-height: 100%!important; top: 0; }

当然，也可以通过单个regular expression / RegExp 来matchAll 所需的令牌，该令牌具有named capturing groups 并且还使用Unicode escapes 以实现更好的国际化（i18n）覆盖。

正则表达式本身看起来和工作起来都像这样......

• (?:\b(?<digit>\p{N}+)|(?<longWord>\p{L}{4,})|(?<shortWord>\p{L}+)\b)|(?<rest>[^\p{Z}]+)

...派生自...

• (?:\b(?<digit>\p{N}+)|(?<word>\p{L}+)\b)|(?<rest>[^\p{Z}]+)

第一种方法的 reducer 函数必须适应第二种方法，以便相应地处理每个捕获的组...

function collectWordsDigitsAndRest(collector, { groups }) {
  const { shortWord, longWord, digit, rest } = groups;

  const listName = (shortWord
    && 'shortWords') || (longWord
    && 'longWords') || (digit
    && 'digits') || (rest
    && 'rest');

  if (listName) {
    (collector[listName] ??= []).push(shortWord || longWord || digit || rest);
  }
  return collector;
}

// Unicode Categories ... [https://www.regularexpressions.info/unicode.html#category]
// regex101.com ... [https://regex101.com/r/nCga5u/2]
const regXWordDigitRestTokens =
  /(?:\b(?<digit>\p{N}+)|(?<longWord>\p{L}{4,})|(?<shortWord>\p{L}+)\b)|(?<rest>[^\p{Z}]+)/gmu;

const {

  longWords: wordsMoreThanThreeLetters = [],
  shortWords: words = [],
  digits: numbers = [],
  rest: symbols = [],

} = Array
  .from(
    'There are usually 100 to 200 words ++ -- ** in a paragraph.'
    .matchAll(regXWordDigitRestTokens)
  )
  .reduce(collectWordsDigitsAndRest, {});

console.log({
  wordsMoreThanThreeLetters,
  words,
  numbers,
  symbols,
});

.as-console-wrapper { min-height: 100%!important; top: 0; }

Answer 2

您尝试执行的操作称为tokenization。通常这是通过正则表达式完成的。您为要识别的每个标记编写一个正则表达式。每个标记都被空白包围。空格和单词之间的位置称为单词边界，由\b 匹配。以下正则表达式使用Unicode character classes。符号不是单词，所以它们没有单词边界。

• 三个或更少字母的单词：\b\p{Letter}{1,3}\b。
• 三个以上字母的单词：\b\p{Letter}{4,}\b。
• 号码：\b\p{Number}+\b
• 符号：\p{Symbol}+

为了解析不同的标记，将正则表达式放入命名的捕获组是很有用的：(?<anything>.*)。这将匹配任何内容并将匹配存储在捕获组anything。

const input = 'There are usually 100 to 200 words + in a paragraph'; 

let rx = new RegExp ([
  '(?<wle3>\\b\\p{L}{1,3}\\b)',
  '(?<wgt3>\\b\\p{L}{4,}\\b)',
  '(?<n>\\b\\p{N}+\\b)',
  '(?<s>\\p{S}+)'
  ].join ('|'),
  'gmu');

let words_le_3 = [];
let words_gt_3 = [];
let numbers = [];
let symbols = [];

for (match of input.matchAll(rx)) {
  let g = match.groups;
  switch (true) {
  case (!!g.wle3): words_le_3.push (g.wle3); break;
  case (!!g.wgt3): words_gt_3.push (g.wgt3); break;
  case (!!g.n):    numbers   .push (g.n);    break;
  case (!!g.s):    symbols   .push (g.s);    break;
  }
}

console.log (`Words with up to three letters: ${words_le_3}`);
console.log (`Words with more than three letters: ${words_gt_3}`);
console.log (`Numbers: ${numbers}`);
console.log (`Symbols: ${symbols}`);

如果您将匹配项存储在一个对象而不是四个顶级数组中，则代码会更简单。在这种情况下，switch 语句可以被组上的循环和赋值替换。

Answer 3

您可以为这些情况编写一个单独的函数：

const txt  = 'There are usually 100 to 200 words in a paragraph';
console.log(txt);
console.log( ctrim(txt) )

function ctrim(txt) {  
  let w = txt.split(' ');
  let _w = []
  w.forEach((w) => {
    if(w.length <= 3) {
      _w.push( w )
    }
  }) 
  return _w
}

Answer 4

const string = 'There are usually 100 to 200 words + in a paragraph';
const response = [];
for (let i = 0; i < string.length; i++) {
  response.push(string[i]);
  // console.log(response); All process of the loop
}
console.log(response);