Respostas:
Verifique Integer.parse/1
e Float.parse/1
.
Integer.parse/1
mais String.to_integer/1
?
Integer.parse/1
retorna um :error
átomo se malsucedido. String.to_integer/1
joga um (FunctionClauseError)
.
Além das funções Integer.parse/1
e Float.parse/1
que José sugeriu, você também pode verificar String.to_integer/1
e String.to_float/1
.
Dica: Veja também to_atom/1
, to_char_list/1
, to_existing_atom/1
para outras conversões.
Obrigado pessoal nesta página, apenas simplificando uma resposta aqui:
{intVal, ""} = Integer.parse(val)
uma vez que valida que toda a string foi analisada (não apenas um prefixo).
Existem 4 funções para criar um número a partir da string
String.to_integer
funciona bem, mas String.to_float
é mais difícil:
iex()> "1 2 3 10 100" |> String.split |> Enum.map(&String.to_integer/1)
[1, 2, 3, 10, 100]
iex()> "1.0 1 3 10 100" |> String.split |> Enum.map(&String.to_float/1)
** (ArgumentError) argument error
:erlang.binary_to_float("1")
(elixir) lib/enum.ex:1270: Enum."-map/2-lists^map/1-0-"/2
(elixir) lib/enum.ex:1270: Enum."-map/2-lists^map/1-0-"/2
Como String.to_float
só pode lidar com float bem formatado, por exemplo:, 1.0
não 1
(inteiro). Isso foi documentado no String.to_float
doc de
Retorna um float cuja representação de texto é string.
string deve ser a representação de string de um float incluindo um ponto decimal. Para analisar uma string sem ponto decimal como um float, Float.parse / 1 deve ser usado. Caso contrário, um ArgumentError será gerado.
Mas Float.parse
retorna uma tupla de 2 elementos, não o número que você deseja, então colocá-lo no pipeline não é "legal":
iex()> "1.0 1 3 10 100" |> String.split \
|> Enum.map(fn n -> {v, _} = Float.parse(n); v end)
[1.0, 1.0, 3.0, 10.0, 100.0]
Usar elem
para obter o primeiro elemento da tupla torna-o mais curto e mais doce:
iex()> "1.0 1 3 10 100" |> String.split \
|> Enum.map(fn n -> Float.parse(n) |> elem(0) end)
[1.0, 1.0, 3.0, 10.0, 100.0]
Você pode convertê-lo em um char_list e então usar o Erlang to_integer/1
ou to_float/1
.
Por exemplo
iex> {myInt, _} = :string.to_integer(to_char_list("23"))
{23, []}
iex> myInt
23
fn q -> {v, _} = Float.parse(q); v end
que eu não gosto. Eu gosto de usar Enum.map
, por exemplo, list |> Enum.map(&String.to_float/1)
mas string.to_float não funciona para números inteiros?
Decimal.new("1") |> Decimal.to_integer
Decimal.new("1.0") |> Decimal.to_float
O problema de usar Integer.parse/1
é que ele analisa qualquer parte não numérica da string, desde que esteja no final. Por exemplo:
Integer.parse("01") # {1, ""}
Integer.parse("01.2") # {1, ".2"}
Integer.parse("0-1") # {0, "-1"}
Integer.parse("-01") # {-1, ""}
Integer.parse("x-01") # :error
Integer.parse("0-1x") # {0, "-1x"}
Da mesma forma, String.to_integer/1
tem os seguintes resultados:
String.to_integer("01") # 1
String.to_integer("01.2") # ** (ArgumentError) argument error :erlang.binary_to_integer("01.2")
String.to_integer("0-1") # ** (ArgumentError) argument error :erlang.binary_to_integer("01.2")
String.to_integer("-01") # -1
String.to_integer("x-01") # ** (ArgumentError) argument error :erlang.binary_to_integer("01.2")
String.to_integer("0-1x") # ** (ArgumentError) argument error :erlang.binary_to_integer("01.2")
Em vez disso, valide a string primeiro.
re = Regex.compile!("^[+-]?[0-9]*\.?[0-9]*$")
Regex.match?(re, "01") # true
Regex.match?(re, "01.2") # true
Regex.match?(re, "0-1") # false
Regex.match?(re, "-01") # true
Regex.match?(re, "x-01") # false
Regex.match?(re, "0-1x") # false
A expressão regular pode ser mais simples (por exemplo ^[0-9]*$
), dependendo do seu caso de uso.
Se você quiser converter uma string para qualquer tipo numérico que esteja dentro da string e remover todos os outros caracteres, isso provavelmente é um exagero, mas retornará um float se for um float ou um int se for um int ou nil se a string não contiver um tipo numérico.
@spec string_to_numeric(binary()) :: float() | number() | nil
def string_to_numeric(val) when is_binary(val), do: _string_to_numeric(Regex.replace(~r{[^\d\.]}, val, ""))
defp _string_to_numeric(val) when is_binary(val), do: _string_to_numeric(Integer.parse(val), val)
defp _string_to_numeric(:error, _val), do: nil
defp _string_to_numeric({num, ""}, _val), do: num
defp _string_to_numeric({num, ".0"}, _val), do: num
defp _string_to_numeric({_num, _str}, val), do: elem(Float.parse(val), 0)
String.to_integer/1