summaryrefslogtreecommitdiffhomepage
diff options
context:
space:
mode:
-rw-r--r--ta_in/javascript.html.markdown86
1 files changed, 53 insertions, 33 deletions
diff --git a/ta_in/javascript.html.markdown b/ta_in/javascript.html.markdown
index c1d7a961..f0b0a36a 100644
--- a/ta_in/javascript.html.markdown
+++ b/ta_in/javascript.html.markdown
@@ -418,28 +418,29 @@ anotherFunc.call(myObj, " And Hello Moon!"); // = "Hello World! And Hello Moon!"
anotherFunc.apply(myObj, [" And Hello Sun!"]); // = "Hello World! And Hello Sun!"
-// This is useful when working with a function that accepts a sequence of
-// arguments and you want to pass an array.
+//இது தொடர்ச்சியான 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
-// But, `call` and `apply` are only temporary. When we want it to stick, we can
-// use `bind`.
+//ஆனால் `call ` ,`apply ` இரண்டும் தற்காலிகமானவை
+//அவற்றை நிரந்தரமாக்க bind function ஐ பயன்படுத்தவும்
var boundFunc = anotherFunc.bind(myObj);
boundFunc(" And Hello Saturn!"); // = "Hello World! And Hello Saturn!"
-// `bind` can also be used to partially apply (curry) a function.
+//`bind ` ஐ உபயோகித்து ஒரு function ஐ பகுதியாக apply செய்ய முடியும்
var product = function(a, b){ return a * b; }
var doubler = product.bind(this, 2);
doubler(8); // = 16
-// When you call a function with the `new` keyword, a new object is created, and
-// made available to the function via the this keyword. Functions designed to be
-// called like that are called constructors.
+
+//ஒரு function ஐ நாம் new என்ற குறியீட்டு சொல்லை பயன்படுத்தி
+//அழைக்கும் போது புதிய object உருவாக்கப்படும் .இவ்வாறான functions
+//constructors என அழைக்கப்படும்
var MyConstructor = function(){
this.myNumber = 5;
@@ -447,13 +448,15 @@ var MyConstructor = function(){
myNewObj = new MyConstructor(); // = {myNumber: 5}
myNewObj.myNumber; // = 5
-// Every JavaScript object has a 'prototype'. When you go to access a property
-// on an object that doesn't exist on the actual object, the interpreter will
-// look at its prototype.
+//ஒவ்வொரு JavaScript object உம் ஒரு `prototype ` கொண்டுள்ளது
+//நீங்கள் object ஒன்றின் ஒரு property ஐ அணுகும் போது
+//அந்த property இல்லாவிடின் interpreter ஆனது
+//அதன் prototype உள்ளதா என பார்க்கும்
-// Some JS implementations let you access an object's prototype on the magic
-// property `__proto__`. While this is useful for explaining prototypes it's not
-// part of the standard; we'll get to standard ways of using prototypes later.
+//JS இன் சில செயலாக்கங்கள் ஒரு object இன் protoype ஐ
+//இலகுவாக `__proto__` மூலம் access செய்ய முடியும் .
+//இது prototype பாவணை யை இலகுவாக்கினாலும்
+//இது சரியான ஒரு முறை அல்ல
var myObj = {
myString: "Hello world!"
};
@@ -470,32 +473,36 @@ myObj.meaningOfLife; // = 42
// This works for functions, too.
myObj.myFunc(); // = "hello world!"
-// Of course, if your property isn't on your prototype, the prototype's
-// prototype is searched, and so on.
+//உங்கள் property prototype இல் இல்லது இருப்பின் , protype இன்
+//prototype search செய்யப்படும்
myPrototype.__proto__ = {
myBoolean: true
};
myObj.myBoolean; // = true
-// There's no copying involved here; each object stores a reference to its
-// prototype. This means we can alter the prototype and our changes will be
-// reflected everywhere.
+//ஒவ்வொரு object உம் அதன் protype க்கும் reference (மேற்கோள் ) ஒன்றை வைத்திருக்கும்
+//நாம் ஒரு protype இணை மாற்றினால் அதன் மாற்றங்கள் எல்லா இடத்திலும் (program இல் )
+//பிரதிபலிக்கும்
myPrototype.meaningOfLife = 43;
myObj.meaningOfLife; // = 43
-// We mentioned that `__proto__` was non-standard, and there's no standard way to
-// change the prototype of an existing object. However, there are two ways to
-// create a new object with a given prototype.
+
+//நாம் முன்பு கூறியது போல் `__proto__` பயன்படுத்துவது சரியான முறை அல்ல
+//எனவே நாம் ஒரு protype ஐ object இல் உருவாக்க இரண்டு வழிமுறைகள்
+//உள்ளன
+
+// முதல் முறை Object.create இது அண்மையில் அறிமுகம் செய்ய பட்ட ஒன்று
+//எனவே சில இடங்களில் இந்த முறை இன்னும் அறிமுகம் ஆகவில்லை
-// The first is Object.create, which is a recent addition to JS, and therefore
-// not available in all implementations yet.
var myObj = Object.create(myPrototype);
myObj.meaningOfLife; // = 43
-// The second way, which works anywhere, has to do with constructors.
-// Constructors have a property called prototype. This is *not* the prototype of
-// the constructor function itself; instead, it's the prototype that new objects
-// are given when they're created with that constructor and the new keyword.
+
+// இரண்டாவது முறை , இது சகல இடங்களிலும் வேலைசெய்யும், இது constructors மூலம்.
+//constructors prototype என்னும் ஒரு காரணியை கொண்டுள்ளது , இது constructor function
+//இன் prototype அன்று. ,இது நாம் new என்ற குறியீட்டு சொல்லையும் அந்த constructor உபயோகித்து
+//உருவாக்கபடுகிறது
+
MyConstructor.prototype = {
myNumber: 5,
getMyNumber: function(){
@@ -509,20 +516,26 @@ 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
-// Except, they aren't exactly equivalent.
+
+//இவை மிக சிறிய அளவில் ஒத்தவை
typeof myNumber; // = 'number'
typeof myNumberObj; // = 'object'
myNumber === myNumberObj; // = false
if (0){
- // This code won't execute, because 0 is falsy.
+ // இந்த கூற்றானது செயல்படுத்தபடாது ஏனெனில் ௦ 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);
}
@@ -532,8 +545,15 @@ String.prototype.firstCharacter = function(){
// features of JavaScript in an older subset of JavaScript, so that they can be
// used in older environments such as outdated browsers.
-// For instance, we mentioned that Object.create isn't yet available in all
-// implementations, but we can still use it with this polyfill:
+//இந்த முறையானது "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
@@ -545,7 +565,7 @@ if (Object.create === undefined){ // don't overwrite it if it exists
}
```
-## Further Reading
+## மேலும் JavaScript பற்றி கற்க
The [Mozilla Developer
Network](https://developer.mozilla.org/en-US/docs/Web/JavaScript) provides