otra - startswith javascript
¿Cómo comprobar si una cadena "StartsWith" otra cadena? (17)
Acabo de enterarme de esta biblioteca de cadenas:
Incluya el archivo js y luego use la variable S como esta:
S(''hi there'').endsWith(''hi there'')
También se puede utilizar en NodeJS al instalarlo:
npm install string
Entonces requiriéndolo como la variable S :
var S = require(''string'');
La página web también tiene enlaces a bibliotecas de cadenas alternativas, si esta no le interesa.
¿Cómo escribiría el equivalente de String.StartsWith de C # en JavaScript?
var haystack = ''hello world'';
var needle = ''he'';
haystack.startsWith(needle) == true
Nota: Esta es una pregunta antigua y, como se señaló en los comentarios, ECMAScript 2015 (ES6) introdujo el método .startsWith . Sin embargo, en el momento de escribir esta actualización (2015) , el soporte del navegador está lejos de ser completo .
Aquí hay una pequeña mejora en la solución de CMS:
if(!String.prototype.startsWith){
String.prototype.startsWith = function (str) {
return !this.indexOf(str);
}
}
"Hello World!".startsWith("He"); // true
var data = "Hello world";
var input = ''He'';
data.startsWith(input); // true
Verifique si la función ya existe en caso de que un navegador futuro la implemente en código nativo o si es implementada por otra biblioteca. Por ejemplo, la biblioteca de prototipos implementa esta función ya.
Utilizando ! es ligeramente más rápido y más conciso que === 0 aunque no es tan legible.
Dado que esto es tan popular, creo que vale la pena señalar que hay una implementación para este método en ECMA 6 y, en preparación para eso, se debe usar el relleno de polietileno "oficial" para evitar futuros problemas y desgarros.
Afortunadamente los expertos de Mozilla nos proporcionan uno:
https://developer.mozilla.org/de/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith
if (!String.prototype.startsWith) {
String.prototype.startsWith = function(searchString, position) {
position = position || 0;
return this.indexOf(searchString, position) === position;
};
}
Tenga en cuenta que esto tiene la ventaja de ser ignorado con gracia en la transición a ECMA 6.
Estaba buscando rendimiento, así que ejecuté las funciones a través de jsperf. Probé las funciones contra el sujeto y las cadenas de búsqueda de varios tamaños y parece que todos los métodos muestran un rendimiento diferente de las diferentes entradas; el patrón general es que el rendimiento se degrada a medida que aumenta la longitud de la cadena de búsqueda.
El ganador general resulta ser el método de substr(ing) .
La mejor solución es dejar de usar las llamadas de la biblioteca y simplemente reconocer que estás trabajando con dos arreglos. Una implementación enrollada a mano es corta y también más rápida que cualquier otra solución que he visto aquí.
function startsWith2(str, prefix) {
if (str.length < prefix.length)
return false;
for (var i = prefix.length - 1; (i >= 0) && (str[i] === prefix[i]); --i)
continue;
return i < 0;
}
Para las comparaciones de rendimiento (éxito y fracaso), consulte http://jsperf.com/startswith2/4 . (Asegúrate de buscar versiones posteriores que puedan haber superado las mías).
Mejor solución:
function startsWith(str, word) {
return str.lastIndexOf(word, 0) === 0;
}
startsWith("aaa", "a")
true
startsWith("aaa", "ab")
false
startsWith("abc", "abc")
true
startsWith("abc", "c")
false
startsWith("abc", "a")
true
startsWith("abc", "ba")
false
startsWith("abc", "ab")
true
Y aquí está el final con si también necesitas eso:
function endsWith(str, word) {
return str.indexOf(word, str.length - word.length) !== -1;
}
Para aquellos que prefieren prototipo en String:
String.prototype.startsWith || (String.prototype.startsWith = function(word) {
return this.lastIndexOf(word, 0) === 0;
});
String.prototype.endsWith || (String.prototype.endsWith = function(word) {
return this.indexOf(word, this.length - word.length) !== -1;
});
Uso:
"abc".startsWith("ab")
true
"c".ensdWith("c")
true
Otra alternativa con .lastIndexOf :
haystack.lastIndexOf(needle, 0) === 0
Esto mira hacia atrás a través del haystack para encontrar una needle partir del índice 0 del haystack . En otras palabras, solo comprueba si el haystack comienza con una needle .
En principio, esto debería tener ventajas de rendimiento sobre algunos otros enfoques:
- No busca en todo el
haystack. - No crea una nueva cadena temporal y luego la descarta de inmediato.
Puede usar el método .startsWith ECMAScript 6, pero aún no es compatible con todos los navegadores . Querrá usar un shim / polyfill para agregarlo a los navegadores que no lo admiten. Crear una implementación que cumpla con todos los detalles establecidos en la especificación es un poco complicado, y la versión definida en esta respuesta no servirá; Si quieres un shim fiel, usa:
-
String.prototype.startsWithMatthias Bynens con calza , o - El es6-shim , que recorta la mayor cantidad posible de especificaciones de ES6, incluido
String.prototype.startsWith.
Una vez que haya modificado el método (o si solo admite navegadores y motores de JavaScript que ya lo tienen), puede usarlo así:
"Hello World!".startsWith("He"); // true
var haystack = "Hello world";
var prefix = ''orl'';
haystack.startsWith(prefix); // false
Recientemente me hice la misma pregunta.
Existen múltiples soluciones posibles, aquí hay 3 válidas:
-
s.indexOf(starter) === 0 -
s.substr(0,starter.length) === starter -
s.lastIndexOf(starter, 0) === 0(agregado después de ver la answer Mark Byers) utilizando un bucle:
function startsWith(s,starter) { for (var i = 0,cur_c; i < starter.length; i++) { cur_c = starter[i]; if (s[i] !== starter[i]) { return false; } } return true; }
No he encontrado la última solución que hace uso de un bucle.
Sorprendentemente, esta solución supera a las 3 primeras por un margen significativo.
Aquí está la prueba jsperf que realicé para llegar a esta conclusión: http://jsperf.com/startswith2/2
Paz
ps: ecmascript 6 (harmony) introduce un método de startsWith nativo con cadenas para cadenas.
Solo piense cuánto tiempo se habría ahorrado si hubieran pensado en incluir este método tan necesario en la versión inicial.
Actualizar
Como Steve señaló (el primer comentario sobre esta respuesta), la función personalizada anterior generará un error si el prefijo dado es más corto que toda la cadena. Lo solucionó y agregó una optimización de bucle que puede verse en http://jsperf.com/startswith2/4 .
Tenga en cuenta que hay 2 optimizaciones de bucle que Steve incluyó, la primera de las dos mostró un mejor rendimiento, por lo tanto, publicaré ese código a continuación:
function startsWith2(str, prefix) {
if (str.length < prefix.length)
return false;
for (var i = prefix.length - 1; (i >= 0) && (str[i] === prefix[i]); --i)
continue;
return i < 0;
}
Según las respuestas aquí, esta es la versión que estoy usando ahora, ya que parece dar el mejor rendimiento basado en las pruebas de JSPerf (y está funcionalmente completo por lo que puedo decir).
if(typeof String.prototype.startsWith != ''function''){
String.prototype.startsWith = function(str){
if(str == null) return false;
var i = str.length;
if(this.length < i) return false;
for(--i; (i >= 0) && (this[i] === str[i]); --i) continue;
return i < 0;
}
}
Esto se basó en startsWith2 desde aquí: http://jsperf.com/startswith2/6 . Agregué un pequeño ajuste para una pequeña mejora en el rendimiento, y desde entonces también agregué un chequeo para que la cadena de comparación sea nula o indefinida, y la convertí para agregarla al prototipo de String usando la técnica en la respuesta de CMS.
Tenga en cuenta que esta implementación no admite el parámetro "posición" que se menciona en esta página de la Red de desarrolladores de Mozilla , pero de todos modos no parece ser parte de la propuesta de ECMAScript.
Si está trabajando con startsWith() y endsWith() , debe tener cuidado con los espacios endsWith() . Aquí hay un ejemplo completo:
var str1 = " Your String Value Here.!! "; // Starts & ends with spaces
if (str1.startsWith("Your")) { } // returns FALSE due to the leading spaces…
if (str1.endsWith("Here.!!")) { } // returns FALSE due to trailing spaces…
var str2 = str1.trim(); // Removes all spaces (and other white-space) from start and end of `str1`.
if (str2.startsWith("Your")) { } // returns TRUE
if (str2.endsWith("Here.!!")) { } // returns TRUE
Sin una función auxiliar, solo se usa el método .test de regex:
/^He/.test(''Hello world'')
Para hacer esto con una cadena dinámica en lugar de una codificada (asumiendo que la cadena no contendrá ningún control de expresión regular):
new RegExp(''^'' + needle).test(haystack)
Deberías revisar ¿Existe una función RegExp.escape en Javascript? Si existe la posibilidad de que aparezcan caracteres de control de expresiones regulares en la cadena.
Solo quería añadir mi opinión sobre esto.
Creo que podemos usar así:
var haystack = ''hello world'';
var needle = ''he'';
if (haystack.indexOf(needle) == 0) {
// Code if string starts with this substring
}
También puede devolver a todos los miembros de una matriz que comiencen con una cadena creando su propio prototipo / extensión al prototipo de matriz, también conocido como
Array.prototype.mySearch = function (target) {
if (typeof String.prototype.startsWith != ''function'') {
String.prototype.startsWith = function (str){
return this.slice(0, str.length) == str;
};
}
var retValues = [];
for (var i = 0; i < this.length; i++) {
if (this[i].startsWith(target)) { retValues.push(this[i]); }
}
return retValues;
};
Y para usarlo:
var myArray = [''Hello'', ''Helium'', ''Hideout'', ''Hamster''];
var myResult = myArray.mySearch(''Hel'');
// result -> Hello, Helium
También puedes ver underscore.string.js . Viene con un montón de métodos útiles de prueba y manipulación de cadenas, incluido el método startsWith . De la documentación:
startsWith
_.startsWith(string, starts)Este método comprueba si la
stringcomienza constarts.
_("image.gif").startsWith("image") => true
data.substring(0, input.length) === input
var str = ''hol'';
var data = ''hola mundo'';
if (data.length >= str.length && data.substring(0, str.length) == str)
return true;
else
return false;