அடிப்படைகள்

தொடக்கம்

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

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, 3)
3
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

Elixir-ல், “உண்மைத்தன்மை” என்ற கருத்து மிகவும் எளிமையானது: false மற்றும் nil மட்டுமே பொய்யாகக் கருதப்படும். 0, "" (காலி சரம்), மற்றும் [] (காலி பட்டியல்) உட்பட மற்ற ஒவ்வொரு மதிப்பும் உண்மையாகக் கருதப்படும். இந்த கடுமையான விதி ||, &&, மற்றும் ! போன்ற பூலியன் இயக்கிகளை நிபந்தனை தர்க்கத்திற்கு எந்த தரவு வகையுடனும் முன்கணிக்கக்கூடிய வகையில் செயல்பட அனுமதிக்கிறது.

இவை தவிர மேலும் மூன்று சிறப்பு செயல்பாடுகள் உள்ளன. அவற்றின் முதல் செயலுருபு, கட்டாயம் ஒரு பூலியனாக இருக்கவேண்டும் (true அல்லது false):

iex> true and 42
42
iex> false or true
true
iex> not false
true
iex> 42 and true
** (BadBooleanError) expected a boolean on left-side of "and", got: 42
iex> not 42
** (ArgumentError) argument error

குறிப்பு: Elixir-ன் and மற்றும் or உண்மையில் Erlang-ன் andalso மற்றும் orelse என மாற்றப்படுகின்றன.

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

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

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"

முடிவுரை

இந்தப் பாடத்தில், Elixir-ன் அடிப்படை கட்டமைப்புக் கூறுகளைப் பற்றி அறிந்தோம்.

Elixir-ஐ நிறுவி, ஊடாடும் ஷெல் IEx-ஐ தொடங்குவதில் ஆரம்பித்தோம், அங்கு எளிய வெளிப்பாடுகளை மதிப்பீடு செய்து உடனடி முடிவுகளைப் பார்த்தோம். அங்கிருந்து, அடிப்படை தரவு வகைகளை ஆராய்ந்தோம்: முழு எண்கள் (இருமம், எண்மம் மற்றும் பதினறுமம் வடிவங்கள் உட்பட), மிதப்புப் புள்ளி எண்கள், பூலியன்கள், அணுக்கள் மற்றும் சரங்கள்.

எண்கணிதம், பூலியன் தர்க்கம் மற்றும் ஒப்பீட்டு இயக்கிகள் போன்ற அடிப்படை செயல்பாடுகளிலும் பணியாற்றினோம். வழியில், Elixir உண்மைத்தன்மையை எவ்வாறு கையாளுகிறது என்பதைப் பார்த்தோம் — false மற்றும் nil மட்டுமே பொய் — மற்றும் ||, &&, and, or இயக்கிகள் அவற்றின் எதிர்பார்ப்புகளைப் பொறுத்து எவ்வாறு வேறுபட்ட முறையில் செயல்படுகின்றன என்பதையும் கண்டோம்.

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

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

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