Merge pull request #41 from javascript-tutorial/revert-40-master

Revert "translate Alternate OR| into arabic"

Author: OmarioHassan

9-regular-expressions/13-regexp-alternation/01-find-programming-language/solution.md

@@ -1,7 +1,7 @@
 
-يمكن أن تكون الفكرة الأولى هي سرد اللغات التي يوجد بها "|" في الوسط.
+The first idea can be to list the languages with `|` in-between.
 
-لكن هذا لا يعمل بشكل صحيح:
+But that doesn't work right:
 
 ```js run
 let regexp = /Java|JavaScript|PHP|C|C\+\+/g;
@@ -11,18 +11,18 @@ let str = "Java, JavaScript, PHP, C, C++";
 alert( str.match(regexp) ); // Java,Java,PHP,C,C
 ```
 
-يبحث محرك التعبير العادي عن البدائل واحدة تلو الأخرى. هذا هو: أولاً يتحقق مما إذا كان لدينا `match: Java` ، وإلا - يبحث عن` match: JavaScript` وما إلى ذلك.
+The regular expression engine looks for alternations one-by-one. That is: first it checks if we have  `match:Java`, otherwise -- looks for `match:JavaScript` and so on.
 
-ونتيجة لذلك ، لا يمكن العثور على `match: JavaScript` مطلقًا ، فقط لأنه يتم تحديد` match: Java` أولاً.
+As a result, `match:JavaScript` can never be found, just because `match:Java` is checked first.
 
-نفس الشيء مع `match: C` و` match: C ++ `.
+The same with `match:C` and `match:C++`.
 
-هناك حلان لهذه المشكلة:
+There are two solutions for that problem:
 
-1. قم بتغيير الترتيب للتحقق من المطابقة الأطول أولاً: `pattern: JavaScript | Java | C \ + \ + | C | PHP`.
-2. دمج المتغيرات بنفس البداية: `pattern: Java (Script)؟ | C (\ + \ +)؟ | PHP`.
+1. Change the order to check the longer match first: `pattern:JavaScript|Java|C\+\+|C|PHP`.
+2. Merge variants with the same start: `pattern:Java(Script)?|C(\+\+)?|PHP`.
 
-بشكل عملي: 
+In action:
 
 ```js run
 let regexp = /Java(Script)?|C(\+\+)?|PHP/g;
@@ -31,4 +31,3 @@ let str = "Java, JavaScript, PHP, C, C++";
 
 alert( str.match(regexp) ); // Java,JavaScript,PHP,C,C++
 ```
-

9-regular-expressions/13-regexp-alternation/01-find-programming-language/task.md

@@ -1,12 +1,11 @@
-# البحث عن لغات البرمجة
+# Find programming languages
 
-هناك العديد من لغات البرمجة ، مثل Java و JavaScript و PHP و C و C ++.
+There are many programming languages, for instance Java, JavaScript, PHP, C, C++.
 
-أنشئ التعبير العادي الذي يعثر عليه في السلسلة `الموضوع: Java JavaScript PHP C ++ C`:
+Create a regexp that finds them in the string `subject:Java JavaScript PHP C++ C`:
 
 ```js
 let regexp = /your regexp/g;
 
 alert("Java JavaScript PHP C++ C".match(regexp)); // Java JavaScript PHP C++ C
 ```
-

9-regular-expressions/13-regexp-alternation/02-find-matching-bbtags/solution.md

@@ -1,11 +1,11 @@
 
-علامة الفتح هي `النمط: \ [(b | url | الاقتباس) \]`.
+Opening tag is `pattern:\[(b|url|quote)\]`.
 
-ثم للعثور على كل شيء حتى علامة الإغلاق - دعنا نستخدم النمط `pattern:. *؟` مع العلامة `pattern: s` لمطابقة أي حرف بما في ذلك السطر الجديد ثم إضافة مرجع خلفي إلى علامة الإغلاق.
+Then to find everything till the closing tag -- let's use the pattern `pattern:.*?` with flag `pattern:s` to match any character including the newline and then add a backreference to the closing tag.
 
-النمط الكامل: `pattern: \ [(b | url | الاقتباس) \]. *؟ \ [/ \ 1 \]`.
+The full pattern: `pattern:\[(b|url|quote)\].*?\[/\1\]`.
 
-بشكل عملي:
+In action:
 
 ```js run
 let regexp = /\[(b|url|quote)\].*?\[\/\1\]/gs;
@@ -20,4 +20,4 @@ let str = `
 alert( str.match(regexp) ); // [b]hello![/b],[quote][url]http://google.com[/url][/quote]
 ```
 
-يرجى ملاحظة أنه بالإضافة إلى الهروب من `نمط: [` و `نقش:]` ، كان علينا أن نهرب من شرطة مائلة لنموذج علامة الإغلاق: [\ / \ 1] `، لأن الخط المائل يغلق النمط عادةً.
+Please note that besides escaping `pattern:[` and `pattern:]`, we had to escape a slash for the closing tag `pattern:[\/\1]`, because normally the slash closes the pattern.

9-regular-expressions/13-regexp-alternation/02-find-matching-bbtags/task.md

@@ -1,35 +1,35 @@
-# البحث عن أزواج bbtag
+# Find bbtag pairs
 
-تبدو علامة "bb-tag" مثل `[tag] ... [/ tag]` ، حيث `tag` هي واحدة من:` b` أو `url` أو` quote`.
+A "bb-tag" looks like `[tag]...[/tag]`, where `tag` is one of: `b`, `url` or `quote`.
 
-على سبيل المثال:
+For instance:
 ```
 [b]text[/b]
 [url]http://google.com[/url]
 ```
 
-يمكن أن تتداخل علامات BB. ولكن لا يمكن إدراج علامة في نفسها ، على سبيل المثال:
+BB-tags can be nested. But a tag can't be nested into itself, for instance:
 
 ```
-بشكل طبيعي:
+Normal:
 [url] [b]http://google.com[/b] [/url]
 [quote] [b]text[/b] [/quote]
 
-لا يمكن حدوثه:
+Can't happen:
 [b][b]text[/b][/b]
 ```
 
-يمكن أن تحتوي العلامات على فواصل أسطر ، وهذا أمر طبيعي:
+Tags can contain line breaks, that's normal:
 
 ```
 [quote]
   [b]text[/b]
 [/quote]
 ```
 
-قم بإنشاء التعبير العادي للعثور على جميع علامات BB مع محتوياتها.
-على سبيل المثال:
+Create a regexp to find all BB-tags with their contents.
 
+For instance:
 
 ```js
 let regexp = /your regexp/flags;
@@ -38,12 +38,11 @@ let str = "..[url]http://google.com[/url]..";
 alert( str.match(regexp) ); // [url]http://google.com[/url]
 ```
 
-إذا كانت العلامات متداخلة ، فإننا نحتاج إلى العلامة الخارجية (إذا أردنا ، يمكننا متابعة البحث في محتواها):
+If tags are nested, then we need the outer tag (if we want we can continue the search in its content):
 
 ```js
 let regexp = /your regexp/flags;
 
 let str = "..[url][b]http://google.com[/b][/url]..";
 alert( str.match(regexp) ); // [url][b]http://google.com[/b][/url]
 ```
-

9-regular-expressions/13-regexp-alternation/03-match-quoted-string/solution.md

@@ -1,18 +1,17 @@
-الحل: `pattern: /" (\\. | [^ "\\]) *" / g`.
+The solution: `pattern:/"(\\.|[^"\\])*"/g`.
 
-خطوة بخطوة:
+Step by step:
 
-- أولاً نبحث عن "نمط" الاقتباس الافتتاحي: "
-- ثم إذا كان لدينا نمط `` الشرطة المائلة للخلف '': `` (يجب علينا تقنيًا مضاعفته في النمط ، لأنه شخصية خاصة ، لذلك فهي خط مائل عكسي في الواقع) ، فإن أي حرف يكون جيدًا بعده (نقطة ).
-- وإلا فإننا نأخذ أي حرف باستثناء الاقتباس (وهذا يعني نهاية السلسلة) وشرطة مائلة للخلف (لمنع الخطوط المائلة العكسية الوحيدة ، يتم استخدام الشرطة المائلة للخلف فقط مع بعض الرموز الأخرى بعدها): `النمط: [^" \\] `
-- ... وهلم جرا حتى آخر quote أو علامة افتباس .
+- First we look for an opening quote `pattern:"`
+- Then if we have a backslash `pattern:\\` (we technically have to double it in the pattern, because it is a special character, so that's a single backslash in fact), then any character is fine after it (a dot).
+- Otherwise we take any character except a quote (that would mean the end of the string) and a backslash (to prevent lonely backslashes, the backslash is only used with some other symbol after it): `pattern:[^"\\]`
+- ...And so on till the closing quote.
 
-بشكل:
+In action:
 
 ```js run
 let regexp = /"(\\.|[^"\\])*"/g;
 let str = ' .. "test me" .. "Say \\"Hello\\"!" .. "\\\\ \\"" .. ';
 
 alert( str.match(regexp) ); // "test me","Say \"Hello\"!","\\ \""
 ```
-

9-regular-expressions/13-regexp-alternation/03-match-quoted-string/task.md

@@ -1,33 +1,32 @@
-# البحث عن سلاسل الاقتباس
+# Find quoted strings
 
-قم بإنشاء regexp للعثور على سلاسل في علامات اقتباس مزدوجة `الموضوع:" ... "`.
+Create a regexp to find strings in double quotes `subject:"..."`.
 
-يجب أن تدعم السلاسل الهروب ، بنفس الطريقة التي تدعمها سلاسل JavaScript. على سبيل المثال ، يمكن إدراج علامات الاقتباس كـ `subject: \" `سطر جديد مثل` subject: \ n` ، والشرطة نفسها كـ `subject: \\`.
+The strings should support escaping, the same way as JavaScript strings do. For instance, quotes can be inserted as `subject:\"` a newline as `subject:\n`, and the slash itself as `subject:\\`.
 
 ```js
 let str = "Just like \"here\".";
 ```
 
-يرجى ملاحظة ، على وجه الخصوص ، أن الاقتباس الهارب `موضوع: \" `لا ينهي سلسلة.
+Please note, in particular, that an escaped quote `subject:\"` does not end a string.
 
-لذلك يجب علينا البحث من اقتباس واحد إلى الآخر تجاهل علامات الاقتباس الهاربة على الطريق.
+So we should search from one quote to the other ignoring escaped quotes on the way.
 
-هذا هو الجزء الأساسي من المهمة ، وإلا سيكون تافها.
+That's the essential part of the task, otherwise it would be trivial.
 
-أمثلة على السلاسل المراد مطابقتها:
+Examples of strings to match:
 ```js
 .. *!*"test me"*/!* ..  
 .. *!*"Say \"Hello\"!"*/!* ... (escaped quotes inside)
 .. *!*"\\"*/!* ..  (double slash inside)
 .. *!*"\\ \""*/!* ..  (double slash and an escaped quote inside)
 ```
 
-في جافا سكريبت ، نحتاج إلى مضاعفة الخطوط المائلة لتمريرها مباشرة في السلسلة ، مثل هذا:
+In JavaScript we need to double the slashes to pass them right into the string, like this:
 
 ```js run
 let str = ' .. "test me" .. "Say \\"Hello\\"!" .. "\\\\ \\"" .. ';
 
 // the in-memory string
 alert(str); //  .. "test me" .. "Say \"Hello\"!" .. "\\ \"" ..
 ```
-

9-regular-expressions/13-regexp-alternation/04-match-exact-tag/solution.md

@@ -1,17 +1,16 @@
 
-بداية النمط واضحة: `pattern: <style`.
+The pattern start is obvious: `pattern:<style`.
 
-... ولكن بعد ذلك لا يمكننا ببساطة كتابة `pattern: <style. *؟>` ، لأن `match: <styler>` ستطابقها.
+...But then we can't simply write `pattern:<style.*?>`, because `match:<styler>` would match it.
 
-نحتاج إلى مسافة بعد `match: <style` ثم اختياريًا شيء آخر أو` `match:>` النهائي.
+We need either a space after `match:<style` and then optionally something else or the ending `match:>`.
 
-في لغة regexp: `pattern: <style (> | \ s. *؟>)`.
+In the regexp language: `pattern:<style(>|\s.*?>)`.
 
-بشكل عملي:
+In action:
 
 ```js run
 let regexp = /<style(>|\s.*?>)/g;
 
 alert( '<style> <styler> <style test="...">'.match(regexp) ); // <style>, <style test="...">
 ```
-

9-regular-expressions/13-regexp-alternation/04-match-exact-tag/task.md

@@ -1,14 +1,13 @@
-# البحث عن العلامة الكاملة
+# Find the full tag
 
-اكتب regexp للعثور على العلامة `<style ...>`. يجب أن تتطابق مع العلامة الكاملة: قد لا تحتوي على سمات `<style>` أو تحتوي على العديد منها `<style type =" ... "id =" ... ">`.
+Write a regexp to find the tag `<style...>`. It should match the full tag: it may have no attributes  `<style>` or have several of them `<style type="..." id="...">`.
 
-... لكن التعبير العادي يجب ألا يطابق `<styler>`!
+...But the regexp should not match `<styler>`!
 
-على سبيل المثال:
+For instance:
 
 ```js
 let regexp = /your regexp/g;
 
 alert( '<style> <styler> <style test="...">'.match(regexp) ); // <style>, <style test="...">
 ```
-

9-regular-expressions/13-regexp-alternation/article.md

@@ -1,14 +1,14 @@
-# التناوب (أو) |
+# Alternation (OR) |
 
-البديل هو المصطلح في التعبير العادي وهو في الواقع "OR" بسيط.
+Alternation is the term in regular expression that is actually a simple "OR".
 
-في التعبير العادي ، يُشار إليه بحرف السطر العمودي `pattern: |`.
+In a regular expression it is denoted with a vertical line character `pattern:|`.
 
-على سبيل المثال ، نحتاج إلى العثور على لغات البرمجة: HTML أو PHP أو Java أو JavaScript.
+For instance, we need to find programming languages: HTML, PHP, Java or JavaScript.
 
-التعبير العادي المقابل: `pattern: html | php | java (script)؟`.
+The corresponding regexp: `pattern:html|php|java(script)?`.
 
-مثال للاستخدام:
+A usage example:
 
 ```js run
 let regexp = /html|php|css|java(script)?/gi;
@@ -18,54 +18,53 @@ let str = "First HTML appeared, then CSS, then JavaScript";
 alert( str.match(regexp) ); // 'HTML', 'CSS', 'JavaScript'
 ```
 
-لقد رأينا بالفعل شيئًا مشابهًا - الأقواس المربعة. تسمح بالاختيار بين عدة أحرف ، على سبيل المثال `pattern: gr [ae] y` يطابق` match: gre` أو `match: grey`.
+We already saw a similar thing -- square brackets. They allow to choose between multiple characters, for instance `pattern:gr[ae]y` matches `match:gray` or `match:grey`.
 
-تسمح الأقواس المربعة باستخدام الأحرف أو مجموعات الأحرف فقط. يسمح التناوب بأي تعبيرات. نمط regexp `: A | B | C` يعني أحد التعبيرات` A` أو `B` أو` C`.
+Square brackets allow only characters or character sets. Alternation allows any expressions. A regexp `pattern:A|B|C` means one of expressions `A`, `B` or `C`.
 
-على سبيل المثال:
+For instance:
 
-- `pattern: gr (a | e) y` يعني تمامًا مثل` pattern: gr [ae] y`.
-- `pattern: gra | ey` تعني` match: gra` أو `match: ey`.
+- `pattern:gr(a|e)y` means exactly the same as `pattern:gr[ae]y`.
+- `pattern:gra|ey` means `match:gra` or `match:ey`.
 
-لتطبيق التناوب على جزء مختار من النمط ، يمكننا تضمينه بين قوسين:
-- `النمط: أحب HTML | CSS` يطابق` مطابقة: أنا أحب HTML` أو `تطابق: CSS`.
-- `pattern: I love (HTML | CSS)` يتطابق مع `match: I love HTML` أو` match: I love CSS`.
+To apply alternation to a chosen part of the pattern, we can enclose it in parentheses:
+- `pattern:I love HTML|CSS` matches `match:I love HTML` or `match:CSS`.
+- `pattern:I love (HTML|CSS)` matches `match:I love HTML` or `match:I love CSS`.
 
-## مثال: regexp للوقت
+## Example: regexp for time
 
-في المقالات السابقة ، كانت هناك مهمة لبناء regexp لوقت البحث في شكل `hh: mm` ، على سبيل المثال` 12: 00`. لكن `` النمط البسيط: \ d \ d: \ d \ d` غامض للغاية. يقبل `25: 99` كوقت (حيث تتطابق 99 ثانية مع النمط ، لكن ذلك الوقت غير صالح).
+In previous articles there was a task to build a regexp for searching time in the form `hh:mm`, for instance `12:00`. But a simple `pattern:\d\d:\d\d` is too vague. It accepts `25:99` as the time (as 99 seconds match the pattern, but that time is invalid).
 
-كيف يمكننا صنع نمط أفضل؟
+How can we make a better pattern?
 
-يمكننا استخدام مطابقة أكثر دقة. اولا الساعات:
+We can use more careful matching. First, the hours:
 
-- إذا كان الرقم الأول هو "0" أو "1" ، فيمكن أن يكون الرقم التالي أي: `pattern: [01] \ d`.
-- وإلا ، إذا كان الرقم الأول هو "2" ، فيجب أن يكون الرقم التالي "pattern: [0-3]`.
-- (غير مسموح بالرقم الأول الآخر)
+- If the first digit is `0` or `1`, then the next digit can be any: `pattern:[01]\d`.
+- Otherwise, if the first digit is `2`, then the next must be `pattern:[0-3]`.
+- (no other first digit is allowed)
 
-يمكننا كتابة كلا المتغيرين في regexp باستخدام البديل: `pattern: [01] \ d | 2 [0-3]`.
+We can write both variants in a regexp using alternation: `pattern:[01]\d|2[0-3]`.
 
-بعد ذلك ، يجب أن تكون الدقائق من `00` إلى` 59`. في لغة التعبير العادي التي يمكن كتابتها كـ `pattern: [0-5] \ d`: الرقم الأول` 0-5` ، ثم أي رقم.
+Next, minutes must be from `00` to `59`. In the regular expression language that can be written as `pattern:[0-5]\d`: the first digit `0-5`, and then any digit.
 
-إذا صقنا الدقائق والثواني معًا ، نحصل على النمط: `pattern: [01] \ d | 2 [0-3]: [0-5] \ d`.
+If we glue minutes and seconds together, we get the pattern: `pattern:[01]\d|2[0-3]:[0-5]\d`.
 
-لقد انتهينا تقريبًا ، ولكن هناك مشكلة. يحدث "النمط البديل": | `الآن بين` النمط: [01] \ d` و "النمط: 2 [0-3]: [0-5] \ d`.
+We're almost done, but there's a problem. The alternation `pattern:|` now happens to be between `pattern:[01]\d` and `pattern:2[0-3]:[0-5]\d`.
 
-أي: تمت إضافة الدقائق إلى البديل الثاني ، إليك صورة واضحة:
+That is: minutes are added to the second alternation variant, here's a clear picture:
 
-``
-[01] \ d | 2 [0-3]: [0-5] \ د
-``
+```
+[01]\d  |  2[0-3]:[0-5]\d
+```
 
-يبحث هذا النمط عن `النمط: [01] \ d` أو` النمط: 2 [0-3]: [0-5] \ d`.
+That pattern looks for `pattern:[01]\d` or `pattern:2[0-3]:[0-5]\d`.
 
-ولكن هذا خطأ ، يجب استخدام التناوب فقط في جزء "الساعات" من التعبير العادي ، للسماح بـ "pattern: [01] \ d` OR` pattern: 2 [0-3] `. دعنا نصحح ذلك عن طريق وضع "ساعات" بين قوسين: `النمط: ([01] \ d | 2 [0-3]): [0-5] \ d`.
+But that's wrong, the alternation should only be used in the "hours" part of the regular expression, to allow `pattern:[01]\d` OR `pattern:2[0-3]`. Let's correct that by enclosing "hours" into parentheses: `pattern:([01]\d|2[0-3]):[0-5]\d`.
 
-الحل النهائي:
+The final solution:
 
 ```js run
 let regexp = /([01]\d|2[0-3]):[0-5]\d/g;
 
 alert("00:00 10:10 23:59 25:99 1:2".match(regexp)); // 00:00,10:10,23:59
 ```
-