% hello world program
-module(helloworld). 
-export([start/0]). 

start() -> 
   io:fwrite("Hello, world!\n").

Следующие вещи должны быть отмечены о вышеупомянутой программе —

• Знак% используется для добавления комментариев к программе.

• Оператор модуля похож на добавление пространства имен, как в любом языке программирования. Итак, здесь мы упоминаем, что этот код будет частью модуля с именем helloworld .

• Функция экспорта используется для того, чтобы можно было использовать любую функцию, определенную в программе. Мы определяем функцию с именем start, и чтобы использовать функцию start, мы должны использовать оператор экспорта. / 0 означает, что наша функция ‘start’ принимает 0 параметров.

• Мы наконец определим нашу начальную функцию. Здесь мы используем другой модуль с именем io, который имеет все необходимые функции ввода-вывода в Erlang. Мы использовали функцию fwrite для вывода «Hello World» на консоль.

Знак% используется для добавления комментариев к программе.

Оператор модуля похож на добавление пространства имен, как в любом языке программирования. Итак, здесь мы упоминаем, что этот код будет частью модуля с именем helloworld .

Функция экспорта используется для того, чтобы можно было использовать любую функцию, определенную в программе. Мы определяем функцию с именем start, и чтобы использовать функцию start, мы должны использовать оператор экспорта. / 0 означает, что наша функция ‘start’ принимает 0 параметров.

Мы наконец определим нашу начальную функцию. Здесь мы используем другой модуль с именем io, который имеет все необходимые функции ввода-вывода в Erlang. Мы использовали функцию fwrite для вывода «Hello World» на консоль.

Выход вышеупомянутой программы будет —

Выход

Hello, world!

Общая форма заявления

В Erlang вы видели, что в языке Erlang используются разные символы. Давайте пройдемся по тому, что мы видели в простой программе Hello World —

• Символ дефиса (-) обычно используется вместе с модулем, оператором импорта и экспорта. Символ дефиса используется для придания значения каждому утверждению соответственно. Так что примеры из программы Hello world показаны в следующей программе —

Символ дефиса (-) обычно используется вместе с модулем, оператором импорта и экспорта. Символ дефиса используется для придания значения каждому утверждению соответственно. Так что примеры из программы Hello world показаны в следующей программе —

-module(helloworld).
-export([start/0]).

Каждое утверждение ограничено символом точки (.) . Каждое утверждение в Erlang должно заканчиваться этим разделителем. Пример из программы Hello world, как показано в следующей программе —

io:fwrite("Hello, world!\n").

• Символ косой черты (/) используется вместе с функцией для определения количества параметров, которые принимаются функцией.

Символ косой черты (/) используется вместе с функцией для определения количества параметров, которые принимаются функцией.

-export([start/0]).

Модули

В Erlang весь код разделен на модули. Модуль состоит из последовательности атрибутов и объявлений функций. Это похоже на концепцию пространства имен в других языках программирования, которая используется для логического разделения различных блоков кода.

Определение модуля

Модуль определяется с помощью идентификатора модуля. Общий синтаксис и пример следующие.

Синтаксис

-module(ModuleName)

Имя модуля должно совпадать с именем файла минус расширение .erl . В противном случае загрузка кода не будет работать так, как задумано.

пример

-module(helloworld)

Эти модули будут подробно рассмотрены в следующих главах, это было только для того, чтобы дать вам общее представление о том, как должен быть определен модуль.

Импорт заявления в Эрланге

В Erlang, если кто-то хочет использовать функциональность существующего модуля Erlang, можно использовать оператор импорта. Общая форма заявления на импорт изображена в следующей программе —

пример

-import (modulename, [functionname/parameter]).

Куда,

• Modulename — это имя модуля, который необходимо импортировать.

• имя_функции / параметр — функция в модуле, которую необходимо импортировать.

Modulename — это имя модуля, который необходимо импортировать.

имя_функции / параметр — функция в модуле, которую необходимо импортировать.

Давайте изменим способ написания нашей программы hello world для использования оператора import. Пример будет таким, как показано в следующей программе.

пример

% hello world program
-module(helloworld).
-import(io,[fwrite/1]).
-export([start/0]).

start() ->
   fwrite("Hello, world!\n").

В приведенном выше коде мы используем ключевое слово import для импорта библиотеки ‘io’ и, в частности, функцию fwrite . Поэтому теперь, когда мы вызываем функцию fwrite, нам не нужно нигде упоминать имя модуля io .

Ключевые слова в Erlang

Ключевое слово — это зарезервированное слово в Erlang, которое не должно использоваться для каких-либо иных целей, кроме цели, для которой оно предназначено. Ниже приведен список ключевых слов в Erlang.

Комментарии в Erlang

Комментарии используются для документирования вашего кода. Однострочные комментарии идентифицируются с помощью символа % в любой позиции в строке. Ниже приведен пример для того же —

пример

% hello world program
-module(helloworld).
% import function used to import the io module
-import(io,[fwrite/1]).
% export function used to ensure the start function can be accessed.
-export([start/0]).

start() ->
   fwrite("Hello, world!\n").

Эрланг — Шелл

Оболочка Erlang используется для тестирования выражений. Следовательно, тестирование может быть выполнено в оболочке очень легко, прежде чем оно будет фактически протестировано в самом приложении.

В следующем примере показано, как выражение сложения можно использовать в оболочке. Здесь необходимо отметить, что выражение должно заканчиваться точкой (.).

После выполнения команды оболочка выводит еще одно приглашение, на этот раз для команды № 2 (поскольку номер команды увеличивается при каждом вводе новой команды).

Следующие функции являются наиболее распространенными в оболочке Erlang.

• b () — печатает текущие привязки переменных.

• Синтаксис — b ().

• Например — Ниже приведен пример использования функции. Сначала определяется переменная с именем Str , которая имеет значение abcd . Затем b () используется для отображения всех связанных переменных.

b () — печатает текущие привязки переменных.

Синтаксис — b ().

Например — Ниже приведен пример использования функции. Сначала определяется переменная с именем Str , которая имеет значение abcd . Затем b () используется для отображения всех связанных переменных.

• f () — Удаляет все текущие привязки переменных.

• Синтаксис — f ().

• Например — Ниже приведен пример использования функции. Сначала определяется переменная с именем Str, которая имеет значение abcd. Затем f () используется для удаления привязки переменной Str. Затем вызывается b (), чтобы убедиться, что привязка была успешно удалена.

f () — Удаляет все текущие привязки переменных.

Синтаксис — f ().

Например — Ниже приведен пример использования функции. Сначала определяется переменная с именем Str, которая имеет значение abcd. Затем f () используется для удаления привязки переменной Str. Затем вызывается b (), чтобы убедиться, что привязка была успешно удалена.

• f (x) — удаляет привязку для определенной переменной.

• Синтаксис — f (x). Где x — переменная, для которой необходимо удалить привязку.

• Например — Ниже приведен пример использования функции. Сначала определяются переменные с именами Str и Str1. Затем f (Str) используется для удаления привязки переменной Str. Затем вызывается b (), чтобы убедиться, что привязка была успешно удалена.

f (x) — удаляет привязку для определенной переменной.

Синтаксис — f (x). Где x — переменная, для которой необходимо удалить привязку.

Например — Ниже приведен пример использования функции. Сначала определяются переменные с именами Str и Str1. Затем f (Str) используется для удаления привязки переменной Str. Затем вызывается b (), чтобы убедиться, что привязка была успешно удалена.

• h () — печатает список истории всех команд, выполненных в оболочке.

• Синтаксис — h ().

• Например — Пример команды h (), которая печатает историю команд, выполненных в оболочке, показан на следующем снимке экрана.

h () — печатает список истории всех команд, выполненных в оболочке.

Синтаксис — h ().

Например — Пример команды h (), которая печатает историю команд, выполненных в оболочке, показан на следующем снимке экрана.

• history (N) — Устанавливает количество предыдущих команд для сохранения в списке истории равным N. Предыдущее число возвращается. Номер по умолчанию — 20.

• Синтаксис — история (N). Где N — номер, которым должен быть ограничен список истории команд.

• Например — Пример команды history (N) показан на следующем снимке экрана.

history (N) — Устанавливает количество предыдущих команд для сохранения в списке истории равным N. Предыдущее число возвращается. Номер по умолчанию — 20.

Синтаксис — история (N). Где N — номер, которым должен быть ограничен список истории команд.

Например — Пример команды history (N) показан на следующем снимке экрана.

• e (N) — повторяет команду N, если N положительно. Если оно отрицательное, N- ^я предыдущая команда повторяется (т. Е. E (-1) повторяет предыдущую команду).

• Синтаксис — e (N). Где N — команда на N- ^й позиции в списке.

• Например — Пример команды e (N) показан ниже. Поскольку мы выполнили команду e (-1), она выполнит предыдущую команду, которая была history (5).

e (N) — повторяет команду N, если N положительно. Если оно отрицательное, N- ^я предыдущая команда повторяется (т. Е. E (-1) повторяет предыдущую команду).

Синтаксис — e (N). Где N — команда на N- ^й позиции в списке.

Например — Пример команды e (N) показан ниже. Поскольку мы выполнили команду e (-1), она выполнит предыдущую команду, которая была history (5).

Эрланг — Типы данных

На любом языке программирования вам нужно использовать несколько переменных для хранения различных типов информации. Переменные — это не что иное, как зарезервированные области памяти для хранения значений. Это означает, что при создании переменной вы резервируете некоторое пространство в памяти для хранения значения, связанного с этой переменной.

Вам может потребоваться хранить информацию различных типов данных, таких как строка, символ, широкий символ, целое число, число с плавающей запятой, логическое значение и т. Д. На основе типа данных переменной операционная система выделяет память и решает, что можно сохранить в зарезервированном объем памяти.

Встроенные типы данных

Erlang предлагает широкий спектр встроенных типов данных. Ниже приведен список типов данных, которые определены в Erlang —

• Число — в Erlang есть 2 типа числовых литералов, которые являются целыми числами и числами с плавающей точкой.

• Атом — Атом — это литерал, константа с именем. Атом должен быть заключен в одинарные кавычки (‘), если он не начинается со строчной буквы или содержит другие символы, кроме буквенно-цифровых символов, подчеркивания (_) или @.

• Boolean — Булевы типы данных в Erlang — это два зарезервированных атома: true и false.

• Битовая строка — битовая строка используется для хранения области нетипизированной памяти.

• Кортеж — кортеж — это составной тип данных с фиксированным числом терминов. Каждый термин в кортеже называется элементом. Количество элементов называется размером кортежа.

• Карта — карта — это составной тип данных с переменным числом ассоциаций ключ-значение. Каждая ассоциация ключ-значение на карте называется парой ассоциации. Ключевые и значимые части пары называются элементами. Количество пар ассоциаций называется размером карты.

• Список — список — это составной тип данных с переменным количеством терминов. Каждый термин в списке называется элементом. Количество элементов называется длиной списка.

Число — в Erlang есть 2 типа числовых литералов, которые являются целыми числами и числами с плавающей точкой.

Атом — Атом — это литерал, константа с именем. Атом должен быть заключен в одинарные кавычки (‘), если он не начинается со строчной буквы или содержит другие символы, кроме буквенно-цифровых символов, подчеркивания (_) или @.

Boolean — Булевы типы данных в Erlang — это два зарезервированных атома: true и false.

Битовая строка — битовая строка используется для хранения области нетипизированной памяти.

Кортеж — кортеж — это составной тип данных с фиксированным числом терминов. Каждый термин в кортеже называется элементом. Количество элементов называется размером кортежа.

Карта — карта — это составной тип данных с переменным числом ассоциаций ключ-значение. Каждая ассоциация ключ-значение на карте называется парой ассоциации. Ключевые и значимые части пары называются элементами. Количество пар ассоциаций называется размером карты.

Список — список — это составной тип данных с переменным количеством терминов. Каждый термин в списке называется элементом. Количество элементов называется длиной списка.

Примечание. Вы будете удивлены тем, что нигде в списке выше не видите тип String. Это потому, что нет строкового типа данных, определенного исключительно в Erlang. Но мы увидим, как мы можем работать со строками в следующей главе.

Ниже приведены примеры использования каждого типа данных. Опять же, каждый тип данных будет подробно обсуждаться в следующих главах. Это просто для ознакомления с кратким описанием вышеупомянутых типов данных.

Число

Пример использования числового типа данных показан в следующей программе. Эта программа показывает сложение 2 целых чисел.

пример

Live Demo

-module(helloworld).
-export([start/0]).

start() ->
   io:fwrite("~w",[1+1]).

2

-module(helloworld).
-export([start/0]).

start() ->
   io:fwrite(atom1).

atom1

-module(helloworld).
-export([start/0]).

start() ->
   io:fwrite(2 =< 3).

true

-module(helloworld).
-export([start/0]).

start() ->
   Bin1 = <<10,20>>,
   X = binary_to_list(Bin1),
   io:fwrite("~w",[X]).

[10,20]

-module(helloworld). 
-export([start/0]). 

start() -> 
   P = {john,24,{june,25}} , 
   io:fwrite("~w",[tuple_size(P)]).

3

-module(helloworld). 
-export([start/0]). 

start() -> 
   M1 = #{name=>john,age=>25}, 
   io:fwrite("~w",[map_size(M1)]).

2

-module(helloworld). 
-export([start/0]). 

start() -> 
   L = [10,20,30] , 
   io:fwrite("~w",[length(L)]).

3

var-name = var-value

-module(helloworld). 
-export([start/0]). 

start() -> 
   X = 40, 
   Y = 50, 
   Result = X + Y, 
   io:fwrite("~w",[Result]).

90

-module(helloworld). 
-export([start/0]). 

start() -> 
   X = 40, 
   Y = 50, 
   result = X + Y, 
   io:fwrite("~w",[Result]).

helloworld.erl:8: variable 'Result' is unbound

-module(helloworld). 
-export([start/0]). 

start() -> 
   X = 40, 
   Y = 50, 
   X = 60, 
   io:fwrite("~w",[X]).

helloworld.erl:6: Warning: variable 'Y' is unused
helloworld.erl:7: Warning: no clause will ever match
helloworld.erl:7: Warning: the guard for this clause evaluates to 'false'

-module(helloworld). 
-export([start/0]). 

start() -> 
   X = 40.00, 
   Y = 50.00, 
   io:fwrite("~f~n",[X]), 
   io:fwrite("~e",[Y]).

40.000000
5.00000e+1

-module(helloworld). 
-export([while/1,while/2, start/0]). 

while(L) -> while(L,0). 
while([], Acc) -> Acc;

while([_|T], Acc) ->
   io:fwrite("~w~n",[Acc]), 
   while(T,Acc+1). 
   
   start() -> 
   X = [1,2,3,4], 
   while(X).

0
1
2
3

-module(helloworld). 
-export([for/2,start/0]). 

for(0,_) -> 
   []; 
   
   for(N,Term) when N > 0 -> 
   io:fwrite("Hello~n"), 
   [Term|for(N-1,Term)]. 
   
start() -> 
   for(5,1).

Hello
Hello
Hello
Hello
Hello

FunctionName(Pattern1… PatternN) ->
Body;

-module(helloworld). 
-export([add/2,start/0]). 

add(X,Y) -> 
   Z = X+Y, 
   io:fwrite("~w~n",[Z]). 
   
start() -> 
   add(5,6).

11

-module(helloworld). 
-export([start/0]). 

start() -> 
   Fn = fun() -> 
      io:fwrite("Anonymous Function") end, 
   Fn().

Anonymous Function

-module(helloworld). 
-export([add/2,add/3,start/0]). 

add(X,Y) -> 
   Z = X+Y, 
   io:fwrite("~w~n",[Z]). 
   
add(X,Y,Z) -> 
   A = X+Y+Z, 
   io:fwrite("~w~n",[A]). 
 
start() ->
   add(5,6), 
   add(5,6,6).

11
17

FunctionName(Pattern1… PatternN) [when GuardSeq1]->
Body;

-module(helloworld). 
-export([add/1,start/0]). 

add(X) when X>3 -> 
   io:fwrite("~w~n",[X]). 

start() -> 
   add(4).

4

-module(modulename)

-module(helloworld). 
-export([start/0]). 

start() -> 
   io:fwrite("Hello World").

Hello World

-Tag(Value)

-module(helloworld). 
-author("TutorialPoint"). 
-version("1.0"). 
-export([start/0]). 

start() -> 
   io:fwrite("Hello World").

Hello World

export([FunctionName1/FunctionArity1,.,FunctionNameN/FunctionArityN])

-module(helloworld). 
-author("TutorialPoint"). 
-version("1.0"). 
-export([start/0]). 

start() -> 
   io:fwrite("Hello World").

Hello World

-import (modulename , [functionname/parameter]).

-module(helloworld). 
-import(io,[fwrite/1]). 
-export([start/0]). 

start() -> 
   fwrite("Hello, world!\n").

Hello, world! 

-module(helloworld). 
-export([fac/1,start/0]). 

fac(N) when N == 0 -> 1; 
fac(N) when N > 0 -> N*fac(N-1). 

start() -> 
   X = fac(4), 
   io:fwrite("~w",[X]).

24

-module(helloworld). 
-export([len/1,start/0]). 

len([]) -> 0; 
len([_|T]) -> 1 + len(T). 

start() -> 
   X = [1,2,3,4], 
   Y = len(X), 
   io:fwrite("~w",[Y]).

4

len([]) -> 0; 
len([_|T]) -> 1 + len(T).

-module(helloworld).
-export([tail_len/1,tail_len/2,start/0]). 

tail_len(L) -> tail_len(L,0). 
tail_len([], Acc) -> Acc; 
tail_len([_|T], Acc) -> tail_len(T,Acc+1). 

start() -> 
   X = [1,2,3,4], 
   Y = tail_len(X), 
   io:fwrite("~w",[Y]).

4

-module(helloworld). 
-export([duplicate/2,start/0]). 

duplicate(0,_) -> 
   []; 
duplicate(N,Term) when N > 0 ->
   io:fwrite("~w,~n",[Term]),
   [Term|duplicate(N-1,Term)]. 
start() -> 
   duplicate(5,1).

1,
1,
1,
1,
1,

-module(helloworld). 
-export([tail_reverse/2,start/0]). 

tail_reverse(L) -> tail_reverse(L,[]).

tail_reverse([],Acc) -> Acc; 
tail_reverse([H|T],Acc) -> tail_reverse(T, [H|Acc]).

start() -> 
   X = [1,2,3,4], 
   Y = tail_reverse(X), 
   io:fwrite("~w",[Y]).

[4,3,2,1]

-module(helloworld). 
-export([start/0]). 

start() -> 
   io:fwrite("~w",[1+1]).

2

-module(helloworld).
-export([start/0]). 

start() -> 
   io:fwrite("~w",[1.1+1.2]).

2.3

-module(helloworld). 
-export([start/0]). 

start() -> 
   io:fwrite("~f~n",[1.1+1.2]), 
   io:fwrite("~e~n",[1.1+1.2]).

2.300000
2.30000e+0

-module(helloworld). 
-export([start/0]). 

start() ->
   Str1 = "This is a string", 
   io:fwrite("~p~n",[Str1]).

“This is a string”

left(str1,number,$character)

-module(helloworld). 
-import(string,[left/3]). 
-export([start/0]). 

start() -> 
   Str1 = "hello", 
   Str2 = left(Str1,10,$.), 
   io:fwrite("~p~n",[Str2]).

"hello....."

right(str1,number)

-module(helloworld). 
-import(string,[right/2]). 
-export([start/0]). 

start() -> 
   Str1 = "hello World", 
   Str2 = right(Str1,2), 
   io:fwrite("~p~n",[Str2]).

“ld”

right(str1,number,$character)

-module(helloworld). 
-import(string,[right/3]). 
-export([start/0]). 

start() -> 
   Str1 = "hello", 
   Str2 = right(Str1,10,$.), 
   io:fwrite("~p~n",[Str2]).

".....hello"

to_lower(str1)

-module(helloworld). 
-import(string,[to_lower/1]). 
-export([start/0]). 

start() -> 
   Str1 = "HELLO WORLD", 
   Str2 = to_lower(Str1), 
   io:fwrite("~p~n",[Str2]).

"hello world"

to_upper(str1)

-module(helloworld). 
-import(string,[to_upper/1]). 
-export([start/0]). 

start() -> 
   Str1 = "hello world", 
   Str2 = to_upper(Str1), 
   io:fwrite("~p~n",[Str2]).

"HELLO WORLD"

sub_string(str1,start,stop)

-module(helloworld). 
-import(string,[sub_string/3]). 
-export([start/0]). 

start() -> 
   Str1 = "hello world", 
   Str2 = sub_string(Str1,1,5), 
   io:fwrite("~p~n",[Str2]).

"hello"

-module(helloworld). 
-export([start/0]). 

start() -> 
   Lst1 = [1,2,3], 
   io:fwrite("~w~n",[Lst1]).

[1 2 3]

-module(helloworld). 
-export([start/0]). 

start() -> 
   {ok, File} = file:open("Newfile.txt",[read]),
   Txt = file:read(File,1024 * 1024), 
   io:fwrite("~p~n",[Txt]).

Example1

-module(helloworld). 
-export([start/0]). 

start() -> 
   io:fwrite(atom1), 
   io:fwrite("~n"), 
   io:fwrite(atom_1), 
   io:fwrite("~n"), 
   io:fwrite('atom 1'), 
   io:fwrite("~n").

atom1

atom_1

atom 1

-module(helloworld). 
-export([start/0]). 

start() -> 
   M1 = #{name=>john,age=>25}, 
   io:fwrite("~w",[map_size(M1)]).

2

-module(helloworld). 
-export([start/0]). 

start() ->
   P = {john,24,{june,25}} , 
   io:fwrite("~w",[tuple_size(P)]).

3

record(recordname , {Field1,Field2 ..Fieldn})

-module(helloworld). 
-export([start/0]). 
-record(person, {name = "", id}). 

start() -> 
   P = #person{name="John",id = 1}.

#recordname {fieldName1 = value1, fieldName2 = value2 .. fieldNameN = valueN}

#recordname.Fieldname

-module(helloworld). 
-export([start/0]). 
-record(person, {name = "", id}). 

start() -> 
   P = #person{name = "John",id = 1}, 
   io:fwrite("~p~n",[P#person.id]), 
   io:fwrite("~p~n",[P#person.name]).

1
“John”

#recordname.Fieldname = newvalue

-module(helloworld). 
-export([start/0]). 
-record(person, {name = "", id}). 

start() -> 
   P = #person{name = "John",id = 1}, 
   P1 = P#person{name = "Dan"}, 
   
   io:fwrite("~p~n",[P1#person.id]), 
   io:fwrite("~p~n",[P1#person.name]).

1
“Dan”

-module(helloworld). 
-export([start/0]). 
-record(person, {name = "", address}). 
-record(employee, {person, id}). 

start() -> 
   P = #employee{person = #person{name = "John",address = "A"},id = 1}, 
   io:fwrite("~p~n",[P#employee.id]).

1

{"init terminating in do_boot", {undef,[{helloworld,start,[],[]}, 
{init,start_it,1,[]},{init,start_em,1,[]}]}}

erl_crash.dump
init terminating in do_boot ()

try Expression of 
SuccessfulPattern1 [Guards] -> 
Expression1; 
SuccessfulPattern2 [Guards] -> 
Expression2 

catch 
TypeOfError:ExceptionPattern1 -> 
Expression3; 
TypeOfError:ExceptionPattern2 -> 
Expression4 
end

-module(helloworld). 
-compile(export_all). 

generate_exception(1) -> a; 
generate_exception(2) -> throw(a); 
generate_exception(3) -> exit(a); 
generate_exception(4) -> {'EXIT', a}; 
generate_exception(5) -> erlang:error(a). 

demo1() -> 
   [catcher(I) || I <- [1,2,3,4,5]]. 
catcher(N) -> 
   try generate_exception(N) of 
      Val -> {N, normal, Val} 
   catch 
      throw:X -> {N, caught, thrown, X}; 
      exit:X -> {N, caught, exited, X}; 
      error:X -> {N, caught, error, X} 
   end. 
      
demo2() -> 
   [{I, (catch generate_exception(I))} || I <- [1,2,3,4,5]]. 
demo3() -> 
   try generate_exception(5) 
   catch 
      error:X -> 
         {X, erlang:get_stacktrace()} 
   end. 
   
lookup(N) -> 
   case(N) of 
      1 -> {'EXIT', a}; 
      2 -> exit(a) 
   end.

[{1,normal,a},
{2,caught,thrown,a},
{3,caught,exited,a},
{4,normal,{'EXIT',a}},
{5,caught,error,a}]

-module(helloworld). 
-export([start/0]). 
-define(a,1). 

start() -> 
   io:fwrite("~w",[?a]).

1

-module(helloworld). 
-export([start/0]). 
-define(macro1(X,Y),{X+Y}). 

start() ->
   io:fwrite("~w",[?macro1(1,2)]).

{3}

-ifdef(<FlagName>).

-define(...).
-else.
-define(...).
-endif.

-record(person, {name = "", id}).

-module(helloworld). 
-export([start/0]). 
-include("user.hrl"). 

start() -> 
   P = #person{name = "John",id = 1}, 
   io:fwrite("~p~n",[P#person.id]), 
   io:fwrite("~p~n",[P#person.name]).

1
“John”

-define(macro1(X,Y),{X+Y}).

-module(helloworld). 
-export([start/0]). 
-include("user.hrl"). 

start() -> 
   io:fwrite("~w",[?macro1(1,2)]).

{3}

erlc -P some_module.erl

-module(helloworld). 
-export([start/0]). 
-include("user.hrl"). 

start() -> 
   io:fwrite("~w",[?macro1(1,2)]).

erlc –P helloworld.erl

-file("helloworld.erl", 1). -module(helloworld).

-export([start/0]).
-file("user.hrl", 1).
-file("helloworld.erl", 3).

start() ->
   io:fwrite("~w", [{1 + 2}]).

function(parameter) when condition ->

-module(helloworld). 
-export([display/1,start/0]). 

display(N) when N > 10 ->   
   io:fwrite("greater then 10"); 
display(N) when N < 10 -> io:fwrite("Less 
   than 10"). 

start() -> 
   display(11).

greater than 10

-module(helloworld). 
-export([start/0]). 

start() -> 
   N = 9, 
   if 
      N > 10 -> 
         io:fwrite("N is greater than 10"); 
      true -> 
         io:fwrite("N is less than 10") 
   end.

N is less than 10

-module(helloworld). 
-export([start/0]). 

start() -> 
   A = 9, 
   case A of {A} when A>10 -> 
      io:fwrite("The value of A is greater than 10"); _ -> 
      io:fwrite("The value of A is less than 10") 
   end.

The value of A is less than 10

function(parameter) when condition1 , condition1 , .. conditionN ->

-module(helloworld). 
-export([display/1,start/0]). 

display(N) when N > 10 , is_integer(N) -> 
   io:fwrite("greater then 10"); 
display(N) when N < 10 -> 
   io:fwrite("Less than 10"). 
   
start() -> 
   display(11).

Greater than 10

-module(helloworld). 
-export([start/0]). 

start() ->   
   io:fwrite("~p~n",[tuple_to_list({1,2,3})]), 
   io:fwrite("~p~n",[time()]).

[1,2,3]
{10,54,56}

-module(helloworld). 
-export([start/0]). 

start() -> 
   io:fwrite("~p~n",[<<5,10,20>>]), 
   io:fwrite("~p~n",[<<"hello">>]).

<<5,10,20>>
<<"hello">>

F = fun (Arg1, Arg2, ... ArgN) ->
   ...
End