ഷെൽ സ്ക്രിപ്റ്റുകളിലെ പ്രവർത്തനങ്ങൾ മനസ്സിലാക്കുകയും എഴുതുകയും ചെയ്യുക - ഭാഗം VI

ഏതൊരു പ്രോഗ്രാമിംഗ് ഭാഷയിലും ഫംഗ്ഷനുകൾ ഒരു പ്രധാന പങ്ക് വഹിക്കുന്നു. പല യഥാർത്ഥ പ്രോഗ്രാമിംഗ് ഭാഷകളെയും പോലെ, ബാഷിന് പരിമിതമായ നിർവ്വഹണത്തിൽ ഉപയോഗിക്കുന്ന ഫംഗ്ഷനുകളുണ്ട്.

പ്രവർത്തനങ്ങൾ എന്തൊക്കെയാണ്?

പ്രോഗ്രാമിംഗിൽ, ഒരു നിർദ്ദിഷ്ട ചുമതല നിർവഹിക്കുന്ന ഒരു പ്രോഗ്രാമിന്റെ വിഭാഗങ്ങളെ ഫംഗ്ഷനുകൾ എന്ന് വിളിക്കുന്നു. ഈ അർത്ഥത്തിൽ, ഒരു ഫംഗ്ഷൻ ഒരു തരം നടപടിക്രമം അല്ലെങ്കിൽ ദിനചര്യയാണ്. ഒരു ഫംഗ്uഷൻ എന്ന് വിളിക്കുമ്പോൾ, പ്രോഗ്രാം കോഡിന്റെ നിലവിലെ വിഭാഗം വിട്ട് ഫംഗ്uഷനുള്ളിലെ ആദ്യ വരി എക്uസിക്യൂട്ട് ചെയ്യാൻ തുടങ്ങുന്നു. ആവർത്തന കോഡ് ഉണ്ടാകുമ്പോഴോ ഒരു ടാസ്ക് ആവർത്തിക്കുമ്പോഴോ, പകരം ഒരു ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നത് പരിഗണിക്കുക.

ഉദാഹരണത്തിന്, ഒരു പ്രത്യേക പ്രോഗ്രാമിന്റെ നിരവധി ഘട്ടങ്ങളിൽ ഒരു സംഖ്യയുടെ ഫാക്uടോറിയൽ കണ്ടെത്തേണ്ട സാഹചര്യം പരിഗണിക്കുക. ഓരോ തവണയും മുഴുവൻ കോഡും (ഫാക്uടോറിയൽ കണക്കാക്കുന്നതിന്) എഴുതുന്നതിനുപകരം, ഒരു ബ്ലോക്കിനുള്ളിൽ ഒരിക്കൽ ഫാക്uടോറിയൽ കണക്കാക്കുന്ന കോഡിന്റെ ആ ഭാഗം നമുക്ക് എഴുതാനും അത് ഒന്നിലധികം അവസരങ്ങളിൽ വീണ്ടും ഉപയോഗിക്കാനും കഴിയും.

1. കോഡ് വീണ്ടും ഉപയോഗിക്കാൻ ഇത് ഞങ്ങളെ സഹായിക്കുന്നു.
2. പ്രോഗ്രാമിന്റെ വായനാക്ഷമത മെച്ചപ്പെടുത്തുക.
3. പ്രോഗ്രാമിനുള്ളിലെ വേരിയബിളുകളുടെ കാര്യക്ഷമമായ ഉപയോഗം.
4. പ്രോഗ്രാം ഭാഗികമായി പരിശോധിക്കാൻ ഞങ്ങളെ അനുവദിക്കുന്നു.
5. ഒരു കൂട്ടം ഉപ-ഘട്ടങ്ങളായി പ്രോഗ്രാം പ്രദർശിപ്പിക്കുന്നു.

ഷെൽ സ്ക്രിപ്റ്റിൽ ഫംഗ്ഷനുകൾ എഴുതുന്നതിനുള്ള പൊതു വാക്യഘടനയിൽ ഇനിപ്പറയുന്ന വഴികൾ ഉൾപ്പെടുന്നു.

function func_name {
	. . .
	commands
	. . .
}

or

func_name ( ) {
	. . .
	commands
	. . .
}

Opening curly braces can also be used in the second line as well.

func_name ( )
{
	. . .
	commands
	. . .
}

ഷെൽ സ്ക്രിപ്റ്റുകളിൽ നമ്മൾ സാധാരണയായി ചെയ്യുന്നതുപോലെ ഈ ഫംഗ്ഷൻ ബ്ലോക്കുകളിൽ സാധുവായ കമാൻഡുകൾ എഴുതാൻ നിങ്ങൾക്ക് എല്ലായ്പ്പോഴും സ്വാതന്ത്ര്യമുണ്ട്. ഇപ്പോൾ ഒരു ചെറിയ ഫംഗ്uഷൻ ഉള്ള ഒരു ലളിതമായ സ്uക്രിപ്റ്റ് എഴുതാൻ ശ്രമിക്കാം.

#!/bin/bash

call_echo ( ) {
	echo ‘This is inside function’
}

op=$1

if [ $# -ne 1 ]; then
	echo "Usage: $0 <1/0>"
else
	if [ $1 = 0 ] ; then
		echo ‘This is outside function’
	elif [ $1 = 1 ] ; then
		call_echo
	else
		echo ‘Invalid argument’
	fi
fi

exit 0

ഫംഗ്ഷൻ നിർവചനം അതിലേക്കുള്ള ആദ്യ കോളിന് മുമ്പായിരിക്കണം. വിളിക്കുന്നതിന് മുമ്പ് 'ഫംഗ്ഷൻ പ്രഖ്യാപിക്കുന്നത്' പോലെ ഒന്നുമില്ല. ഫംഗ്uഷനുകൾക്കുള്ളിൽ നമുക്ക് എപ്പോഴും ഫംഗ്uഷനുകൾ നെസ്റ്റ് ചെയ്യാൻ കഴിയും.

കുറിപ്പ്:- ശൂന്യമായ ഫംഗ്uഷനുകൾ എഴുതുന്നത് എല്ലായ്പ്പോഴും വാക്യഘടന പിശകുകൾക്ക് കാരണമാകുന്നു.

ഒരേ ഫംഗ്uഷൻ ഒന്നിലധികം തവണ നിർവചിക്കുമ്പോൾ, അന്തിമ പതിപ്പാണ് അഭ്യർത്ഥിക്കുന്നത്. നമുക്ക് ഒരു ഉദാഹരണം എടുക്കാം.

#!/bin/bash

func_same ( ) {
	echo ‘First definition’
}

func_same ( ) {
	echo ‘Second definition’
}

func_same

exit 0

പാരാമീറ്ററുകൾ എടുക്കുന്നതും മൂല്യങ്ങൾ നൽകുന്നതുമായ ഫംഗ്uഷനുകൾ പരിഗണിച്ച് നമുക്ക് കൂടുതൽ ആഴത്തിൽ വരാം. ഒരു ഫംഗ്uഷനിൽ നിന്ന് ഒരു മൂല്യം തിരികെ നൽകാൻ ഞങ്ങൾ ബിൽറ്റ്-ഇൻ 'റിട്ടേൺ' ഷെൽ ഉപയോഗിക്കുന്നു. വാക്യഘടന ഇപ്രകാരമാണ്.

func_name ( ) {
	. . .
	commands
	. . .
	return $ret_val
}

അതുപോലെ താഴെ നൽകിയിരിക്കുന്നത് പോലെ സ്uപെയ്uസുകൾ കൊണ്ട് വേർതിരിച്ച ഫംഗ്uഷനുകളിലേക്ക് നമുക്ക് ആർഗ്യുമെന്റുകൾ കൈമാറാം.

func_name $arg_1 $arg_2 $arg_3

ഫംഗ്uഷനുള്ളിൽ നമുക്ക് $1, $2, $3 എന്നിങ്ങനെ ക്രമത്തിൽ ആർഗ്യുമെന്റുകൾ ആക്uസസ് ചെയ്യാൻ കഴിയും. കൂടുതൽ വ്യക്തത ചേർക്കുന്നതിന് ഫംഗ്ഷൻ ഉപയോഗിച്ച് പരമാവധി രണ്ട് പൂർണ്ണസംഖ്യകൾ കണ്ടെത്താൻ ഇനിപ്പറയുന്ന ഉദാഹരണ സ്ക്രിപ്റ്റ് നോക്കുക.

#!/bin/bash

USG_ERR=7

max_two ( ) {
	if [ "$1" -eq "$2" ] ; then
		echo 'Equal'
		exit 0
	elif [ "$1" -gt "$2" ] ; then
		echo $1
	else
		echo $2
	fi
}

err_str ( ) {
	echo "Usage: $0 <number1>  <number2>"
	exit $USG_ERR
}

NUM_1=$1
NUM_2=$2
x
if [ $# -ne 2 ] ; then
	err_str
elif [ `expr $NUM_1 : '[0-9]*'` -eq ${#NUM_1} ] ; then
	if [ `expr $NUM_2 : '[0-9]*'` -eq ${#NUM_2} ] ; then  
		max_two $NUM_1 $NUM_2
	else
		err_str
	fi
else
	err_str
fi

exit 0

മുകളിൽ പറഞ്ഞവ അൽപ്പം സങ്കീർണ്ണമാണെന്ന് തോന്നുന്നു, പക്ഷേ വരികളിലൂടെ വായിച്ചാൽ അത് ലളിതമാണ്. മൂല്യനിർണ്ണയ ആവശ്യങ്ങൾക്കായി ആദ്യം നെസ്റ്റഡ് if-else if വരികൾ, അതായത്, പതിവ് എക്സ്പ്രഷനുകളുടെ സഹായത്തോടെ ആർഗ്യുമെന്റുകളുടെ എണ്ണവും തരവും പരിശോധിക്കാൻ. അതിനുശേഷം ഞങ്ങൾ രണ്ട് കമാൻഡ് ലൈൻ ആർഗ്യുമെന്റുകൾ ഉപയോഗിച്ച് ഫംഗ്ഷനെ വിളിക്കുകയും ഫലം അവിടെ തന്നെ പ്രദർശിപ്പിക്കുകയും ചെയ്യുന്നു. ഒരു ഫംഗ്ഷനിൽ നിന്ന് വലിയ പൂർണ്ണസംഖ്യകൾ തിരികെ നൽകാനാവില്ല എന്നതിനാലാണിത്. ഈ പ്രശ്നം പരിഹരിക്കാനുള്ള മറ്റൊരു മാർഗ്ഗം ഫംഗ്uഷനിൽ ഫലം സംഭരിക്കുന്നതിന് ആഗോള വേരിയബിളുകൾ ഉപയോഗിക്കുക എന്നതാണ്. താഴെയുള്ള സ്ക്രിപ്റ്റ് ഈ രീതി വിശദീകരിക്കുന്നു.

#!/bin/bash

USG_ERR=7
ret_val=

max_two ( ) {
	if [ "$1" -eq "$2" ] ; then
		echo 'Equal'
		exit 0
	elif [ "$1" -gt "$2" ] ; then
		ret_val=$1
	else
		ret_val=$2
	fi
}

err_str ( ) {
	echo "Usage: $0 <number1>  <number2>"
	exit $USG_ERR
}

NUM_1=$1
NUM_2=$2

if [ $# -ne 2 ] ; then
	err_str
elif [ `expr $NUM_1 : '[0-9]*'` -eq ${#NUM_1} ] ; then
	if [ `expr $NUM_2 : '[0-9]*'` -eq ${#NUM_2} ] ; then  
		max_two $NUM_1 $NUM_2
		echo $ret_val
	else
		err_str
	fi
else
	err_str
fi

exit 0

മുമ്പത്തെ ഷെൽ സ്uക്രിപ്റ്റിംഗ് സീരീസിൽ വിശദീകരിച്ച ചില ആവേശകരമായ പ്രശ്uനങ്ങൾ ഇനിപ്പറയുന്ന ഫംഗ്uഷനുകൾ ഉപയോഗിച്ച് ഇപ്പോൾ പരീക്ഷിക്കുക.

1. അടിസ്ഥാന ലിനക്സ് ഷെൽ സ്ക്രിപ്റ്റിംഗ് ഭാഷാ നുറുങ്ങുകൾ മനസ്സിലാക്കുക - ഭാഗം I
2. ഷെൽ പ്രോഗ്രാമിംഗ് പഠിക്കാൻ Linux നുള്ള 5 ഷെൽ സ്ക്രിപ്റ്റുകൾ - ഭാഗം II
3. ലിനക്സ് ബാഷ് സ്ക്രിപ്റ്റിംഗിന്റെ ലോകത്തിലൂടെയുള്ള യാത്ര - ഭാഗം III
4. ലിനക്സ് ഷെൽ പ്രോഗ്രാമിംഗിന്റെ ഗണിതശാസ്ത്ര വശം - ഭാഗം IV
5. ഷെൽ സ്ക്രിപ്റ്റിംഗ് ഭാഷയിൽ ഗണിതശാസ്ത്രപരമായ പദപ്രയോഗങ്ങൾ കണക്കാക്കുന്നു - ഭാഗം V

അടുത്ത ഭാഗത്തിൽ ലോക്കൽ വേരിയബിളുകൾ ഉപയോഗിക്കുന്നത്, ആവർത്തനം മുതലായവ പോലുള്ള ഫങ്ഷണൽ ഫീച്ചറുകളെ കുറിച്ചുള്ള കൂടുതൽ ഉൾക്കാഴ്ചയോടെ ഞാൻ തിരിച്ചെത്തും. അഭിപ്രായങ്ങളുമായി അപ്ഡേറ്റ് ആയി തുടരുക.