அடிப்படைகள்

தொடக்கம்

எலிக்சரை நிறவுதல்

elixir-lang.org என்ற வலைதளத்தில், ஒவ்வொரு பணிசெயல்முறைமையிலும் எலிக்சரை நிறுவுவதற்கான வழிமுறைகளைக்கொண்ட கையேடு உள்ளது.

எலிக்சரை நிறுவியவுடன், அதன் பதிப்பெண்ணை எளிதாக உறுதிசெய்து கொள்ளலாம்.

$ elixir -v
Erlang/OTP {{ site.erlang.OTP }} [erts-{{ site.erlang.erts }}] [source] [64-bit] [smp:4:4] [async-threads:10] [hipe] [kernel-poll:false] [dtrace]

Elixir {{ site.elixir.version }}

ஊடாடும்முறையை முயன்றுபார்த்தல்

எலிக்சருடன் IEx என்ற ஊடாடும் கூடும் சேர்த்து நிறுவப்படும். அதைப்பயன்படுத்தி எலிக்சர் கோவைகளை எளிதில் மதிப்பிட்டுப்பார்க்கமுடியும்.

முதலில் iex-ஐ இயக்கலாம்:

Erlang/OTP {{ site.erlang.OTP }} [erts-{{ site.erlang.erts }}] [source] [64-bit] [smp:4:4] [async-threads:10] [hipe] [kernel-poll:false] [dtrace]

Interactive Elixir ({{ site.elixir.version }}) - press Ctrl+C to exit (type h() ENTER for help)
iex>

இப்போது சில எளிய கோவைகளை இயக்கிப்பார்க்கலாம்:

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

இக்கோவைகளை இப்போது விளங்கிக்கொள்ள முடியவில்லையென்றால் கவலையில்லை. ஊடாடும் கூடு பற்றிய புரிதல் கிடைத்தால் போதும்.

அடிப்படைத் தரவினங்கள்

எண்கள்

iex> 255
255

தசம எண்களுடன், பைனரி, எண்ம மற்றும் அறுபதின்ம எண்களையும் இயல்பாகவே பயனபடுத்தலாம்:

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

பின்னங்கள்

பின்னங்கள், குறைந்தபட்சம் ஒரு எண்ணையடுத்து தசமப்புள்ளியைக்கொண்டிருக்கவேண்டும். இவை 64-பிட் அளவுகொண்டதாகவும், இரட்டை துல்லியம் கொண்டதாகவும் உள்ளன. மேம்பட்ட மதிப்புடைய பின்னங்களுக்கு e -ஐப்பயன்படுத்தலாம்:

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

பூலியன்கள்

உண்மை (true), பொய்மை (false) ஆகிய பூலியன்களை எலிக்சர் கொண்டுள்ளது. மதிப்பிலியும் (nil), பொய்மையையும் (false) தவிர மற்ற அனைத்தும் உண்மை மதிப்பைக்கொண்டவை:

iex> true
true
iex> false
false

அணுக்கள்

தன் பெயரையே மதிப்பாகக்கொண்ட மாறிலிகளுக்கு அணுக்கள் என்று பெயர். உங்களுக்கு ரூபியுடன் பரிச்சயம் இருப்பின், அதன் சிம்பள்களுக்கு இணையாக அணுக்களைக்கருதலாம்:

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

உண்மை, பொய்மை என்ற பூலியன்களும், முறையே :true, :false என்ற மதிப்புகளைக்கொண்ட அணுக்களாகும்:

iex> is_atom(true)
true
iex> is_boolean(:true)
true
iex> :true === true
true

எலிக்சரில் கூறுகளின் பெயர்களும் அணுக்களே. MyApp.MyModule என்பது ஒரு எலிக்சர் கூறின் பெயர் எனக்கொண்டால், அப்படியொரு கூறு இன்னும் அறிவிக்கப்படவில்லையென்றாலும் அது ஒரு அணுவாகவே கருதப்படும்.

iex> is_atom(MyApp.MyModule)
true

எர்லாங்கின் திரட்டுகளை, உட்பொதிந்த திரட்டுகளையும் சேர்த்து, மேற்கோள் காட்டி குறிப்பிடவும் அணுக்கள் பயன்படுகின்றன.

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

சரங்கள்

எலிக்சரின் சரங்கள், ஒருங்குறியில் (UTF-8) என்கோட் செய்யப்பட்டு, இரட்டை மேற்கோள் குறிக்குள் அடைக்கப்படுகின்றன:

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

பத்திகளையும், தப்புவிக்கும் குறியீடுகளையும் சரங்கள் கொண்டுள்ளன:

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

இவைதவிர, இன்னும்பல மேம்பட்ட தரவினங்களும் எலிக்சரில் உள்ளன. தொகுப்புகள் மற்றும் செயற்கூறுகள் பற்றி கற்கும்போது நாம் அவற்றைக்காணலாம்.

அடிப்படை செயல்பாடுகள்

கணித செயல்பாடுகள்

கூட்டல் (+), கழித்தல் (-), பெருக்கல் (*) மற்றும் வகுத்தலுக்கான (/) செயல்பாடுகளை எலிக்சர் வழங்குகிறது. வகுத்தலின் விடை எப்போதும் பின்னமாகவே இருக்கும் என்பதை நினைவில் கொள்க:

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

வகுத்தலின் ஈவு, மீதி ஆகியவற்றைப்பெற பயனுள்ள இரு செயற்கூறுகளை எலிக்சர் வழங்குகிறது:

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

பூலியன் செயல்பாடுகள்

அடிப்படை பூலியன் செயல்பாடுகளான ||, && மற்றும் ! ஐ எலிக்சர் வழங்குகிறது. இவை எல்லா தரவினங்களையும் ஏற்கும்:

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

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

iex> !42
false
iex> !false
true

இவை தவிர மேலும் மூன்று சிறப்பு செயல்பாடுகள் உள்ளன. அவற்றின் முதல் செயலுருபு, கட்டாயம் ஒரு பூலியனாக இருக்கவேண்டும் (true அல்லது 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

ஒப்பீட்டு செயல்பாடுகள்

நாம் அடிக்கடி பயன்படுத்தும் செயல்பாடுகளான, ==, !=, ===, !==, <=, >=, <, மற்றும் > ஆகியவை எலிக்சரில் உள்ளன..

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

எண்களையும், பின்னங்களையும் கண்டிப்பான முறையில் ஒப்பிட, === என்ற செயல்பாட்டைப்பயன்படுத்தலாம்:

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

இருவேறு தரவினங்களை ஒப்பிடுவது எலிக்சரின் முக்கிய அம்சங்களுள் ஒன்றாகும். மாறிகளை வரிசைப்படுத்தும்போது இது மிகவும் பயனுள்ளதாகிறது. இவ்வரிசையை அறிந்திருப்ப்து போதுமானது. நினைவில் வைத்துக்கொள்ளவேண்டிய அவசியமில்லை:

number < atom < reference < function < port < pid < tuple < map < list < bitstring

இதனால், சில சுவாரசியமான ஒப்பீடுகளை நாம் செய்யமுடியும். பிற நிரல்மொழிகளில் இது சாத்தியமில்லை:

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

சரங்களின் இடைச்சொருகல்

ரூபி தெரிந்தவர்களுக்கு, எலிக்ஶ்சரின் இடைச்சொருகல் பரிச்சயமானதாக இருக்கலாம்:

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

சரங்களை இணைத்தல்

சரங்களை இணைக்க <> என்ற செயல்பாட்டைப்பயன்படுத்தலாம்:

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

Caught a mistake or want to contribute to the lesson? Edit this lesson on GitHub!