c while loop பற்றிய பதிவு

c language-ல் while loop பற்றிய பதிவு ஒன்று இந்த வீடியோவில் கொடுக்கப்பட்டுள்ளது.

பொதுவாக லூப் என்பது நிரலாக்க மொழிகளில் ஒரு ஸ்டேட்மெண்ட் அல்லது ஒரு ப்ளாக் ஆஃப் ஸ்டேட்மெண்ட் குறிப்பிட்ட நிபந்தணை சரியாக இருக்கும் வரை திரும்ப திரும்ப இயக்கப்படும்.
while loop syntax:
while(condition)
{
//body of loop
}
-நன்றி முத்து கார்த்திகேயன்,மதுரை

Node.js என்பது என்ன?

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

இது  ஓபன் சோர்ஸ் மற்றும் இலவசமானதாகும்.

இதை link https://nodejs.org/en/ என்கின்ற முகவரியிலிருந்து பதிவிரக்கி உபயோகக்கிலாம்.

Node.js-ன் பெரும்பாலான  மாடூல்கள் ஜாவாஸ்கிரிப்டிலேயே எழுதப்பட்டுள்ளது. இது ரியல் டைம் சர்வர் அப்ளிகேசன்களை இயக்கப் பயன்படுகின்றது..

Node.js என்பது க்ரோமின் ஜாவாஸ்கிரிப்ட் ரன் டைம் ஆகும். இது விரைவாகவும்  மேம்பட்டதும் ஆன நெட் வொர்க் அப்ளிகேசன்களை  உருவாக்கப் பயன்படுகின்றது. இது ஈவண்ட் டிரைவன் மற்றும் நான்-பிளாக்கிங் இன்புட்/அவுட்புட் மாடல் ஆகும்.

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

ஆகவே NODE.JS ஜாவாஸ்கிரிப்ட் மாடூல்களின் லைப்ரரி தொகுப்பு மற்றும் ரன் டைம் என்விரான்மெண்ட் ஆகும்.

Node.js = Runtime Environment + JavaScript Library  

Node.js-ன் தன்மைகள்

மிகவும் வேகமானதாகும்.

இது I/O ஆனது synchronous மற்றும் ஈவண்ட் டிரைவன் ஆகும்.

இது சிங்கிள் திரட் மற்றும் ஈவண்ட் லூ[ப்பிங்குடன் கூடியதாகும்

இது மேம்பட்டதாகும்.

Node.js அப்ளிகேசன்கள் எந்த டேட்டாவையும் பஃபர் செய்வது கிடையாது.

இது ஒபன் சோர்ஸ் சாஃப்ட்வேர் ஆகும்.

இது MIT லைசன்ஸின் கீழ் ரிலீஸ் செய்யப் பட்டுள்ளது.

Node.js எவ்வாறு நிறுவுவது.?

இதை உபயோகிப்பதற்கு இரண்டு மென் பொருட்கள் தேவைப் படுகின்றது.

1.   டெக்ஸ்ட் எடிட்டர்.

2.   நிறுவப்பட்ட நோட்.ஜெஎஸ் மென்பொருள்.

இதற்கு nodepad++ ,visual studio code போன்ற எடிட்டர்கள் தேவைப்படுகின்றது. ஒரு டெக்ஸ்ட் எடிட்டரின் பெயரானது ஆபரேட்டிங்க் சிஸ்டத்திற்கு ஏற்ப்ட்ட மாறுபடும்.

டெக்ஸ்ட் எடிட்டரில் நாம் எழுதும் ஃபைல்கள் சோர்ஸ் கோட் கொண்ட சோர்ஸ் ஃபைல் ஆகும். Node.js-ல் நாம் உருவாக்கும் ஃபைல்கள் js என்கின்ற நீட்சியுடன் சேவ் செய்யப்படுகின்றது.

The Node.js Runtime:

ஜாவா ஸ்கிரிட்டில் எழுதப்பட்ட சோர்ஸ் கோட் ஆனது நோட்.ஜெ எஸ்ஸால் இண்டர்பிரட் செய்து இயக்கப் படுகின்றது.

இதற்கு இணைய தளத்தில் கீழ்கண்ட முகவரியை டைப் செய்யவும்

https://nodejs.org/en/

கீழே உள்ள படம் தோன்றும்.

தேவையான பதிப்பை தேர்வு செய்து பதிவிரக்கிக் கொள்ளவும்..

Accept the terms of license agreement.

Choose the location where you want to install.

Ready to install:

Node.js முதல் உதாரணம்.

Node.js –ல் நாம் உருவாக்கும் அப்ளிகேசன்கள் கன்சோல் அடிப்படையிலோ அல்லது வெப் அடிபடையிலோ இருக்கலாம்.

Node.js console-based Example

டெக்ஸ்ட் எடிட்டரில் கீழ்கண்டவாறு கோடிங் எழுதி அதை console_example.js என்ற பெயரில் சேவ் செய்து கொள்ளவும்.

console.log('Hello JavaTpoint');   

Node.js கமாண்ட் பிராம்ப்டை ஓபன் செய்து பின்வருமாறு கோடிந் எழுதவும்.

1. node console_example1.js  
2.  

மேலே உள்ள நிரலில் console.log என்பது டெக்ஸ்டை கன்சோலில் பிரிண்ட் செய்ய பயன்படுகின்றது.

Node.js web-based Example

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

1.      தேவைப்படும் லைப்ரரி மாடூலை இம்போர்ட் செய்து கொள்ளவும் அதற்கு require என்கின்ற டைரெக்டிவ் பயன்படுகின்றது.

2.       

3.      கிளையண்ட் ரெகுவஸ்டிற்கு பதிலளிக்கக் கூடிய சர்வரை உருவாக்க வேண்டும்.

4.      உருவாக்கப்பட்ட சர்வர் ஆனது http request –ஆனதை படித்து கன்சோலிலோ அல்லது வெப் பிரவுசரிலோ பதிலளிக்கும்.

How to create node.js web applications

Follow these steps:

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

உதாரணம்.

1. var http = require("http"); 

இரண்டாவது சர்வரை உருவாக்குவதாகும். http.createServer() என்கின்ற மெதடை அழைத்து அதை போர்ட் எண் 8081 உடன் பைண்ட் செய்து கொள்ளவும்.request மற்றும் response பராமீட்டர்களுடன் அழைத்து உதாரணத்திற்கு hello world என்பதை ரிடர்ன் செய்யுமாறு கீழ்கண்டவாறு எழுதவும்:

http.createServer(function (request, response) {  

   // Send the HTTP header   

   // HTTP Status: 200 : OK  

   // Content Type: text/plain  

   response.writeHead(200, {'Content-Type': 'text/plain'});  

   // Send the response body as "Hello World"  

   response.end('Hello World\n');  

}).listen(8081);  

// Console will print the message  

console.log('Server running at http://127.0.0.1:8081/');  

0. முதல் மற்றும் இரண்டாவது பகுதிகளை ஒன்றினைத்து main.js என்கின்ற பெயரில் நிரல் எழுதி சேமிக்கவும்.

var http = require("http");  

http.createServer(function (request, response) {  

 // Send the HTTP header   

   // HTTP Status: 200 : OK  

   // Content Type: text/plain  

   response.writeHead(200, {'Content-Type': 'text/plain'});  

   // Send the response body as "Hello World"  

   response.end('Hello World\n');  

}).listen(8081);  

// Console will print the message  

console.log('Server running at http://127.0.0.1:8081/');  

How to start your server:

Node.js command prompt செல்லவும்.. 

Now command prompt is open:

டெக்ஸ்டாப்பில் main.js என்கின்ற ஃபைல் இருப்பதாக எடுத்துக் கொள்வோம்.

முதலில் டெக்ஸ்டாப்பிற்கு மூவ் செய்யவும்.

பிறகு கீழ்கண்டவாறு டைப் செய்யவும்.

1. node main.js  
2.  

இப்பொழுது சர்வர் ஸ்டார்ட் ஆகும்.

ஏதாவது ஒரு பிரவுசரில் http://127.0.0.1:8081 என டைப் செய்து வெளியீட்டை பார்க்கவும்.

main.js என்ற ஃபைலில் ஏதாவது மாறுதல் செய்தால் மீண்டும் node main.js என கமாண்ட் பிராம்ப்டில் டைப் செய்து இயக்க வேண்டி இருக்கும்.

-முத்து கார்த்திகேயன்,மதுரை.

Python ஃபங்சன்கள்

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

இது டேட்டாவை manipulate செய்து வெளியீடு செய்கின்றது.

இதன் மூலம் கோடிங்க் ஆனது reusability ஆகின்றது.

ஃபங்க்சனின் இரு வகைகள்”

ஃபங்க்சனில் இரு வகைகள் உண்டு . முதலாவது Built-in functions.இது சாஃப்ட் வேரை இன்ஸ்டால் செய்யும் பொழுது லைப்ரரி ஃபங்க்சன்களாக கிடைக்கின்றன.

இரண்டாவது ஒரு நிரலில் நிரலாளரால் எழுதப்படும் கோடிங் ஆகும்.

ஃபங்க்சனை வரையறு செய்தல்:

ஒரு ஃபங்கசன் ஆனது பைத்தானில் def என்கின்ற கீவேர்டு அதை அறிவிக்க(declare) செய்ய பயன்படுகின்றது.

Def கீவேர்டுக்கு அடுத்து ஃபங்க்சனில் பெயர் வருகின்றது. அதை அடித்து அடைப்புக் குறிக்குள்  பராமீட்டர் சேர்க்கப் படுகின்றது. முடிவில் கோலன் வைக்கப்படுகின்றது

Python Function Syntax

1. def <function_name>(parameters):  
2. </function_name>  

உதாரணம்:

1. def sum(a,b):  

ஃபங்க்சனின் பாடி ஆனது குறிப்பிட்ட இண்டண்டேசன் விட்டு எழுதப்படுகின்றது.

ஃபங்க்சனின் முதல் வரியாக ஒரு ஆப்சனல் ஸ்டேட்மெண்ட் உண்டு. இது ஃபங்கசன் பற்றிய டாக்குமென்டேசனுக்கு பயன்படுகின்றது.

அதை அடுத்து இயக்கப்பட வேண்டிய நிரல் வரிகள் சேர்க்கபடுகின்றது.

Syntax:

பைத்தான் ஃபங்க்சனை அழைத்தல்

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

Python Function Syntax

1. <function_name>(parameters)  
2. </function_name>  

Python Function Example

1. sum(a,b)   

சான்று நிரல்:

1. #Providing Function Definition  
2. def sum(x,y):  
3.      "Going to add x and y"  
4.       s=x+y  
5.      print "Sum of two numbers is"  
6.        print s  
7.        #Calling the sum Function  
8.       sum(10,20)  
9.       sum(20,30)   

வெளியீடு:

1. >>>   
2. Sum of two numbers is  
3. 30  
4. Sum of two numbers is  
5. 50  
6. >>> 
7. குறிப்பு:

ஒரு ஃபங்க்சன் என்ன ஆர்டரில் அழைக்கப்படுகின்றதோ அதே ஆர்டரில் இயக்கப்படுகின்றது.

பைத்தான் ஃபங்க்சன் ரிடர்ன் ஸ்டேட்மெண்ட்

 Return  ஸ்டேட்மென்ட் ஆனது அந்த ஃபன்சனால் வெள்யீடு செய்யப்பட்டு அந்த ஃபங்க்சனை அழைக்கும் வரியின் இடது புறம் உள்ள வேரியபிளுக்கு மதிப்பிருத்தப்படுகின்றது.

மற்ற படி பார்த்தால் ஃபங்க்சனின் முடிவாக return ஸ்டேட்மெண்ட் எடுத்துக் கொள்ளப்படுகின்றது.

சான்று நிரல்

1. def sum(a,b):  
2.             "Adding the two values"  
3.          print "Printing within Function"  
4.  print a+b  
5.             return a+b  
6. def msg():  
7.             print "Hello"  
8.             return  
9.   
10. total=sum(10,20)  
11. print “Printing Outside: “,total  
12. msg()  
13. print "Rest of code"  

வெளியீடு:

1. >>>   
2. Printing within Function  
3. 30  
4. Printing outside:  30  
5. Hello  
6. Rest of code  
7. >>>  

Python Function Argument and Parameter

பைத்தான் ஆர்க்கியூமென்ட் மற்றும் பராமீட்டரின் வித்தியாசம்.:

.ஃபங்க்சன் அழைக்கப்படும் பொழுது அதில் pass செய்யப்படும் டேட்டா “arguments” எனப்படுகின்றது.

ஃபங்க்சனின் வரிகளில் கிடைக்கப்படும் டேட்டா பராமீட்டர் எனப்படுகின்றது.

ஆர்க்கியூமெண்ட் ஆனது லிட்டரலாகவும் இருக்கலாம் அல்லது வேரியபிளாகவும் இருக்கலாம்.

பராமீட்டர்கள் மதிப்பை சேமிக்க உதவும் வேரியபிளாக  இருக்க வேண்டும்

சான்று நிரல்:

1. def addition(x,y):  
2.             print x+y  
3. x=15  
4. addition(x ,10)  
5. addition(x,x)  
6. y=20  
7. addition(x,y)  

வெளியீடு:

1. >>>   
2. 25  
3. 30  
4. 35  
5. >>>  

பராமீட்டரை பாஸ் செய்தல்

Apart from matching the parameters, there are other ways of matching the parameters.

பைத்தான் ஆனது மூன்று வகையான ஃபார்மல் ஆர்க்கியூமெண்டை கொண்டுள்ளது.

1) Positional argument (Required argument).

2) Default argument.

3) Keyword argument (Named argument)

Positional/Required Arguments:

ஃபங்க்சன் ஆர்க்கியூமெண்டின்  எண்ணிக்கையும் பராமீட்டரின் எண்ணிக்கையும் ஒரே மாதிரி இருக்க வேண்டும்.இது தான் Positional சான்று நிரல்:

1. #Function definition of sum   
2. def sum(a,b):  
3.             "Function having two parameters"  
4.          c=a+b  
5.               print c  
6.   
7. sum(10,20)  
8. sum(20)  

வெளியீடு:

1. >>>   
2. 30  
3.   
4. Traceback (most recent call last):  
5.     File "C:/Python27/su.py", line 8, in <module>  
6.         sum(20)  
7. TypeError: sum() takes exactly 2 arguments (1 given)  
8. >>>  
9. </module>  

விளக்கம்:

முதல் sum() ஸ்டேட்மென்ட் 10,20 என இரு ஆர்க்கியூமெண்ட்களைக் கொண்டுள்ளது. இது பங்க்சனின் பராமீட்டர் லிஸ்ட் உடன் மேட்ச் ஆகின்றது. எனவே பிழையில்லாமல் வெளியீடு கிடைக்கின்றது,

இரண்டாவது sum() ஸ்டேட்மெண்ட் ஆனது ஒரே ஒரு ஆர்க்கியூமெண்ட்களைக் கொண்டுள்ளது. எனவே பிழை சுட்டப்படுகின்றது.

Python Function டிஃபால்ட் பராமீட்டர்

Default Argument ஆனது ஃபங்க்சன் அழைக்கபடும் பொழுது அது pass செய்யப்படாவிட்டால் பராமீட்டராக அதன் default மதிப்பு எடுத்துக் கொள்ளபடுகின்றது

சான்று நிரல்:

1. #Function Definition  
2. def msg(Id,Name,Age=21):  
3.             "Printing the passed value"  
4.             print Id  
5.          print Name  
6.          print Age  
7.          return  
8. #Function call  
9. msg(Id=100,Name='Ravi',Age=20)  
10. msg(Id=101,Name='Ratan')  

வெளியெடு:

1. >>>   
2. 100  
3. Ravi  
4. 20  
5. 101  
6. Ratan  
7. 21  
8. >>>  

Explanation:

முதல் தடவை ஃபங்சன் அழைக்கப்படும் பொழுது மூன்று ஆர்க்கியூமென்ட்களும் pass செய்யப்படுகின்றது. இரண்டாவது தடவை  அது அழைக்கப்படும் பொழுது age ஆனது pass செய்யபடவில்லை.எனினும் ஃபன்சன் வரைரறை செய்யும் பொழுது அதில் கொடுக்கப்பட்டுள்ள default மதிப்பு எடுத்துக் கொள்ளப்படுகின்றது.

 Python கீவேர்டு ஆர்க்கியூமென்ட்

கீவேர்டு ஆர்க்கியூமெண்ட் ஆனது  அந்த மதிப்பு pass செய்யப்படும் பொழுது அதன் பெயருடன் பாஸ் செய்யப்படுகின்றது எனவே அதன் ஆர்டர் மாறினாலும் பிரசனையில்லை.

சான்று நிரல்

1. def msg(id,name):  
2.          "Printing passed value"  
3.                print id  
4.                print name  
5.            return  
6. msg(id=100,name='Raj')  
7. msg(name='Rahul',id=101)  

வெளியீடு:

1. >>>   
2. 100  
3. Raj  
4. 101  
5. Rahul  
6. >>>  

Python Anonymous Function

ஆனானிமஸ் ஃபங்க்சன் என்பது பெயரிடப்படாத ஃபங்க்சன் ஆகும்.

இதற்கு lambda என்ற கீவேர்டு  பயன்படுகின்றது.

Lambda ஆனதும் எந்த என்னிக்கையிலான ஆர்க்கியூமெண்ட்களையும் ஏற்றுக்கொள்ளுகின்றது.

இதற்கு def கீவேர்டு பயன்படுவதில்லை.

Python Anonymous Function Syntax

1. lambda arg1,args2,args3,?,argsn :expression  

சான்று நிரல்

1. #Function Definiton  
2. square=lambda x1: x1*x1  
3.   
4. #Calling square as a function  
5. print "Square of number is",square(10)  

வெளியீடு:

1. >>>   
2. Square of number is 100  
3. >>>  

சாதாரண ஃபங்க்சனுக்கும் அனானிமஸ் ஃபங்க்சனுக்கும் உள்ள வேறுபாடு:

சான்று நிரல்:

Example:

Normal function:

1. #Function Definiton  
2. def square(x):  
3.     return x*x  
4.       
5. #Calling square function  
6. print "Square of number is",square(10)  

Anonymous function:

1. #Function Definiton  
2. square=lambda x1: x1*x1  
3.   
4. #Calling square as a function  
5. print "Square of number is",square(10)  

விளக்கம்:

அனானிமஸ் ஃபங்க்சன் def கீவேர்டை பயன் படுத்துவதில்லை.

மாறாக lambda கீவேர்டு பயன்படுகின்றது.

 இது மதிப்ப்டப்பட்ட எக்ஸ்பிரஸனை வெளியீடு செய்கின்றது.

Scope of Variable:

ஒரு வேரியபிள் அறிவிக்கப்படும் இடத்தை பொருத்து அது இரண்டு வகைப்படுகின்றது

1) Local Variable.

2) Global Variable.

1) Python Local Variables

ஒரு ஃபங்க்சனின் உள்ளே அறிவிக்கபடும் வேரியபிள் லோக்கல் வேரியபிள் ஆகும். அதை அந்த ஃபங்க்சனுக்கு வெளியே பயன்படுத்த முடியாது.

சான்று நிரல்

1. def msg():  
2.            a=10  
3.            print "Value of a is",a  
4.            return  
5.   
6. msg()  
7. print a #it will show error since variable is local  

வெளியீடு:

1. >>>   
2. Value of a is 10  
3.   
4. Traceback (most recent call last):  
5.     File "C:/Python27/lam.py", line 7, in <module>  
6.      print a #it will show error since variable is local  
7. NameError: name 'a' is not defined  
8. >>>  
9. </module>  

b) Python Global Variable

ஃபங்க்சனுக்கு வெளியே அறிவிக்கப்படும் வேரியபிள்கள் global variable எனப்படுகின்றது. இதை நிரலின் எந்த பகுதியிலும் ஆக்சஸ் செய்யலாம்.

சான்று நிரல்

1. b=20  
2. def msg():  
3.            a=10  
4.            print "Value of a is",a  
5.            print "Value of b is",b  
6.            return  
7.   
8.            msg()  
9.            print b  

வெளியீடு:

1. >>>   
2. Value of a is 10  
3. Value of b is 20  
4. 20  
5. >>>  

-முத்து கார்த்திகேயன் மதுரை.