What is the best way to use regex for splitting an array?

Question

What is the best way to use regex for splitting an array?

I have a string that I need to convert into an array of objects

const str = "Nike (brand|category) shoes(product) for women(o)"

Expected result

let output = [
 { 
  key:"Nike",
  value:["brand","category"]
 },
{ 
  key:"shoes",
  value:["product"]
 },
{ 
  key:"for women",
  value:[]
 }

]

Here is the code I attempted

function generateSchema(val) {
       let split = val.split(" ")
       let maps = split.map((i) => {
           let obj = i.split("(")
           let key = obj[0].replaceAll(/\s/g, "")
           let cleanValue = obj[1].replace(/[{()}]/g, "")
           let stripedValues = cleanValue.split("|")

           return {
               key: key,
               value: stripedValues,
           }
       })
       return maps

}
let out = generateSchema(str)

However, this breaks when there is a word with a space, for example for women

How can I split with a regex?

javascript arrays split splice

Answer 1

Answer №1

To efficiently extract key/value pairs from a string, one method involves using regex to identify all instances of these combinations. By iterating through the results, a hashmap can be constructed with the keys as words and the values as arrays.

var str = "addias (brand|type) sneakers(product) for men(o)";
var matches = str.match(/\w+(?: \w+)*\s*\(.*?\)/g, str);
var array = [];
for (var i=0; i < matches.length; ++i) {
    var parts = matches[i].split(/\s*(?=\()/);
    var map = {};
    map["key"] = parts[0];
    map["value"] = parts[1].replace(/^\(|\)$/g, "").split(/\|/);
    array.push(map);
}
console.log(array);

The initial regex pattern targets each key/value pair in the string:

\w+        captures a word
(?: \w+)*  followed by additional words and spaces multiple times
\s*        optional spaces
\(         (
.*?        non-greedy match for content within parentheses
\)         )

Subsequently, splitting occurs on \s*(?=\(), identifying spaces preceding a (...|...) segment. The values are then separated using the pipe symbol |.

Answer 2

To efficiently extract key/value pairs from a string, one method involves using regex to identify all instances of these combinations. By iterating through the results, a hashmap can be constructed with the keys as words and the values as arrays.

var str = "addias (brand|type) sneakers(product) for men(o)";
var matches = str.match(/\w+(?: \w+)*\s*\(.*?\)/g, str);
var array = [];
for (var i=0; i < matches.length; ++i) {
    var parts = matches[i].split(/\s*(?=\()/);
    var map = {};
    map["key"] = parts[0];
    map["value"] = parts[1].replace(/^\(|\)$/g, "").split(/\|/);
    array.push(map);
}
console.log(array);

The initial regex pattern targets each key/value pair in the string:

\w+        captures a word
(?: \w+)*  followed by additional words and spaces multiple times
\s*        optional spaces
\(         (
.*?        non-greedy match for content within parentheses
\)         )

Subsequently, splitting occurs on \s*(?=\(), identifying spaces preceding a (...|...) segment. The values are then separated using the pipe symbol |.

Answer 3

Answer №2

Here is an alternative approach.

const str = "addias (brand|type) sneakers(product) for men(o)"
const array = str.split(')').filter(i => i.length).map(i => {
   const item = i.split('(');
   return {
     key: item[0].trim(),
     value: item[1].split('|')
   }
})

console.log(array)

Answer 4

Here is an alternative approach.

const str = "addias (brand|type) sneakers(product) for men(o)"
const array = str.split(')').filter(i => i.length).map(i => {
   const item = i.split('(');
   return {
     key: item[0].trim(),
     value: item[1].split('|')
   }
})

console.log(array)

Answer 5

Answer №3

To simplify the process, consider utilizing the exec method to loop through the patterns identified by the regex.

const str = 'addias(brand|type|size|color) sneakers(pro) for men(o)';

// This regex locates a group of letters initially,
// then matches the text inside the parentheses
const regex = /([a-z]+)\(([a-z\|]+)\)/g;

let myArray;
const arr = [];

while ((myArray = regex.exec(str)) !== null) {

  // Extract the key and the delimited string
  const [_,  key, ...rest] = myArray;

  // Split the string found in `rest` first element
  const values = rest[0].split('|');

  // Add a new object to the output array
  // (excluding "o" for some reason)
  arr.push({
    key,
    value: values.filter(v => v !== 'o')
  });
}

console.log(arr);

Answer 6

To simplify the process, consider utilizing the exec method to loop through the patterns identified by the regex.

const str = 'addias(brand|type|size|color) sneakers(pro) for men(o)';

// This regex locates a group of letters initially,
// then matches the text inside the parentheses
const regex = /([a-z]+)\(([a-z\|]+)\)/g;

let myArray;
const arr = [];

while ((myArray = regex.exec(str)) !== null) {

  // Extract the key and the delimited string
  const [_,  key, ...rest] = myArray;

  // Split the string found in `rest` first element
  const values = rest[0].split('|');

  // Add a new object to the output array
  // (excluding "o" for some reason)
  arr.push({
    key,
    value: values.filter(v => v !== 'o')
  });
}

console.log(arr);

Answer 7

Answer №4

Utilizing the resources of regex101.com, I uncovered the following regex expressions and subsequent code.

([^\(]+)\(([^\)]*)\) can be broken down into

([^\(]+) - capturing 1 or more characters until the first ( as group 1

\( - absorbing the left parenthesis

([^\)]*) - capturing everything until the next ) as group 2

\) - absorbing the right parenthesis

Initially, I tried using [^|]+ to dissect the text of group 2, but it turned out to be more streamlined with a simple split statement.

    function generateSchema(str) {
        const regex = /([^\(]+)\(([^\)]*)\)/mg;  // captures the 'word (word)' pattern
        let m;
        let output = [];
        let obj = {};
    
        while ((m = regex.exec(str)) !== null) {
    
            // This is necessary to avoid infinite loops with zero-width matches
            if (m.index === regex.lastIndex) {
                regex.lastIndex++;
            }
        
            m.forEach((match, groupIndex) => {
                if (groupIndex === 1) {
                    obj = {};
                    obj.key = match.trim();
                } else if (groupIndex === 2) {
                    obj.value = match.split('|').map(i=>i.trim());
                    output.push(obj);
                }
            });
        }
        return output;
    }

    const str = "addidas (brand | type  ) sneakers(product) for men(o)";
    console.log(generateSchema(str));

Answer 8

Utilizing the resources of regex101.com, I uncovered the following regex expressions and subsequent code.

([^\(]+)\(([^\)]*)\) can be broken down into

([^\(]+) - capturing 1 or more characters until the first ( as group 1

\( - absorbing the left parenthesis

([^\)]*) - capturing everything until the next ) as group 2

\) - absorbing the right parenthesis

Initially, I tried using [^|]+ to dissect the text of group 2, but it turned out to be more streamlined with a simple split statement.

    function generateSchema(str) {
        const regex = /([^\(]+)\(([^\)]*)\)/mg;  // captures the 'word (word)' pattern
        let m;
        let output = [];
        let obj = {};
    
        while ((m = regex.exec(str)) !== null) {
    
            // This is necessary to avoid infinite loops with zero-width matches
            if (m.index === regex.lastIndex) {
                regex.lastIndex++;
            }
        
            m.forEach((match, groupIndex) => {
                if (groupIndex === 1) {
                    obj = {};
                    obj.key = match.trim();
                } else if (groupIndex === 2) {
                    obj.value = match.split('|').map(i=>i.trim());
                    output.push(obj);
                }
            });
        }
        return output;
    }

    const str = "addidas (brand | type  ) sneakers(product) for men(o)";
    console.log(generateSchema(str));

What is the best way to use regex for splitting an array?

Answer №1

Answer №2

Answer №3

Answer №4

Similar questions

Issue with height in self-invoking function not functioning correctly

Kendo UI Web - MultiSelect: choosing an option multiple times

Enhancing Navbar Design with Tailwind CSS in NextJS and React

I am attempting to retrieve the initial three results from my MySQL database using Node.js, but I keep encountering an error

What is the best way to implement rate limiting for Next.js server actions?

Guide to activating a reaction following an occurrence in a React component

Having trouble accessing the iframe element in an Angular controller through a directive

A guide on how to activate an event when a radio button is selected using jQuery

Deactivating Timeout Requests in Koa Server

Error: Google chart for Google Maps is not displaying text every 1 unit as expected

Is it possible to attach React Components to Elements without using JSX?

The pagination feature in React MUI DataGrid is malfunctioning

Angular 5 with Typescript encountered a failure in webpack due to the absence of the property "data" on the Response

Is it possible for an ul to be displayed beneath a white section within an li

E6 arrow functions simplify the process of condensing an array of objects into a single object

How can I use jQuery to hide each div of the same class individually when a user clicks on each div to close

Choose a value to apply to the dropdown menus

Why is my JSON object showing up as undefined in my Node.js POST request?

How can I use an input array to filter data in mongodb?

Ways of accessing an array within an if statement