Erlang Language
Types de données

Remarques

Nombres

Dans Erlang, les nombres sont soit des entiers, soit des flottants. Erlang utilise une précision arbitraire pour les entiers (bignums), donc leurs valeurs ne sont limitées que par la taille de la mémoire de votre système.

1> 11.
11
2> -44.
-44
3> 0.1.
0.1
4> 5.1e-3.
0.0051
5> 5.2e2.
520.0

Les numéros peuvent être utilisés dans différentes bases:

1> 2#101.
5
2> 16#ffff.
65535

La notation $ -prefix donne la valeur entière de n'importe quel caractère ASCII / Unicode:

3> $a.
97
4> $A.
65
5> $2.
50
6> $🤖.
129302

Les atomes

Un atome est un objet avec un nom identifié uniquement par le nom lui-même.

Les atomes sont définis dans Erlang en utilisant des littéraux atomiques qui sont soit

• une chaîne non cotée qui commence par une lettre minuscule et ne contient que des lettres, des chiffres, des traits de soulignement ou le caractère @ , ou
• Une seule chaîne citée

Exemples

1> hello.
hello

2> hello_world.
hello_world

3> world_Hello@.
world_Hello@

4> '1234'.     
'1234'

5> '!@#$%% ä'.
'!@#$%% ä'

Atomes utilisés dans la plupart des programmes Erlang

Certains atomes apparaissent dans presque tous les programmes Erlang, notamment en raison de leur utilisation dans la bibliothèque standard.

• true et false sont utilisés pour désigner les valeurs booléennes respectives
• ok est généralement utilisé comme valeur de retour d'une fonction appelée uniquement pour son effet, ou dans le cadre d'une valeur de retour, dans les deux cas pour indiquer une exécution réussie
• De la même manière, une error est utilisée pour indiquer une condition d'erreur qui ne justifie pas un retour rapide des fonctions supérieures.
• undefined est généralement utilisé comme espace réservé pour une valeur non spécifiée

Utiliser comme balises

ok et error sont assez souvent utilisés dans le cadre d'un tuple, dans lequel le premier élément du tuple signale le succès alors que d'autres éléments contiennent la valeur de retour ou la condition d'erreur:

func(Input) ->
    case Input of
        magic_value ->
            {ok, got_it};
        _ ->
            {error, wrong_one}
    end.

{ok, _} = func(SomeValue).

Espace de rangement

Une chose à garder à l'esprit lors de l'utilisation des atomes est qu'ils sont stockés dans leur propre table globale en mémoire et que cette table n'est pas nettoyée, donc la création dynamique d'atomes, en particulier lorsqu'un utilisateur peut influencer le nom de l'atome est fortement déconseillée.

Binaires et Bitstrings

Un binaire est une séquence d'octets de 8 bits non signés.

1> <<1,2,3,255>>.
<<1,2,3,255>>
2> <<256,257,258>>.
<<0,1,2>>
3> <<"hello","world">>.
<<"helloworld">>

Une chaîne de bits est un binaire généralisé dont la longueur en bits n'est pas nécessairement un multiple de 8.

1> <<1:1, 0:2, 1:1>>.
<<9:4>> % 4 bits bitstring

Tuples

Un tuple est une séquence ordonnée de longueur fixe d'autres termes Erlang. Chaque élément du tuple peut être n'importe quel type de terme (n'importe quel type de données).

1> {1, 2, 3}.
{1,2,3}
2> {one, two, three}.
{one,two,three}
3> {mix, atom, 123, {<<1,2>>, [list]}}.
{mix,atom,123,{<<1,2>>,[list]}}

Des listes

Une liste dans Erlang est une séquence de zéro ou plus de termes Erlang, mis en œuvre sous la forme d'une liste liée par un seul élément. Chaque élément de la liste peut être n'importe quel type de terme (n'importe quel type de données).

1> [1,2,3].
[1,2,3]
2> [wow,1,{a,b}].     
[wow,1,{a,b}]

La tête de la liste est le premier élément de la liste.

La queue de la liste est le reste de la liste (sans la tête). C'est aussi une liste.
Vous pouvez utiliser hd/1 et tl/1 ou correspondre à [H|T] pour obtenir la tête et la queue de la liste.

3> hd([1,2,3]).
1
4> tl([1,2,3]).
[2,3]
5> [H|T] = [1,2,3].
[1,2,3]
6> H.
1
7> T.
[2,3]

Ajouter un élément à une liste

8> [new | [1,2,3]].
[new,1,2,3]

Listes concaténantes

9> [concat,this] ++ [to,this].
[concat,this,to,this]

Cordes

Dans Erlang, les chaînes de caractères ne sont pas un type de données distinct: elles ne sont que des listes d'entiers représentant des points de code ASCII ou Unicode:

> [97,98,99].
"abc"
> [97,98,99] =:= "abc".
true
> hd("ABC").
65

Lorsque le shell Erlang va imprimer une liste, il essaie de deviner si vous voulez vraiment dire qu’il s’agit d’une chaîne. Vous pouvez désactiver ce comportement en appelant shell:strings(false) :

> [8].
"\b"
> shell:strings(false).
true
> [8].
[8]

Dans l'exemple ci-dessus, l'entier 8 est interprété comme le caractère de contrôle ASCII pour le retour arrière, que le shell considère comme un caractère "valide" dans une chaîne.

Identificateurs de processus (Pid)

Chaque processus dans erlang a un identifiant de processus ( Pid ) dans ce format <xxx> , x étant un nombre naturel. Voici un exemple de Pid

<0.1252.0>

Pid peut être utilisé pour envoyer des messages au processus en utilisant "bang" ( ! ), Pid peut être limité à une variable

MyProcessId = self().
MyProcessId ! {"Say Hello"}.

En savoir plus sur la création de processus et plus généralement sur les processus dans erlang

Funs

Erlang est un langage de programmation fonctionnel. L'une des fonctionnalités d'un langage de programmation de fonctions est la gestion des fonctions sous forme de données (objets fonctionnels).

• Passer une fonction en argument à une autre fonction.
• Fonction de retour résultant d'une fonction.
• Fonctions de maintien dans certaines structures de données.

Dans Erlang, ces fonctions sont appelées funs. Les funs sont des fonctions anonymes.

1> Fun = fun(X) -> X*X end.
#Fun<erl_eval.6.52032458>
2> Fun(5).
25

Les Funs peuvent aussi avoir plusieurs clauses.

3> AddOrMult = fun(add,X) -> X+X;
3>                (mul,X) -> X*X 
3> end.
#Fun<erl_eval.12.52032458>
4> AddOrMult(mul,5).
25
5> AddOrMult(add,5).
10

Vous pouvez également utiliser les fonctions du module comme des fonctions fun Module:Function/Arity avec la syntaxe suivante: fun Module:Function/Arity .
Par exemple, prenons la fonction max partir du module de lists , qui a l’arité 1.

6> Max = fun lists:max/1.
#Fun<lists.max.1>
7> Max([1,3,5,9,2]). 
9

Plans

Une carte est un tableau ou un dictionnaire associatif composé de paires (clé, valeur).

1> M0 = #{}.
#{}
2> M1 = #{ "name" => "john", "age" => "28" }.
#{"age" => "28","name" => "john"}
3> M2 = #{ a => {M0, M1} }.
#{a => {#{},#{"age" => "28","name" => "john"}}}

Pour mettre à jour une carte:

1> M = #{ 1 => x }.
2> M#{ 1 => c }.
#{1 => c}
3> M.
#{1 => x}

Ne mettez à jour que certaines clés existantes:

1> M = #{ 1 => a, 2 => b}.
2> M#{ 1 := c, 2:= d }.
#{1 => c,2 => d}
3> M#{ 3 := c }.
** exception error: {badkey,3}

Correspondance de motif:

1> M = #{ name => "john", age => 28 }.
2> #{ name := Name, age := Age } = M.
3> Name.
"john"
4> Age.
28

Bit Syntax: Defaults

Clarification du document Erlang sur la syntaxe des bits:

4.4 Valeurs par défaut

[Début omis: << 3.14 >> n'est même pas une syntaxe légale.]

La taille par défaut dépend du type. Pour entier, il est de 8. Pour float, il est de 64. Pour binaire, c'est la taille réelle du binaire spécifié:

    1> Bin = << 17/integer, 3.2/float, <<97, 98, 99>>/binary >>. 
    <<17,64,9,153,153,153,153,153,154,97,98,99>>
      ^ |<-------------------------->|<------>|
      |            float=64           binary=24
  integer=8


    2> size(Bin). % Returns the number of bytes:
    12            % 8 bits + 64 bits + 3*8 bits = 96 bits => 96/8 = 12 bytes

Lors de la mise en correspondance, un segment binaire sans Taille est uniquement autorisé à la fin du modèle, et la Taille par défaut correspond au reste du fichier binaire sur le côté droit de la correspondance:

25> Bin = <<97, 98, 99>>. 
<<"abc">>

26> << X/integer, Rest/binary >> = Bin. 
<<"abc">>

27> X. 
97

28> Rest. 
<<"bc">>

Tous les autres segments avec un type binaire dans un modèle doivent spécifier une taille:

12> Bin = <<97, 98, 99, 100>>.         
<<"abcd">>

13> << B:1/binary, X/integer, Rest/binary >> = Bin. %'unit' defaults to 8 for  
<<"abcd">>                    %binary type, total segment size is Size * unit  

14> B.
<<"a">>

15> X.
98

16> Rest.
<<"cd">>

17> << B2/binary, X2/integer, Rest2/binary >> = Bin. 
* 1: a binary field without size is only allowed at the end of a binary pattern