Fork me on GitHub

Basics

Getting started, basic data types and basic operations.

Table of Contents

Getting Started

Installing Elixir

Installation instructions for each OS can be found on elixir-lang.org in the Installing Elixir guide.

After Elixir is installed you can easily confirm the installed version.

% elixir -v
Erlang/OTP 20 [erts-8.0.1] [source] [64-bit] [smp:4:4] [async-threads:10] [hipe] [kernel-poll:false] [dtrace]

Elixir 1.3.4

Trying Interactive Mode

Elixir comes with iex, an interactive shell, which allows us to evaluate Elixir expressions as we go.

To get started, let’s run iex:

Erlang/OTP 20 [erts-8.0.1] [source] [64-bit] [smp:4:4] [async-threads:10] [hipe] [kernel-poll:false] [dtrace]

Interactive Elixir (1.3.4) - press Ctrl+C to exit (type h() ENTER for help)
iex>

Let’s go ahead and give it a try now by typing in a few simple expressions:

iex> 2+3
5
iex> 2+3 == 5
true
iex> String.length("The quick brown fox jumps over the lazy dog")
43

Don’t worry if you don’t understand every expression yet, but we hope you get the idea.

Basic Data Types

Integers

iex> 255
255

Support for binary, octal, and hexadecimal numbers comes built in:

iex> 0b0110
6
iex> 0o644
420
iex> 0x1F
31

Floats

In Elixir, float numbers require a decimal after at least one digit; they have 64 bit double precision and support e for exponent numbers:

iex> 3.14
3.14
iex> .14
** (SyntaxError) iex:2: syntax error before: '.'
iex> 1.0e-10
1.0e-10

Booleans

Elixir supports true and false as booleans; everything is truthy except for false and nil:

iex> true
true
iex> false
false

Atoms

An atom is a constant whose name is their value. If you’re familiar with Ruby these are synonymous with Symbols:

iex> :foo
:foo
iex> :foo == :bar
false

Booleans true and false are also the atoms :true and :false respectively.

iex> true |> is_atom
true
iex> :true |> is_boolean
true
iex> :true === true
true

Names of modules in Elixir are also atoms. MyApp.MyModule is a valid atom, even if no such module has been declared yet.

iex> is_atom(MyApp.MyModule)
true

Atoms are also used to reference modules from Erlang libraries, including built in ones.

iex> :crypto.rand_bytes 3
<<23, 104, 108>>

Strings

Strings in Elixir are UTF-8 encoded and are wrapped in double quotes:

iex> "Hello"
"Hello"
iex> "dziękuję"
"dziękuję"

Strings support line breaks and escape sequences:

iex> "foo
...> bar"
"foo\nbar"
iex> "foo\nbar"
"foo\nbar"

Elixir also includes more complex data types. We’ll learn more about these when we learn about Collections and Functions.

Basic Operations

Arithmetic

Elixir supports the basic operators +, -, *, and / as you would expect. It’s important to notice that / will always return a float:

iex> 2 + 2
4
iex> 2 - 1
1
iex> 2 * 5
10
iex> 10 / 5
2.0

If you need integer division or the division remainder, Elixir comes with two helpful functions to achieve this:

iex> div(10, 5)
2
iex> rem(10, 3)
1

Boolean

Elixir provides the ||, &&, and ! boolean operators. These support any types:

iex> -20 || true
-20
iex> false || 42
42

iex> 42 && true
true
iex> 42 && nil
nil

iex> !42
false
iex> !false
true

There are three additional operators whose first argument must be a boolean (true or false):

iex> true and 42
42
iex> false or true
true
iex> not false
true
iex> 42 and true
** (ArgumentError) argument error: 42
iex> not 42
** (ArgumentError) argument error

Comparison

Elixir comes with all the comparisons operators we’re used to: ==, !=, ===, !==, <=, >=, < and >.

iex> 1 > 2
false
iex> 1 != 2
true
iex> 2 == 2
true
iex> 2 <= 3
true

For strict comparison of integers and floats use ===:

iex> 2 == 2.0
true
iex> 2 === 2.0
false

An important feature of Elixir is that any two types can be compared; this is particularly useful in sorting. We don’t need to memorize the sort order, but it is important to be aware of it:

number < atom < reference < functions < port < pid < tuple < maps < list < bitstring

This can lead to some interesting, yet valid, comparisons you may not find in other languages:

iex> :hello > 999
true
iex> {:hello, :world} > [1, 2, 3]
false

String Interpolation

If you’ve used Ruby, string interpolation in Elixir will look familiar:

iex> name = "Sean"
iex> "Hello #{name}"
"Hello Sean"

String Concatenation

String concatenation uses the <> operator:

iex> name = "Sean"
iex> "Hello " <> name
"Hello Sean"

Share This Page