Remove email addresses

1 files changed, 116 insertions, 120 deletions

diff --git a/ta-in/javascript-ta.html.markdown b/ta-in/javascript-ta.html.markdown
index 539218a6..f7fd282e 100644
--- a/ta-in/javascript-ta.html.markdown
+++ b/ta-in/javascript-ta.html.markdown
@@ -4,7 +4,7 @@ contributors:
     - ['Leigh Brenecki', 'https://leigh.net.au']
     - ['Ariel Krakowski', 'http://www.learneroo.com']
 translators:
-  - ["Rasendran Kirushan", "https://github.com/kirushanr"]
+    - ["Rasendran Kirushan", "https://github.com/kirushanr"]
 filename: javascript-ta.js
 lang: ta-in
 ---
@@ -12,37 +12,33 @@ lang: ta-in
 javascript 1995 ஆம்  ஆண்டு Netscape இல் பணிபுரிந்த Brendan Eich
 என்பவரால் உருவாக்கபட்டது.ஆரம்பத்தில் மிகவும் எளிமையான
 ஸ்க்ரிப்டிங் மொழியாக இணையதளங்களில் பயன்படுத்தபட்டது.
-இது ஜாவா (java ) வில் உருவாக்கபட்ட மிகவும் சிக்கலான இணைய செயலிகளுக்கு 
-உதவும் முகமாக உருவாக்கபட்டது. எனினும் இணையதள பக்கங்களில் இதன் முழுதான பயன்பாடு 
-மற்றும் உலாவிகளில்   பயன்படுத்த கூடிய வகையில் இருந்தமையாலும் Java வை விட 
+இது ஜாவா (java ) வில் உருவாக்கபட்ட மிகவும் சிக்கலான இணைய செயலிகளுக்கு
+உதவும் முகமாக உருவாக்கபட்டது. எனினும் இணையதள பக்கங்களில் இதன் முழுதான பயன்பாடு
+மற்றும் உலாவிகளில்   பயன்படுத்த கூடிய வகையில் இருந்தமையாலும் Java வை விட
 இணையதளகளின் முகப்பு உருவாக்கத்தில் இன்றளவில் முன்னிலை பெற்றுள்ளது.
 
-உலாவிகளுக்கு மட்டும் மட்டுபடுத்தபடவில்லை , Node.js மூலமாக 
-மிகவும் பிரபல்யமடைந்து வருகின்றது , உதாரணமாக கூகிள்க்ரோம் உலாவியின் 
+உலாவிகளுக்கு மட்டும் மட்டுபடுத்தபடவில்லை , Node.js மூலமாக
+மிகவும் பிரபல்யமடைந்து வருகின்றது , உதாரணமாக கூகிள்க்ரோம் உலாவியின்
 V8 JavaScript engine Node .js உதவியுடன் இயங்குகிறது .
 
-உங்கள் கருத்துக்கள் மிகவும் வரவேற்கபடுகின்றன , என்னுடன் தொடர்புகொள்ள 
-[@ExcitedLeigh](https://twitter.com/ExcitedLeigh), or
-[l@leigh.net.au](mailto:l@leigh.net.au).
-
 ```js
-// குறிப்புக்கள் C நிரலாக்கத்தை ஒத்தது .ஒரு வரி குறிப்புக்கள்  "//" குறியீடுடன் ஆரம்பமாகும் 
+// குறிப்புக்கள் C நிரலாக்கத்தை ஒத்தது .ஒரு வரி குறிப்புக்கள்  "//" குறியீடுடன் ஆரம்பமாகும்
 
 /* பலவரி குறிப்புக்கள் "/*" ஆரம்பமாகி "/*" இல் முடிவடையும்  */
 
 // ஒரு கூற்று முற்றுபெற செய்ய ; இடல் வேண்டும் .
 doStuff();
 
-// ...ஆனால் அரைபுள்ளி இட வேண்டும் என்று அவசியம் இல்லை ஏன்  எனில் 
+// ...ஆனால் அரைபுள்ளி இட வேண்டும் என்று அவசியம் இல்லை ஏன்  எனில்
 // ஒரு வரி புதிதாக இடப்படும் போது அரைபுள்ளிகள் தானாகவே இடப்படும் ஆனால் சில தருணங்களை தவிர .
 doStuff()
 
-// ஆனால் அவ்வாறான தருணங்கள் எதிர்பாராத முடிவுகளை தரலாம் 
+// ஆனால் அவ்வாறான தருணங்கள் எதிர்பாராத முடிவுகளை தரலாம்
 
 // எனவே நாம் தொடர்ந்து ஒரு கூற்று நிறைவடையும் போது அரைபுள்ளி ஒன்றை இடுவோம் .
 
 ///////////////////////////////////
-// 1. எண்கள்(Number) ,சரம் (String),செயற்குறிகள்(Operators) 
+// 1. எண்கள்(Number) ,சரம் (String),செயற்குறிகள்(Operators)
 
 // JavaScript ஒரே ஒரு எண்வகை காணப்படுகிறது  தசமி  (which is a 64-bit IEEE 754 double).
 // தசமி எண்வகை  (Doubles) 2^ 52 வரை சேமிக்க கூடியது
@@ -50,7 +46,7 @@ doStuff()
 3; // = 3
 1.5; // = 1.5
 
-// அடிப்படை கணித பொறிமுறைகள் 
+// அடிப்படை கணித பொறிமுறைகள்
 1 + 1; // = 2
 0.1 + 0.2; // = 0.30000000000000004
 8 - 1; // = 7
@@ -61,29 +57,29 @@ doStuff()
 5 / 2; // = 2.5
 
 
-//bitwise பொறிமுறையை உபயோகிக்கும் போது 
-//உங்கள் தசம எண்ணின் பெறுமானமானது ஒரு நேர் அல்லது மறை அல்லது பூசியமாகவுள்ள முழு எண்ணாக 
-//மாற்றம் பெறுகிறது  இது 32 இருமம்(bit) வரை செல்லலாம் 
+//bitwise பொறிமுறையை உபயோகிக்கும் போது
+//உங்கள் தசம எண்ணின் பெறுமானமானது ஒரு நேர் அல்லது மறை அல்லது பூசியமாகவுள்ள முழு எண்ணாக
+//மாற்றம் பெறுகிறது  இது 32 இருமம்(bit) வரை செல்லலாம்
 
 1 << 2; // = 4
 
-// நிரலாக்கத்தில் செயலியை அமுல்படுத்தும் வரிசைமுறையில் அடைப்பு குறிக்கு முன்னிலை வழங்கபடுகிறது 
+// நிரலாக்கத்தில் செயலியை அமுல்படுத்தும் வரிசைமுறையில் அடைப்பு குறிக்கு முன்னிலை வழங்கபடுகிறது
 (1 + 3) * 2; // = 8
 
 // மெய் எண்  அல்லாத மூன்றுபெறுமானங்கள் உள்ளன :
 Infinity; // result of e.g. 1/0
 -Infinity; // result of e.g. -1/0
-NaN; // result of e.g. 0/0, இது எண்  அல்ல என்பதை  குறிக்கும் 
+NaN; // result of e.g. 0/0, இது எண்  அல்ல என்பதை  குறிக்கும்
 
 // தர்க ரீதியில் ஆன கட்டமைப்பு காணப்படுகிறது .
 true;
 false;
 
-// சரம் (string) ' அல்லது "  குறியீட்டினால்  உருவாக்கபடுகிறது 
+// சரம் (string) ' அல்லது "  குறியீட்டினால்  உருவாக்கபடுகிறது
 'abc';
 "Hello, world";
 
-// ஒரு boolean பெறுமானத்தின் எதிர்மறை பெறுமானத்தை பெற ! குறியீடு பயன்படுத்தபடுகிறது 
+// ஒரு boolean பெறுமானத்தின் எதிர்மறை பெறுமானத்தை பெற ! குறியீடு பயன்படுத்தபடுகிறது
 !true; // = false
 !false; // = true
 
@@ -95,7 +91,7 @@ false;
 1 !== 1; // = false
 2 !== 1; // = true
 
-// மேலும் சில ஒப்பீடுகள் 
+// மேலும் சில ஒப்பீடுகள்
 1 < 10; // = true
 1 > 10; // = false
 2 <= 2; // = true
@@ -107,15 +103,15 @@ false;
 // இரண்டு மாறிகளை/பெறுமானங்களை  ஒப்பிட  < and >
 "a" < "b"; // = true
 
-// இரண்டு பெறுமானங்கள் / மாறிகள்  ஒரேவகையை சேர்ந்தவையா என பார்க்க 
+// இரண்டு பெறுமானங்கள் / மாறிகள்  ஒரேவகையை சேர்ந்தவையா என பார்க்க
 "5" == 5; // = true
 null == undefined; // = true
 
 // ...இல்லாவிடின்  ===
 "5" === 5; // = false
-null === undefined; // = false 
+null === undefined; // = false
 
-// ...கிழே உள்ள கூற்றுகள் எதிர்பாராத 
+// ...கிழே உள்ள கூற்றுகள் எதிர்பாராத
 வெளியீடுகளை தரலாம் ...
 13 + !0; // 14
 "13" + !0; // '13true'
@@ -127,11 +123,11 @@ null === undefined; // = false
 //... ஒரு சரத்தை(string )  சொற்களாக பிரிக்க (substring) `substring
 "Hello world".substring(0, 5); // = "Hello"
 
-// `length` ஒரு சரத்தில்(string) உள்ள சொற்களின் எண்ணிக்கை அல்லது நீளத்தை(length)அறிய 
+// `length` ஒரு சரத்தில்(string) உள்ள சொற்களின் எண்ணிக்கை அல்லது நீளத்தை(length)அறிய
 "Hello".length; // = 5
 
 // `null` மற்றும்  `undefined` இரு பெறுமானங்கள் உள்ளன  .
-null;      // மதிப்பு அற்ற ஒரு பெறுமானத்தை குறிக்கும் 
+null;      // மதிப்பு அற்ற ஒரு பெறுமானத்தை குறிக்கும்
 undefined; // பெறுமானம் இன்னும் நிர்ணயிக்க படவில்லை என்பதை குறிக்கும்  (
            // `undefined` இருப்பினும் இதுவும் ஒரு பெறுமானமாக கருதபடுகிறது )
 
@@ -142,35 +138,35 @@ undefined; // பெறுமானம் இன்னும் நிர்ண�
 // 2. மாறிகள்  (Variables),அணிகள் (Arrays) மற்றும் பொருட்கள் (Objects)
 
 // மாறிகளை உருவாக்க `var ` என்னும் குறியீட்டு சொல் (keyword ) பயன்படுகிறது .
-//உருவாக்கப்படும் மாறிகள் எந்த வகையை சார்ந்தன என்பதை  JavaScript 
-//தானாகவே நிர்ணயிக்கும் . மாறிக்கு  ஒரு பெறுமானத்தை வழங்க  `=` பாவிக்க 
+//உருவாக்கப்படும் மாறிகள் எந்த வகையை சார்ந்தன என்பதை  JavaScript
+//தானாகவே நிர்ணயிக்கும் . மாறிக்கு  ஒரு பெறுமானத்தை வழங்க  `=` பாவிக்க
 var someVar = 5;
 
-// //நீங்கள் மாறிகளை  நிறுவ  'var' குறியீட்டு சொல்லை பயன்படுத்தா விடினும் 
+// //நீங்கள் மாறிகளை  நிறுவ  'var' குறியீட்டு சொல்லை பயன்படுத்தா விடினும்
 //அது தவறில்லை ...
 someOtherVar = 10;
 
-// ...ஆனால் நீங்கள் நிறுவிய மாறி(variable) எல்லா உங்கள் ப்ரோக்ராம் இன் சகல இடங்களிலும் 
-//அணுக கூடியதாய் அமையும் , இல்லாவிடின் அது ஒரு குறிபிட்ட இடத்திற்கு மட்டும் 
+// ...ஆனால் நீங்கள் நிறுவிய மாறி(variable) எல்லா உங்கள் ப்ரோக்ராம் இன் சகல இடங்களிலும்
+//அணுக கூடியதாய் அமையும் , இல்லாவிடின் அது ஒரு குறிபிட்ட இடத்திற்கு மட்டும்
 //மட்டுபடுத்தபடும் .
 
-//பெறுமானம் வழங்கபடாத மாறிகளுக்கு ,இயல்பாக/தானாக undefined என்ற பெறுமானம் 
-//வழங்கப்படும் 
+//பெறுமானம் வழங்கபடாத மாறிகளுக்கு ,இயல்பாக/தானாக undefined என்ற பெறுமானம்
+//வழங்கப்படும்
 var someThirdVar; // = undefined
 
 // மாறிகளில் கணித செயல்பாடுகளை நடத்த சுருக்கெழுத்து முறைகள் காணப்படுகின்றன :
 someVar += 5; // இது  someVar = someVar + 5; ஐ  ஒத்தது someVar இன் பெறுமானம் இப்போது  10
 someVar *= 10; //  someVar இன் பெறுமானம் இப்போது  100
 
-//மிகவும் சுருக்கமான சுருகேழுத்து முறை கூட்டல்  அல்லது  கழித்தல் செயன்முறையை 
-//மேற்கொள்ள    
+//மிகவும் சுருக்கமான சுருகேழுத்து முறை கூட்டல்  அல்லது  கழித்தல் செயன்முறையை
+//மேற்கொள்ள
 someVar++; // someVar இன் பெறுமானம் இப்போது is 101
 someVar--; // someVar இன் பெறுமானம் இப்போது 100
 
-// அணிகள்(Arrays) எல்லாவகையான  பெறுமானங்களையும் உள்ளடக்க கூடியது 
+// அணிகள்(Arrays) எல்லாவகையான  பெறுமானங்களையும் உள்ளடக்க கூடியது
 var myArray = ["Hello", 45, true];
 
-// அணிகள்(Arrays) உறுப்பினர்கள் சதுர அடைப்புக்குறிக்குள் அதன் தான இலக்கத்தை கொண்டு 
+// அணிகள்(Arrays) உறுப்பினர்கள் சதுர அடைப்புக்குறிக்குள் அதன் தான இலக்கத்தை கொண்டு
 //அணுகமுடியும் .
 // அணிகளில் உள்ள உறுப்புகள் 0 இருந்து  ஆரம்பமாகும் .
 myArray[1]; // = 45
@@ -182,47 +178,47 @@ myArray.length; // = 4
 // அணியில்(Array)  ஒரு குறிப்பிட்ட இடத்தில உள்ள பெறுமானத்தை மாற்ற .
 myArray[3] = "Hello";
 
-// JavaScript's பொருள் (objects) அகராதியை ஒத்தன  
-// ஒழுங்கு படுத்த படாத சேகரிப்பு (collection) ஆகும் இதில் ஒரு சாவியும்(key) 
+// JavaScript's பொருள் (objects) அகராதியை ஒத்தன
+// ஒழுங்கு படுத்த படாத சேகரிப்பு (collection) ஆகும் இதில் ஒரு சாவியும்(key)
 //அதுக்குரிய பெறுமானமும்(value) காணப்படும் .
 var myObj = {key1: "Hello", key2: "World"};
 
 // விசைகள் சரங்களை, ஆனால் அவர்கள் சரியான என்றால் மேற்கோள் அவசியம் இல்லை
 //சாவிகளை உ.ம் : "key" என நிறுவலாம் ஆனால் , மேற்கோள்  ஆனது சாவி முன்பே நிறுவபட்டிருப்பின்
-//அவசியம் இல்லை   
-// சாவிகளுக்குரிய பெறுமானங்கள் எந்த வகையாகவும் இருக்கலாம் 
+//அவசியம் இல்லை
+// சாவிகளுக்குரிய பெறுமானங்கள் எந்த வகையாகவும் இருக்கலாம்
 var myObj = {myKey: "myValue", "my other key": 4};
 
-//பொருள் பண்புகளை சதுர அடைப்புக்குறிக்குள் அதன் சாவியின் பெயரை (key) கொண்டு 
+//பொருள் பண்புகளை சதுர அடைப்புக்குறிக்குள் அதன் சாவியின் பெயரை (key) கொண்டு
 //அணுகமுடியும் ,
 myObj["my other key"]; // = 4
 
 // ... அல்லது புள்ளி குறியீட்டை பயன்படுத்தி ,சாவியின் (key is a valid identifier)
-//பெயர் மூலம் அணுக முடியும் 
+//பெயர் மூலம் அணுக முடியும்
 myObj.myKey; // = "myValue"
 
-// பொருட்கள்(ஒப்ஜெக்ட்ஸ்) மாற்றபடகூடியான சாவிகளின் பெறுமதிகளை மாற்ற முடியும் அத்துடன் புதிய 
-//சாவிகளை(keys) இடவும் முடியும் 
+// பொருட்கள்(ஒப்ஜெக்ட்ஸ்) மாற்றபடகூடியான சாவிகளின் பெறுமதிகளை மாற்ற முடியும் அத்துடன் புதிய
+//சாவிகளை(keys) இடவும் முடியும்
 myObj.myThirdKey = true;
 
-//பெறுமதி வரையறுக்கபடாத ஒரு சாவியினை அணுகும் போது 
+//பெறுமதி வரையறுக்கபடாத ஒரு சாவியினை அணுகும் போது
 //அது வெளியிடும் பெறுமதி `undefined`.
 myObj.myFourthKey; // = undefined
 
 ///////////////////////////////////
 // 3. தர்க்கம் மற்றும் கட்டுப்பாட்டு கட்டமைப்பு
 
-// கீழே காட்டப்பட்டுள்ள தொடரியல் ஜாவா வை ஒத்தது 
+// கீழே காட்டப்பட்டுள்ள தொடரியல் ஜாவா வை ஒத்தது
 
-// The `if` ஒரு குறித்த தர்க்கம் சரியாயின் 
-//அல்லது என்ற வடிவமைப்பை 
+// The `if` ஒரு குறித்த தர்க்கம் சரியாயின்
+//அல்லது என்ற வடிவமைப்பை
 var count = 1;
 if (count == 3){
-    // count  இன் பெறுமானம் 3 சமமா என பார்க்கபடுகிறது 
+    // count  இன் பெறுமானம் 3 சமமா என பார்க்கபடுகிறது
 } else if (count == 4){
-    // count  இன் பெறுமானம் 4க்கு  சமமா என பார்க்கபடுகிறது 
+    // count  இன் பெறுமானம் 4க்கு  சமமா என பார்க்கபடுகிறது
 } else {
-    // count ஆனது 3  அல்ல  4 அல்ல  எனின் 
+    // count ஆனது 3  அல்ல  4 அல்ல  எனின்
 }
 
 // ஒரு குறிப்பிட்ட  ஒப்பீடு உண்மையாக இருக்கும் வரை  `while`.
@@ -230,40 +226,40 @@ while (true){
     // இந்த இருக்கும் கூற்றுகள் முடிவிலி தடவை மறுபடி செயற்படுத்தப்படும் !
 }
 
-// while போல் அல்லாது do-while ,அவை ஒரு தடவையேனும் அதனுள் உள்ள கூற்றுகள் செயற்படுத்தபடும் 
+// while போல் அல்லாது do-while ,அவை ஒரு தடவையேனும் அதனுள் உள்ள கூற்றுகள் செயற்படுத்தபடும்
 var input;
 do {
     input = getInput();
 } while (!isValid(input))
 
-// for (loop /சுற்று ) C , ஜாவாவை ஒத்தது 
+// for (loop /சுற்று ) C , ஜாவாவை ஒத்தது
 //மாறிக்கு பெறுமானத்தை  வழங்கல் , மாறியானது தர்க்கத்தை பூர்த்தி செய்கிறதா என பார்த்தல் ,
-//சுற்றுக்குள் இருக்கும் கூற்றை செயற்படுதல்  
+//சுற்றுக்குள் இருக்கும் கூற்றை செயற்படுதல்
 
 for (var i = 0; i < 5; i++){
-    // இந்த சுற்று 5 தடவைகள் தொடர்ந்து செயற்படுத்தபடும் 
+    // இந்த சுற்று 5 தடவைகள் தொடர்ந்து செயற்படுத்தபடும்
 }
 
-//for /In  சுற்றுகள் prototype சங்கிலியில் உள்ள சகல காரணிகள் ஊடகவும் செல்லும் 
+//for /In  சுற்றுகள் prototype சங்கிலியில் உள்ள சகல காரணிகள் ஊடகவும் செல்லும்
 var description = "";
-var person = {fname:"Paul", lname:"Ken", age:18}; 
+var person = {fname:"Paul", lname:"Ken", age:18};
 for (var x in person){
     description += person[x] + " ";
 }
 
 //ஒரு பொருளில் (Object) இடப்பட்ட பண்புகளை (properties) கருத்தில் கொள்ளும் போது
-//குறிப்பிட்ட பண்புகளை அந்த Object கொண்டுள்ளதா என பார்க்க  
+//குறிப்பிட்ட பண்புகளை அந்த Object கொண்டுள்ளதா என பார்க்க
 var description = "";
-var person = {fname:"Paul", lname:"Ken", age:18}; 
+var person = {fname:"Paul", lname:"Ken", age:18};
 for (var x in person){
     if (person.hasOwnProperty(x)){
         description += person[x] + " ";
     }
 }
 
-//for /in  ஆனது அணியில் உள்ள பண்புகள் ஒழுங்குபடுத்தப்பட்டவிதம் முக்கியம் 
-//ஆயின் பாவிப்பதை தவிர்க்கவும் ஏனெனில் அது சரியான ஒழுங்கில் 
-//வெளியீட்டை தரும் என்பது ஐயம் ஆகும் 
+//for /in  ஆனது அணியில் உள்ள பண்புகள் ஒழுங்குபடுத்தப்பட்டவிதம் முக்கியம்
+//ஆயின் பாவிப்பதை தவிர்க்கவும் ஏனெனில் அது சரியான ஒழுங்கில்
+//வெளியீட்டை தரும் என்பது ஐயம் ஆகும்
 
 // && is logical and, || is logical or
 if (house.size == "big" && house.colour == "blue"){
@@ -298,16 +294,16 @@ switch (grade) {
 ///////////////////////////////////
 // 4. Functions, Scope and Closures
 
-// JavaScript இல் functions நிறுவ  `function` keyword.பயன்படும் 
+// JavaScript இல் functions நிறுவ  `function` keyword.பயன்படும்
 function myFunction(thing){
     return thing.toUpperCase();
 }
 myFunction("foo"); // = "FOO"
 
-//ஒரு பெறுமானத்தை return செய்ய வேண்டும் எனின் இரண்டும் ஒரே வரியில் 
-//இருக்க வேண்டும் இல்லாவிடின் return ஆனது `undefined ` return செய்யும் 
-//காற் புள்ளி  தானாகவே இடப்படும் , நீங்கள்  Allman style உபயோகிக்கும் போது 
-//அவதானமாக இருக்கவும் 
+//ஒரு பெறுமானத்தை return செய்ய வேண்டும் எனின் இரண்டும் ஒரே வரியில்
+//இருக்க வேண்டும் இல்லாவிடின் return ஆனது `undefined ` return செய்யும்
+//காற் புள்ளி  தானாகவே இடப்படும் , நீங்கள்  Allman style உபயோகிக்கும் போது
+//அவதானமாக இருக்கவும்
 function myFunction()
 {
     return // <- semicolon automatically inserted here
@@ -317,20 +313,20 @@ function myFunction()
 }
 myFunction(); // = undefined
 
-// JavaScript functions ஆனது   first class objects ஆகும் ,எனவே அவற்றை மாறிகளுக்கு 
-//assign செய்ய முடியும் அதுமட்டும் அல்லது functions களில் arguments ஆக அனுப்பமுடியும் 
+// JavaScript functions ஆனது   first class objects ஆகும் ,எனவே அவற்றை மாறிகளுக்கு
+//assign செய்ய முடியும் அதுமட்டும் அல்லது functions களில் arguments ஆக அனுப்பமுடியும்
 // உதாரணமாக ஒரு event handler:
 function myFunction(){
-    //இந்த code 5 செக்கன்களில்  செயற்படுத்தப்படும் 
+    //இந்த code 5 செக்கன்களில்  செயற்படுத்தப்படும்
 }
 setTimeout(myFunction, 5000);
-// Note: setTimeout ஆனது  ஜாவஸ்க்ரிப்ட்  சேர்ந்தது அன்று , ஆனால் அந்த வசதி 
-//உலாவிகளிலும் ,Node .js  காணப்படுகிறது 
+// Note: setTimeout ஆனது  ஜாவஸ்க்ரிப்ட்  சேர்ந்தது அன்று , ஆனால் அந்த வசதி
+//உலாவிகளிலும் ,Node .js  காணப்படுகிறது
 
-// Function objects கட்டாயம் பெயரிடப்பட வீண்டும் என்று அவசியம் இல்லை 
-// அவை  anonymous(பெயரிடப்படாமல்) உருவாக்கபடலாம் 
+// Function objects கட்டாயம் பெயரிடப்பட வீண்டும் என்று அவசியம் இல்லை
+// அவை  anonymous(பெயரிடப்படாமல்) உருவாக்கபடலாம்
 setTimeout(function(){
-        //இந்த code 5 செக்கன்களில்  செயற்படுத்தப்படும் 
+    //இந்த code 5 செக்கன்களில்  செயற்படுத்தப்படும்
 }, 5000);
 
 // JavaScript  function ஒரு குறிப்பிட்ட  scope(எல்லை) கொண்டுள்ளது ;
@@ -339,42 +335,42 @@ setTimeout(function(){
 if (true){
     var i = 5;
 }
-i; // = 5 - //இது undefined அல்ல 
+i; // = 5 - //இது undefined அல்ல
 
-// இதன் காரணமாக anonymous functions உடனடியாக செயற்படுத்தபடுகின்றன 
+// இதன் காரணமாக anonymous functions உடனடியாக செயற்படுத்தபடுகின்றன
 //இதன் மூலம் தற்காலிக மாறிகள்(variable) குளோபல் scope
 //இற்கு மாறுவதை தவிர்க்கலாம் .
 (function(){
     var temporary = 5;
-	//நாங்கள் ஒரு மாறியை எங்கிருந்தும் அணுக (access) அதை "global object"
-	//ஒன்றுக்கு வழங்க வேண்டும் உலாவியில் அது எப்போதும் `window` ஆகும் .
-	//உலாவி  அல்லாத சூழலில் (Node.js) வேறு பெயருடன் இருக்கும் 
+    //நாங்கள் ஒரு மாறியை எங்கிருந்தும் அணுக (access) அதை "global object"
+    //ஒன்றுக்கு வழங்க வேண்டும் உலாவியில் அது எப்போதும் `window` ஆகும் .
+    //உலாவி  அல்லாத சூழலில் (Node.js) வேறு பெயருடன் இருக்கும்
     window.permanent = 10;
 })();
 temporary; // raises ReferenceError
 permanent; // = 10
 
-//JavaScript's மிகவும் சக்தி வாய்ந்த ஒரு வசதி closures ஆகும் 
+//JavaScript's மிகவும் சக்தி வாய்ந்த ஒரு வசதி closures ஆகும்
 //ஒரு function இன்னொரு function உள் உருவாக்கபடின்
-//அது உருவாகப்பட்ட function  இன் மாறிகளை அணுக முடியும்  
+//அது உருவாகப்பட்ட function  இன் மாறிகளை அணுக முடியும்
 function sayHelloInFiveSeconds(name){
     var prompt = "Hello, " + name + "!";
-    // Inner functions ஆனது local scope இல்  காணப்படும் 
-	//அது `var ` என்ற குறியீட்டு சொல்லால் நிறுவப்படும் 
+    // Inner functions ஆனது local scope இல்  காணப்படும்
+    //அது `var ` என்ற குறியீட்டு சொல்லால் நிறுவப்படும்
     function inner(){
         alert(prompt);
     }
     setTimeout(inner, 5000);
     //setTimeout  ஆனது background இல் இயங்கும்  , எனவே sayHelloInFiveSeconds function,
-	//செயற்பாடு முடிவடைய ,setTimeout ஆனது inner function call செய்யும்.
+    //செயற்பாடு முடிவடைய ,setTimeout ஆனது inner function call செய்யும்.
 
 }
-sayHelloInFiveSeconds("Adam"); // //இது ஒரு popup  ஐ ஐந்து செக்கன்களில் காட்டும் 
+sayHelloInFiveSeconds("Adam"); // //இது ஒரு popup  ஐ ஐந்து செக்கன்களில் காட்டும்
 
 ///////////////////////////////////
-// 5.  Objects; Constructors and Prototypes  பற்றி மேலும் 
+// 5.  Objects; Constructors and Prototypes  பற்றி மேலும்
 
-// Objects  functions ஐ கொண்டிருக்கலாம் 
+// Objects  functions ஐ கொண்டிருக்கலாம்
 var myObj = {
     myFunc: function(){
         return "Hello world!";
@@ -382,8 +378,8 @@ var myObj = {
 };
 myObj.myFunc(); // = "Hello world!"
 
-//functions ஆனது objects உடன் இணைக்கப்பட்டுள போது அவை object ஐ அணுக முடியும் 
-//அவை this என்ற  குறியீட்டு  சொல்லை பயன்படுத்தி இணைக்கபடுகின்றன 
+//functions ஆனது objects உடன் இணைக்கப்பட்டுள போது அவை object ஐ அணுக முடியும்
+//அவை this என்ற  குறியீட்டு  சொல்லை பயன்படுத்தி இணைக்கபடுகின்றன
 myObj = {
     myString: "Hello world!",
     myFunc: function(){
@@ -392,20 +388,20 @@ myObj = {
 };
 myObj.myFunc(); // = "Hello world!"
 
-//எங்கள் function ஆனது தொழிற் படாமல் போகலாம் அது context(அமைப்பு ) of the object call செய்யபடவிடின் 
+//எங்கள் function ஆனது தொழிற் படாமல் போகலாம் அது context(அமைப்பு ) of the object call செய்யபடவிடின்
 var myFunc = myObj.myFunc;
 myFunc(); // = undefined
 
 
-//function ஆனது ஒரு object உக்கு assign செய்யலாம் பிறகு அதை நாம் அணுகமுடியும் 
-//`this` மூலம்  
+//function ஆனது ஒரு object உக்கு assign செய்யலாம் பிறகு அதை நாம் அணுகமுடியும்
+//`this` மூலம்
 var myOtherFunc = function(){
     return this.myString.toUpperCase();
 }
 myObj.myOtherFunc = myOtherFunc;
 myObj.myOtherFunc(); // = "HELLO WORLD!"
 
-//ஒரு function ஒரு அமைப்பை நாம் உருவாக்க முடியும் 
+//ஒரு function ஒரு அமைப்பை நாம் உருவாக்க முடியும்
 //அதை நாம் `call` அல்லது  `apply` மூலம் செயல்படுத்த முடியும்
 
 var anotherFunc = function(s){
@@ -413,34 +409,34 @@ var anotherFunc = function(s){
 }
 anotherFunc.call(myObj, " And Hello Moon!"); // = "Hello World! And Hello Moon!"
 
-//apply செயற்பாட்டளவில் ஒத்தன ,ஆனால் அது array (அணி) argument 
+//apply செயற்பாட்டளவில் ஒத்தன ,ஆனால் அது array (அணி) argument
 //ஆக எடுக்கிறது.
 
 anotherFunc.apply(myObj, [" And Hello Sun!"]); // = "Hello World! And Hello Sun!"
 
-//இது தொடர்ச்சியான arguments ஐ நாம் function ஒன்றுக்குள் pass பண்ண 
-//வேண்டும் எனில் மிகவும் உபயோகமானது 
+//இது தொடர்ச்சியான arguments ஐ நாம் function ஒன்றுக்குள் pass பண்ண
+//வேண்டும் எனில் மிகவும் உபயோகமானது
 
 Math.min(42, 6, 27); // = 6
 Math.min([42, 6, 27]); // = NaN (uh-oh!)
 Math.min.apply(Math, [42, 6, 27]); // = 6
 
-//ஆனால் `call ` ,`apply ` இரண்டும் தற்காலிகமானவை 
-//அவற்றை நிரந்தரமாக்க bind function ஐ பயன்படுத்தவும் 
+//ஆனால் `call ` ,`apply ` இரண்டும் தற்காலிகமானவை
+//அவற்றை நிரந்தரமாக்க bind function ஐ பயன்படுத்தவும்
 
 var boundFunc = anotherFunc.bind(myObj);
 boundFunc(" And Hello Saturn!"); // = "Hello World! And Hello Saturn!"
 
-//`bind ` ஐ உபயோகித்து ஒரு function ஐ பகுதியாக apply செய்ய முடியும் 
+//`bind ` ஐ உபயோகித்து ஒரு function ஐ பகுதியாக apply செய்ய முடியும்
 
 var product = function(a, b){ return a * b; }
 var doubler = product.bind(this, 2);
 doubler(8); // = 16
 
 
-//ஒரு function ஐ நாம் new என்ற குறியீட்டு சொல்லை பயன்படுத்தி 
-//அழைக்கும் போது  புதிய object உருவாக்கப்படும் .இவ்வாறான  functions 
-//constructors என அழைக்கப்படும் 
+//ஒரு function ஐ நாம் new என்ற குறியீட்டு சொல்லை பயன்படுத்தி
+//அழைக்கும் போது  புதிய object உருவாக்கப்படும் .இவ்வாறான  functions
+//constructors என அழைக்கப்படும்
 
 var MyConstructor = function(){
     this.myNumber = 5;
@@ -448,15 +444,15 @@ var MyConstructor = function(){
 myNewObj = new MyConstructor(); // = {myNumber: 5}
 myNewObj.myNumber; // = 5
 
-//ஒவ்வொரு JavaScript object உம் ஒரு `prototype ` கொண்டுள்ளது 
-//நீங்கள் object ஒன்றின் ஒரு property ஐ அணுகும் போது 
-//அந்த property இல்லாவிடின்  interpreter  ஆனது 
-//அதன் prototype உள்ளதா என பார்க்கும் 
+//ஒவ்வொரு JavaScript object உம் ஒரு `prototype ` கொண்டுள்ளது
+//நீங்கள் object ஒன்றின் ஒரு property ஐ அணுகும் போது
+//அந்த property இல்லாவிடின்  interpreter  ஆனது
+//அதன் prototype உள்ளதா என பார்க்கும்
 
-//JS இன் சில செயலாக்கங்கள் ஒரு object இன் protoype ஐ 
+//JS இன் சில செயலாக்கங்கள் ஒரு object இன் protoype ஐ
 //இலகுவாக `__proto__` மூலம் access செய்ய முடியும் .
-//இது prototype பாவணை யை இலகுவாக்கினாலும் 
-//இது சரியான ஒரு முறை அல்ல 
+//இது prototype பாவணை யை இலகுவாக்கினாலும்
+//இது சரியான ஒரு முறை அல்ல
 var myObj = {
     myString: "Hello world!"
 };
@@ -473,21 +469,21 @@ myObj.meaningOfLife; // = 42
 // This works for functions, too.
 myObj.myFunc(); // = "hello world!"
 
-//உங்கள் property prototype இல் இல்லது இருப்பின் , protype இன் 
-//prototype search செய்யப்படும் 
+//உங்கள் property prototype இல் இல்லது இருப்பின் , protype இன்
+//prototype search செய்யப்படும்
 myPrototype.__proto__ = {
     myBoolean: true
 };
 myObj.myBoolean; // = true
 
-//ஒவ்வொரு object உம்  அதன் protype க்கும்  reference (மேற்கோள் ) ஒன்றை வைத்திருக்கும்  
+//ஒவ்வொரு object உம்  அதன் protype க்கும்  reference (மேற்கோள் ) ஒன்றை வைத்திருக்கும்
 //நாம் ஒரு protype இணை மாற்றினால் அதன் மாற்றங்கள் எல்லா இடத்திலும் (program இல் )
-//பிரதிபலிக்கும் 
+//பிரதிபலிக்கும்
 myPrototype.meaningOfLife = 43;
 myObj.meaningOfLife; // = 43
 
- 
-//நாம் முன்பு கூறியது போல் `__proto__` பயன்படுத்துவது சரியான முறை அல்ல 
+
+//நாம் முன்பு கூறியது போல் `__proto__` பயன்படுத்துவது சரியான முறை அல்ல
 //எனவே நாம் ஒரு protype ஐ object இல் உருவாக்க  இரண்டு வழிமுறைகள்
 //உள்ளன
 
@@ -550,7 +546,7 @@ String.prototype.firstCharacter = function(){
 //இது பழைய சூழல்களில் உபயோகிகப்படும்.
 
 
-//நாங்கள் முன்பு கூறி இருந்தோம்  Object.create சில இடங்களில் இந்த முறை இன்னும் 
+//நாங்கள் முன்பு கூறி இருந்தோம்  Object.create சில இடங்களில் இந்த முறை இன்னும்
 //அறிமுகம் ஆகவில்லை என்று ஆனால் இதை polyfill ஐ  பயன்படுத்தி உருவாக்க
 //முடியும்