String

Em Elixir, uma string é uma sequência de caracteres delimitada por aspas duplas (" ") ou aspas simples (' ').

Vamos a um exemplo.

test/my_name_test.exs
defmodule MyNameTest do
  use ExUnit.Case
  
  test "Write my name with the double quote" do
    my_name = "Iago"
    
    assert my_name == "Iago"
  end
end

Criamos uma string no exemplo anterior, utilizando aspas duplas e esperamos que ela seja igual ao texto "Iago" também com aspas duplas. Vamos rodar esse teste:

mix test test/my_name_test.exs
.
Finished in 0.01 seconds (0.00s async, 0.01s sync)
1 test, 0 failures

Tudo funcionando. Comentei mais acima que também podemos criar strings utilizando aspas simples (' '). Vamos dar uma olhada nisso:

test/my_name_test.exs
defmodule MyNameTest do
  use ExUnit.Case
  
  test "Write my name with the single quote" do
    my_name = 'Iago'
    
    assert my_name == 'Iago'
  end
end

Se rodarmos o teste, ele passará.

mix test test/my_name_test.exs
..
Finished in 0.01 seconds (0.00s async, 0.01s sync)
2 tests, 0 failures

Tudo perfeito até então. Vamos agora comparar um texto com aspas simples com um texto de aspas duplas e ver o que acontece.

test/my_name_test.exs
defmodule MyNameTest do
  use ExUnit.Case

  # ...

  test "Write my name with the single quote and compare with double quotes" do
    my_name = 'Iago'

    assert my_name == "Iago"
  end
end

mix test test/my_name_test.exs


  1) test Write my name with the single quote and compare with double quotes (MyNameTest)
     test/my_name_test.exs:16
     Assertion with == failed
     code:  assert my_name == "Iago"
     left:  'Iago'
     right: "Iago"
     stacktrace:
       test/my_name_test.exs:19: (test)

..
Finished in 0.02 seconds (0.00s async, 0.02s sync)
3 tests, 1 failure

A há! Te pegamos. Mesmo os dois sendo considerados textos, o tipo retornado é diferente.

  • Quando utilizamos aspas duplas (" ") o tipo retornado é um binário.

  • Enquanto que quando utilizado aspas simples (' ') temos um charlist

Vamos alterar o teste para garantir que string com aspas simples é diferente de aspas duplas:

test/my_name_test.exs
defmodule MyNameTest do
  use ExUnit.Case

  # ...

  test "Write my name with the single quote and compare with double quotes" do
    my_name = 'Iago'

    assert my_name != "Iago"
  end
end

Apenas alteramos a linha 9. Se rodarmos os testes, teremos mensagem de sucesso.

mix test test/my_name_test.exs
...
Finished in 0.02 seconds (0.00s async, 0.02s sync)
3 tests, 0 failures

Agora vamor provar que os tipos retornados são diferentes. Começando com aspas duplas. Vamos alterar o primeiro teste:

test/my_name_test.exs
defmodule MyNameTest do
  use ExUnit.Case
  
  test "Write my name with the double quote" do
    my_name = "Iago"
    
    assert my_name == "Iago"
    
    assert is_binary(my_name) == true
    assert is_list(my_name) == false
  end
end

Adicionamos as validações is_binary/1 onde esperamos que seja verdadeira e is_list/1 onde esperamos que seja falso. Vamos rodar esse teste:

mix test test/my_name_test.exs
...
Finished in 0.02 seconds (0.00s async, 0.02s sync)
3 tests, 0 failures

Agora validaremos a string com aspas simples onde esperamos retornar um charlist. Em geral o charlist é uma lista. Então utilizaremos a função is_list/1.

defmodule MyNameTest do
  use ExUnit.Case

  # ...

  test "Write my name with the single quote" do
    my_name = 'Iago'

    assert my_name == 'Iago'
    
    assert is_binary(my_name) == false
    assert is_list(my_name) == true
  end

  # ...
end

mix test test/my_name_test.exs
...
Finished in 0.02 seconds (0.00s async, 0.02s sync)
3 tests, 0 failures

Isso se comprova verdadeiro.

  • Aspas duplas -> Retorna o tipo de dado binário

  • Aspas simples -> Retorna o tipo de dado lista

Isso acontece porque as aspas simples (' ') são usadas para representar uma lista de caracteres individuais. Cada elemento da lista é um caractere Unicode de 1 byte, portanto, uma lista de caracteres pode ser vista como uma sequência de inteiros, onde cada inteiro representa um caractere.

Por outro lado, as aspas duplas (" ") são usadas para criar uma string. Em Elixir, uma string é uma sequência de bytes, e cada caractere Unicode pode ser representado por vários bytes.

Escolhendo um tipo de retorno

A escolha entre o uso de charlists ou strings em Elixir dependerá do contexto em que estamos trabalhando e das necessidades específicas do problema em questão. Aqui estão algumas diretrizes gerais que podem ajudar na escolha:

Use strings quando:

  • A eficiência na manipulação de strings é importante e a concatenação não é um problema (por exemplo, quando as strings são pequenas e/ou há poucas concatenações);

  • Você está trabalhando com operações que requerem o uso de funções de string específicas em Elixir, como String.length/1, String.split/2, String.downcase/1, entre outras;

  • A interoperabilidade com outras linguagens não é um problema e o código está sendo escrito exclusivamente em Elixir.

Use charlists quando:

  • A eficiência na concatenação de strings é importante e há muitas concatenações envolvidas;

  • Você está trabalhando com código que usa charlists (por exemplo, se estiver interagindo com código escrito em Erlang);

  • Você está trabalhando com caracteres Unicode complexos que requerem mais de um byte para serem codificados;

  • Você precisa manipular listas de caracteres usando funções de lista em Elixir.

Conclusão

Em resumo, charlists são mais adequadas para situações em que a eficiência na concatenação é importante e para lidar com caracteres Unicode complexos, enquanto strings são mais adequadas para operações gerais de manipulação de strings e interoperabilidade com outras linguagens.

PreviousTiposNextInteger

Last updated