Ruby/C2/Variables-in-Ruby/Malayalam

Time	Narration
00:02	Rubyയിലെ Variables എന്ന സ്പോകെന്‍ ട്യൂട്ടോറിയലിലേക്ക് സ്വാഗതം.
00:06	ഇവിടെ പഠിക്കുന്നത്,
00:09	എന്താണ് വേരിയബിൾ?
00:10	Rubyയിലെ dynamic typing.
00:13	ഒരു വേരിയബിൾ ഡിക്ലയർ ചെയ്യുന്നത്.
00:15	variable type മാറ്റുന്നത്.
00:18	എന്താണ് വേരിയബിളിന്റെ scope?
00:20	variable types.
00:23	ഇതിനായി ഉപയോഗിക്കുന്നത്, Ubuntu Linux version 12.04 Ruby 1.9.3
00:32	ഈ ട്യൂട്ടോറിയല്‍ പിന്തുടരുന്നതിനായി Linux ൽ ടെർമിനല്‍ ഉപയോഗിക്കുവാൻ അറിഞ്ഞിരിക്കണം.
00:38	irbയും അറിഞ്ഞിരിക്കണം.
00:41	അറിയില്ലെങ്കിൽ ബന്ധപ്പെട്ട ട്യൂട്ടോറിയലുകൾക്കായി ഞങ്ങളുടെ വെബ്സൈറ്റ് സന്ദർശിക്കുക.
00:47	ഇപ്പോൾ എന്താണ് വേരിയബിൾ എന്ന് വിശദമാക്കാം.
00:50	ഒരു മൂല്യം സ്റ്റോർ ചെയ്യാൻ വേരിയബിൾ ഉപയോഗിക്കുന്നു.
00:54	Assign ചെയ്യാൻ കഴിയുന്ന ഒരു റെഫറൻസ് ആണ് വേരിയബിൾ.
00:58	Ruby വേരിയബിളുകൾ case sensitive ആണ്.
01:04	വേരിയബിളുകളുടെ പേര് അർത്ഥവത്തായിരിക്കണം.
01:07	വേരിയബിളിന്റെ പേര് ചെറിയക്ഷരത്തിൽ, അക്കങ്ങളും underscoresഉം ചേർന്നതായിരിക്കും. ഉദാഹരണം: first_name
01:20	ഇപ്പോൾ എന്താണ് dynamic typing എന്ന് നോക്കാം.
01:23	Ruby ഒരു dynamic typed ലാംഗ്വേജ് ആണ്.
01:27	അതായത് നിങ്ങൾ ഒരു വേരിയബിൾ സൃഷ്ടിക്കുമ്പോൾ datatype ഡിക്ലയർ ചെയ്യേണ്ട ആവശ്യമില്ല.
01:34	അസൈൻമെന്റിന്റെ സമയത്ത് Ruby interpreter ഡേറ്റ ടൈപ്പ് മനസിലാക്കുന്നു.
01:39	Rubyയിലെ വേരിയബിൾ ഡിക്ലയർ ചെയ്യുന്നതെങ്ങനെ എന്ന് ഇപ്പോൾ നോക്കാം.
01:45	Ctrl, Alt, T കീകൾ ഒരുമിച്ച് പ്രസ്‌ ചെയ്ത് ടെർമിനൽ തുറക്കുക.
01:51	സ്ക്രീനിൽ ടെർമിനൽ വിൻഡോ തുറക്കുന്നു.
01:55	irb ടൈപ്പ് ചെയ്യുക.
01:57	Interactive Ruby തുറക്കുന്നതിനായി എന്റർ പ്രസ്‌ ചെയ്യുക.
02:02	ടൈപ്പ് ചെയ്യുക, var1 equal to 10. Enter പ്രസ്‌ ചെയ്യുക.
02:09	ഇവിടെ var1 ഡിക്ലയർ ചെയ്തിട്ട് അതിൽ 10 അസൈൻ ചെയ്തു.
02:15	Interpreter നല്കിയ ഡേറ്റ ടൈപ്പ് ഇന്റിജർ ആണോ അല്ലയോ എന്ന് പരിശോധിക്കാം.
02:21	അതിനായി ടൈപ്പ് ചെയ്യുക var1 dot kind_(underscore)of (?)question mark Integer എന്റർ പ്രസ്‌ ചെയ്യുക.
02:37	ഔട്ട്‌പുട്ട് true എന്ന് കിട്ടും.
02:39	Rubyയിൽ നിങ്ങൾക്ക് വേരിയബിൾ ടൈപ്പ് dynamic ആയി മാറ്റാൻ കഴിയുന്നു.
02:44	അതിനായി അതിൽ ഒരു പുതിയ മൂല്യം അസൈൻ ചെയ്യുക.
02:47	var1ൽ ഒരു string മൂല്യം അസൈൻ ചെയ്യാം.
02:53	ടൈപ്പ് ചെയ്യുക, var1 equal to ഡബിൾ quotesസിനുള്ളിൽ hello. എന്റർ പ്രസ്‌ ചെയ്യുക.
03:02	വേരിയബിൾ ടൈപ്പ് എന്താണെന്ന് പരിശോധിക്കാം.
03:06	ടൈപ്പ് ചെയ്യുക var1 dot class
03:12	variable class അറിയുവാൻ Class method ഉപയോഗിക്കുന്നു. എന്റർ പ്രസ്‌ ചെയ്യുക.
03:20	ഔട്ട്‌പുട്ട് string എന്ന് കിട്ടുന്നു.
03:23	Ruby സ്വയമേ വേരിയബിൾ type integerൽ നിന്ന് stringലേക്ക് മാറ്റി.
03:29	വേരിയബിൾ മൂല്യം മറ്റൊരു ടൈപ്പിലേക്ക് മാറ്റുന്നത് എങ്ങനെ എന്ന് നോക്കാം.
03:35	സ്ലൈഡുകളിലേക്ക് തിരികെ പോകാം.
03:38	Ruby variable classesൽ അവയുടെ മൂല്യം മറ്റൊരു ടൈപ്പിലേക്ക് മാറ്റുവാനുള്ള methods ഉണ്ട്.
03:45	ഒരു വേരിയബിളിനെ integer ആക്കുവാൻ to_i method ഉപയോഗിക്കുന്നു.
03:51	ഒരു വേരിയബിളിനെ floating point ആക്കുവാൻ to_f method ഉപയോഗിക്കുന്നു.
03:57	ഒരു വേരിയബിളിനെ string ആക്കുവാൻ to_s method ഉപയോഗിക്കുന്നു.
04:03	to _s method number baseനെ argument സ്വീകരിക്കുന്നു.
04:08	Conversion ഈ number baseനെ അനുസരിച്ചായിരിക്കും.
04:12	ഇപ്പോൾ ഈ methods ശ്രമിച്ച് നോക്കാം.
04:15	ടെർമിനലിൽ പോകുക. ആദ്യം ടെർമിനൽ വൃത്തിയാക്കുക.
04:21	irb console വൃത്തിയാക്കാനായി Ctrl L പ്രസ്‌ ചെയ്യുക.
04:25	ടൈപ്പ് ചെയ്യുക, y equal to 20 എന്റർ പ്രസ്‌ ചെയ്യുക.
04:32	ഇവിടെ y എന്ന വേരിയബിൾ ഡിക്ലയർ ചെയ്തിട്ട് 20 എന്ന മൂല്യം അസൈൻ ചെയ്തു.
04:39	to underscore f method ഉപയോഗിച്ച് y യെ ഒരു floating point ആയി മാറ്റുന്നു.
04:47	ടൈപ്പ് ചെയ്യുക y dot to underscore f എന്റർ പ്രസ്‌ ചെയ്യുക.
04:55	നമുക്ക് മൂല്യം float ആയി കിട്ടുന്നു.
04:57	ടൈപ്പ് ചെയ്യുക y dot to underscore s എന്റർ പ്രസ്‌ ചെയ്യുക.
05:06	ഡബിൾ quotesസിനുള്ളിൽ 20 എന്ന ഔട്ട്‌പുട്ട് കിട്ടുന്നു.
05:10	വേരിയബിൾ yയെ ബൈനറി ആക്കണമെങ്കിൽ to_s methodൽ number base 2 നല്കുക.
05:18	മുൻപിലത്തെ കമാൻഡ് ലഭിക്കാൻ up arrow കീ പ്രസ്‌ ചെയ്യുക.
05:22	ടൈപ്പ് ചെയ്യുക തുറക്കുന്ന ബ്രാക്കറ്റ് 2 അടയ്ക്കുന്ന ബ്രാക്കറ്റ്. എന്റർ പ്രസ്‌ ചെയ്യുക.
05:29	ബൈനറി രൂപത്തിൽ ഔട്ട്‌പുട്ട് കിട്ടുന്നു.
05:33	അതുപോലെ നിങ്ങൾക്ക് വേരിയബിൾ yയെ octal അല്ലെങ്കിൽ hexadecimal formൽ ആക്കുവാൻ number base 8 അല്ലെങ്കിൽ 16 ആക്കുക.
05:44	സ്ലൈഡിലേക്ക് തിരികെ വരാം.
05:47	ഒരു variable scope എന്താണെന്ന് ഇപ്പോൾ പഠിക്കാം.
05:51	ഒരു പ്രോഗ്രാമിൽ വേരിയബിൾ എവിടെ ലഭ്യമാണ് എന്നത് Scope ഡിഫൈൻ ചെയ്യുന്നു.
05:56	Rubyയ്ക്ക് നാല് തരത്തിലുള്ള variable scope ഉണ്ട്.
06:00	Local
06:01	Global
06:02	Instance
06:04	Class
06:06	വേരിയബിൾ നെയിമിന് മുൻപിലായി ഒരു സ്പെഷ്യൽ ക്യാരക്റ്റർ ഉപയോഗിച്ച് variable type ഡിക്ലയർ ചെയ്യുന്നു.
06:14	global വേരിയബിളിനായി $ .
06:18	ചെറിയക്ഷരങ്ങളും underscoreഉം local വേരിയബിളിനെ കാണിക്കുന്നു.
06:25	instance വേരിയബിളിന് @.
06:29	രണ്ട് @@, class വേരിയബിളിനെ സൂചിപ്പിക്കുന്നു.
06:33	വലിയക്ഷരങ്ങൾ constantനെ സൂചിപ്പിക്കുന്നു.
06:37	ഇതിനെ കുറിച്ച് വിശദമായി മറ്റൊരു ട്യൂട്ടോറിയലിൽ പഠിക്കാം.
06:42	ഇതോടെ ട്യൂട്ടോറിയലിന്റെ അവസാന ഭാഗത്ത്‌ എത്തിയിരിക്കുന്നു. ചുരുക്കത്തിൽ
06:48	ഇവിടെ പഠിച്ചത്
06:51	ഒരു വേരിയബിൾ ഡിക്ലയർ ചെയ്യാൻ ഉദാഹരണം var1=10
06:56	to_f, to_s methodകൾ ഉപയോഗിച്ച് variable type മാറ്റുന്നു.
07:04	വ്യത്യസ്ഥ Variable scope
07:06	അസൈൻമെന്റ്,
07:08	ഒരു വേരിയബിൾ ഡിക്ലയർ ചെയ്തിട്ട് അതിനെ octal, hexadecimal formകളിലേക്ക് മാറ്റുക.
07:14	ഇവിടെ ലഭ്യമായ വീഡിയോ കാണുക.
07:17	ഇതു സ്പോകെന്‍ ട്യൂട്ടോറിയല്‍ പ്രൊജക്റ്റിനെ സംഗ്രഹിക്കുന്നു.
07:20	നല്ല ബാന്‍ഡ് വിഡ്ത്ത് ഇല്ലെങ്കില്‍, ഡൌണ്‍ലോഡ് ചെയ്ത് കാണാവുന്നതാണ്.
07:24	സ്പോകെന്‍ ട്യൂട്ടോറിയല്‍ പ്രൊജക്റ്റ്‌ ടീം,
07:27	സ്പോകെന്‍ ട്യൂട്ടോറിയലുകള്‍ ഉപയോഗിച്ച് വര്‍ക്ക് ഷോപ്പുകള്‍ നടത്തുന്നു.
07:31	ഓണ്‍ലൈന്‍ ടെസ്റ്റ്‌ പാസ്സാകുന്നവര്‍ക്ക് സര്‍ട്ടിഫികറ്റുകള്‍ നല്കുന്നു.
07:36	കുടുതല്‍ വിവരങ്ങള്‍ക്കായി ഈ വെബ്സൈറ്റ് സന്ദർശിക്കുക.
07:41	സ്പോകെന്‍ ട്യൂട്ടോറിയല്‍ പ്രൊജക്റ്റ്‌, ടോക്ക് ടു എ ടീച്ചര്‍ പ്രൊജക്റ്റിന്റെ ഭാഗമാണ്.
07:46	ഇതിനെ പിന്താങ്ങുന്നത് "നാഷണല്‍ മിഷന്‍ ഓണ്‍ എഡ്യൂക്കേഷന്‍ ത്രൂ ICT, MHRD, ഗവന്മെന്റ് ഓഫ് ഇന്ത്യ"
07:53	ഈ മിഷനെ കുറിച്ചുള്ള കുടുതല്‍ വിവരങ്ങള്‍ ഇവിടെ ലഭ്യമാണ്.
07:57	ഈ ട്യൂട്ടോറിയല്‍ സമാഹരിച്ചത് ദേവി സേനന്‍, IIT Bombay. നന്ദി.

Contributors and Content Editors

Devisenan