Alternate OR

Author: Salah856

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
 ```
 
-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: Java` ، وإلا - يبحث عن` match: JavaScript` وما إلى ذلك.
 
-As a result, `match:JavaScript` can never be found, just because `match:Java` is checked first.
+ونتيجة لذلك ، لا يمكن العثور على `match: JavaScript` مطلقًا ، فقط لأنه يتم تحديد` match: Java` أولاً.
 
-The same with `match:C` and `match:C++`.
+نفس الشيء مع `match: C` و` match: C ++ `.
 
-There are two solutions for that problem:
+هناك حلان لهذه المشكلة:
 
-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`.
+1. قم بتغيير الترتيب للتحقق من المطابقة الأطول أولاً: `pattern: JavaScript | Java | C \ + \ + | C | PHP`.
+2. دمج المتغيرات بنفس البداية: `pattern: Java (Script)؟ | C (\ + \ +)؟ | PHP`.
 
-In action:
+بشكل عملي: 
 
 ```js run
 let regexp = /Java(Script)?|C(\+\+)?|PHP/g;
@@ -31,3 +31,4 @@ 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,11 +1,12 @@
-# Find programming languages
+# البحث عن لغات البرمجة
 
-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`:
+أنشئ التعبير العادي الذي يعثر عليه في السلسلة `الموضوع: 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 @@
 
-Opening tag is `pattern:\[(b|url|quote)\]`.
+علامة الفتح هي `النمط: \ [(b | url | الاقتباس) \]`.
 
-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:. *؟` مع العلامة `pattern: s` لمطابقة أي حرف بما في ذلك السطر الجديد ثم إضافة مرجع خلفي إلى علامة الإغلاق.
 
-The full pattern: `pattern:\[(b|url|quote)\].*?\[/\1\]`.
+النمط الكامل: `pattern: \ [(b | url | الاقتباس) \]. *؟ \ [/ \ 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]
 ```
 
-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.
+يرجى ملاحظة أنه بالإضافة إلى الهروب من `نمط: [` و `نقش:]` ، كان علينا أن نهرب من شرطة مائلة لنموذج علامة الإغلاق: [\ / \ 1] `، لأن الخط المائل يغلق النمط عادةً.

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

@@ -1,35 +1,35 @@
-# Find bbtag pairs
+# البحث عن أزواج bbtag
 
-A "bb-tag" looks like `[tag]...[/tag]`, where `tag` is one of: `b`, `url` or `quote`.
+تبدو علامة "bb-tag" مثل `[tag] ... [/ tag]` ، حيث `tag` هي واحدة من:` b` أو `url` أو` quote`.
 
-For instance:
+على سبيل المثال:
 ```
 [b]text[/b]
 [url]http://google.com[/url]
 ```
 
-BB-tags can be nested. But a tag can't be nested into itself, for instance:
+يمكن أن تتداخل علامات BB. ولكن لا يمكن إدراج علامة في نفسها ، على سبيل المثال:
 
 ```
-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]
 ```
 
-Create a regexp to find all BB-tags with their contents.
+قم بإنشاء التعبير العادي للعثور على جميع علامات BB مع محتوياتها.
+على سبيل المثال:
 
-For instance:
 
 ```js
 let regexp = /your regexp/flags;
@@ -38,11 +38,12 @@ 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,17 +1,18 @@
-The solution: `pattern:/"(\\.|[^"\\])*"/g`.
+الحل: `pattern: /" (\\. | [^ "\\]) *" / g`.
 
-Step by step:
+خطوة بخطوة:
 
-- 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.
+- أولاً نبحث عن "نمط" الاقتباس الافتتاحي: "
+- ثم إذا كان لدينا نمط `` الشرطة المائلة للخلف '': `` (يجب علينا تقنيًا مضاعفته في النمط ، لأنه شخصية خاصة ، لذلك فهي خط مائل عكسي في الواقع) ، فإن أي حرف يكون جيدًا بعده (نقطة ).
+- وإلا فإننا نأخذ أي حرف باستثناء الاقتباس (وهذا يعني نهاية السلسلة) وشرطة مائلة للخلف (لمنع الخطوط المائلة العكسية الوحيدة ، يتم استخدام الشرطة المائلة للخلف فقط مع بعض الرموز الأخرى بعدها): `النمط: [^" \\] `
+- ... وهلم جرا حتى آخر 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,32 +1,33 @@
-# Find quoted strings
+# البحث عن سلاسل الاقتباس
 
-Create a regexp to find strings in double quotes `subject:"..."`.
+قم بإنشاء regexp للعثور على سلاسل في علامات اقتباس مزدوجة `الموضوع:" ... "`.
 
-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:\\`.
+يجب أن تدعم السلاسل الهروب ، بنفس الطريقة التي تدعمها سلاسل JavaScript. على سبيل المثال ، يمكن إدراج علامات الاقتباس كـ `subject: \" `سطر جديد مثل` subject: \ n` ، والشرطة نفسها كـ `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,16 +1,17 @@
 
-The pattern start is obvious: `pattern:<style`.
+بداية النمط واضحة: `pattern: <style`.
 
-...But then we can't simply write `pattern:<style.*?>`, because `match:<styler>` would match it.
+... ولكن بعد ذلك لا يمكننا ببساطة كتابة `pattern: <style. *؟>` ، لأن `match: <styler>` ستطابقها.
 
-We need either a space after `match:<style` and then optionally something else or the ending `match:>`.
+نحتاج إلى مسافة بعد `match: <style` ثم اختياريًا شيء آخر أو` `match:>` النهائي.
 
-In the regexp language: `pattern:<style(>|\s.*?>)`.
+في لغة regexp: `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,13 +1,14 @@
-# Find the full tag
+# البحث عن العلامة الكاملة
 
-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="...">`.
+اكتب regexp للعثور على العلامة `<style ...>`. يجب أن تتطابق مع العلامة الكاملة: قد لا تحتوي على سمات `<style>` أو تحتوي على العديد منها `<style type =" ... "id =" ... ">`.
 
-...But the regexp should not match `<styler>`!
+... لكن التعبير العادي يجب ألا يطابق `<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) |
+# التناوب (أو) |
 
-Alternation is the term in regular expression that is actually a simple "OR".
+البديل هو المصطلح في التعبير العادي وهو في الواقع "OR" بسيط.
 
-In a regular expression it is denoted with a vertical line character `pattern:|`.
+في التعبير العادي ، يُشار إليه بحرف السطر العمودي `pattern: |`.
 
-For instance, we need to find programming languages: HTML, PHP, Java or JavaScript.
+على سبيل المثال ، نحتاج إلى العثور على لغات البرمجة: HTML أو PHP أو Java أو JavaScript.
 
-The corresponding regexp: `pattern:html|php|java(script)?`.
+التعبير العادي المقابل: `pattern: html | php | java (script)؟`.
 
-A usage example:
+مثال للاستخدام:
 
 ```js run
 let regexp = /html|php|css|java(script)?/gi;
@@ -18,53 +18,54 @@ let str = "First HTML appeared, then CSS, then JavaScript";
 alert( str.match(regexp) ); // 'HTML', 'CSS', 'JavaScript'
 ```
 
-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`.
+لقد رأينا بالفعل شيئًا مشابهًا - الأقواس المربعة. تسمح بالاختيار بين عدة أحرف ، على سبيل المثال `pattern: gr [ae] y` يطابق` match: gre` أو `match: grey`.
 
-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`.
+تسمح الأقواس المربعة باستخدام الأحرف أو مجموعات الأحرف فقط. يسمح التناوب بأي تعبيرات. نمط regexp `: A | B | C` يعني أحد التعبيرات` A` أو `B` أو` C`.
 
-For instance:
+على سبيل المثال:
 
-- `pattern:gr(a|e)y` means exactly the same as `pattern:gr[ae]y`.
-- `pattern:gra|ey` means `match:gra` or `match:ey`.
+- `pattern: gr (a | e) y` يعني تمامًا مثل` pattern: gr [ae] y`.
+- `pattern: gra | ey` تعني` match: gra` أو `match: ey`.
 
-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`.
+لتطبيق التناوب على جزء مختار من النمط ، يمكننا تضمينه بين قوسين:
+- `النمط: أحب HTML | CSS` يطابق` مطابقة: أنا أحب HTML` أو `تطابق: CSS`.
+- `pattern: I love (HTML | CSS)` يتطابق مع `match: I love HTML` أو` match: I love CSS`.
 
-## Example: regexp for time
+## مثال: regexp للوقت
 
-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).
+في المقالات السابقة ، كانت هناك مهمة لبناء regexp لوقت البحث في شكل `hh: mm` ، على سبيل المثال` 12: 00`. لكن `` النمط البسيط: \ d \ d: \ d \ d` غامض للغاية. يقبل `25: 99` كوقت (حيث تتطابق 99 ثانية مع النمط ، لكن ذلك الوقت غير صالح).
 
-How can we make a better pattern?
+كيف يمكننا صنع نمط أفضل؟
 
-We can use more careful matching. First, the hours:
+يمكننا استخدام مطابقة أكثر دقة. اولا الساعات:
 
-- 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)
+- إذا كان الرقم الأول هو "0" أو "1" ، فيمكن أن يكون الرقم التالي أي: `pattern: [01] \ d`.
+- وإلا ، إذا كان الرقم الأول هو "2" ، فيجب أن يكون الرقم التالي "pattern: [0-3]`.
+- (غير مسموح بالرقم الأول الآخر)
 
-We can write both variants in a regexp using alternation: `pattern:[01]\d|2[0-3]`.
+يمكننا كتابة كلا المتغيرين في regexp باستخدام البديل: `pattern: [01] \ d | 2 [0-3]`.
 
-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.
+بعد ذلك ، يجب أن تكون الدقائق من `00` إلى` 59`. في لغة التعبير العادي التي يمكن كتابتها كـ `pattern: [0-5] \ d`: الرقم الأول` 0-5` ، ثم أي رقم.
 
-If we glue minutes and seconds together, we get the pattern: `pattern:[01]\d|2[0-3]:[0-5]\d`.
+إذا صقنا الدقائق والثواني معًا ، نحصل على النمط: `pattern: [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`.
+لقد انتهينا تقريبًا ، ولكن هناك مشكلة. يحدث "النمط البديل": | `الآن بين` النمط: [01] \ d` و "النمط: 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]\d
-```
+``
+[01] \ d | 2 [0-3]: [0-5] \ د
+``
 
-That pattern looks for `pattern:[01]\d` or `pattern:2[0-3]:[0-5]\d`.
+يبحث هذا النمط عن `النمط: [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`.
+ولكن هذا خطأ ، يجب استخدام التناوب فقط في جزء "الساعات" من التعبير العادي ، للسماح بـ "pattern: [01] \ d` OR` pattern: 2 [0-3] `. دعنا نصحح ذلك عن طريق وضع "ساعات" بين قوسين: `النمط: ([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
 ```
+