Cordas F#

As cadeias de caracteres F# são representadas como matrizes de caracteres Unicode e o F# vem com um conjunto muito rico de funções que permitem trabalhar com cadeias de caracteres, como concatenação , extração de subcadeia de caracteres , correspondência de expressão regular e muito mais.

O F# inclui vários recursos úteis, como correspondência de padrões e inferência de tipo, que tornam fácil e eficiente trabalhar com strings F#.

Este artigo apresentará alguns dos recursos de manipulação de cadeia de caracteres do F# , incluindo suporte a Unicode, concatenação de cadeia de caracteres, formatação de cadeia de caracteres, análise e expressões regulares correspondentes para corresponder aos padrões.



F# String Literais

Literais em forma de string são delimitados por aspas  para indicar que são strings.

Vários caracteres especiais são usados ​​para fins específicos, como novas linhas, tabulações, etc.

Usando o caractere barra invertida \  , eles são codificados. Barras invertidas são usadas como parte da sequência de escape, junto com seu caractere relacionado.

Abaixo está uma tabela de sequências de escape do F#.

Personagens sequências de escape
Backspace \b
Nova linha \n
Retorno de carro \r
Aba \t
Barra invertida \\
Aspa \”
Apóstrofo \'
caractere Unicode \uXXXX ou \UXXXXXXXX (onde X indica um dígito hexadecimal)

Ignorar sequência de escape

Os compiladores podem ignorar sequências de escape de duas maneiras diferentes, conforme mostrado abaixo:

  • Usando o símbolo @ .
  • Coloque uma aspa tripla  “' ao redor da string.

O símbolo @ precede uma string literal, que é chamada de string literal. Dessa forma, todas as sequências de escape na string são ignoradas, com exceção de duas aspas sendo interpretadas como uma única aspa.

Sempre que uma string é colocada entre aspas triplas, todas as sequências de escape, incluindo as aspas duplas, são ignoradas, o que significa que todas as sequências de escape são ignoradas.

Exemplo

Usando o exemplo a seguir, demonstraremos como usar essa técnica ao lidar com estruturas contendo aspas embutidas em XML ou outras linguagens:

Example: 

1
2
3
4
5
let data = @"<user firstname = ""Jennifer"" lastname = ""Anniston"">"
printfn "%s" data
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

A saída do exemplo a seguir pode ser vista da seguinte forma:

<user firstname = "Jennifer" lastname = "Anniston">

Operadores de strings F#

Strings são as sequências de caracteres que compõem um programa.

Existem muitos operadores básicos em strings que podem ser usados ​​para manipular strings em linguagens de programação.

Entre os operadores básicos mais comuns que podem ser usados ​​em strings estão os seguintes:

Valor Visão geral
coletar : (char → string) → string → string O propósito desta função é criar uma string cujos caracteres são o resultado da anexação de uma função especificada aos caracteres na string de entrada e produzir uma nova string. Uma string concatenada é criada como resultado.
concat : string → seq<string> → string Ao concatenar as strings com um separador, esse método retorna uma nova string que contém todas essas strings combinadas.
existe: (char → bool) → string → bool A função determina se algum caractere na string atende ao predicado fornecido pelo usuário.
forall : (char → bool) → string → bool Esta função determina se todos os caracteres na string satisfazem o predicado fornecido na string de entrada.
init: int → (int → string) → string Este método criará uma nova string que conterá caracteres criados aplicando uma função predefinida a cada índice e concatenando as strings resultantes para formar a nova string.
iter : (char → unidade) → string → unidade Cada caractere na string será aplicado com a função especificada.
iteri : (int → char → unidade) → string → unidade Essa função pode ser aplicada a cada índice de um caractere em uma string, bem como ao próprio caractere de acordo com uma especificação.
iteri : (int → char → unidade) → string → unidade O comprimento de uma string é retornado por este método.
map : (char → char) → string → string Nesta função, a string de entrada é convertida em uma nova string com caracteres cujos valores são determinados com base na aplicação de uma função especificada para cada valor dentro da string.
mapi : (int → char → char) → string → string Nesse método, os caracteres na string de entrada são substituídos pelos resultados da aplicação de uma função especificada a cada um dos caracteres e índices dentro da string de entrada para produzir uma nova string.
replicar: int → string → string Uma instância de uma string é concatenada com o número especificado de instâncias de outra string para retornar uma string.

Aqui estão alguns exemplos de como algumas das funcionalidades acima podem ser usadas nos seguintes cenários:

F# String.collect

String.collect é usado para criar uma string a partir da string de caracteres de entrada, aplicando uma função especificada a todos os caracteres dessa string para criar uma nova string cujos caracteres resultam da aplicação dessa função. Como resultado disso, uma string foi concatenada.

Example: 

1
2
3
4
5
let stringCollect inputString =
String.collect (fun c -> sprintf "%c – " c) inputString
printfn "%s" (stringCollect "mrexamples")
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

A seguir está a saída que você receberá depois de ter compilado e executado o programa:

Exemplos de Operadores de Strings F#


F# String.concat

Usando String.concat, você pode concatenar uma sequência de strings com um separador e retornar uma nova string depois de concatenar as strings.

Example: 

1
2
3
4
5
6
7
let firstName = "Michael"
let lastName = "Jordan"
let fullName = String.concat " " [firstName; lastName]
printfn "Hello %s!" fullName
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

A saída do exemplo mencionado acima é:

Exemplos de concatenação de string F#


F# String.exists

Para determinar se existe uma substring em uma determinada string, podemos usar a função String.exists .

Example: 

1
2
3
4
5
6
7
8
9
let message = "mrexamples is a great platform to learn programming"
let mrexamples= String.exists (fun c -> c = 'm') message
if mrexamples then
printfn "The message contains the substring 'mrexamples'."
else
printfn "The message does not contain the substring 'mrexamples'."
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Como 'mrexamples' é colocado na instrução, a saída será:

A mensagem contém a substring ' mrexamples '.

F# String.forall

Usando String.forall , você pode testar se uma condição é válida para todos os caracteres da string fornecida.

Example: 

1
2
3
4
5
6
7
8
9
10
let message = "MREXAMPLES"
let allUpperCase = String.forall (fun c -> System.Char.ToUpper c) message
if allUpperCase then
printfn "All characters in the message are uppercase."
else
printfn "The message contains lowercase characters."
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

'MREXAMPLES' está em letras maiúsculas, portanto a saída será a seguinte:

All characters in the message are uppercase.

F# String.init

Usando String.init, você pode construir uma nova string e aplicar uma função a cada índice para gerar uma nova string.

Example: 

1
2
3
4
5
6
7
let message = "mrexamples"
let reversed = String.init message.Length (fun i -> sprintf " %c " message.[message.Lengthi1])
printfn "Reversed message: %s" reversed
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
Usando a função String.init, invertemos a string que resulta da seguinte forma:
Exemplos de inicialização de string F#

F# String.iter

Se uma string contém uma série de caracteres, podemos usar String.iter para executar uma ação específica em cada um.

Example: 

1
2
3
4
5
let message = "mrexamples"
String.iter (fun c -> printfn "%c " c) message
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

A seguir está a saída do exemplo acima para imprimir todos os caracteres da string:

m
r
e
x
a
m
p
l
e
s

F# String.iteri

Um String.iteri pode ser usado para iterar cada caractere em uma string, bem como seu índice dentro da string.

Example: 

1
2
3
4
5
let message = "mrexamples"
String.iteri (fun i c -> printfn "Char %d is '%c'" i c) message
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Aqui está um exemplo que imprime tanto o caractere que está sendo exibido quanto sua posição dentro da string:

Char 0 is 'm'
Char 1 is 'r'
Char 2 is 'e'
Char 3 is 'x'
Char 4 is 'a'
Char 5 is 'm'
Char 6 is 'p'
Char 7 is 'l'
Char 8 is 'e'
Char 9 is 's'

F# String.length

O comprimento de uma string pode ser determinado usando String.length , que retorna um número inteiro de todos os caracteres em uma string.

Example: 

1
2
3
4
5
let message = "mrexamples"
let length = message.Length
printfn "The lenght of the message is: %d" length
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

O exemplo acima imprime o comprimento da mensagem com a ajuda da função length:

The lenght of the message is: 10

F# String.map

Usando String.map , é possível aplicar uma determinada função a cada caractere de uma string para criar uma nova string com os caracteres transformados em vez de apenas retornar as strings originais.

Example: 

1
2
3
4
5
6
7
8
let message = "mrexamples!"
let reversed = String.map (fun c -> if c = ',' then c else message.[message.Length1message.IndexOf(c)]) message
printfn "Original message: %s" message
printfn "Reversed message: %s" reversed
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Abaixo está um exemplo da função map() para mapear caracteres de string e transformá-los em vez de retornar as strings originais.

Original message: mrexamples!
Reversed message: !selp!axerm

F# String.mapi

Usando String.mapi , você pode mapear um caractere de uma string para um único valor, com base no índice do caractere na string.

Example: 

1
2
3
4
5
6
7
let message = "mrexamples"
let modifiedMessage = String.mapi (fun i c -> if i % 2 = 0 then System.Char.ToUpper c else c) message
printfn "Original message: %s" message
printfn "Modified message: %s" modifiedMessage
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

No exemplo acima, a mensagem será transformada com caracteres maiúsculos em cada índice par:

Original message: mrexamples
Modified message: MrExAmPlEs

F# String.replicate

O método String.replicate pode ser usado para criar uma nova string consistindo em caracteres repetidos ou strings com um número especificado de repetições.

Example: 

1
2
3
4
5
let s = String.replicate 5 "s"
printfn "mrexample%s" s
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

O exemplo a seguir gera a replicação de 's' no final da string

mrexamplesssss

Exemplo de Explicação

Este código F# cria uma nova string s usando a função String.replicate para repetir a string “ s ” cinco vezes.

Em seguida, ele imprime uma string formatada usando printfn que inclui a string s concatenada ao final de mrexample .

Aqui está uma explicação passo a passo do que acontece:

  1. String.replicate 5 s cria uma nova string repetindo a string “s” cinco vezes, resultando na string sssss .
  2. let s = String.replicate 5 s vincula a nova string à variável s .
  3. printfn “ mrexample%ss imprime uma string formatada no console, onde %s é um espaço reservado para a string s. A string s é então concatenada ao final de mrexample  para produzir a saída final: mrexamplesssss .'
Nós valorizamos o seu feedback.
+1
0
+1
0
+1
0
+1
0
+1
0
+1
0
+1
0

Assine a nossa newsletter
Digite seu e-mail para receber um resumo semanal de nossos melhores posts. Saber mais!
ícone