Merge remote-tracking branch 'adambard/master'

2 files changed, 463 insertions, 0 deletions

diff --git a/hd-hd/amd.html.markdown b/hd-hd/amd.html.markdown
new file mode 100644
index 00000000..0a6581d6
--- /dev/null
+++ b/hd-hd/amd.html.markdown
@@ -0,0 +1,207 @@
+---
+category: tool
+tool: amd
+contributors:
+    - ["Frederik Ring", "https://github.com/m90"]
+filename: learnamd-hd.js
+lang: hd
+---
+## एएमडी के साथ प्रारंभ करना
+
+एपीआई को परिभाषित करने के लिए एक तंत्र को निर्दिष्ट ** ** अतुल्यकालिक मॉड्यूल परिभाषा
+जावास्क्रिप्ट मॉड्यूल ऐसे मॉड्यूल और इसकी अतुल्यकालिक निर्भरता से भरा हुआ है। यह ब्राउज़र पर्यावरण जहां के लिए विशेष रूप से अच्छी तरह से अनुकूल है, और प्रदर्शन , प्रयोज्य, डीबगिंग, और क्रॉस-डोमेन जैसे मॉड्यूल्स को जल्दी सिंक्रनाइज़ लोडिंग करता hai।
+
+### मूल अवधारणा
+```javascript
+// बुनियादी एएमडी एपीआई दो तरीकों लेकिन कुछ भी नहीं होते : ` define` और` require`
+// और सभी मॉड्यूल परिभाषा और खपत के बारे में है :
+// `define` एक मॉड्यूल को परिभाषित करता है
+// ` require` निर्भरता का एक सेट का आयात करता है और
+// पारित कर दिया कॉलबैक में उन्हें सेवन करती है
+
+// एक नया नाम देकर हम मॉड्यूल को परिभाषित करने का उपयोग करके शुरू करते हैं
+// जिसकी कोई निर्भरता है । हम एक नाम से गुजर रहा है ऐसा करेंगे
+// और एक कारखाने समारोह को परिभाषित करने के लिए :
+define('awesomeAMD', function(){
+  var isAMDAwesome = function(){
+    return true;
+  };
+// एक मॉड्यूल के कारखाने समारोह की मान है
+  // जब प्राप्त होगा क्या अन्य मॉड्यूल या आवश्यकता कॉल
+  // हमारे ` awesomeAMD` मॉड्यूल की आवश्यकता होती है ।
+  // निर्यात मूल्य कुछ भी हो सकता है, (निर्माता ) काम करता है,
+  // वस्तुओं, पुरातन, (जो कि बहुत ज्यादा मदद नहीं करेगा , हालांकि) भी अपरिभाषित ।
+  return isAMDAwesome;
+});
+
+// अब, हमारे ` awesomeAMD` मॉड्यूल पर निर्भर करता है कि किसी अन्य मॉड्यूल परिभाषित करते हैं।
+// हमारे परिभाषित करने के लिए एक अतिरिक्त तर्क है कि नोटिस
+अब // मॉड्यूल की निर्भरता :
+define('loudmouth', ['awesomeAMD'], function(awesomeAMD){
+// निर्भरता कारखाने के तर्कों को पारित हो जाएगा
+  // क्रम में वे निर्दिष्ट कर रहे हैं
+  var tellEveryone = function(){
+    if (awesomeAMD()){
+      alert('This is sOoOo rad!');
+    } else {
+      alert('Pretty dull, isn\'t it?');
+    }
+  };
+  return tellEveryone;
+});
+
+// हम अब परिभाषित का उपयोग करने के लिए कैसे जानते हैं के रूप में, के लिए ` require` का उपयोग करते हैं
+// हमारे कार्यक्रम बंद किक । ` require` के हस्ताक्षर है :(arrayOfDependencies, callback)`.
+require(['loudmouth'], function(loudmouth){
+  loudmouth();
+});
+
+// इस ट्यूटोरियल रन कोड बनाने के लिए है, चलो एक बहुत ही बुनियादी लागू करते हैं
+// (गैर अतुल्यकालिक ) की मौके पर यहीं एएमडी के संस्करण:
+function define(name, deps, factory){
+// निर्भरता के बिना मॉड्यूल नियंत्रित किया जाता है कैसे नोटिस
+  define[name] = require(factory ? deps : [], factory || deps);
+}
+
+function require(deps, callback){
+  var args = [];
+ // पहले की जरूरत है सभी निर्भरता पुनः प्राप्त करते हैं
+  // आवश्यकता कॉल द्वारा
+  for (var i = 0; i < deps.length; i++){
+    args[i] = define[deps[i]];
+  }
+// सभी कॉलबैक की निर्भरता को संतुष्ट
+  return callback.apply(null, args);
+}
+// आप यहाँ कार्रवाई में इस कोड को देख सकते हैं: http://jsfiddle.net/qap949pd/
+```
+
+### Require.js के साथ वास्तविक दुनिया के उपयोग
+
+परिचयात्मक उदाहरण के विपरीत, ` require.js` (सबसे लोकप्रिय एएमडी पुस्तकालय ) वास्तव में लागू करता है ** ** Amd ** में  *A * **, आप XHR के माध्यम से  मॉड्यूल और उनकी निर्भरता लोड करने के लिए सक्षम करने के लिए :
+```javascript
+/* file: app/main.js */
+require(['modules/someClass'], function(SomeClass){
+  // निर्भरता लोड होने तक कॉलबैक टाल दिया गया है
+  var thing = new SomeClass();
+});
+console.log('So here we are, waiting!'); // this will run first
+```
+
+परंपरा के अनुसार , आप आमतौर पर एक फाइल में एक मॉड्यूल में ही रखते है । ` require.js` फ़ाइल पथ पर आधारित मॉड्यूल नाम को हल कर सकते हैं , तो आप अपने मॉड्यूल के नाम करने की जरूरत नहीं है , लेकिन बस उनके स्थान का उपयोग कर उन्हें संदर्भित कर सकते हैं । उदाहरण के `में someClass` आपके विन्यास की ` baseUrl` के सापेक्ष ` modules` फ़ोल्डर में माना गया है :
+
+* app/
+  * main.js
+  * modules/
+    * someClass.js
+    * someHelpers.js
+    * ...
+  * daos/
+    * things.js
+    * ...
+
+इसका मतलब यह है कि हम एक मॉड्यूल आईडी निर्दिष्ट किए बिना ` someClass` परिभाषित कर सकते हैं :
+
+```javascript
+/* file: app/modules/someClass.js */
+define(['daos/things', 'modules/someHelpers'], function(thingsDao, helpers){
+  // module definition, of course, will also happen asynchronously
+  function SomeClass(){
+    this.method = function(){/**/};
+    // ...
+  }
+  return SomeClass;
+});
+```
+अपने ` main.js` में डिफ़ॉल्ट पथ मानचित्रण व्यवहार का उपयोग ` requirejs.config ( configObj ) ` में परिवर्तन करने के लिए:
+
+```javascript
+/* file: main.js */
+requirejs.config({
+  baseUrl : 'app',
+  paths : {
+    // आप भी अन्य स्थानों से मॉड्यूल लोड कर सकते हैं
+    jquery : '//ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min',
+    coolLibFromBower : '../bower_components/cool-lib/coollib'
+  }
+});
+require(['jquery', 'coolLibFromBower', 'modules/someHelpers'], function($, coolLib, helpers){
+  //एक ` main` फ़ाइल में कम से कम एक बार की आवश्यकता को फोन करने की जरूरत है,
+  // अन्यथा कोई कोड कभी चलेंगे
+  coolLib.doFancyStuffWith(helpers.transform($('#foo')));
+});
+```
+` require.js` आधारित क्षुधा आमतौर पर एक डाटा विशेषता के रूप में ` require.js` स्क्रिप्ट टैग को पारित कर दिया है कि एक एकल प्रवेश बिंदु (` main.js` ) होगा। यह स्वचालित रूप से भरी हुई है और pageload पर क्रियान्वित किया जाएगा :
+
+```html
+<!DOCTYPE html>
+<html>
+<head>
+  <title>A hundred script tags? Never again!</title>
+</head>
+<body>
+  <script src="require.js" data-main="app/main"></script>
+</body>
+</html>
+```
+
+### R.js का उपयोग कर एक पूरी परियोजना का अनुकूलन
+
+कई लोगों को विकास के दौरान समझदार कोड संगठन के लिए एएमडी का उपयोग कर पसंद करते हैं, लेकिन अभी भी पेज लोड पर XHRs के सैकड़ों करने के बजाय उत्पादन में एक भी स्क्रिप्ट फ़ाइल जहाज करने के लिए चाहते हैं।
+
+(राइनो भी समर्थन किया है, तो आप शायद Node.js में चलेगा ) ` require.js` ( अपनी परियोजना की निर्भरता ग्राफ का विश्लेषण , और अपने सभी मॉड्यूल युक्त एक एकल फाइल निर्माण कर सकते हैं कि ` r.js` नामक एक स्क्रिप्ट के साथ आता है ठीक से minified और उपभोग के लिए तैयार है, ) नाम दिया है।
+Install it using `npm`:
+```shell
+$ npm install requirejs -g
+```
+
+अब आप एक विन्यास फाइल के साथ फ़ीड कर सकते हैं:
+```shell
+$ r.js -o app.build.js
+```
+
+हमारे ऊपर के उदाहरण के लिए विन्यास की तरह लग सकता है:
+```javascript
+/* file : app.build.js */
+({
+  name : 'main', // प्रवेश बिंदु के नाम
+  out : 'main-built.js', // फ़ाइल का नाम करने के लिए उत्पादन में लिखने के लिए
+  baseUrl : 'app',
+  paths : {
+    // ` empty :` का उपयोग कर , यह अभी भी समन्वय से लोड किया जाना चाहिए कि r.js बताता है
+    // main.js में निर्दिष्ट स्थान
+    jquery : 'empty:',
+    coolLibFromBower : '../bower_components/cool-lib/coollib'
+  }
+})
+```
+
+उत्पादन में बनाया फ़ाइल का उपयोग करने के लिए, बस ` Data-main` स्वैप:
+```html
+<script src="require.js" data-main="app/main-built"></script>
+```
+
+एक अविश्वसनीय रूप से विस्तृत [निर्माण विकल्पों में से अवलोकन] (https://github.com/jrburke/r.js/blob/master/build/example.build.js) GitHub रेपो में उपलब्ध है।
+
+### विषय इस ट्यूटोरियल में शामिल नहीं
+* [लोडर प्लगइन्स / रूपांतरण] (http://requirejs.org/docs/plugins.html)
+* [CommonJS शैली लोड हो रहा है और निर्यात] (http://requirejs.org/docs/commonjs.html)
+* [उन्नत विन्यास] (http://requirejs.org/docs/api.html#config)
+* [शिम विन्यास (गैर एएमडी मॉड्यूल लोडिंग)] (http://requirejs.org/docs/api.html#config-shim)
+* [सीएसएस लदान और require.js साथ अनुकूलन] (http://requirejs.org/docs/optimization.html#onecss)
+* (Https://github.com/jrburke/almond) [बनाता है के लिए almond.js का प्रयोग]
+
+### अग्रिम पठन:
+
+* [सरकारी कल्पना] (https://github.com/amdjs/amdjs-api/wiki/AMD)
+* [क्यों एएमडी?] (Http://requirejs.org/docs/whyamd.html)
+* [यूनिवर्सल मॉड्यूल परिभाषा] (https://github.com/umdjs/umd)
+
+### कार्यान्वयन:
+
+* [Require.js] (http://requirejs.org)
+* [डोजो टूलकिट] (http://dojotoolkit.org/documentation/tutorials/1.9/modules/)
+* [Cujo.js] (http://cujojs.com/)
+* [Curl.js] (https://github.com/cujojs/curl)
+* [Lsjs] (https://github.com/zazl/lsjs)
+* [एमडी] (https://github.com/alexlawrence/mmd)
diff --git a/hd-hd/d.html.markdown b/hd-hd/d.html.markdown
new file mode 100644
index 00000000..96274e2b
--- /dev/null
+++ b/hd-hd/d.html.markdown
@@ -0,0 +1,256 @@
+---
+language: D
+filename: learnd-hd.d
+contributors:
+    - ["Nick Papanastasiou", "www.nickpapanastasiou.github.io"]
+lang: hd
+---
+
+```c
+//क्या आ रहा है पता है ...
+module hello;
+
+import std.stdio;
+
+void main(string[] args) {
+    writeln("Hello, World!");
+}
+```
+
+अगर आप मेरे जैसे हैं और इंटरनेट पर समय बहुत अधिक समय खर्च करते हैं, तो आप बाधाओं के बारे में सुना है
+के बारे में [डी ] ( http://dlang.org/ )। डी प्रोग्रामिंग भाषा में एक आधुनिक, सामान्य प्रयोजन है ,
+सब कुछ के लिए समर्थन कम स्तर की सुविधाओं से करने के साथ बहु - प्रतिमान भाषा
+अर्थपूर्ण उच्च स्तरीय चीजें ।
+
+D सक्रिय रूप से सुपर स्मार्ट लोगों का एक बड़ा समूह द्वारा विकसित की है और नेतृत्व द्वारा किया जाता है
+[ वाल्टर ब्राइट ] ( https://en.wikipedia.org/wiki/Walter_Bright ) और
+[ आंद्रेई Alexandrescu ] ( https://en.wikipedia.org/wiki/Andrei_Alexandrescu )।
+जिस तरह की है कि सभी के साथ बाहर, चलो कुछ उदाहरणों पर गौर करते हैं!
+
+
+```c
+import std.stdio;
+
+void main() {
+
+    for(int i = 0; i < 10000; i++) {
+        writeln(i);
+    }
+
+    // 'auto' can be used for inferring types.
+    auto n = 1;
+
+    // संख्यात्मक literals स्पष्टता के लिए एक अंकों विभाजक के रूप में '_' का उपयोग कर सकते हैं।
+    while(n < 10_000) {
+        n += n;
+    }
+
+    do {
+        n -= (n / 2);
+    } while(n > 0);
+    // लिए और जब तक अच्छा कर रहे हैं, लेकिन D में हम 'foreach' छोरों पसंद करते हैं।
+    // '..' पहला मान सहित एक सतत श्रृंखला बनाता है,
+    // लेकिन पिछले छोड़कर।
+    foreach(i; 1..1_000_000) {
+        if(n % 2 == 0)
+            writeln(i);
+    }
+
+    // वहाँ भी 'foreach_reverse' आप पीछे की ओर पाश करना चाहते हैं।
+    foreach_reverse(i; 1..int.max) {
+        if(n % 2 == 1) {
+            writeln(i);
+        } else {
+            writeln("No!");
+        }
+    }
+}
+```
+
+हम ' struct`, `class`,` union`, और `` enum` साथ नए प्रकार परिभाषित कर सकते हैं। Structs और unions
+मूल्य से कार्य करने के लिए पारित कर रहे हैं (यानी नकल) और वर्गों के संदर्भ द्वारा पारित कर रहे हैं। इसके अलावा,
+हम प्रकारों और मानों दोनों पर करने के लिए टेम्पलेट का उपयोग कर सकते हैं!
+
+```c
+// इधर, 'T' एक प्रकार पैरामीटर है। लगता है कि '&lt;+T&gt;' C++ / C/ Java से।
+struct LinkedList(T) {
+    T data = null;
+
+    // '!'का प्रयोग करें , एक पैरामिट्रीकृत प्रकार इन्स्तांत । फिर, '<T >' लगता है।
+    LinkedList!(T)* next;
+}
+
+class BinTree(T) {
+    T data = null;
+
+// केवल एक टेम्पलेट पैरामीटर नहीं है, तो  , हम कोष्ठकों छोड़ सकते हैं।
+    BinTree!T left;
+    BinTree!T right;
+}
+
+enum Day {
+    Sunday,
+    Monday,
+    Tuesday,
+    Wednesday,
+    Thursday,
+    Friday,
+    Saturday,
+}
+
+// उपयोग उर्फ प्रकार (alias) के लिए संक्षिप्त बनाने के लिए।
+alias IntList = LinkedList!int;
+alias NumTree = BinTree!double;
+
+//हम के रूप में अच्छी तरह से कार्य टेम्पलेट्स बना सकते हैं!
+T max(T)(T a, T b) {
+    if(a < b)
+        return b;
+
+    return a;
+}
+
+// संदर्भ द्वारा पारित सुनिश्चित करने के लिए रेफरी कीवर्ड का प्रयोग करें । यही कारण है कि यहां तक ​​कि 'A' और 'B' , तो है
+//मान प्रकार वे हमेशा ' swap()' के संदर्भ द्वारा पारित हो जाएगा  हैं ।
+void swap(T)(ref T a, ref T b) {
+    auto temp = a;
+
+    a = b;
+    b = temp;
+}
+
+// टेम्पलेट्स के साथ, हम भी मूल्यों पर परमेटेराइज़  कर सकते हैं , न सिर्फ types.With टेम्पलेट्स, हम भी नहीं है, बस प्रकार , मूल्यों पर parameterize कर सकते हैं।
+class Matrix(uint m, uint n, T = int) {
+    T[m] rows;
+    T[n] columns;
+}
+
+auto mat = new Matrix!(3, 3);
+
+```
+
+Classes की बात हो रही है , एक दूसरे के लिए गुणों के बारे में बात करते हैं। एक संपत्ति
+एक value की तरह कार्य कर सकते हैं कि एक समारोह में मोटे तौर पर है, इसलिए हम कर सकते हैं
+के शब्दों के साथ पॉड संरचनाओं की वाक्य रचना (` structure.x = 7` ) है
+मनुष्य और सेटर तरीकों ( ` object.setX (7) `) !
+
+```c
+// Consider a class parameterized on types 'T' & 'U'.
+class MyClass(T, U) {
+    T _data;
+    U _other;
+}
+
+// And "getter" and "setter" methods like so:
+class MyClass(T, U) {
+    T _data;
+    U _other;
+
+    // भवन निर्माताओं हमेशा नामित कर रहे हैं 'this'.
+    this(T t, U u) {
+        //यह नीचे सेटर तरीकों से मुलाकात करेंगे।
+        data = t;
+        other = u;
+    }
+
+    // getters
+    @property T data() {
+        return _data;
+    }
+
+    @property U other() {
+        return _other;
+    }
+
+    // setters
+    @property void data(T t) {
+        _data = t;
+    }
+
+    @property void other(U u) {
+        _other = u;
+    }
+}
+
+//और हम इस तरह से उन का उपयोग करें :
+void main() {
+    auto mc = new MyClass!(int, string)(7, "seven");
+
+   करने के लिए लिखने के लिए मानक पुस्तकालय से
+   // आयात ' stdio ' मॉड्यूल
+    // सांत्वना (आयात एक गुंजाइश के लिए स्थानीय हो सकता है) ।
+    import std.stdio;
+
+    // Call the getters to fetch the values.
+    writefln("Earlier: data = %d, str = %s", mc.data, mc.other);
+
+    // Call the setters to assign new values.
+    mc.data = 8;
+    mc.other = "eight";
+
+    // Call the getters again to fetch the new values.
+    writefln("Later: data = %d, str = %s", mc.data, mc.other);
+}
+```
+
+गुणों के साथ, हम तर्क की किसी भी राशि को जोड़ सकते हैं
+हमारे मनुष्य और सेटर तरीकों, और की साफ वाक्य रचना रखना
+सीधे सदस्यों तक पहुँचने !
+
+हमारे निपटान पर अन्य वस्तु उन्मुख उपहार
+` interface`s , ` सार class`es शामिल
+और ` तरीकों override`ing । डी सिर्फ जावा की तरह विरासत करता है:
+आप कृपया के रूप में कई इंटरफेस को लागू करने, एक वर्ग का विस्तार ।
+
+हम डी एस OOP सुविधाओं देखा , लेकिन स्विच गियर छोड़ दिया । डी प्रस्तावों
+प्रथम श्रेणी के कार्यों के साथ कार्यात्मक प्रोग्रामिंग, ` pure`
+काम करता है, और अपरिवर्तनीय डेटा । इसके अलावा, अपने पसंदीदा के सभी
+कार्यात्मक एल्गोरिदम ( नक्शा, फिल्टर , कम करने और मित्र हो सकते हैं)
+अद्भुत ` std.algorithm` मॉड्यूल में पाया!
+
+```c
+import std.algorithm : map, filter, reduce;
+import std.range : iota; // builds an end-exclusive range
+
+void main() {
+    // हम भी ints के वर्गों की एक सूची का योग मुद्रित करना चाहते हैं
+    // 1 से 100 के लिए आसान करने के लिए!
+
+    // बस टेम्पलेट पैरामीटर के रूप में लैम्ब्डा भाव के पास!
+    // आप आप की तरह किसी भी पुराने समारोह पारित कर सकते हैं , लेकिन lambdas यहाँ सुविधाजनक हैं।
+    auto num = iota(1, 101).filter!(x => x % 2 == 0)
+                           .map!(y => y ^^ 2)
+                           .reduce!((a, b) => a + b);
+
+    writeln(num);
+}
+```
+
+हम NUM गणना करने के लिए एक अच्छा Haskellian पाइपलाइन का निर्माण करने के लिए मिला सूचना कैसे ?
+यही कारण है कि एक डी नवाचार करने के लिए धन्यवाद वर्दी समारोह कॉल सिंटेक्स के रूप में जानते हैं।
+UFCS के साथ, हम एक विधि के रूप में एक समारोह कॉल लिखने के लिए चुन सकते हैं
+या मुफ्त समारोह कॉल ! वाल्टर इस पर एक अच्छा लेख लिखा था
+[यहाँ ।] ( http://www.drdobbs.com/cpp/uniform-function-call-syntax/232700394 )
+संक्षेप में, आप जिनकी पहली पैरामीटर कार्यों कॉल कर सकते हैं
+एक विधि के रूप में ग्रुप ए की किसी भी अभिव्यक्ति पर कुछ प्रकार एक की है ।
+
+मैं समानता चाहते । समानता की तरह कोई और? ज़रूर तुम करना। चलो कुछ करते हैं!
+```c
+import std.stdio;
+import std.parallelism : parallel;
+import std.math : sqrt;
+
+void main() {
+ // हम हमारे सरणी में वर्गमूल हर नंबर ले जाना चाहता हूँ ,
+ // हम उपलब्ध है के रूप में और के रूप में कई कोर का लाभ ले।
+    auto arr = new double[1_000_000];
+
+   // संदर्भ के द्वारा एक सूचकांक , और एक सरणी तत्व का प्रयोग
+    // और सिर्फ सरणी पर समानांतर फोन!
+    foreach(i, ref elem; parallel(arr)) {
+        ref = sqrt(i + 1.0);
+    }
+}
+
+
+```