javascript - ejemplos - title css

¿Cómo contar la ocurrencia de la cadena en la cadena?

Question

¿Cómo puedo contar el número de veces que una cadena en particular ocurre en otra cadena? Por ejemplo, esto es lo que estoy tratando de hacer en Javascript:

var temp = "This is a string.";
alert(temp.count("is")); //should output ''2''

Answer 1

¡Aquí está la función más rápida!

¿Por qué es más rápido?

• No comprueba char por char (con 1 excepción)
• Usa un tiempo e incrementa 1 var (la var del recuento de caracteres) frente a un bucle for que comprueba la longitud e incrementa 2 vars (generalmente var i y una var con el recuento de caracteres)
• Utiliza mucho menos vars
• ¡No usa expresiones regulares!
• Utiliza una función altamente optimizada (con suerte)

• Todas las operaciones son lo más combinadas posible, evitando desaceleraciones debido a múltiples operaciones

  String.prototype.timesCharExist=function(c){var t=0,l=0,c=(c+'''')[0];while(l=this.indexOf(c,l)+1)++t;return t};

Aquí hay una versión más lenta y más legible:

    String.prototype.timesCharExist = function ( chr ) {
        var total = 0, last_location = 0, single_char = ( chr + '''' )[0];
        while( last_location = this.indexOf( single_char, last_location ) + 1 )
        {
            total = total + 1;
        }
        return total;
    };

Este es más lento debido al contador, los nombres var largos y el mal uso de 1 var.

Para usarlo, simplemente haz esto:

    ''The char "a" only shows up twice''.timesCharExist(''a'');

Edición: (2013/12/16)

¡NO lo use con Opera 12.16 o mayor! ¡tomará casi 2.5x más que la solución de expresiones regulares!

En Chrome, esta solución tomará entre 14ms y 20ms para 1,000,000 caracteres.

La solución regex toma 11-14ms por la misma cantidad.

Usar una función (fuera de String.prototype ) tomará alrededor de 10-13ms.

Aquí está el código utilizado:

    String.prototype.timesCharExist=function(c){var t=0,l=0,c=(c+'''')[0];while(l=this.indexOf(c,l)+1)++t;return t};

    var x=Array(100001).join(''1234567890'');

    console.time(''proto'');x.timesCharExist(''1'');console.timeEnd(''proto'');

    console.time(''regex'');x.match(/1/g).length;console.timeEnd(''regex'');

    var timesCharExist=function(x,c){var t=0,l=0,c=(c+'''')[0];while(l=x.indexOf(c,l)+1)++t;return t;};

    console.time(''func'');timesCharExist(x,''1'');console.timeEnd(''func'');

El resultado de todas las soluciones debe ser 100.000!

Nota: si desea que esta función cuente más de 1 carácter, cambie dónde está c=(c+'''')[0] en c=c+''''

Answer 2

Ahora, este es un tema muy antiguo que he encontrado, pero como muchos han empujado sus respuestas, aquí está el mío con la esperanza de ayudar a alguien con este simple código.

var search_value = "This is a dummy sentence!";
var letter = ''a''; /*Can take any letter, have put in a var if anyone wants to use this variable dynamically*/
letter = letter[letter.length - 1];
var count;
for (var i = count = 0; i < search_value.length; count += (search_value[i++] == letter));
console.log(count);

No estoy seguro de que sea la solución más rápida, pero la prefiero por simplicidad y por no usar expresiones regulares (¡simplemente no me gusta usarlas!)

Answer 3

Creo que el propósito de las indexOf regulares es muy diferente de indexOf . indexOf simplemente encuentra la aparición de una determinada cadena mientras que en regex puedes usar comodines como [AZ] que significa que encontrará cualquier carácter de capital en la palabra sin indicar el carácter real.

Ejemplo:

 var index = "This is a string".indexOf("is");
 console.log(index);
 var length = "This is a string".match(/[a-z]/g).length;
 // where [a-z] is a regex wildcard expression thats why its slower
 console.log(length);

Answer 4

Intentalo

<?php 
$str = "33,33,56,89,56,56";
echo substr_count($str, ''56'');
?>

<script type="text/javascript">
var temp = "33,33,56,89,56,56";
var count = temp.match(/56/g);  
alert(count.length);
</script>

Answer 5

La g en la expresión regular (abreviatura de global ) dice que se busque toda la cadena en lugar de simplemente encontrar la primera aparición. Esta coincidencia is dos veces:

var temp = "This is a string.";
var count = (temp.match(/is/g) || []).length;
console.log(count);

Y, si no hay coincidencias, devuelve 0 :

var temp = "Hello World!";
var count = (temp.match(/is/g) || []).length;
console.log(count);

Answer 6

Mi solución:

var temp = "This is a string.";

function countOcurrences(str, value) {
  var regExp = new RegExp(value, "gi");
  return (str.match(regExp) || []).length;
}

console.log(countOcurrences(temp, ''is''));

Answer 7

Para cualquier persona que encuentre este hilo en el futuro, tenga en cuenta que la respuesta aceptada no siempre devolverá el valor correcto si lo generaliza, ya que ahogará a los operadores de expresiones regulares como $ y . . Aquí hay una versión mejor, que puede manejar cualquier aguja:

function occurrences (haystack, needle) {
  var _needle = needle
    .replace(//[/g, ''//['')
    .replace(//]/g, ''//]'')
  return (
    haystack.match(new RegExp(''['' + _needle + '']'', ''g'')) || []
  ).length
}

Answer 8

Prueba esto:

function countString(str, search){
    var count=0;
    var index=str.indexOf(search);
    while(index!=-1){
        count++;
        index=str.indexOf(search,index+1);
    }
    return count;
}

Answer 9

Puede utilizar la match para definir dicha función:

String.prototype.count = function(search) {
    var m = this.match(new RegExp(search.toString().replace(/(?=[.//+*?[^/]$(){}/|])/g, "//"), "g"));
    return m ? m.length:0;
}

Answer 10

Puedes probar esto:

var theString = "This is a string.";
console.log(theString.split("is").length - 1);

Answer 11

Respuesta de Leandro Batista: solo un problema con la expresión regular.

 "use strict";
 var dataFromDB = "testal";
 
  $(''input[name="tbInput"]'').on("change",function(){
 var charToTest = $(this).val();
 var howManyChars = charToTest.length;
 var nrMatches = 0;
 if(howManyChars !== 0){
  charToTest = charToTest.charAt(0);
  var regexp = new RegExp(charToTest,''gi'');
  var arrMatches = dataFromDB.match(regexp);
  nrMatches = arrMatches ? arrMatches.length : 0;
 }
  $(''#result'').html(nrMatches.toString());

  });

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<div class="main">
What do you wanna count <input type="text" name="tbInput" value=""><br />
Number of occurences = <span id="result">0</span>
</div>

Answer 12

Sólo el código de golf de la share :-)

alert(("This is a string.".match(/is/g) || []).length);

Answer 13

Súper duper viejo, pero necesitaba hacer algo así hoy y solo pensé en verificar el SO después. Funciona bastante rápido para mí.

String.prototype.count = function(substr,start,overlap) {
    overlap = overlap || false;
    start = start || 0;

    var count = 0, 
        offset = overlap ? 1 : substr.length;

    while((start = this.indexOf(substr, start) + offset) !== (offset - 1))
        ++count;
    return count;
};

Answer 14

Sobre la base de @ Vittim.us respuesta anterior. Me gusta el control que me da su método, lo que lo hace fácil de extender, pero necesitaba agregar insensibilidad a los casos y limitar las coincidencias a palabras completas con soporte para la puntuación. (por ejemplo, "baño" está en "tomar un baño", pero no "bañarse")

La expresión regular de puntuación provino de: https://.com/a/25575009/497745 ( ¿Cómo puedo eliminar toda la puntuación de una cadena en JavaScript usando regex? )

function keywordOccurrences(string, subString, allowOverlapping, caseInsensitive, wholeWord)
{

    string += "";
    subString += "";
    if (subString.length <= 0) return (string.length + 1); //deal with empty strings

    if(caseInsensitive)
    {            
        string = string.toLowerCase();
        subString = subString.toLowerCase();
    }

    var n = 0,
        pos = 0,
        step = allowOverlapping ? 1 : subString.length,
        stringLength = string.length,
        subStringLength = subString.length;

    while (true)
    {
        pos = string.indexOf(subString, pos);
        if (pos >= 0)
        {
            var matchPos = pos;
            pos += step; //slide forward the position pointer no matter what

            if(wholeWord) //only whole word matches are desired
            {
                if(matchPos > 0) //if the string is not at the very beginning we need to check if the previous character is whitespace
                {                        
                    if(!/[/s/u2000-/u206F/u2E00-/u2E7F//'!"#$%&/(/)*+,/-.//:;<=>?@/[/]^_`{|}~]/.test(string[matchPos - 1])) //ignore punctuation
                    {
                        continue; //then this is not a match
                    }
                }

                var matchEnd = matchPos + subStringLength;
                if(matchEnd < stringLength - 1)
                {                        
                    if (!/[/s/u2000-/u206F/u2E00-/u2E7F//'!"#$%&/(/)*+,/-.//:;<=>?@/[/]^_`{|}~]/.test(string[matchEnd])) //ignore punctuation
                    {
                        continue; //then this is not a match
                    }
                }
            }

            ++n;                
        } else break;
    }
    return n;
}

Siéntase libre de modificar y refactorizar esta respuesta si detecta errores o mejoras.

Answer 15

Un poco tarde pero, asumiendo que tenemos la siguiente cadena:

var temp = "This is a string.";

Primero nos dividimos en lo que sea que busques para que coincida, esto devolverá una serie de cadenas.

var array = temp.split("is");

Luego obtenemos la longitud del mismo y le restamos 1, ya que dividimos los valores predeterminados en una matriz de tamaño 1 y, por consiguiente, incrementamos su tamaño cada vez que encuentra una ocurrencia.

var occurrenceCount = array.length - 1;
alert(occurrenceCount); //should output ''2''

También puede hacer todo esto en una línea de la siguiente manera:

alert("This is a string.".split("is").length - 1); //should output ''2''

Espero que ayude: D

Answer 16

Versión simple sin expresiones regulares:

var temp = "This is a string.";

var count = (temp.split(''is'').length - 1);

alert(count);

Answer 17

String.prototype.Count = function (find) { return this.split(find).length - 1; } "This is a string.".Count("is");

Esto devolverá 2.

Answer 18

La versión no regex:

 var string = ''This is a string'',
    searchFor = ''is'',
    count = 0,
    pos = string.indexOf(searchFor);

while (pos > -1) {
    ++count;
    pos = string.indexOf(searchFor, ++pos);
}

console.log(count);   // 2

Answer 19

function get_occurrence(varS,string){//Find All Occurrences
        c=(string.split(varS).length - 1);
        return c;
    }
    temp="This is a string.";
    console.log("Total Occurrence is "+get_occurrence("is",temp));

Use get_occurrence (varS, string) para encontrar la ocurrencia de ambos caracteres y string en un String.

Answer 20

var countInstances = function(body, target) {
  var globalcounter = 0;
  var concatstring  = '''';
  for(var i=0,j=target.length;i<body.length;i++){
    concatstring = body.substring(i-1,j);
    
    if(concatstring === target){
       globalcounter += 1;
       concatstring = '''';
    }
  }
  
  
  return globalcounter;
 
};

console.log(   countInstances(''abcabc'', ''abc'')   ); // ==> 2
console.log(   countInstances(''ababa'', ''aba'')   ); // ==> 2
console.log(   countInstances(''aaabbb'', ''ab'')   ); // ==> 1

Answer 21

var s = "1";replaced word
var a = "HRA"; //have to replace 
var str = document.getElementById("test").innerHTML;
var count = str.split(a).length - 1;
for (var i = 0; i < count; i++) {
    var s = "1";
    var a = "HRA";
    var str = document.getElementById("test").innerHTML;
    var res = str.replace(a, s);
    document.getElementById("test").innerHTML = res;
}

<input " type="button" id="Btn_Validate" value="Validate" class="btn btn-info" />
<div class="textarea"  id="test" contenteditable="true">HRABHRA</div>

Answer 22

var temp = "This is a string.";
console.log((temp.match(new RegExp("is", "g")) || []).length);

Answer 23

       var myString = "This is a string.";
        var foundAtPosition = 0;
        var Count = 0;
        while (foundAtPosition != -1)
        {
            foundAtPosition = myString.indexOf("is",foundAtPosition);
            if (foundAtPosition != -1)
            {
                Count++;
                foundAtPosition++;
            }
        }
        document.write("There are " + Count + " occurrences of the word IS");

Consulte: - contar una subcadena aparece en la cadena para una explicación paso a paso.

Answer 24

/** Function that count occurrences of a substring in a string;
 * @param {String} string               The string
 * @param {String} subString            The sub string to search for
 * @param {Boolean} [allowOverlapping]  Optional. (Default:false)
 *
 * @author Vitim.us https://gist.github.com/victornpb/7736865
 * @see Unit Test https://jsfiddle.net/Victornpb/5axuh96u/
 * @see http://.com/questions/4009756/how-to-count-string-occurrence-in-string/7924240#7924240
 */
function occurrences(string, subString, allowOverlapping) {

    string += "";
    subString += "";
    if (subString.length <= 0) return (string.length + 1);

    var n = 0,
        pos = 0,
        step = allowOverlapping ? 1 : subString.length;

    while (true) {
        pos = string.indexOf(subString, pos);
        if (pos >= 0) {
            ++n;
            pos += step;
        } else break;
    }
    return n;
}

Uso

occurrences("foofoofoo", "bar"); //0

occurrences("foofoofoo", "foo"); //3

occurrences("foofoofoo", "foofoo"); //1

allowOverlapping

occurrences("foofoofoo", "foofoo", true); //2

Partidos:

  foofoofoo
1 `----´
2    `----´

Prueba de unidad

• https://jsfiddle.net/Victornpb/5axuh96u/

Punto de referencia

Hice una prueba de referencia y mi función es más de 10 veces más rápida que la función de coincidencia de expresiones regulares publicada por Gumbo. En mi cadena de prueba es de 25 caracteres de longitud. Con 2 apariciones del carácter ''o''. Ejecuté 1 000 000 veces en Safari.

Safari 5.1

Punto de referencia> Tiempo total de ejecución: 5617 ms (regexp)

Punto de referencia> Tiempo total de ejecución: 881 ms (mi función 6.4x más rápida)

Firefox 4

Punto de referencia> Tiempo total de ejecución: 8547 ms (Rexexp)

Punto de referencia> Tiempo total de ejecución: 634 ms (mi función es 13.5x más rápida)

Edición: cambios que he hecho

• longitud de subcadena en caché

• agregado de tipo de fundición a la cadena.

• añadido el parámetro opcional ''allowOverlapping''

• Se corrigió la salida correcta para "" caso de subcadena vacía

Esencia

• https://gist.github.com/victornpb/7736865

Answer 25

function countInstances(string, word) {
   return string.split(word).length - 1;
}