Rename javascript.html.markdown to javascript-ta.html.markdown

1 files changed, 594 insertions, 0 deletions

diff --git a/ta_in/javascript-ta.html.markdown b/ta_in/javascript-ta.html.markdown
new file mode 100644
index 00000000..f0b0a36a
--- /dev/null
+++ b/ta_in/javascript-ta.html.markdown
@@ -0,0 +1,594 @@
+---
+language: javascript
+contributors:
+    - ['Adam Brenecki', 'http://adam.brenecki.id.au']
+    - ['Ariel Krakowski', 'http://www.learneroo.com']
+translators:
+  - ["Rasendran Kirushan", "https://github.com/kirushanr"]
+filename: javascript.js
+lang:in-ta
+---
+
+javascript 1995 ஆம்  ஆண்டு Netscape இல் பணிபுரிந்த Brendan Eich
+என்பவரால் உருவாக்கபட்டது.ஆரம்பத்தில் மிகவும் எளிமையான
+ஸ்க்ரிப்டிங் மொழியாக இணையதளங்களில் பயன்படுத்தபட்டது.
+இது ஜாவா (java ) வில் உருவாக்கபட்ட மிகவும் சிக்கலான இணைய செயலிகளுக்கு 
+உதவும் முகமாக உருவாக்கபட்டது. எனினும் இணையதள பக்கங்களில் இதன் முழுதான பயன்பாடு 
+மற்றும் உலாவிகளில்   பயன்படுத்த கூடிய வகையில் இருந்தமையாலும் Java வை விட 
+இணையதளகளின் முகப்பு உருவாக்கத்தில் இன்றளவில் முன்னிலை பெற்றுள்ளது.
+
+உலாவிகளுக்கு மட்டும் மட்டுபடுத்தபடவில்லை , Node.js மூலமாக 
+மிகவும் பிரபல்யமடைந்து வருகின்றது , உதாரணமாக கூகிள்க்ரோம் உலாவியின் 
+V8 JavaScript engine Node .js உதவியுடன் இயங்குகிறது .
+
+உங்கள் கருத்துக்கள் மிகவும் வரவேற்கபடுகின்றன , என்னுடன் தொடர்புகொள்ள 
+[@adambrenecki](https://twitter.com/adambrenecki), or
+[adam@brenecki.id.au](mailto:adam@brenecki.id.au).
+
+```js
+// குறிப்புக்கள் C நிரலாக்கத்தை ஒத்தது .ஒரு வரி குறிப்புக்கள்  "//" குறியீடுடன் ஆரம்பமாகும் 
+
+/* பலவரி குறிப்புக்கள் "/*" ஆரம்பமாகி "/*" இல் முடிவடையும்  */
+
+// ஒரு கூற்று முற்றுபெற செய்ய ; இடல் வேண்டும் .
+doStuff();
+
+// ...ஆனால் அரைபுள்ளி இட வேண்டும் என்று அவசியம் இல்லை ஏன்  எனில் 
+// ஒரு வரி புதிதாக இடப்படும் போது அரைபுள்ளிகள் தானாகவே இடப்படும் ஆனால் சில தருணங்களை தவிர .
+doStuff()
+
+// ஆனால் அவ்வாறான தருணங்கள் எதிர்பாராத முடிவுகளை தரலாம் 
+
+// எனவே நாம் தொடர்ந்து ஒரு கூற்று நிறைவடையும் போது அரைபுள்ளி ஒன்றை இடுவோம் .
+
+///////////////////////////////////
+// 1. எண்கள்(Number) ,சரம் (String),செயற்குறிகள்(Operators) 
+
+// JavaScript ஒரே ஒரு எண்வகை காணப்படுகிறது  தசமி  (which is a 64-bit IEEE 754 double).
+// தசமி எண்வகை  (Doubles) 2^ 52 வரை சேமிக்க கூடியது
+// முழு எண்வகையின் 9✕10¹⁵ சேமிக்க போதுமானது .
+3; // = 3
+1.5; // = 1.5
+
+// அடிப்படை கணித பொறிமுறைகள் 
+1 + 1; // = 2
+0.1 + 0.2; // = 0.30000000000000004
+8 - 1; // = 7
+10 * 2; // = 20
+35 / 5; // = 7
+
+// வகுத்தல்
+5 / 2; // = 2.5
+
+
+//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, இது எண்  அல்ல என்பதை  குறிக்கும் 
+
+// தர்க ரீதியில் ஆன கட்டமைப்பு காணப்படுகிறது .
+true;
+false;
+
+// சரம் (string) ' அல்லது "  குறியீட்டினால்  உருவாக்கபடுகிறது 
+'abc';
+"Hello, world";
+
+// ஒரு boolean பெறுமானத்தின் எதிர்மறை பெறுமானத்தை பெற ! குறியீடு பயன்படுத்தபடுகிறது 
+!true; // = false
+!false; // = true
+
+//  சமமா என பார்க்க  ===
+1 === 1; // = true
+2 === 1; // = false
+
+// சமனற்றவையா  என பார்க்க  !==
+1 !== 1; // = false
+2 !== 1; // = true
+
+// மேலும் சில ஒப்பீடுகள் 
+1 < 10; // = true
+1 > 10; // = false
+2 <= 2; // = true
+2 >= 2; // = true
+
+// இரண்டு சரங்களை(Strings) ஒன்றாக இணைப்பதற்கு +
+"Hello " + "world!"; // = "Hello world!"
+
+// இரண்டு மாறிகளை/பெறுமானங்களை  ஒப்பிட  < and >
+"a" < "b"; // = true
+
+// இரண்டு பெறுமானங்கள் / மாறிகள்  ஒரேவகையை சேர்ந்தவையா என பார்க்க 
+"5" == 5; // = true
+null == undefined; // = true
+
+// ...இல்லாவிடின்  ===
+"5" === 5; // = false
+null === undefined; // = false 
+
+// ...கிழே உள்ள கூற்றுகள் எதிர்பாராத 
+வெளியீடுகளை தரலாம் ...
+13 + !0; // 14
+"13" + !0; // '13true'
+
+// ஒரு சரத்தில்(string ) உள்ள எழுத்தை பெற  `charAt`
+"This is a string".charAt(0);  // = 'T'
+
+
+//... ஒரு சரத்தை(string )  சொற்களாக பிரிக்க (substring) `substring
+"Hello world".substring(0, 5); // = "Hello"
+
+// `length` ஒரு சரத்தில்(string) உள்ள சொற்களின் எண்ணிக்கை அல்லது நீளத்தை(length)அறிய 
+"Hello".length; // = 5
+
+// `null` மற்றும்  `undefined` இரு பெறுமானங்கள் உள்ளன  .
+null;      // மதிப்பு அற்ற ஒரு பெறுமானத்தை குறிக்கும் 
+undefined; // பெறுமானம் இன்னும் நிர்ணயிக்க படவில்லை என்பதை குறிக்கும்  (
+           // `undefined` இருப்பினும் இதுவும் ஒரு பெறுமானமாக கருதபடுகிறது )
+
+// ஆகியன  தர்க்க ரீதியாக பிழையானவை(false) , மற்றவை யாவும் சரியானவை (true).
+// 0 மானது பிழையை (false) குறிக்கும்  "0" சரியை (true) குறிக்கும் எனினும் 0 == "0".
+
+///////////////////////////////////
+// 2. மாறிகள்  (Variables),அணிகள் (Arrays) மற்றும் பொருட்கள் (Objects)
+
+// மாறிகளை உருவாக்க `var ` என்னும் குறியீட்டு சொல் (keyword ) பயன்படுகிறது .
+//உருவாக்கப்படும் மாறிகள் எந்த வகையை சார்ந்தன என்பதை  JavaScript 
+//தானாகவே நிர்ணயிக்கும் . மாறிக்கு  ஒரு பெறுமானத்தை வழங்க  `=` பாவிக்க 
+var someVar = 5;
+
+// //நீங்கள் மாறிகளை  நிறுவ  'var' குறியீட்டு சொல்லை பயன்படுத்தா விடினும் 
+//அது தவறில்லை ...
+someOtherVar = 10;
+
+// ...ஆனால் நீங்கள் நிறுவிய மாறி(variable) எல்லா உங்கள் ப்ரோக்ராம் இன் சகல இடங்களிலும் 
+//அணுக கூடியதாய் அமையும் , இல்லாவிடின் அது ஒரு குறிபிட்ட இடத்திற்கு மட்டும் 
+//மட்டுபடுத்தபடும் .
+
+//பெறுமானம் வழங்கபடாத மாறிகளுக்கு ,இயல்பாக/தானாக undefined என்ற பெறுமானம் 
+//வழங்கப்படும் 
+var someThirdVar; // = undefined
+
+// மாறிகளில் கணித செயல்பாடுகளை நடத்த சுருக்கெழுத்து முறைகள் காணப்படுகின்றன :
+someVar += 5; // இது  someVar = someVar + 5; ஐ  ஒத்தது someVar இன் பெறுமானம் இப்போது  10
+someVar *= 10; //  someVar இன் பெறுமானம் இப்போது  100
+
+//மிகவும் சுருக்கமான சுருகேழுத்து முறை கூட்டல்  அல்லது  கழித்தல் செயன்முறையை 
+//மேற்கொள்ள    
+someVar++; // someVar இன் பெறுமானம் இப்போது is 101
+someVar--; // someVar இன் பெறுமானம் இப்போது 100
+
+// அணிகள்(Arrays) எல்லாவகையான  பெறுமானங்களையும் உள்ளடக்க கூடியது 
+var myArray = ["Hello", 45, true];
+
+// அணிகள்(Arrays) உறுப்பினர்கள் சதுர அடைப்புக்குறிக்குள் அதன் தான இலக்கத்தை கொண்டு 
+//அணுகமுடியும் .
+// அணிகளில் உள்ள உறுப்புகள் 0 இருந்து  ஆரம்பமாகும் .
+myArray[1]; // = 45
+
+// அணிகள் உள்ள உறுப்புகளை மாற்றமுடியும்  அத்துடன் உறுப்புகளின் எண்ணிக்கையும் மாறலாம் .
+myArray.push("World");
+myArray.length; // = 4
+
+// அணியில்(Array)  ஒரு குறிப்பிட்ட இடத்தில உள்ள பெறுமானத்தை மாற்ற .
+myArray[3] = "Hello";
+
+// JavaScript's பொருள் (objects) அகராதியை ஒத்தன  
+// ஒழுங்கு படுத்த படாத சேகரிப்பு (collection) ஆகும் இதில் ஒரு சாவியும்(key) 
+//அதுக்குரிய பெறுமானமும்(value) காணப்படும் .
+var myObj = {key1: "Hello", key2: "World"};
+
+// விசைகள் சரங்களை, ஆனால் அவர்கள் சரியான என்றால் மேற்கோள் அவசியம் இல்லை
+//சாவிகளை உ.ம் : "key" என நிறுவலாம் ஆனால் , மேற்கோள்  ஆனது சாவி முன்பே நிறுவபட்டிருப்பின்
+//அவசியம் இல்லை   
+// சாவிகளுக்குரிய பெறுமானங்கள் எந்த வகையாகவும் இருக்கலாம் 
+var myObj = {myKey: "myValue", "my other key": 4};
+
+//பொருள் பண்புகளை சதுர அடைப்புக்குறிக்குள் அதன் சாவியின் பெயரை (key) கொண்டு 
+//அணுகமுடியும் ,
+myObj["my other key"]; // = 4
+
+// ... அல்லது புள்ளி குறியீட்டை பயன்படுத்தி ,சாவியின் (key is a valid identifier)
+//பெயர் மூலம் அணுக முடியும் 
+myObj.myKey; // = "myValue"
+
+// பொருட்கள்(ஒப்ஜெக்ட்ஸ்) மாற்றபடகூடியான சாவிகளின் பெறுமதிகளை மாற்ற முடியும் அத்துடன் புதிய 
+//சாவிகளை(keys) இடவும் முடியும் 
+myObj.myThirdKey = true;
+
+//பெறுமதி வரையறுக்கபடாத ஒரு சாவியினை அணுகும் போது 
+//அது வெளியிடும் பெறுமதி `undefined`.
+myObj.myFourthKey; // = undefined
+
+///////////////////////////////////
+// 3. தர்க்கம் மற்றும் கட்டுப்பாட்டு கட்டமைப்பு
+
+// கீழே காட்டப்பட்டுள்ள தொடரியல் ஜாவா வை ஒத்தது 
+
+// The `if` ஒரு குறித்த தர்க்கம் சரியாயின் 
+//அல்லது என்ற வடிவமைப்பை 
+var count = 1;
+if (count == 3){
+    // count  இன் பெறுமானம் 3 சமமா என பார்க்கபடுகிறது 
+} else if (count == 4){
+    // count  இன் பெறுமானம் 4க்கு  சமமா என பார்க்கபடுகிறது 
+} else {
+    // count ஆனது 3  அல்ல  4 அல்ல  எனின் 
+}
+
+// ஒரு குறிப்பிட்ட  ஒப்பீடு உண்மையாக இருக்கும் வரை  `while`.
+while (true){
+    // இந்த இருக்கும் கூற்றுகள் முடிவிலி தடவை மறுபடி செயற்படுத்தப்படும் !
+}
+
+// while போல் அல்லாது do-while ,அவை ஒரு தடவையேனும் அதனுள் உள்ள கூற்றுகள் செயற்படுத்தபடும் 
+var input;
+do {
+    input = getInput();
+} while (!isValid(input))
+
+// for (loop /சுற்று ) C , ஜாவாவை ஒத்தது 
+//மாறிக்கு பெறுமானத்தை  வழங்கல் , மாறியானது தர்க்கத்தை பூர்த்தி செய்கிறதா என பார்த்தல் ,
+//சுற்றுக்குள் இருக்கும் கூற்றை செயற்படுதல்  
+
+for (var i = 0; i < 5; i++){
+    // இந்த சுற்று 5 தடவைகள் தொடர்ந்து செயற்படுத்தபடும் 
+}
+
+//for /In  சுற்றுகள் prototype சங்கிலியில் உள்ள சகல காரணிகள் ஊடகவும் செல்லும் 
+var description = "";
+var person = {fname:"Paul", lname:"Ken", age:18}; 
+for (var x in person){
+    description += person[x] + " ";
+}
+
+//ஒரு பொருளில் (Object) இடப்பட்ட பண்புகளை (properties) கருத்தில் கொள்ளும் போது
+//குறிப்பிட்ட பண்புகளை அந்த Object கொண்டுள்ளதா என பார்க்க  
+var description = "";
+var person = {fname:"Paul", lname:"Ken", age:18}; 
+for (var x in person){
+    if (person.hasOwnProperty(x)){
+        description += person[x] + " ";
+    }
+}
+
+//for /in  ஆனது அணியில் உள்ள பண்புகள் ஒழுங்குபடுத்தப்பட்டவிதம் முக்கியம் 
+//ஆயின் பாவிப்பதை தவிர்க்கவும் ஏனெனில் அது சரியான ஒழுங்கில் 
+//வெளியீட்டை தரும் என்பது ஐயம் ஆகும் 
+
+// && is logical and, || is logical or
+if (house.size == "big" && house.colour == "blue"){
+    house.contains = "bear";
+}
+if (colour == "red" || colour == "blue"){
+    // colour is either red or blue
+}
+
+// && and || "short circuit", which is useful for setting default values.
+var name = otherName || "default";
+
+
+
+grade = 'B';
+switch (grade) {
+  case 'A':
+    console.log("Great job");
+    break;
+  case 'B':
+    console.log("OK job");
+    break;
+  case 'C':
+    console.log("You can do better");
+    break;
+  default:
+    console.log("Oy vey");
+    break;
+}
+
+
+///////////////////////////////////
+// 4. Functions, Scope and Closures
+
+// JavaScript இல் functions நிறுவ  `function` keyword.பயன்படும் 
+function myFunction(thing){
+    return thing.toUpperCase();
+}
+myFunction("foo"); // = "FOO"
+
+//ஒரு பெறுமானத்தை return செய்ய வேண்டும் எனின் இரண்டும் ஒரே வரியில் 
+//இருக்க வேண்டும் இல்லாவிடின் return ஆனது `undefined ` return செய்யும் 
+//காற் புள்ளி  தானாகவே இடப்படும் , நீங்கள்  Allman style உபயோகிக்கும் போது 
+//அவதானமாக இருக்கவும் 
+function myFunction()
+{
+    return // <- semicolon automatically inserted here
+    {
+        thisIsAn: 'object literal'
+    }
+}
+myFunction(); // = undefined
+
+// JavaScript functions ஆனது   first class objects ஆகும் ,எனவே அவற்றை மாறிகளுக்கு 
+//assign செய்ய முடியும் அதுமட்டும் அல்லது functions களில் arguments ஆக அனுப்பமுடியும் 
+// உதாரணமாக ஒரு event handler:
+function myFunction(){
+    //இந்த code 5 செக்கன்களில்  செயற்படுத்தப்படும் 
+}
+setTimeout(myFunction, 5000);
+// Note: setTimeout ஆனது  ஜாவஸ்க்ரிப்ட்  சேர்ந்தது அன்று , ஆனால் அந்த வசதி 
+//உலாவிகளிலும் ,Node .js  காணப்படுகிறது 
+
+// Function objects கட்டாயம் பெயரிடப்பட வீண்டும் என்று அவசியம் இல்லை 
+// அவை  anonymous(பெயரிடப்படாமல்) உருவாக்கபடலாம் 
+setTimeout(function(){
+        //இந்த code 5 செக்கன்களில்  செயற்படுத்தப்படும் 
+}, 5000);
+
+// JavaScript  function ஒரு குறிப்பிட்ட  scope(எல்லை) கொண்டுள்ளது ;
+//functions தமக்கென  ஒரு scope கொண்டுள்ளன .
+
+if (true){
+    var i = 5;
+}
+i; // = 5 - //இது undefined அல்ல 
+
+// இதன் காரணமாக anonymous functions உடனடியாக செயற்படுத்தபடுகின்றன 
+//இதன் மூலம் தற்காலிக மாறிகள்(variable) குளோபல் scope
+//இற்கு மாறுவதை தவிர்க்கலாம் .
+(function(){
+    var temporary = 5;
+	//நாங்கள் ஒரு மாறியை எங்கிருந்தும் அணுக (access) அதை "global object"
+	//ஒன்றுக்கு வழங்க வேண்டும் உலாவியில் அது எப்போதும் `window` ஆகும் .
+	//உலாவி  அல்லாத சூழலில் (Node.js) வேறு பெயருடன் இருக்கும் 
+    window.permanent = 10;
+})();
+temporary; // raises ReferenceError
+permanent; // = 10
+
+//JavaScript's மிகவும் சக்தி வாய்ந்த ஒரு வசதி closures ஆகும் 
+//ஒரு function இன்னொரு function உள் உருவாக்கபடின்
+//அது உருவாகப்பட்ட function  இன் மாறிகளை அணுக முடியும்  
+function sayHelloInFiveSeconds(name){
+    var prompt = "Hello, " + name + "!";
+    // Inner functions ஆனது local scope இல்  காணப்படும் 
+	//அது `var ` என்ற குறியீட்டு சொல்லால் நிறுவப்படும் 
+    function inner(){
+        alert(prompt);
+    }
+    setTimeout(inner, 5000);
+    //setTimeout  ஆனது background இல் இயங்கும்  , எனவே sayHelloInFiveSeconds function,
+	//செயற்பாடு முடிவடைய ,setTimeout ஆனது inner function call செய்யும்.
+
+}
+sayHelloInFiveSeconds("Adam"); // //இது ஒரு popup  ஐ ஐந்து செக்கன்களில் காட்டும் 
+
+///////////////////////////////////
+// 5.  Objects; Constructors and Prototypes  பற்றி மேலும் 
+
+// Objects  functions ஐ கொண்டிருக்கலாம் 
+var myObj = {
+    myFunc: function(){
+        return "Hello world!";
+    }
+};
+myObj.myFunc(); // = "Hello world!"
+
+//functions ஆனது objects உடன் இணைக்கப்பட்டுள போது அவை object ஐ அணுக முடியும் 
+//அவை this என்ற  குறியீட்டு  சொல்லை பயன்படுத்தி இணைக்கபடுகின்றன 
+myObj = {
+    myString: "Hello world!",
+    myFunc: function(){
+        return this.myString;
+    }
+};
+myObj.myFunc(); // = "Hello world!"
+
+//எங்கள் function ஆனது தொழிற் படாமல் போகலாம் அது context(அமைப்பு ) of the object call செய்யபடவிடின் 
+var myFunc = myObj.myFunc;
+myFunc(); // = undefined
+
+
+//function ஆனது ஒரு object உக்கு assign செய்யலாம் பிறகு அதை நாம் அணுகமுடியும் 
+//`this` மூலம்  
+var myOtherFunc = function(){
+    return this.myString.toUpperCase();
+}
+myObj.myOtherFunc = myOtherFunc;
+myObj.myOtherFunc(); // = "HELLO WORLD!"
+
+//ஒரு function ஒரு அமைப்பை நாம் உருவாக்க முடியும் 
+//அதை நாம் `call` அல்லது  `apply` மூலம் செயல்படுத்த முடியும்
+
+var anotherFunc = function(s){
+    return this.myString + s;
+}
+anotherFunc.call(myObj, " And Hello Moon!"); // = "Hello World! And Hello Moon!"
+
+//apply செயற்பாட்டளவில் ஒத்தன ,ஆனால் அது array (அணி) argument 
+//ஆக எடுக்கிறது.
+
+anotherFunc.apply(myObj, [" And Hello Sun!"]); // = "Hello World! And Hello Sun!"
+
+//இது தொடர்ச்சியான 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 ஐ பயன்படுத்தவும் 
+
+var boundFunc = anotherFunc.bind(myObj);
+boundFunc(" And Hello Saturn!"); // = "Hello World! And Hello Saturn!"
+
+//`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 என அழைக்கப்படும் 
+
+var MyConstructor = function(){
+    this.myNumber = 5;
+}
+myNewObj = new MyConstructor(); // = {myNumber: 5}
+myNewObj.myNumber; // = 5
+
+//ஒவ்வொரு JavaScript object உம் ஒரு `prototype ` கொண்டுள்ளது 
+//நீங்கள் object ஒன்றின் ஒரு property ஐ அணுகும் போது 
+//அந்த property இல்லாவிடின்  interpreter  ஆனது 
+//அதன் prototype உள்ளதா என பார்க்கும் 
+
+//JS இன் சில செயலாக்கங்கள் ஒரு object இன் protoype ஐ 
+//இலகுவாக `__proto__` மூலம் access செய்ய முடியும் .
+//இது prototype பாவணை யை இலகுவாக்கினாலும் 
+//இது சரியான ஒரு முறை அல்ல 
+var myObj = {
+    myString: "Hello world!"
+};
+var myPrototype = {
+    meaningOfLife: 42,
+    myFunc: function(){
+        return this.myString.toLowerCase()
+    }
+};
+
+myObj.__proto__ = myPrototype;
+myObj.meaningOfLife; // = 42
+
+// This works for functions, too.
+myObj.myFunc(); // = "hello world!"
+
+//உங்கள் property prototype இல் இல்லது இருப்பின் , protype இன் 
+//prototype search செய்யப்படும் 
+myPrototype.__proto__ = {
+    myBoolean: true
+};
+myObj.myBoolean; // = true
+
+//ஒவ்வொரு object உம்  அதன் protype க்கும்  reference (மேற்கோள் ) ஒன்றை வைத்திருக்கும்  
+//நாம் ஒரு protype இணை மாற்றினால் அதன் மாற்றங்கள் எல்லா இடத்திலும் (program இல் )
+//பிரதிபலிக்கும் 
+myPrototype.meaningOfLife = 43;
+myObj.meaningOfLife; // = 43
+
+ 
+//நாம் முன்பு கூறியது போல் `__proto__` பயன்படுத்துவது சரியான முறை அல்ல 
+//எனவே நாம் ஒரு protype ஐ object இல் உருவாக்க  இரண்டு வழிமுறைகள்
+//உள்ளன
+
+// முதல் முறை  Object.create இது அண்மையில் அறிமுகம் செய்ய பட்ட ஒன்று
+//எனவே சில இடங்களில் இந்த முறை இன்னும் அறிமுகம் ஆகவில்லை
+
+var myObj = Object.create(myPrototype);
+myObj.meaningOfLife; // = 43
+
+
+// இரண்டாவது முறை , இது சகல இடங்களிலும் வேலைசெய்யும், இது constructors மூலம்.
+//constructors prototype என்னும் ஒரு காரணியை  கொண்டுள்ளது , இது  constructor function
+//இன் prototype அன்று. ,இது நாம் new என்ற குறியீட்டு சொல்லையும்  அந்த constructor உபயோகித்து
+//உருவாக்கபடுகிறது
+
+MyConstructor.prototype = {
+    myNumber: 5,
+    getMyNumber: function(){
+        return this.myNumber;
+    }
+};
+var myNewObj2 = new MyConstructor();
+myNewObj2.getMyNumber(); // = 5
+myNewObj2.myNumber = 6
+myNewObj2.getMyNumber(); // = 6
+
+// Built-in types like strings and numbers also have constructors that create
+// equivalent wrapper objects.
+// JavaScript இல் உள்ள strings மற்றும் numbers வகைகளும் constructors கொண்டுள்ளன
+//இவை wrapper objects ஐ ஒத்தன
+
+var myNumber = 12;
+var myNumberObj = new Number(12);
+myNumber == myNumberObj; // = true
+
+
+//இவை மிக சிறிய அளவில் ஒத்தவை
+typeof myNumber; // = 'number'
+typeof myNumberObj; // = 'object'
+myNumber === myNumberObj; // = false
+if (0){
+    // இந்த கூற்றானது செயல்படுத்தபடாது ஏனெனில் ௦ false ஆகும்
+}
+
+// However, the wrapper objects and the regular builtins share a prototype, so
+// you can actually add functionality to a string, for instance.
+
+//இருப்பினும்  wrapper objects மற்றும் regular builtins ஆகியன  prototype ஒன்றை கொண்டுள்ளன
+String.prototype.firstCharacter = function(){
+    return this.charAt(0);
+}
+"abc".firstCharacter(); // = "a"
+
+// This fact is often used in "polyfilling", which is implementing newer
+// features of JavaScript in an older subset of JavaScript, so that they can be
+// used in older environments such as outdated browsers.
+
+//இந்த முறையானது  "polyfilling" இல் உபயோகபடுத்தபடுகிறது.
+//புதிய சில  வசதிகளை JavaScript பழைய JavaScript பிரதிகளில் இல்  உருவாக்குகிறது.
+//இது பழைய சூழல்களில் உபயோகிகப்படும்.
+
+
+//நாங்கள் முன்பு கூறி இருந்தோம்  Object.create சில இடங்களில் இந்த முறை இன்னும் 
+//அறிமுகம் ஆகவில்லை என்று ஆனால் இதை polyfill ஐ  பயன்படுத்தி உருவாக்க
+//முடியும்
+
+if (Object.create === undefined){ // don't overwrite it if it exists
+    Object.create = function(proto){
+        // make a temporary constructor with the right prototype
+        var Constructor = function(){};
+        Constructor.prototype = proto;
+        // then use it to create a new, appropriately-prototyped object
+        return new Constructor();
+    }
+}
+```
+
+## மேலும் JavaScript பற்றி கற்க
+
+The [Mozilla Developer
+Network](https://developer.mozilla.org/en-US/docs/Web/JavaScript) provides
+excellent documentation for JavaScript as it's used in browsers. Plus, it's a
+wiki, so as you learn more you can help others out by sharing your own
+knowledge.
+
+MDN's [A re-introduction to
+JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript)
+covers much of the concepts covered here in more detail. This guide has quite
+deliberately only covered the JavaScript language itself; if you want to learn
+more about how to use JavaScript in web pages, start by learning about the
+[Document Object
+Model](https://developer.mozilla.org/en-US/docs/Using_the_W3C_DOM_Level_1_Core)
+
+[Learn Javascript by Example and with Challenges](http://www.learneroo.com/modules/64/nodes/350) is a variant of this reference with built-in challenges.
+
+[JavaScript Garden](http://bonsaiden.github.io/JavaScript-Garden/) is an in-depth
+guide of all the counter-intuitive parts of the language.
+
+[JavaScript: The Definitive Guide](http://www.amazon.com/gp/product/0596805527/) is a classic guide / reference book.
+
+In addition to direct contributors to this article, some content is adapted
+from Louie Dinh's Python tutorial on this site, and the [JS
+Tutorial](https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript)
+on the Mozilla Developer Network.