Calculating the frequency of specific substrings present in the complete object

Question

Calculating the frequency of specific substrings present in the complete object

I am seeking a method to tally substrings of object values. In other words, instead of the entire object containing a string, I want it where one key equals a string. An effective Xpath in XSLT is:

count(//v[contains(.,current-grouping-key())])

However, I am struggling to achieve this using JavaScript.

I have attempted the following:

const obj = 
  [ { v: 'Bla Blu Bli' },
    { v: 'Bla Blu Bli' },
    { v: 'Bla Blu' },
    { v: 'Bla Bli' }
  ];

const count = obj.reduce( function(sums,entry) {
    sums[entry.v] = (sums[entry.v] || 0) + 1;
    return sums;
 },{});
 
console.log(count)

Unfortunately, this approach only counts exact strings. The output I receive is:

"Bla Blu Bli": 2,
"Bla Blu": 1,
"Bla Bli": 1

instead of

 "Bla Blu Bli": 2,
 "Bla Blu": 3,
 "Bla Bli": 3

Is there a way to count the substrings rather than just the exact values?

javascript arrays count substring javascript-objects

Answer 1

Answer №1

In order to optimize performance, this updated version is designed to execute more efficiently.

(in response to your statement I have 100k+ values made in a comment)

The approach involves creating an array solely for unique series, along with keeping track of the number of identical series copies.
The process entails navigating through this array and incrementing the count by considering other sets containing the same values,
but specifically focusing on those with larger sizes.

Set elements were utilized due to their efficiency compared to arrays, as per the documentation stating that [set].has(value) performs better than [array].includes(value).

const obj = 
  [ { v: 'Bla Blu Bli' }
  , { v: 'Bla Bli Blu' }
  , { v: 'Bla Blu'     }
  , { v: 'Bla Bli'     }
  ];

const counts = obj
  .reduce((r,o) => // creating an array with unique sets along with copy count
    {
    let 
      arr = o.v.split(' ')
    , sam = r.find(x=>(x.s.size===arr.length) && arr.every(a=>x.s.has(a)) )
      ;
    if (sam)  ++sam.n   // increment by one more copy
    else      r.push({arr, s:new Set(arr), n:1 })
       // needing array and set for next step to avoid unnecessary conversions
    return r
    },[]) 
  .reduce((c,e,_,all) =>
    {
    c[e.arr.join(' ')] = e.n  
      + all.reduce((s,x)=>((x.s.size > e.s.size && e.arr.every(a=>x.s.has(a))) ? s + x.n : s),0)
      // attempting to find inclusion only within larger sets
    return c
    },{})  

console.log(  counts  )

.as-console-wrapper {max-height: 100% !important;top: 0;}
.as-console-row::after {display: none !important;}

Answer 2

In order to optimize performance, this updated version is designed to execute more efficiently.

(in response to your statement I have 100k+ values made in a comment)

The approach involves creating an array solely for unique series, along with keeping track of the number of identical series copies.
The process entails navigating through this array and incrementing the count by considering other sets containing the same values,
but specifically focusing on those with larger sizes.

Set elements were utilized due to their efficiency compared to arrays, as per the documentation stating that [set].has(value) performs better than [array].includes(value).

const obj = 
  [ { v: 'Bla Blu Bli' }
  , { v: 'Bla Bli Blu' }
  , { v: 'Bla Blu'     }
  , { v: 'Bla Bli'     }
  ];

const counts = obj
  .reduce((r,o) => // creating an array with unique sets along with copy count
    {
    let 
      arr = o.v.split(' ')
    , sam = r.find(x=>(x.s.size===arr.length) && arr.every(a=>x.s.has(a)) )
      ;
    if (sam)  ++sam.n   // increment by one more copy
    else      r.push({arr, s:new Set(arr), n:1 })
       // needing array and set for next step to avoid unnecessary conversions
    return r
    },[]) 
  .reduce((c,e,_,all) =>
    {
    c[e.arr.join(' ')] = e.n  
      + all.reduce((s,x)=>((x.s.size > e.s.size && e.arr.every(a=>x.s.has(a))) ? s + x.n : s),0)
      // attempting to find inclusion only within larger sets
    return c
    },{})  

console.log(  counts  )

.as-console-wrapper {max-height: 100% !important;top: 0;}
.as-console-row::after {display: none !important;}

Answer 3

Answer №2

Here is an example of how you can achieve this:

const obj = 
  [ { v: 'Bla Blu Bli' }
  , { v: 'Bla Blu Bli' }
  , { v: 'Bla Blu'     }
  , { v: 'Bla Bli'     }
  ];

const counts = obj
  .map(e=>e.v.split(' ').sort((a,b)=>a.localeCompare(b)))
  .reduce((r,a,_,all)=>
    {
    let terms = a.join(' ')
    if (!r[terms])
      r[terms] = all.reduce((c,x)=>c+(a.every(v=>x.includes(v))?1:0),0);
    return r
    },{})
    
console.log(  counts )

.as-console-wrapper {max-height: 100% !important;top: 0;}
.as-console-row::after {display: none !important;}

Answer 4

Here is an example of how you can achieve this:

const obj = 
  [ { v: 'Bla Blu Bli' }
  , { v: 'Bla Blu Bli' }
  , { v: 'Bla Blu'     }
  , { v: 'Bla Bli'     }
  ];

const counts = obj
  .map(e=>e.v.split(' ').sort((a,b)=>a.localeCompare(b)))
  .reduce((r,a,_,all)=>
    {
    let terms = a.join(' ')
    if (!r[terms])
      r[terms] = all.reduce((c,x)=>c+(a.every(v=>x.includes(v))?1:0),0);
    return r
    },{})
    
console.log(  counts )

.as-console-wrapper {max-height: 100% !important;top: 0;}
.as-console-row::after {display: none !important;}

Answer 5

Answer №3

To determine if a substring is present in a string, you can utilize the indexOf method or similar.

For instance:

obj = [
    {
        "v": "Bla † Blu † Bli"
    },
    {
        "v": "Bla † Blu † Bli"
    },
    {
        "v": "Bla † Blu"
    }
]

const counts = Object.fromEntries(
  obj.map(({v}) => [v, obj.reduce((acc, el) => {
    if (el.v.indexOf(v) > -1) acc++;
    return acc;
  }, 0)])
);

console.log(counts);

Answer 6

To determine if a substring is present in a string, you can utilize the indexOf method or similar.

For instance:

obj = [
    {
        "v": "Bla † Blu † Bli"
    },
    {
        "v": "Bla † Blu † Bli"
    },
    {
        "v": "Bla † Blu"
    }
]

const counts = Object.fromEntries(
  obj.map(({v}) => [v, obj.reduce((acc, el) => {
    if (el.v.indexOf(v) > -1) acc++;
    return acc;
  }, 0)])
);

console.log(counts);

Calculating the frequency of specific substrings present in the complete object

Answer №1

Answer №2

Answer №3

Similar questions

Leveraging node modules in the browser using browserify - Error: fileType is not recognized

Transforming a flexible array of numerical values into a predetermined size

Execute JavaScript code once the XMLHttpRequest has completed execution

Securing data in the browser using JavaScript encryption and decrypting on the server side using Node.js

Display advertisement upon clicking

Guide on how to use a JavaScript AJAX call to download a text file in Java

Conceal the Angular alert message automatically after a specified number of seconds or when the page

Discovering a specific value by locating a string in an array nested inside an object

Reorganizing Elements within an Array using JavaScript

Extracting web search result URLs using Puppeteer

Prevent click event listener from activating if the click results in a new tab or window being opened

Twice Triggered: Firebase Cloud Function HTTPS Call

Debugging Typescript code with line numbers

Avoid API calls by using connect-history-api-fallback

Get rid of empty spaces in gridstack js

Troubleshooting: Missing MapState in Vuex4 for Vue3 within an MVC project

Steps for accessing the "this" keyword within the parent function

Disabling scrolling on body while scrolling a superimposed element

Tips for choosing and deselecting data using jQuery

Issue encountered when attempting to merge all components utilizing PHP's array_combine() function