Using regex, match any word along with the preserved white space and consider parentheses as a single word

Question

Using regex, match any word along with the preserved white space and consider parentheses as a single word

I need help with creating a regex pattern to split a string of words in a specific way.

The current pattern I've been using is (?!\(.*)\s(?![^(]*?\)), but it's not giving me the desired outcome.

It's close, but not quite there yet.

let message = 'The quick    brown fox (and friend) (jumps over    the) lazy     dog.'

let result = message.match(/regex/g);

Result:

[
 'The', 
 'quick', 
 '    ', 
 'brown', 
 ' ', 
 'fox', 
 ' ',
 '(and friend)',
 ' ',
 '(jumps over ( bonus regex - only captures   the most outer parent parentheses) the)', 
 ' ', 
 'lazy', 
 '     ', 
 'dog.'
];

Special attention should be given to preserving white space and treating long sentences within parentheses as single array items.

Despite finding similar questions, I struggle to adjust the answers to fit my needs due to variations in regex solutions. I'm really bad at regex overall.

Any assistance on this matter would be greatly appreciated!

Edit - Remembered another scenario where consecutive parentheses are present in the string.

javascript regex

Answer 1

Answer №1

Here is a solution that should meet your needs:

(\((?:[^)]*)(?:[^(]*)\))|([\w.,'"!?\\-]+)|(\s+)

// Captures anything within parentheses
// Matches ( followed by anything that is not ), then anything that is not (
(\((?:[^)]*)(?:[^(]*)\))

// Recognizes words with punctuation
([\w.,'"!?\\-]+)

// Identifies any whitespace
(\s+)

This method should only work if the parentheses are balanced pairs. Once matched, you can cycle through the groups accordingly.

Answer 2

Here is a solution that should meet your needs:

(\((?:[^)]*)(?:[^(]*)\))|([\w.,'"!?\\-]+)|(\s+)

// Captures anything within parentheses
// Matches ( followed by anything that is not ), then anything that is not (
(\((?:[^)]*)(?:[^(]*)\))

// Recognizes words with punctuation
([\w.,'"!?\\-]+)

// Identifies any whitespace
(\s+)

This method should only work if the parentheses are balanced pairs. Once matched, you can cycle through the groups accordingly.

Answer 3

Answer №2

below is the regex pattern that will be utilized /(\(.*\)|\s+)/. The explanation of this pattern is as follows ...

/( ... )/ ... captures any match like ...
either ... \(.*\) ... an opening parentheses followed by any characters until the last closing parentheses ...
| ... or ...
\s+ any sequence of whitespace.

const sample = "The quick    brown fox (jumps over ( bonus regex - only captures   the most outer parent parentheses) the) lazy     dog."

const regXSplit = (/(\(.*\)|\s+)/);


console.log(
  'almost the result that was ask for ...',
  sample.split(regXSplit)
);
console.log(
  'the exact result that was ask for via additional filtering ...',
  sample.split(regXSplit).filter(str => !!str)
);

console.log(
  'test viability of both results ...',
   (sample.split(regXSplit).join('') === sample),
   (sample.split(regXSplit).filter(str => !!str).join('') === sample)
);

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

The method below considers the new criteria for approval. It incorporates a basic form of parsing logic to handle both types of parenthesis-enclosed elements, sequential and nested ones ...

const sample = `The quick    brown fox (and friend) (jumps over the) (lazy)     dog.

The quick    brown fox (and friend) (jumps over ( bonus regex - (only captures   the most outer) parent parentheses) the) (lazy)     dog.`;

function parseWordsParenthesisAndWhitespaceSequencesAsEntities(text) {
  function collectOrConcat(collector, token) {

    let { nestingCount, concatenated, list } = collector;

    if (regXLeadingOPT.test(token)) {
      ++nestingCount;
    }
    if (regXTrailingCPT.test(token)) {
      --nestingCount;
    }
    if (nestingCount === 0) {
      if (concatenated !== '') {

        list.push(concatenated + token);

        concatenated = '';
      } else {
        list.push(token);
      } 
    } else {
      concatenated = (concatenated + token);
    }
    collector.nestingCount = nestingCount;
    collector.concatenated = concatenated;

    return collector;
  }
  const regXLeadingOPT = (/^\(/);   // - leading opening parentheses.
  const regXTrailingCPT = (/\)$/);  // - trailing closing parentheses.
  const regXSplit = (/(\([^)(]+\)|\s+)/);

  return text
    .split(regXSplit)
    .filter(str => !!str)
    .reduce(collectOrConcat, {

      nestingCount: 0,
      concatenated: '',
      list: []

    }).list;
}

console.log(
  'demonstration of how the new split regex functions ...',
  'break down into smaller tokens, filter out empty strings and hope for the best ...',
  sample.split(/(\([^)(]+\)|\s+)/).filter(str => !!str)
);

console.log(
  'implementation of minimal *parsing* logic for consecutive and nested parenthesis ...',
  'parse words enclosed within parentheses and sequences of whitespace as entities  ...',
  parseWordsParenthesisAndWhitespaceSequencesAsEntities(sample)
);

console.log(
  'validate effectiveness of final parsing approach ...',
   (parseWordsParenthesisAndWhitespaceSequencesAsEntities(sample).join('') === sample)
);

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

Answer 4

below is the regex pattern that will be utilized /(\(.*\)|\s+)/. The explanation of this pattern is as follows ...

/( ... )/ ... captures any match like ...
either ... \(.*\) ... an opening parentheses followed by any characters until the last closing parentheses ...
| ... or ...
\s+ any sequence of whitespace.

const sample = "The quick    brown fox (jumps over ( bonus regex - only captures   the most outer parent parentheses) the) lazy     dog."

const regXSplit = (/(\(.*\)|\s+)/);


console.log(
  'almost the result that was ask for ...',
  sample.split(regXSplit)
);
console.log(
  'the exact result that was ask for via additional filtering ...',
  sample.split(regXSplit).filter(str => !!str)
);

console.log(
  'test viability of both results ...',
   (sample.split(regXSplit).join('') === sample),
   (sample.split(regXSplit).filter(str => !!str).join('') === sample)
);

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

The method below considers the new criteria for approval. It incorporates a basic form of parsing logic to handle both types of parenthesis-enclosed elements, sequential and nested ones ...

const sample = `The quick    brown fox (and friend) (jumps over the) (lazy)     dog.

The quick    brown fox (and friend) (jumps over ( bonus regex - (only captures   the most outer) parent parentheses) the) (lazy)     dog.`;

function parseWordsParenthesisAndWhitespaceSequencesAsEntities(text) {
  function collectOrConcat(collector, token) {

    let { nestingCount, concatenated, list } = collector;

    if (regXLeadingOPT.test(token)) {
      ++nestingCount;
    }
    if (regXTrailingCPT.test(token)) {
      --nestingCount;
    }
    if (nestingCount === 0) {
      if (concatenated !== '') {

        list.push(concatenated + token);

        concatenated = '';
      } else {
        list.push(token);
      } 
    } else {
      concatenated = (concatenated + token);
    }
    collector.nestingCount = nestingCount;
    collector.concatenated = concatenated;

    return collector;
  }
  const regXLeadingOPT = (/^\(/);   // - leading opening parentheses.
  const regXTrailingCPT = (/\)$/);  // - trailing closing parentheses.
  const regXSplit = (/(\([^)(]+\)|\s+)/);

  return text
    .split(regXSplit)
    .filter(str => !!str)
    .reduce(collectOrConcat, {

      nestingCount: 0,
      concatenated: '',
      list: []

    }).list;
}

console.log(
  'demonstration of how the new split regex functions ...',
  'break down into smaller tokens, filter out empty strings and hope for the best ...',
  sample.split(/(\([^)(]+\)|\s+)/).filter(str => !!str)
);

console.log(
  'implementation of minimal *parsing* logic for consecutive and nested parenthesis ...',
  'parse words enclosed within parentheses and sequences of whitespace as entities  ...',
  parseWordsParenthesisAndWhitespaceSequencesAsEntities(sample)
);

console.log(
  'validate effectiveness of final parsing approach ...',
   (parseWordsParenthesisAndWhitespaceSequencesAsEntities(sample).join('') === sample)
);

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

Using regex, match any word along with the preserved white space and consider parentheses as a single word

Answer №1

Answer №2

Similar questions

React: Modifying state does not update useState array

Anticipate feedback from Python script in Node.js

Executing code asynchronously and handling callbacks using Process.nextTick and Promise

Looking for a unique search object specifically designed for mongodb?

Transferring data between different elements in a React application

Ways to incorporate radio buttons, checkboxes, and select fields into a multi-step form using JavaScript

Executing a time-consuming function call within the componentDidMount lifecycle method of a React component

What is the best way to fetch the data from this API?

Q.all failing to execute promises within array

`Some Items Missing from Responsive Navigation Menu`

What is the best way to display only a specific container from a page within an IFRAME?

JavaScript code that moves the active link to the top of the navigation when the window width is less than or equal to 800px

I need to input text into a specific element on the page, however there are four elements on the page that have identical properties

Navigating to a Website Based on the Selected Option in a Drop-Down Menu

Jquery Droppable issue arising with dynamically added DIVs

Issue with Datepicker not updating when triggered by event handler

Tips for setting up a popup menu when clicking a button on a webpage

Tips for adding a new column to a website

Exploring jQuery's capabilities with Cross-Domain URLs

JS and its dynamic color changes