An Introduction to Basic Types in Elixir
Tags: elixir, functional, learning, education
Published: 2019-10-27 12:29:21

---
title: An Introduction to Basic Types in Elixir
published: true
description: 
tags: #elixir #functional #learning #education
cover_image : https://thepracticaldev.s3.amazonaws.com/i/e5y8dsbnebab08orhrod.png
---
Before all, this post it aims to share and learn a new programming language ( called **[Elixir](https://elixir-lang.org/)**) and new knowledges about **functional programming** world.Like any begin in any programming language, it important start learn about **``syntax``** and the **``basic data types``**. **So, let's go!**

**``just wait a little longer, I swear it will be important``**.I need talk about print to the console in Elixir.

**Console**

If you are running on Windows, there is a chance your terminal does not use UTF-8 by default. You can change the encoding of your current session by running **``chcp 65001``** before entering IEx.

Basicaly, exists two way for print to console in Elixir : 

**``IO.puts``** : requires the argument to be either a string, or a struct that implements the String.Chars protocol.

**``IO.inspect``** : can print an arbitrary elixir term, like a list of strings.

**ok, now let's go!**

**Integer**

Represent numbers without floating point.These are the methods of this kind : 

sum 
```elixir
sum = 7 + 1
IO.puts(sum)

output : 8
```
division ( div( ) )
```elixir
division = div(9,2)
IO.puts(division)

output : 4
# the div() method will always take integers as parameters and return integer values.

```
rem ( division remainder )
```elixir
remMethod = rem(10,3)
IO.puts remMethod

output : 1
# Elixir allows you to drop the parentheses when invoking named function.
```

subtraction
```elixir
sub = 9-18
IO.puts sub

output : -9
```
You can use is_integer() method to verify if a value is integer
```elixir
isOrNotInteger = "9"
IO.puts is_integer(isOrNotInteger)

output : false

```
Binary, Octal and Hexadecimal

**``binary``** : begins with **``0b``**
**``octal``**  : begins with **``0o``**
**``hex``**    : begins with **``0x``**

```elixir
bin = 0b1010
octal = 0o666
hex = 0x1D
```
Both binary, octal and hexadecimal types allow the use of the is_integer () method. If you use IO.puts, you can represent these values ​​in decimal basis.

```elixir
IO.puts is_integer(bin)
IO.puts is_integer(octal)
IO.puts is_integer(hex)

output : 
true
true
true

IO.puts (bin)
IO.puts (octal)
IO.puts (hex)

output :
10
438
29
```

**Float**
Represent numbers with floating point

sum
```elixir
sum = 12.0 + 1
IO.puts(sum)

output : 13.0
# note that if you have an operation that has a floating point number, the end result will be a float.

```

subtraction
```elixir
sub = 12.01 - 7.89
IO.puts(sub)

output : 4.12
```

division ( / )
```elixir
div = 9/2
IO.puts(div)

output : 4.5
# note that it's allow use integers in operator / , but always return a float number.
```

**``rem method does not work with floating point numbers``**

```elixir
IO.puts( rem(12.9,2) )
output :
 (ArithmeticError) bad argument in arithmetic expression: rem(12.9, 2)
```
**Booleans**
Elixir basicaly have two values for represent booelans values, **``true``** and **``false``**
```elixir
IO.puts true
IO.puts false
IO.puts false == false

output :
true
false
true
```

**Atom**

 An atom is a constant whose value is its **own name**, like **``Symbols``** in others languages. Often they are used to express the state of an operation.

If you enter in Interative mode ( run iex ), after the end of a successful operation, an **``:ok``** is always returned.

```elixir
iex(1)> IO.puts "atoms"
atoms
:ok
```

Elixir allows you to skip the leading **``:``** for the atoms :  **``nil``** , **``false``**, **``true``**

```elixir
IO.puts :nil == nil
IO.puts :false == false
IO.puts :true == true

output :
true
true
true

IO.puts :elixir == "elixir"
IO.puts :elixir == :elixir

output :
false
true
```

**String**

Strings in Elixir are delimited by double quotes, and they are encoded in UTF-8.The String module contains a bunch of functions that operate on strings, see in [HexDocs](https://hexdocs.pm/elixir/String.html#t:t/0).

Strings are represented internally by binaries which are sequences of bytes. Single quotes aren't represented like binaries.
```elixir
doubleQuotes = "DEV"
singleQuotes = 'DEV'
IO.puts is_binary(doubleQuotes)
IO.puts is_binary(singleQuotes)

output : 
true
false
```

concatenation

Unlike some languages, elixir does not allow the **``+``** operator to join strings, in this case, we use **``<>``**
```elixir
IO.puts "DEV" + "Community"

output : 
(ArithmeticError) bad argument in arithmetic expression: "DEV" + "Community"
```

```elixir
IO.puts "DEV" <> "Community"

output :
"DEVCommunity"
```

string interpolation

Elixir allow you to use string interpolation
```elixir
world = :world
IO.puts "hello #{world}"

output :
hello world
```

break line and multiple lines
```elixir 
# use \n for break line
IO.puts "hello\nworld"

output :
hello
world

# multiple lines
multiLine = "
breathe
think
continues"
IO.puts multiLine

output :
breathe
think
continues
```

preview of some methods
```elixir
dev = "DEV"
IO.puts is_binary dev 
IO.puts byte_size dev
IO.puts String.length dev

output : 
true
3
3

split = String.split("Led Zeppelin", " ")
IO.inspect split

output : 
["Led", "Zeppelin"]

```

**``It was a pleasure learning and writing a little about Elixir, any questions or criticism, please comment below``** :metal: :metal: :metal: