longitud
La propiedad de longitud devuelve el número de caracteres en la cadena.
La longitud se obtiene en función de la codificación UTF-16 de la cadena, y la longitud de la cadena vacía es 0. La longitud no se puede modificar.
charat ()
El método Charat () devuelve caracteres en la posición especificada. Tenga en cuenta que JavaScript no tiene un tipo de datos de caracteres que sea diferente del tipo de cadena, por lo que el carácter devuelto es una cadena de longitud 1.
StringObject.Charat (índice)
Se requiere el índice de parámetros. Un número que representa una posición en una cadena, es decir, el subíndice de un carácter en la cadena. El subíndice del primer carácter en la cadena es 0. Si el índice de parámetros no está entre 0 y String.Length, el método devuelve una cadena vacía.
Nota: El método Charat () tendrá problemas con un soporte de caracteres no BMP (plano básico-multililingüe), consulte: MDN
charcodeat ()
El método Charcodeat () devuelve la codificación unicode de los caracteres en la posición especificada. Este valor de retorno es un número entero entre 0 65535.
El método Charcodeat () es similar a la operación realizada por el método Charat (), excepto que el primero devuelve la codificación de caracteres en la posición especificada, mientras que la segunda devuelve una subcadena de caracteres.
StringObject.CharCodeat (índice)
El índice de parámetros es opcional. Un número que representa una posición en una cadena, es decir, el subíndice de un carácter en la cadena. El subíndice del primer carácter en la cadena es 0. Si el índice es un número negativo, o mayor o igual a la longitud de la cadena, Charcodeat () devuelve Nan. Cuando el índice está vacío, es predeterminado a 0.
La codificación de Unicode varía de 0 a 1,114,111. Las primeras 128 codificaciones unicode coinciden con la codificación de caracteres ASCII. El valor devuelto por el método Charcodeat () siempre es inferior a 65536, porque los caracteres con valores más altos aparecerán en pares y deben recuperarse simultáneamente con Charcodeat (I) y Charcodeat (i+1).
concat () no se recomienda
El método concat () se usa para concatenar dos o más cadenas.
stringObject.concat (stringx, stringx, ..., stringx)
Se requiere el parámetro StringX. es uno o más objetos de cadena que se concatenarán en una cadena.
El método concat () convierte todos sus parámetros en una cadena, luego concatena a la cola de la cadena de cadena StringObject en orden y devuelve la cadena concatenada. Tenga en cuenta que StringObject en sí no ha sido cambiado.
Tenga en cuenta que se recomienda usar el operador "+" para conectar cadenas para reemplazar este método, que es más eficiente. Referencia: Concat vs + vs unión.
indexOf ()
El método indexOf () devuelve la primera ocurrencia de un valor de cadena especificado en la cadena.
stringObject.IndexOf (SearchValue, FromDex)
Se requiere el Valor de búsqueda de parámetros, especificando el valor de la cadena a recuperar. El parámetro fromdex es un parámetro entero opcional. Especifica la ubicación donde comienza la búsqueda en la cadena. Su valor legal es 0 a StringObject.length 1. Si se omite este parámetro, la búsqueda comenzará desde el primer carácter de la cadena.
Este método recuperará la cadena StringObject de principio a fin para ver si contiene un Valor de búsqueda de subcadres. La ubicación donde comienza la búsqueda es en el desdedex de la cadena o al comienzo de la cadena (cuando no se especifica deDex). Si se encuentra un Valor de búsqueda, devuelve la ubicación donde aparece primero el SearchValue. La posición del carácter en StringObject comienza en 0.
NOTA: ¡El método indexOf () es sensible a la caja! Si el valor de la cadena a recuperar no aparece, el método devuelve -1.
lastindexof ()
El método LastIndexOf () devuelve la última posición donde aparece el valor de cadena especificado, buscando de regreso a la parte delantera en la posición especificada en una cadena.
Los parámetros LastIndexof () e indexOf () son los mismos que los utilizados, pero se buscan de regreso a delante.
La copia del código es la siguiente:
var str = "¡Hola Mundo Mundo!"
console.log (str.indexof ("wo")); // 6
console.log (str.indexof ("wo", 2)); // 6
console.log (str.indexof ("wo", 10)); // 12
console.log (str.lastindexof ("wo")); // 12
console.log (str.lastindexof ("wo", 2)); //-1
console.log (str.lastindexof ("wo", 10)); // 6
LocalEcompare ()
Compare dos cadenas en un orden localmente específico.
stringObject.localecompare (objetivo)
Se requiere el objetivo del parámetro, las cadenas que se compararán con StringObject en un orden localmente específico.
Devuelve el número de resultados de comparación. Si StringObject es menor que el objetivo, LocalEcompare () devuelve un número inferior a 0. Si StringObject es mayor que el objetivo, el método devuelve un número mayor que 0. Si las dos cadenas son iguales, o no hay diferencia de acuerdo con las reglas de clasificación local, el método devuelve 0.
Al aplicar los operadores <y> con las cadenas, comparan las cadenas con unicode que codifica solo con caracteres, independientemente de las reglas de clasificación local. El orden de generación de esta manera no es necesariamente correcto. Por ejemplo, en español, el personaje "CH" generalmente se clasifica como un personaje que aparece entre las letras "C" y "D". El método LocalEcompare () proporciona un método para comparar cadenas, teniendo en cuenta las reglas de clasificación locales predeterminadas.
Los parámetros localesCompare () En algunos navegadores avanzados también admiten locales y opciones, consulte el siguiente código y MDN: https://developer.mozilla.org/en-us/docs/web/javascript/reference/global_objects/string/localecompare
La copia del código es la siguiente:
// Las reglas de clasificación para diferentes culturas son diferentes
console.log ('ä'.localecompare (' z ',' de ')); //-1
console.log ('ä'.localecompare (' z ',' sv ')); // 1
fósforo()
El método Match () puede recuperar el valor especificado dentro de una cadena, o encontrar una coincidencia para una o más expresiones regulares.
Este método es similar a indexOf () y lastindexof (), pero devuelve el valor especificado en lugar de la posición de la cadena.
stringObject.match (regexp)
El parámetro regexp puede ser una cadena o un objeto regular de expresión regexp.
Devuelve una matriz que almacena resultados coincidentes. El contenido de esta matriz depende de si REGEXP tiene la bandera global g.
Si Regexp no tiene Flag G, el método Match () solo puede realizar una coincidencia una vez en StringObject. Si no se encuentra ningún texto coincidente, Match () devuelve nulo. De lo contrario, devuelve una matriz que almacena información sobre el texto coincidente que encontró. El elemento 0 de la matriz almacena el texto coincidente, mientras que el texto de los restaurantes coincide con la subexpresión de la expresión regular. Además de estos elementos de matriz regulares, la matriz devuelta también contiene dos propiedades de objetos. El atributo de índice declara la posición del carácter inicial que coincide con el texto en el StringObject, y el atributo de entrada declara una referencia al StringObject.
Si Regexp tiene el Flag G, el método Match () realiza una búsqueda global, encontrando todas las subcadenas coincidentes en StringObject. Si no se encuentra una subcadena coincidente, se devuelve NULL. Si se encuentran una o más subcadenas coincidentes, se devuelve una matriz. Sin embargo, el contenido de la matriz devuelta por Global Match es muy diferente del primero. Su elemento de matriz almacena todas las subcadenas coincidentes en StringObject, y no hay atributo de índice o atributo de entrada.
Sin Flag G, el resultado de llamar a StringObject.Match (Regexp) y llamar a Regexp.exec (StringObject) es el mismo. En el modo de búsqueda global, Match () no proporciona información sobre el texto que coincide con la subexpresión, ni declara la ubicación de cada subcadena coincidente. Si necesita esta información recuperada globalmente, puede usar regexp.exec ().
Nota: Si necesita saber si una cadena coincide con una expresión regular, use regexp.test (string); Si desea que coincida solo una vez, use regexp.exec (string) en lugar de string.match (regexp).
La copia del código es la siguiente:
var str = "¡Hola mundo!"
var str2 = "1 más 2 igual 3"
console.log (str.match ("mundo")); // ["Mundo", Índice: 6, entrada: "¡Hola mundo!"]
console.log (str2.match (// d+/g)); // ["1", "2", "3"]
reemplazar()
El método reemplazar () se usa para reemplazar algunos caracteres en una cadena, o para reemplazar una subcadena que coincida con la expresión regular.
stringObject.replace (regexp/substr, reemplazo)
Se requiere el parámetro regexp/substr. Objeto regexp que especifica la subcadena o el patrón que se reemplazará. Si el valor es una cadena, se usa como el patrón de texto de cantidad directa para recuperarse en lugar de convertirse en un objeto regexp primero. Se requiere reemplazo de parámetros. es un valor de cadena. Especifica una función que reemplaza el texto o genera un texto de reemplazo.
El método devuelve una nueva cadena, obtenida después de reemplazar la primera coincidencia o todas las coincidencias de regexp con reemplazo.
El método reemplazar () de StringObject realiza una operación de búsqueda y reemplazo. Buscará sustras que coincidan con Regexp en StringObject y reemplazarán esas sustros con reemplazo. Si Regexp tiene el Bandero G Global G, el método Reemplazar () reemplaza todas las subcadenas coincidentes. De lo contrario, solo reemplaza la primera subcadena coincidente.
El reemplazo puede ser una cadena o una función. Si es una cadena, cada coincidencia será reemplazado por la cadena. Pero el personaje $ en reemplazo tiene un significado específico. Como se muestra a continuación, establece que la cadena obtenida de la coincidencia de patrones se utilizará para el reemplazo:
1. $$ $
2. $ ` - Texto a la izquierda de la subcadena coincidente.
3. $ ' - texto a la derecha de la subcadena coincidente.
4. $ & - Subcepetación regular.
5. $ Número: texto que coincida con la subexpresión número th en Regexp.
El reemplazo puede ser una función, en cuyo caso cada coincidencia llama a la función y la cadena que devuelve se usará como texto de reemplazo. El primer argumento de esta función es una cadena que coincide con el patrón. Los siguientes parámetros son cadenas que coinciden con la subexpresión en el patrón, y puede haber 0 o más parámetros de este tipo. El siguiente argumento es un entero que declara dónde aparece la coincidencia en el StringObject. El último parámetro es StringObject mismo.
La copia del código es la siguiente:
// reemplazar una vez
var str = "¡Hola Microsoft!";
console.log (str.replace (/Microsoft/, "Google")); // ¡Hola Google!
console.log (str); // ¡Hola Microsoft!
// reemplazar varias veces
var str2 = "¡Hola Microsoft! Y Microsoft! ¡Y Microsoft! ¡O Microsoft!";
console.log (str2.replace (/Microsoft/g, "Google")); // ¡Hola Google! ¡Y Google! ¡Y Google! ¡O Google!
// Conversión de personajes
var str3 = "Doe, John";
console.log (str3.replace (/(/w+)/s*,/s*(/w+)/, "$ 2 $ 1")); // John Doe
var str4 = '"a", "b"';
console.log (str4.replace (/"([^"]*) "/g," '$ 1' ")); // 'a', 'b'
// usa funciones
var str5 = 'aaa bbb ccc';
console.log (str5.replace (// b/w+/b/g, function (word) {
return word.substring (0,1) .ToupperCase ()+word.substring (1);}
)); // AAA BBB CCC
buscar()
El método Search () se usa para recuperar la subcadena especificada en una cadena, o para recuperar la subcadena que coincide con una expresión regular.
stringObject.search (regexp)
El parámetro regexp puede ser una subcadena que debe recuperarse en StringObject, o un objeto regexp que debe recuperarse.
Devuelve la posición de inicio de la primera subcadena en StringObject que coincide con Regexp. Si no se encuentra una subcadena coincidente, -1 se devuelve.
Nota: El método Search () no realiza la coincidencia global, ignorará la bandera g. También ignora la propiedad de LastIdex de Regexp y siempre se recupera desde el comienzo de la cadena, lo que significa que siempre devuelve la primera posición coincidente de StringObject.
La copia del código es la siguiente:
var str = "¡Hola Microsoft!";
console.log (str.search (/microsoft/)); // 6
Si solo desea saber si hay una cadena coincidente, usar Search () es casi lo mismo que usar el método test (). Si desea más información, puede usar los métodos Match () y Exec (), pero la eficiencia será ineficiente.
rebanada()
El método SLICE () extrae una parte de la cadena y devuelve la parte extraída como una nueva cadena.
stringObject.slice (inicio, final)
El comienzo del parámetro es el subíndice inicial del fragmento a extraer. Si es un número negativo, el parámetro especifica la posición calculada desde el final de la cadena. Es decir, -1 se refiere al último carácter de la cadena, -2 se refiere al segundo a último personaje, y así sucesivamente.
El final del parámetro es el subíndice al final del fragmento que se extrae de inmediato. Si no se especifica este parámetro, la subcadena a extraer incluye una cadena desde el inicio hasta el final de la cadena original. Si el parámetro es un número negativo, especifica la posición desde el final de la cadena.
El método devuelve una nueva cadena. Incluye todos los caracteres desde el inicio de String StringObject (incluido el inicio) para finalizar el final (excluyendo el final).
NOTA: Los métodos slice (), sustring () y sustr () del objeto de cadena pueden devolver la parte especificada de la cadena. Se recomienda usar el método Slice () en todas las ocasiones.
La copia del código es la siguiente:
var str = "¡Hola Microsoft!";
console.log (str.slice (6)); // Microsoft!
console.log (str.slice (6, 12)); // micros
Subcadena ()
No se recomienda usarlo, y se recomienda usar SLICE () en su lugar.
subStr ()
No se recomienda usarlo, y se recomienda usar SLICE () en su lugar.
tolocalelowercase ()
No se recomienda usar, solo es útil en algunos idiomas, como el turco. Se recomienda usar tolowercase () en su lugar.
tolocaleUpperCase ()
No se recomienda usar, solo es útil en algunos idiomas, como el turco. En su lugar, se recomienda usar ToupperCase ().
tolowercase ()
El método tolowercase () se utiliza para convertir una cadena en minúsculas.
touppercase ()
El método ToupperCase () se usa para convertir una cadena en mayúsculas.
Existen muchos métodos para etiquetas HTML para objetos de cadena: Anchor (), Big (), Blink (), Bold (), Fixed (), FontColor (), FontSize (), cursiva (), Link (), Small (), Strike (), Sub () y Sup (). Utilizan principalmente el formato HTML de objetos de cadena, que pocas personas han aplicado y no se recomiendan.
Ejemplo de demostración del método:
La copia del código es la siguiente:
<html>
<Body>
<script type = "text/javaScript">
var txt = "¡Hola mundo!"
document.write ("<p> big:" + txt.big () + "</p>")
document.write ("<p> pequeño:" + txt.small () + "</p>")
document.write ("<p> Bold:" + txt.bold () + "</p>")
document.write ("<p> Italic:" + txt.italics () + "</p>")
document.write ("<p> Blink:" + txt.blink () + "(no funciona en IE) </p>")
document.write ("<p> fijo:" + txt.fixed () + "</p>")
document.write ("<p> strike:" + txt.strike () + "</p>")
document.write ("<p> FontColor:" + txt.fontcolor ("rojo") + "</p>")
document.write ("<p> fontSize:" + txt.fontSize (16) + "</p>")
document.write ("<p> minúscula:" + txt.tolowercase () + "</p>")
document.write ("<p> uppercase:" + txt.touppercase () + "</p>")
document.write ("<p> subíndice:" + txt.sub () + "</p>")
document.write ("<p> supscript:" + txt.sup () + "</p>")
document.write ("<p> enlace:" + txt.link ("http://www.w3school.com.cn") + "</p>")
</script>
</body>
</html>