Comment trouver les indices de toutes les occurrences d'une chaîne dans une autre en JavaScript ?

Question

J'essaie de trouver les positions de toutes les occurrences d'une chaîne dans une autre chaîne, sans tenir compte de la casse.

Par exemple, étant donné la chaîne de caractères :

I learned to play the Ukulele in Lebanon.

et la chaîne de recherche le Je souhaite obtenir le tableau :

[2, 25, 27, 33]

Les deux chaînes seront des variables - c'est-à-dire que je ne peux pas coder leurs valeurs en dur.

Je pensais que c'était une tâche facile pour les expressions régulières, mais après avoir lutté pendant un certain temps pour en trouver une qui fonctionnerait, je n'ai pas eu de chance.

J'ai trouvé cet exemple sur la façon d'y parvenir en utilisant .indexOf() Mais il doit bien y avoir un moyen plus concis de le faire.

Answer 1

Merci pour toutes les réponses. Je les ai toutes examinées et j'ai trouvé une fonction qui donne le premier et le dernier indice de chaque occurrence de la sous-chaîne "needle". Je la publie ici au cas où elle aiderait quelqu'un.

Veuillez noter qu'il ne s'agit pas de la même chose que la demande initiale qui consistait à ne demander que le début de chaque occurrence. Cela convient mieux à mon cas d'utilisation car il n'est pas nécessaire de conserver la longueur de l'aiguille.

function findRegexIndices(text, needle, caseSensitive){
  var needleLen = needle.length,
    reg = new RegExp(needle, caseSensitive ? 'gi' : 'g'),
    indices = [],
    result;

  while ( (result = reg.exec(text)) ) {
    indices.push([result.index, result.index + needleLen]);
  }
  return indices
}

Answer 2

Consultez cette solution qui vous permettra de trouver la même chaîne de caractères, faites-moi savoir si quelque chose manque ou n'est pas correct.

function indexes(source, find) {
    if (!source) {
      return [];
    }
    if (!find) {
        return source.split('').map(function(_, i) { return i; });
    }
    source = source.toLowerCase();
    find = find.toLowerCase();
    var result = [];
    var i = 0;
    while(i < source.length) {
      if (source.substring(i, i + find.length) == find)
        result.push(i++);
      else
        i++
    }
    return result;
  }
  console.log(indexes('aaaaaaaa', 'aaaaaa'))
  console.log(indexes('aeeaaaaadjfhfnaaaaadjddjaa', 'aaaa'))
  console.log(indexes('wordgoodwordgoodgoodbestword', 'wordgood'))
  console.log(indexes('I learned to play the Ukulele in Lebanon.', 'le'))

Answer 3

Voici mon code (utilisant les méthodes "search" et "slice")

    let s = "I learned to play the Ukulele in Lebanon"
    let sub = 0 
    let matchingIndex = []
    let index = s.search(/le/i)
    while( index >= 0 ){
       matchingIndex.push(index+sub);
       sub = sub + ( s.length - s.slice( index+1 ).length )
       s = s.slice( index+1 )
       index = s.search(/le/i)
    } 
    console.log(matchingIndex)

Answer 4

C'est ce que j'utilise habituellement pour obtenir l'index d'une chaîne de caractères en fonction de sa position.

Je passe les paramètres suivants :

recherche : la chaîne de caractères dans laquelle il faut chercher

trouver : la chaîne de caractères à trouver

position ("tous" par défaut) : la position à laquelle la chaîne de recherche apparaît dans la chaîne de recherche

(si "tous", il renvoie le tableau complet des index)

(si "dernier", il renvoie la dernière position)

function stringIndex (search, find, position = "all") {

    var currIndex = 0, indexes = [], found = true;

    while (found) {        
        var searchIndex = search.indexOf(find);
        if (searchIndex > -1) {
            currIndex += searchIndex + find.length; 
            search = search.substr (searchIndex + find.length);
            indexes.push (currIndex - find.length);
        } else found = false; //no other string to search for - exit from while loop   
    }

    if (position == 'all') return indexes;
    if (position > indexes.length -1) return [];

    position = (position == "last") ? indexes.length -1 : position;

    return indexes[position];        
}

//Example:

var myString = "Joe meets Joe and together they go to Joe's house";
console.log ( stringIndex(myString, "Joe") ); //0, 10, 38
console.log ( stringIndex(myString, "Joe", 1) ); //10
console.log ( stringIndex(myString, "Joe", "last") ); //38
console.log ( stringIndex(myString, "Joe", 5) ); //[]

Answer 5

Bonjour mes amis, c'est juste une autre façon de trouver des index de phrases correspondantes en utilisant reduce et une méthode d'aide. Bien sûr, RegExp est plus pratique et est peut-être implémenté en interne d'une manière ou d'une autre comme ceci. J'espère que vous trouverez cela utile.

function findIndexesOfPhraseWithReduce(text, phrase) {
      //convert text to array so that be able to manipulate.
          const arrayOfText = [...text];

      /* this function takes the array of characters and
      the search phrase and start index which comes from reduce method
      and calculates the end with length of the given phrase then slices
      and joins characters and compare it whith phrase.
      and returns True Or False */

         function isMatch(array, phrase, start) {
         const end = start + phrase.length;
         return (array.slice(start, end).join('')).toLowerCase() === 
               phrase.toLowerCase();
         }

    /* here we reduce the array of characters and test each character
    with isMach function which takes "current index" and matches the phrase
    with the subsequent character which starts from current index and
    ends at the last character of phrase(the length of phrase). */

        return arrayOfText.reduce((acc, item, index) => isMatch(arrayOfText, phrase, 
        index) ? [...acc, index] : acc, []);
}

findIndexesOfPhraseWithReduce("I learned to play the Ukulele in Lebanon.", "le");

function findIndexesOfPhraseWithReduce(text, phrase) {

         const arrayOfText = [...text];
         function isMatch(array, phrase, start) {
         const end = start + phrase.length;
         return (array.slice(start, end).join('')).toLowerCase() === 
               phrase.toLowerCase();
         }
        return arrayOfText.reduce((acc, item, index) => isMatch(arrayOfText, phrase, 
        index) ? [...acc, index] : acc, []);
}

console.log(findIndexesOfPhraseWithReduce("I learned to play the Ukulele in Lebanon.", "le"));