comprimento
A propriedade Length retorna o número de caracteres na string.
O comprimento é obtido com base na codificação UTF-16 da string e o comprimento da string vazia é 0. O comprimento não pode ser modificado.
charat ()
O método charat () retorna caracteres na posição especificada. Observe que o JavaScript não possui um tipo de dados de caracteres diferente do tipo de string, portanto o caractere retornado é uma sequência de comprimento 1.
StringObject.Charat (índice)
O índice de parâmetros é necessário. Um número representando uma posição em uma string, ou seja, o subscrito de um caractere na string. O subscrito do primeiro caractere na sequência é 0. Se o índice de parâmetros não estiver entre 0 e String.Length, o método retornará uma string vazia.
Nota: O método Charat () terá problemas com alguns caracteres não-BMP (Basic-Multilingual Plane), consulte: MDN
Charcodeat ()
O método Charcodeat () retorna a codificação Unicode dos caracteres na posição especificada. Esse valor de retorno é um número inteiro entre 0 65535.
O método charcodeat () é semelhante à operação realizada pelo método Charat (), exceto que o primeiro retorna a codificação de caracteres na posição especificada, enquanto este retorna uma substring de caracteres.
StringObject.Charcodeat (índice)
O índice de parâmetros é opcional. Um número representando uma posição em uma string, ou seja, o subscrito de um caractere na string. O subscrito do primeiro caractere na sequência é 0. Se o índice for um número negativo, ou maior ou igual ao comprimento da string, Charcodeat () retorna NAN. Quando o índice está vazio, ele padrão é 0.
A codificação do Unicode varia de 0 a 1.114.111. Os primeiros 128 codificações de unicode correspondem à codificação de caracteres ASCII. O valor retornado pelo método Charcodeat () é sempre menor que 65536, porque os caracteres com valores mais altos aparecerão em pares e precisam ser recuperados simultaneamente com Charcodeat (i) e Charcodeat (i+1).
concat () não é recomendado
O método concat () é usado para concatenar duas ou mais cordas.
StringObject.Concat (Stringx, Stringx,…, Stringx)
O parâmetro stringx é necessário. é um ou mais objetos de string que serão concatenados em uma string.
O método concat () converte todos os seus parâmetros em uma string e concatena na cauda da string string stringObject em ordem e retorna a sequência concatenada. Observe que o próprio StringObject não foi alterado.
Observe que é fortemente recomendado usar o operador "+" para conectar strings para substituir esse método, que é mais eficiente. Referência: Concat vs + vs junção.
indexOf ()
O método indexOf () retorna a primeira ocorrência de um valor de string especificado na string.
stringObject.indexOf (SearchValue, Fromdex)
O parâmetro SearchValue é necessário, especificando o valor da string a ser recuperado. O parâmetro fromdex é um parâmetro inteiro opcional. Especifica o local onde a pesquisa é iniciada na string. Seu valor legal é 0 a stringObject.Length 1. Se esse parâmetro for omitido, a pesquisa será iniciada no primeiro caractere da string.
Este método recuperará o String StringObject do começo ao fim para ver se ele contém um Substring SearchValue. O local onde a pesquisa começa está no Fromdex da string ou no início da string (quando o Fromdex não é especificado). Se um searchvalue for encontrado, ele retornará o local onde o SearchValue aparece pela primeira vez. A posição do caractere em StringObject começa em 0.
Nota: O método indexOf () é sensível ao minúsculo! Se o valor da string a ser recuperado não aparecer, o método retornará -1.
LastIndexOf ()
O método lastIndexOF () retorna a última posição em que o valor da string especificado é exibido, pesquisando de volta para frente na posição especificada em uma string.
Os parâmetros LastIndexOF () e IndexOf () são os mesmos que os usados, mas são pesquisados de volta para frente.
A cópia do código é a seguinte:
var str = "Hello World World!"
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
LocalecMare ()
Compare duas cordas em um pedido localmente específico.
StringObject.localecompare (Target)
O alvo do parâmetro é necessário, as seqüências de strings a serem comparadas com o StringObject em um pedido localmente específico.
Retorna o número de resultados de comparação. Se o StringObject for menor que o destino, o localCompare () retornará um número menor que 0. Se o StringObject for maior que o alvo, o método retornará um número maior que 0. Se as duas seqüências forem iguais ou não houver diferença de acordo com as regras de classificação local, o método retornará 0.
Ao aplicar os operadores <e> a strings, eles comparam as strings com a codificação do Unicode apenas com os caracteres, independentemente das regras de classificação locais. A ordem de geração dessa maneira não é necessariamente correta. Por exemplo, em espanhol, o personagem "Ch" geralmente é classificado como um personagem que aparece entre as letras "C" e "D". O método localECompare () fornece um método para comparar strings, levando em consideração as regras de classificação local padrão.
Parâmetros localCompare () Em alguns navegadores avançados, também suportam locais e opções, consulte o código a seguir e MDN: https://developer.mozilla.org/en-us/docs/web/javascript/reference/global_objects/string/localecompare
A cópia do código é a seguinte:
// As regras de classificação para diferentes culturas são diferentes
console.log ('ä'.localecompare (' z ',' de ')); //-1
console.log ('ä'.localecompare (' z ',' sv ')); // 1
corresponder()
O método Match () pode recuperar o valor especificado em uma string ou encontrar uma correspondência para uma ou mais expressões regulares.
Este método é semelhante ao indexOF () e LastIndexOF (), mas retorna o valor especificado em vez da posição da string.
stringObject.match (regexp)
O parâmetro regexp pode ser uma string ou um objeto Regexp de expressão regular.
Retorna uma matriz que armazena resultados correspondentes. O conteúdo dessa matriz depende se o regexp tem o sinalizador global g.
Se o regexp não tiver sinalizador G, o método Match () poderá executar apenas uma correspondência uma vez no StringObject. Se nenhum texto correspondente for encontrado, corresponde () retornará nulo. Caso contrário, ele retorna uma matriz que armazena informações sobre o texto correspondente encontrado. O elemento 0º da matriz armazena o texto correspondente, enquanto o texto da loja de restos corresponde à subexpressão da expressão regular. Além desses elementos regulares da matriz, a matriz retornada também contém duas propriedades de objeto. O atributo de índice declara a posição do caractere inicial que corresponde ao texto no StringObject e o atributo de entrada declara uma referência ao StringObject.
Se o regexp tiver o sinalizador G, o método Match () executa uma pesquisa global, encontrando todas as substringas correspondentes no StringObject. Se nenhuma substring correspondente for encontrada, o NULL será retornado. Se uma ou mais substâncias correspondentes forem encontradas, uma matriz será retornada. No entanto, o conteúdo da matriz retornado pela Global Match é muito diferente do primeiro. Seu elemento de matriz armazena todas as substringas correspondentes no StringObject, e não há atributo de índice ou atributo de entrada.
Sem o sinalizador G, o resultado de chamar stringObject.match (regexp) e chamando regexp.exec (stringObject) é o mesmo. No modo de pesquisa global, o Match () não fornece informações sobre o texto que corresponde à subexpressão, nem declara o local de cada substring correspondente. Se você precisar dessas informações recuperadas globalmente, poderá usar o regexp.exec ().
Nota: Se você precisar saber se uma string corresponde a uma expressão regular, use regexp.test (string); Se você deseja corresponder apenas uma vez, use regexp.exec (String) em vez de string.match (regexp).
A cópia do código é a seguinte:
var str = "Hello World!"
var str2 = "1 mais 2 igual 3"
console.log (str.match ("mundo")); // ["mundo", índice: 6, entrada: "Hello World!"]]
console.log (str2.match (// d+/g)); // ["1", "2", "3"]
substituir()
O método substituir () é usado para substituir alguns caracteres em uma string ou para substituir uma substring que corresponda à expressão regular.
stringObject.Replace (regexp/substrato, substituição)
O parâmetro regexp/substr é necessário. Objeto regexp que especifica a substring ou o padrão a ser substituído. Se o valor for uma string, ele será usado como o padrão de texto de quantidade direta a ser recuperado em vez de ser convertido em um objeto regexp primeiro. A substituição de parâmetros é necessária. é um valor de string. Especifica uma função que substitui o texto ou gera um texto de substituição.
O método retorna uma nova string, obtida após a substituição da primeira partida ou todas as correspondências do Regexp pela substituição.
O método substituído () do StringObject executa uma operação de pesquisa e substituição. Ele procurará substâncias correspondentes ao regexp no StringObject e substituirá essas substituras pela substituição. Se o regexp tiver o sinalizador global G, o método substituir () substituir todas as substringas correspondentes. Caso contrário, ele apenas substitui a primeira substring correspondente.
A substituição pode ser uma string ou uma função. Se for uma string, cada correspondência será substituída pela string. Mas o personagem $ em substituição tem um significado específico. Como mostrado abaixo, afirma que a sequência obtida da correspondência de padrões será usada para substituição:
1. $$ $
2. $ ` - texto à esquerda da substring correspondente.
3. $ ' - texto à direita da substring correspondente.
4. $ & - Substring correspondente a regexp.
5. $ Número - texto que corresponde à subexpressão número em regexp.
A substituição pode ser uma função; nesse caso, cada correspondência chama a função e a string retornada será usada como texto de substituição. O primeiro argumento dessa função é uma string que corresponde ao padrão. Os seguintes parâmetros são strings que correspondem à subexpressão no padrão e pode haver 0 ou mais desses parâmetros. O argumento a seguir é um número inteiro declarando onde a correspondência aparece no StringObject. O último parâmetro é o próprio StringObject.
A cópia do código é a seguinte:
// substitua uma vez
var str = "Olá, Microsoft!";
console.log (str.replace (/Microsoft/, "Google")); // Olá, Google!
console.log (str); // Olá, Microsoft!
// Substitua várias vezes
var str2 = "Olá Microsoft! E Microsoft! E Microsoft! ou Microsoft!";
console.log (str2.replace (/microsoft/g, "google")); // Olá, Google! E Google! E Google! ou Google!
// conversão de caracteres
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'
// Use funções
var str5 = 'aaa bbb ccc';
console.log (str5.replace (// b/w+/b/g, function (word) {
retornar word.substring (0,1) .touppercase ()+word.substring (1);}
)); // AAA BBB CCC
procurar()
O método Search () é usado para recuperar a substring especificada em uma string ou para recuperar a substring que corresponde a uma expressão regular.
StringObject.search (regexp)
O parâmetro regexp pode ser uma substring que precisa ser recuperada no StringObject, ou um objeto regexp que precisa ser recuperado.
Retorna a posição inicial da primeira substring no StringObject que corresponde ao regexp. Se nenhuma substring correspondente for encontrada, -1 será retornado.
Nota: O método Search () não executa a correspondência global, ele ignorará o sinalizador g. Ele também ignora a propriedade LastIndex do REGEXP e é sempre recuperado desde o início da string, o que significa que ela sempre retorna a primeira posição correspondente do StringObject.
A cópia do código é a seguinte:
var str = "Olá, Microsoft!";
console.log (str.search (/microsoft/)); // 6
Se você deseja apenas saber se existe uma string correspondente, o uso de pesquisa () é o mesmo que usar o método test (). Se você deseja mais informações, pode usar os métodos MAKE () e EXEC (), mas a eficiência será ineficiente.
fatiar()
O método slice () extrai uma parte da string e retorna a parte extraída como uma nova string.
stringObject.slice (start, fim)
O início do parâmetro é o subscrito inicial do fragmento a ser extraído. Se for um número negativo, o parâmetro especifica a posição calculada a partir do final da sequência. Ou seja, -1 refere -se ao último personagem da corda, -2 refere -se ao segundo ao último personagem, e assim por diante.
A extremidade do parâmetro é o subscrito no final do fragmento a ser extraído imediatamente. Se este parâmetro não for especificado, a substring a ser extraída incluirá uma string do início ao final da string original. Se o parâmetro for um número negativo, ele especifica a posição a partir do final da string.
O método retorna uma nova string. Inclui todos os caracteres da String StringObject Starting (incluindo Start) a End End (excluindo a extremidade).
Nota: Os métodos Slice (), Substring () e Substr () do objeto String podem retornar a parte especificada da sequência. É altamente recomendável usar o método Slice () em todas as ocasiões.
A cópia do código é a seguinte:
var str = "Olá, Microsoft!";
console.log (str.slice (6)); // Microsoft!
console.log (str.slice (6, 12)); // micros
Substring ()
Não é recomendável usar e é recomendável usar o slice ().
substr ()
Não é recomendável usar e é recomendável usar o slice ().
TolocalelowerCase ()
Não é recomendável usar, é útil apenas em alguns idiomas, como turco. Recomenda -se usar tolowercase ().
Tolocaleupcase ()
Não é recomendável usar, é útil apenas em alguns idiomas, como turco. Recomenda -se usar o ToupperCase ().
tolowerCase ()
O método TolowerCase () é usado para converter uma string em minúsculas.
toupppercase ()
O método ToupPercase () é usado para converter uma sequência em maiúsculas.
Existem muitos métodos para tags html para objetos de string: anchor (), big (), pisca (), negro (), fixo (), fontcolor (), fontsize (), itálico (), link (), pequeno (), greve (), sub () e sup (). Eles usam principalmente a formatação HTML de objetos de string, que poucas pessoas aplicaram e não são recomendadas.
Exemplo de demonstração do método:
A cópia do código é a seguinte:
<html>
<Body>
<script type = "text/javascript">
var txt = "Hello World!"
document.write ("<p> grande:" + txt.big () + "</p>")
document.write ("<p> pequeno:" + txt.small () + "</p>")
document.write ("<p> BOLD:" + txt.bold () + "</p>")
document.write ("<p> itálico:" + txt.italics () + "</p>")
Document.Write ("<p> Blink:" + txt.blink () + "(não funciona no IE) </p>")
document.write ("<p> corrigido:" + txt.fixed () + "</p>")
document.write ("<p> greve:" + txt.strike () + "</p>")
document.write ("<p> fontcolor:" + txt.fontcolor ("vermelho") + "</p>")
document.write ("<p> fontsize:" + txt.fontsize (16) + "</p>")
document.write ("<p> minúsculo:" + txt.tolowercase () + "</p>")
Document.Write ("<p> maiúsculas:" + txt.TOUPPERCASE () + "</p>")
document.write ("<p> Subscrito:" + txt.sub () + "</p>")
document.write ("<p> supscript:" + txt.sup () + "</p>")
document.write ("<p> link:" + txt.link ("http://www.w3school.com.cn") + "</p>")
</script>
</body>
</html>