From 72abbbdde058d2f825a71b43169ba98232844aa4 Mon Sep 17 00:00:00 2001 From: eruvierda Date: Mon, 20 Dec 2021 14:09:33 +0700 Subject: [PATCH 1/4] image for Indonesian translation --- img/regexp-id.png | Bin 0 -> 14803 bytes translations/README-id.md | 593 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 593 insertions(+) create mode 100644 img/regexp-id.png create mode 100644 translations/README-id.md diff --git a/img/regexp-id.png b/img/regexp-id.png new file mode 100644 index 0000000000000000000000000000000000000000..258e5fbce2c91cba7f399f7a47d4edf2f977c831 GIT binary patch literal 14803 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 H@#g;nxs&6{ literal 0 HcmV?d00001 diff --git a/translations/README-id.md b/translations/README-id.md new file mode 100644 index 00000000..2a2d6108 --- /dev/null +++ b/translations/README-id.md @@ -0,0 +1,593 @@ +Buy Me A Coffee + +

+
+ + Learn Regex + +

+ + +## Terjemahan: + +* [English](README.md) +* [German](translations/README-de.md) +* [Español](translations/README-es.md) +* [Français](translations/README-fr.md) +* [Português do Brasil](translations/README-pt_BR.md) +* [中文版](translations/README-cn.md) +* [日本語](translations/README-ja.md) +* [한국어](translations/README-ko.md) +* [Turkish](translations/README-tr.md) +* [Greek](translations/README-gr.md) +* [Magyar](translations/README-hu.md) +* [Polish](translations/README-pl.md) +* [Русский](translations/README-ru.md) +* [Tiếng Việt](translations/README-vn.md) +* [فارسی](translations/README-fa.md) + +## Apa Itu Ekspresi Reguler? + +

+ + Download PDF + +

+ + +> Ekspresi reguler ialah kumpulan dari karakter atau simbol yang digunakan untuk mencari pola tertentu dalam sebuah teks. + +Sebuah ekspresi reguler adalah pola yang dicocokkan terhadap sebuah rangkaian subyek dari kiri ke kanan.Ekspresi reguler digunakan untuk menggantikan teks dalam sebuah rangkaian,memvaliadsi formulir, mengekstraksi sub-rangkaian dari rangkaian dengan berdasarkan pada kecocokan pola, dan masih banyak lagi + +Bayangkan lah Anda menulis sebuah aplikasi dan Anda ingin membuat aturan jika seorang pengguna memilih nama pengguna. Kita ingin mengizinkan nama pengguna mengandung huruf, angka, garis bawah dan tanda hubung. Kita juga ingin membatasi jumlah karakter dalam nama pengguna sehingga tidak terlihat jelek. Kita bisa menggunakan ekspresi reguler berikut untuk memvalidasi nama pengguna : +

+

+ Regular expression +

+Ekspresi reguler di atas dapat menerima rangakaian kata `jo-hn_doe`,`jo-hn-doe` dan `john12_as`. Pola ini tidka cocok dengan `Jo` karena rangkaian ini menggandung huruf besar dan terlalu pendek. + +## Daftar Isi : + +- [Pencocokan Dasar](#1-basic-matchers) +- [Meta Characters](#2-meta-characters) + - [The Full Stop](#21-the-full-stops) + - [Character Sets](#22-character-sets) + - [Negated Character Sets](#221-negated-character-sets) + - [Repetitions](#23-repetitions) + - [The Star](#231-the-star) + - [The Plus](#232-the-plus) + - [The Question Mark](#233-the-question-mark) + - [Braces](#24-braces) + - [Capturing Groups](#25-capturing-groups) + - [Non-Capturing Groups](#251-non-capturing-groups) + - [Alternation](#26-alternation) + - [Escaping Special Characters](#27-escaping-special-characters) + - [Anchors](#28-anchors) + - [The Caret](#281-the-caret) + - [The Dollar Sign](#282-the-dollar-sign) +- [Shorthand Character Sets](#3-shorthand-character-sets) +- [Lookarounds](#4-lookarounds) + - [Positive Lookahead](#41-positive-lookahead) + - [Negative Lookahead](#42-negative-lookahead) + - [Positive Lookbehind](#43-positive-lookbehind) + - [Negative Lookbehind](#44-negative-lookbehind) +- [Flags](#5-flags) + - [Case Insensitive](#51-case-insensitive) + - [Global Search](#52-global-search) + - [Multiline](#53-multiline) +- [Greedy vs Lazy Matching](#6-greedy-vs-lazy-matching) + +## 1. Basic Matchers + +A regular expression is just a pattern of characters that we use to perform a +search in a text. For example, the regular expression `the` means: the letter +`t`, followed by the letter `h`, followed by the letter `e`. + +
+"the" => The fat cat sat on the mat.
+
+ +[Test the regular expression](https://regex101.com/r/dmRygT/1) + +The regular expression `123` matches the string `123`. The regular expression is +matched against an input string by comparing each character in the regular +expression to each character in the input string, one after another. Regular +expressions are normally case-sensitive so the regular expression `The` would +not match the string `the`. + +
+"The" => The fat cat sat on the mat.
+
+ +[Test the regular expression](https://regex101.com/r/1paXsy/1) + +## 2. Meta Characters + +Meta characters are the building blocks of regular expressions. Meta +characters do not stand for themselves but instead are interpreted in some +special way. Some meta characters have a special meaning and are written inside +square brackets. The meta characters are as follows: + +|Meta character|Description| +|:----:|----| +|.|Period matches any single character except a line break.| +|[ ]|Character class. Matches any character contained between the square brackets.| +|[^ ]|Negated character class. Matches any character that is not contained between the square brackets| +|*|Matches 0 or more repetitions of the preceding symbol.| +|+|Matches 1 or more repetitions of the preceding symbol.| +|?|Makes the preceding symbol optional.| +|{n,m}|Braces. Matches at least "n" but not more than "m" repetitions of the preceding symbol.| +|(xyz)|Character group. Matches the characters xyz in that exact order.| +|||Alternation. Matches either the characters before or the characters after the symbol.| +|\|Escapes the next character. This allows you to match reserved characters [ ] ( ) { } . * + ? ^ $ \ || +|^|Matches the beginning of the input.| +|$|Matches the end of the input.| + +## 2.1 The Full Stop + +The full stop `.` is the simplest example of a meta character. The meta character `.` +matches any single character. It will not match return or newline characters. +For example, the regular expression `.ar` means: any character, followed by the +letter `a`, followed by the letter `r`. + +
+".ar" => The car parked in the garage.
+
+ +[Test the regular expression](https://regex101.com/r/xc9GkU/1) + +## 2.2 Character Sets + +Character sets are also called character classes. Square brackets are used to +specify character sets. Use a hyphen inside a character set to specify the +characters' range. The order of the character range inside the square brackets +doesn't matter. For example, the regular expression `[Tt]he` means: an uppercase +`T` or lowercase `t`, followed by the letter `h`, followed by the letter `e`. + +
+"[Tt]he" => The car parked in the garage.
+
+ +[Test the regular expression](https://regex101.com/r/2ITLQ4/1) + +A period inside a character set, however, means a literal period. The regular +expression `ar[.]` means: a lowercase character `a`, followed by the letter `r`, +followed by a period `.` character. + +
+"ar[.]" => A garage is a good place to park a car.
+
+ +[Test the regular expression](https://regex101.com/r/wL3xtE/1) + +### 2.2.1 Negated Character Sets + +In general, the caret symbol represents the start of the string, but when it is +typed after the opening square bracket it negates the character set. For +example, the regular expression `[^c]ar` means: any character except `c`, +followed by the character `a`, followed by the letter `r`. + +
+"[^c]ar" => The car parked in the garage.
+
+ +[Test the regular expression](https://regex101.com/r/nNNlq3/1) + +## 2.3 Repetitions + +The meta characters `+`, `*` or `?` are used to specify how many times a +subpattern can occur. These meta characters act differently in different +situations. + +### 2.3.1 The Star + +The `*` symbol matches zero or more repetitions of the preceding matcher. The +regular expression `a*` means: zero or more repetitions of the preceding lowercase +character `a`. But if it appears after a character set or class then it finds +the repetitions of the whole character set. For example, the regular expression +`[a-z]*` means: any number of lowercase letters in a row. + +
+"[a-z]*" => The car parked in the garage #21.
+
+ +[Test the regular expression](https://regex101.com/r/7m8me5/1) + +The `*` symbol can be used with the meta character `.` to match any string of +characters `.*`. The `*` symbol can be used with the whitespace character `\s` +to match a string of whitespace characters. For example, the expression +`\s*cat\s*` means: zero or more spaces, followed by a lowercase `c`, +followed by a lowercase `a`, followed by a lowercase `t`, +followed by zero or more spaces. + +
+"\s*cat\s*" => The fat cat sat on the concatenation.
+
+ +[Test the regular expression](https://regex101.com/r/gGrwuz/1) + +### 2.3.2 The Plus + +The `+` symbol matches one or more repetitions of the preceding character. For +example, the regular expression `c.+t` means: a lowercase `c`, followed by +at least one character, followed by a lowercase `t`. It needs to be +clarified that`t` is the last `t` in the sentence. + +
+"c.+t" => The fat cat sat on the mat.
+
+ +[Test the regular expression](https://regex101.com/r/Dzf9Aa/1) + +### 2.3.3 The Question Mark + +In regular expressions, the meta character `?` makes the preceding character +optional. This symbol matches zero or one instance of the preceding character. +For example, the regular expression `[T]?he` means: Optional uppercase +`T`, followed by a lowercase `h`, followed by a lowercase `e`. + +
+"[T]he" => The car is parked in the garage.
+
+ +[Test the regular expression](https://regex101.com/r/cIg9zm/1) + +
+"[T]?he" => The car is parked in the garage.
+
+ +[Test the regular expression](https://regex101.com/r/kPpO2x/1) + +## 2.4 Braces + +In regular expressions, braces (also called quantifiers) are used to +specify the number of times that a character or a group of characters can be +repeated. For example, the regular expression `[0-9]{2,3}` means: Match at least +2 digits, but not more than 3, ranging from 0 to 9. + +
+"[0-9]{2,3}" => The number was 9.9997 but we rounded it off to 10.0.
+
+ +[Test the regular expression](https://regex101.com/r/juM86s/1) + +We can leave out the second number. For example, the regular expression +`[0-9]{2,}` means: Match 2 or more digits. If we also remove the comma, the +regular expression `[0-9]{3}` means: Match exactly 3 digits. + +
+"[0-9]{2,}" => The number was 9.9997 but we rounded it off to 10.0.
+
+ +[Test the regular expression](https://regex101.com/r/Gdy4w5/1) + +
+"[0-9]{3}" => The number was 9.9997 but we rounded it off to 10.0.
+
+ +[Test the regular expression](https://regex101.com/r/Sivu30/1) + +## 2.5 Capturing Groups + +A capturing group is a group of subpatterns that is written inside parentheses +`(...)`. As discussed before, in regular expressions, if we put a quantifier +after a character then it will repeat the preceding character. But if we put a quantifier +after a capturing group then it repeats the whole capturing group. For example, +the regular expression `(ab)*` matches zero or more repetitions of the character +"ab". We can also use the alternation `|` meta character inside a capturing group. +For example, the regular expression `(c|g|p)ar` means: a lowercase `c`, +`g` or `p`, followed by `a`, followed by `r`. + +
+"(c|g|p)ar" => The car is parked in the garage.
+
+ +[Test the regular expression](https://regex101.com/r/tUxrBG/1) + +Note that capturing groups do not only match, but also capture, the characters for use in +the parent language. The parent language could be Python or JavaScript or virtually any +language that implements regular expressions in a function definition. + +### 2.5.1 Non-Capturing Groups + +A non-capturing group is a capturing group that matches the characters but +does not capture the group. A non-capturing group is denoted by a `?` followed by a `:` +within parentheses `(...)`. For example, the regular expression `(?:c|g|p)ar` is similar to +`(c|g|p)ar` in that it matches the same characters but will not create a capture group. + +
+"(?:c|g|p)ar" => The car is parked in the garage.
+
+ +[Test the regular expression](https://regex101.com/r/Rm7Me8/1) + +Non-capturing groups can come in handy when used in find-and-replace functionality or +when mixed with capturing groups to keep the overview when producing any other kind of output. +See also [4. Lookaround](#4-lookaround). + +## 2.6 Alternation + +In a regular expression, the vertical bar `|` is used to define alternation. +Alternation is like an OR statement between multiple expressions. Now, you may be +thinking that character sets and alternation work the same way. But the big +difference between character sets and alternation is that character sets work at the +character level but alternation works at the expression level. For example, the +regular expression `(T|t)he|car` means: either (an uppercase `T` or a lowercase +`t`, followed by a lowercase `h`, followed by a lowercase `e`) OR +(a lowercase `c`, followed by a lowercase `a`, followed by +a lowercase `r`). Note that I included the parentheses for clarity, to show that either expression +in parentheses can be met and it will match. + +
+"(T|t)he|car" => The car is parked in the garage.
+
+ +[Test the regular expression](https://regex101.com/r/fBXyX0/1) + +## 2.7 Escaping Special Characters + +A backslash `\` is used in regular expressions to escape the next character. This +allows us to include reserved characters such as `{ } [ ] / \ + * . $ ^ | ?` as matching characters. To use one of these special character as a matching character, prepend it with `\`. + +For example, the regular expression `.` is used to match any character except a +newline. Now, to match `.` in an input string, the regular expression +`(f|c|m)at\.?` means: a lowercase `f`, `c` or `m`, followed by a lowercase +`a`, followed by a lowercase `t`, followed by an optional `.` +character. + +
+"(f|c|m)at\.?" => The fat cat sat on the mat.
+
+ +[Test the regular expression](https://regex101.com/r/DOc5Nu/1) + +## 2.8 Anchors + +In regular expressions, we use anchors to check if the matching symbol is the +starting symbol or ending symbol of the input string. Anchors are of two types: +The first type is the caret `^` that checks if the matching character is the first +character of the input and the second type is the dollar sign `$` which checks if a matching +character is the last character of the input string. + +### 2.8.1 The Caret + +The caret symbol `^` is used to check if a matching character is the first character +of the input string. If we apply the following regular expression `^a` (meaning 'a' must be +the starting character) to the string `abc`, it will match `a`. But if we apply +the regular expression `^b` to the above string, it will not match anything. +Because in the string `abc`, the "b" is not the starting character. Let's take a look +at another regular expression `^(T|t)he` which means: an uppercase `T` or +a lowercase `t` must be the first character in the string, followed by a +lowercase `h`, followed by a lowercase `e`. + +
+"(T|t)he" => The car is parked in the garage.
+
+ +[Test the regular expression](https://regex101.com/r/5ljjgB/1) + +
+"^(T|t)he" => The car is parked in the garage.
+
+ +[Test the regular expression](https://regex101.com/r/jXrKne/1) + +### 2.8.2 The Dollar Sign + +The dollar sign `$` is used to check if a matching character is the last character +in the string. For example, the regular expression `(at\.)$` means: a +lowercase `a`, followed by a lowercase `t`, followed by a `.` +character and the matcher must be at the end of the string. + +
+"(at\.)" => The fat cat. sat. on the mat.
+
+ +[Test the regular expression](https://regex101.com/r/y4Au4D/1) + +
+"(at\.)$" => The fat cat. sat. on the mat.
+
+ +[Test the regular expression](https://regex101.com/r/t0AkOd/1) + +## 3. Shorthand Character Sets + +There are a number of convenient shorthands for commonly used character sets/ +regular expressions: + +|Shorthand|Description| +|:----:|----| +|.|Any character except new line| +|\w|Matches alphanumeric characters: `[a-zA-Z0-9_]`| +|\W|Matches non-alphanumeric characters: `[^\w]`| +|\d|Matches digits: `[0-9]`| +|\D|Matches non-digits: `[^\d]`| +|\s|Matches whitespace characters: `[\t\n\f\r\p{Z}]`| +|\S|Matches non-whitespace characters: `[^\s]`| + +## 4. Lookarounds + +Lookbehinds and lookaheads (also called lookarounds) are specific types of +***non-capturing groups*** (used to match a pattern but without including it in the matching +list). Lookarounds are used when we a pattern must be +preceded or followed by another pattern. For example, imagine we want to get all +numbers that are preceded by the `$` character from the string +`$4.44 and $10.88`. We will use the following regular expression `(?<=\$)[0-9\.]*` +which means: get all the numbers which contain the `.` character and are preceded +by the `$` character. These are the lookarounds that are used in regular +expressions: + +|Symbol|Description| +|:----:|----| +|?=|Positive Lookahead| +|?!|Negative Lookahead| +|?<=|Positive Lookbehind| +|? +"(T|t)he(?=\sfat)" => The fat cat sat on the mat. + + +[Test the regular expression](https://regex101.com/r/IDDARt/1) + +### 4.2 Negative Lookahead + +Negative lookaheads are used when we need to get all matches from an input string +that are not followed by a certain pattern. A negative lookahead is written the same way as a +positive lookahead. The only difference is, instead of an equals sign `=`, we +use an exclamation mark `!` to indicate negation i.e. `(?!...)`. Let's take a look at the following +regular expression `(T|t)he(?!\sfat)` which means: get all `The` or `the` words +from the input string that are not followed by a space character and the word `fat`. + +
+"(T|t)he(?!\sfat)" => The fat cat sat on the mat.
+
+ +[Test the regular expression](https://regex101.com/r/V32Npg/1) + +### 4.3 Positive Lookbehind + +Positive lookbehinds are used to get all the matches that are preceded by a +specific pattern. Positive lookbehinds are written `(?<=...)`. For example, the +regular expression `(?<=(T|t)he\s)(fat|mat)` means: get all `fat` or `mat` words +from the input string that come after the word `The` or `the`. + +
+"(?<=(T|t)he\s)(fat|mat)" => The fat cat sat on the mat.
+
+ +[Test the regular expression](https://regex101.com/r/avH165/1) + +### 4.4 Negative Lookbehind + +Negative lookbehinds are used to get all the matches that are not preceded by a +specific pattern. Negative lookbehinds are written `(? +"(?<!(T|t)he\s)(cat)" => The cat sat on cat. + + +[Test the regular expression](https://regex101.com/r/8Efx5G/1) + +## 5. Flags + +Flags are also called modifiers because they modify the output of a regular +expression. These flags can be used in any order or combination, and are an +integral part of the RegExp. + +|Flag|Description| +|:----:|----| +|i|Case insensitive: Match will be case-insensitive.| +|g|Global Search: Match all instances, not just the first.| +|m|Multiline: Anchor meta characters work on each line.| + +### 5.1 Case Insensitive + +The `i` modifier is used to perform case-insensitive matching. For example, the +regular expression `/The/gi` means: an uppercase `T`, followed by a lowercase +`h`, followed by an `e`. And at the end of regular expression +the `i` flag tells the regular expression engine to ignore the case. As you can +see, we also provided `g` flag because we want to search for the pattern in the +whole input string. + +
+"The" => The fat cat sat on the mat.
+
+ +[Test the regular expression](https://regex101.com/r/dpQyf9/1) + +
+"/The/gi" => The fat cat sat on the mat.
+
+ +[Test the regular expression](https://regex101.com/r/ahfiuh/1) + +### 5.2 Global Search + +The `g` modifier is used to perform a global match (finds all matches rather than +stopping after the first match). For example, the regular expression`/.(at)/g` +means: any character except a new line, followed by a lowercase `a`, +followed by a lowercase `t`. Because we provided the `g` flag at the end of +the regular expression, it will now find all matches in the input string, not just the first one (which is the default behavior). + +
+"/.(at)/" => The fat cat sat on the mat.
+
+ +[Test the regular expression](https://regex101.com/r/jnk6gM/1) + +
+"/.(at)/g" => The fat cat sat on the mat.
+
+ +[Test the regular expression](https://regex101.com/r/dO1nef/1) + +### 5.3 Multiline + +The `m` modifier is used to perform a multi-line match. As we discussed earlier, +anchors `(^, $)` are used to check if a pattern is at the beginning of the input or +the end. But if we want the anchors to work on each line, we use +the `m` flag. For example, the regular expression `/at(.)?$/gm` means: a lowercase +`a`, followed by a lowercase `t` and, optionally, anything except +a new line. And because of the `m` flag, the regular expression engine now matches patterns +at the end of each line in a string. + +
+"/.at(.)?$/" => The fat
+                cat sat
+                on the mat.
+
+ +[Test the regular expression](https://regex101.com/r/hoGMkP/1) + +
+"/.at(.)?$/gm" => The fat
+                  cat sat
+                  on the mat.
+
+ +[Test the regular expression](https://regex101.com/r/E88WE2/1) + +## 6. Greedy vs Lazy Matching +By default, a regex will perform a greedy match, which means the match will be as long as +possible. We can use `?` to match in a lazy way, which means the match should be as short as possible. + +
+"/(.*at)/" => The fat cat sat on the mat.
+ + +[Test the regular expression](https://regex101.com/r/AyAdgJ/1) + +
+"/(.*?at)/" => The fat cat sat on the mat.
+ + +[Test the regular expression](https://regex101.com/r/AyAdgJ/2) + + +## Contribution + +* Open a pull request with improvements +* Discuss ideas in issues +* Spread the word +* Reach out with any feedback [![Twitter URL](https://img.shields.io/twitter/url/https/twitter.com/ziishaned.svg?style=social&label=Follow%20%40ziishaned)](https://twitter.com/ziishaned) + +## License + +MIT © [Zeeshan Ahmad](https://twitter.com/ziishaned) From 879ccd2a736b2c1b6bbe2827612f4363b971f027 Mon Sep 17 00:00:00 2001 From: Ahmad Firdaus Date: Thu, 29 Sep 2022 10:08:29 +0700 Subject: [PATCH 2/4] Update README-id.md --- translations/README-id.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/translations/README-id.md b/translations/README-id.md index 2a2d6108..33475df3 100644 --- a/translations/README-id.md +++ b/translations/README-id.md @@ -42,7 +42,7 @@ Sebuah ekspresi reguler adalah pola yang dicocokkan terhadap sebuah rangkaian su Bayangkan lah Anda menulis sebuah aplikasi dan Anda ingin membuat aturan jika seorang pengguna memilih nama pengguna. Kita ingin mengizinkan nama pengguna mengandung huruf, angka, garis bawah dan tanda hubung. Kita juga ingin membatasi jumlah karakter dalam nama pengguna sehingga tidak terlihat jelek. Kita bisa menggunakan ekspresi reguler berikut untuk memvalidasi nama pengguna :

- Regular expression + Regular expression

Ekspresi reguler di atas dapat menerima rangakaian kata `jo-hn_doe`,`jo-hn-doe` dan `john12_as`. Pola ini tidka cocok dengan `Jo` karena rangkaian ini menggandung huruf besar dan terlalu pendek. From 96983210918bbfe7b56f2d14ca19caccec94a9ba Mon Sep 17 00:00:00 2001 From: Ahmad Firdaus Date: Fri, 18 Oct 2024 14:13:22 +0700 Subject: [PATCH 3/4] Adding translations --- translations/README-id.md | 133 ++++++++++++++++++-------------------- 1 file changed, 64 insertions(+), 69 deletions(-) diff --git a/translations/README-id.md b/translations/README-id.md index 33475df3..37937521 100644 --- a/translations/README-id.md +++ b/translations/README-id.md @@ -49,57 +49,52 @@ Ekspresi reguler di atas dapat menerima rangakaian kata `jo-hn_doe`,`jo-hn-doe` ## Daftar Isi : - [Pencocokan Dasar](#1-basic-matchers) -- [Meta Characters](#2-meta-characters) - - [The Full Stop](#21-the-full-stops) - - [Character Sets](#22-character-sets) - - [Negated Character Sets](#221-negated-character-sets) - - [Repetitions](#23-repetitions) - - [The Star](#231-the-star) - - [The Plus](#232-the-plus) - - [The Question Mark](#233-the-question-mark) - - [Braces](#24-braces) - - [Capturing Groups](#25-capturing-groups) - - [Non-Capturing Groups](#251-non-capturing-groups) - - [Alternation](#26-alternation) - - [Escaping Special Characters](#27-escaping-special-characters) - - [Anchors](#28-anchors) - - [The Caret](#281-the-caret) - - [The Dollar Sign](#282-the-dollar-sign) -- [Shorthand Character Sets](#3-shorthand-character-sets) +- [Karakter Meta](#2-meta-characters) + - [Titik](#21-the-full-stops) + - [Set Karakter](#22-character-sets) + - [Set Karakter yang dinegasikan](#221-negated-character-sets) + - [Perulangan](#23-repetitions) + - [Tanda Bintang](#231-the-star) + - [Tanda Tambah](#232-the-plus) + - [Tanda Tanya](#233-the-question-mark) + - [Tanda Kurung](#24-braces) + - [Kelompok Penangkapan](#25-capturing-groups) + - [Kelompok non-Penangkapan](#251-non-capturing-groups) + - [Alternasi](#26-alternation) + - [Meloloskan Karakter khusus](#27-escaping-special-characters) + - [Penanda Posisi](#28-anchors) + - [Tanda Karat (Caret)](#281-the-caret) + - [Tanda Dolar](#282-the-dollar-sign) +- [Set Karakter Singkatan](#3-shorthand-character-sets) - [Lookarounds](#4-lookarounds) - - [Positive Lookahead](#41-positive-lookahead) - - [Negative Lookahead](#42-negative-lookahead) - - [Positive Lookbehind](#43-positive-lookbehind) - - [Negative Lookbehind](#44-negative-lookbehind) + - [Positif Lookahead](#41-positive-lookahead) + - [Negatif Lookahead](#42-negative-lookahead) + - [Positif Lookbehind](#43-positive-lookbehind) + - [Negatif Lookbehind](#44-negative-lookbehind) - [Flags](#5-flags) - - [Case Insensitive](#51-case-insensitive) - - [Global Search](#52-global-search) - - [Multiline](#53-multiline) -- [Greedy vs Lazy Matching](#6-greedy-vs-lazy-matching) + - [Sensitivitas Huruf (besar/kecil)](#51-case-insensitive) + - [Pencarian Global](#52-global-search) + - [Baris Berganda](#53-multiline) +- [Pencocokan Serakah vs Malas](#6-greedy-vs-lazy-matching) -## 1. Basic Matchers - -A regular expression is just a pattern of characters that we use to perform a -search in a text. For example, the regular expression `the` means: the letter -`t`, followed by the letter `h`, followed by the letter `e`. +## 1. Pencocokan Dasar +Sebuah ekspresi reguler hanyalah pola karakter yang kita gunakan untuk melakukan pencarian dalam teks. Sebagai contoh, ekspresi reguler `the` berarti: huruf `t`, diikuti oleh huruf `h`, diikuti oleh huruf `e`. 
 "the" => The fat cat sat on the mat.
-[Test the regular expression](https://regex101.com/r/dmRygT/1) +[Uji Ekspresi Reguler](https://regex101.com/r/dmRygT/1) + +Ekspresi reguler `123` akan cocok dengan string `123`. Ekspresi reguler dicocokkan dengan string masukan dengan cara membandingkan setiap karakter dalam ekspresi reguler dengan setiap karakter dalam string masukan, satu per satu. Biasanya, ekspresi reguler bersifat case-sensitive (peka terhadap huruf besar/kecil), sehingga ekspresi reguler `The` tidak akan cocok dengan string `the`. -The regular expression `123` matches the string `123`. The regular expression is -matched against an input string by comparing each character in the regular -expression to each character in the input string, one after another. Regular -expressions are normally case-sensitive so the regular expression `The` would -not match the string `the`. +Ini berarti huruf besar dan huruf kecil dianggap berbeda dalam pencocokan pola menggunakan ekspresi reguler, kecuali jika diatur untuk mengabaikan perbedaan tersebut. 
 "The" => The fat cat sat on the mat.
-[Test the regular expression](https://regex101.com/r/1paXsy/1) +[Uji Ekspresi Reguler](https://regex101.com/r/1paXsy/1) ## 2. Meta Characters @@ -134,7 +129,7 @@ letter `a`, followed by the letter `r`. ".ar" => The car parked in the garage. -[Test the regular expression](https://regex101.com/r/xc9GkU/1) +[Uji Ekspresi Reguler](https://regex101.com/r/xc9GkU/1) ## 2.2 Character Sets @@ -148,7 +143,7 @@ doesn't matter. For example, the regular expression `[Tt]he` means: an uppercase "[Tt]he" => The car parked in the garage. -[Test the regular expression](https://regex101.com/r/2ITLQ4/1) +[Uji Ekspresi Reguler](https://regex101.com/r/2ITLQ4/1) A period inside a character set, however, means a literal period. The regular expression `ar[.]` means: a lowercase character `a`, followed by the letter `r`, @@ -158,7 +153,7 @@ followed by a period `.` character. "ar[.]" => A garage is a good place to park a car. -[Test the regular expression](https://regex101.com/r/wL3xtE/1) +[Uji Ekspresi Reguler](https://regex101.com/r/wL3xtE/1) ### 2.2.1 Negated Character Sets @@ -171,7 +166,7 @@ followed by the character `a`, followed by the letter `r`. "[^c]ar" => The car parked in the garage. -[Test the regular expression](https://regex101.com/r/nNNlq3/1) +[Uji Ekspresi Reguler](https://regex101.com/r/nNNlq3/1) ## 2.3 Repetitions @@ -191,7 +186,7 @@ the repetitions of the whole character set. For example, the regular expression "[a-z]*" => The car parked in the garage #21. -[Test the regular expression](https://regex101.com/r/7m8me5/1) +[Uji Ekspresi Reguler](https://regex101.com/r/7m8me5/1) The `*` symbol can be used with the meta character `.` to match any string of characters `.*`. The `*` symbol can be used with the whitespace character `\s` @@ -204,7 +199,7 @@ followed by zero or more spaces. "\s*cat\s*" => The fat cat sat on the concatenation. -[Test the regular expression](https://regex101.com/r/gGrwuz/1) +[Uji Ekspresi Reguler](https://regex101.com/r/gGrwuz/1) ### 2.3.2 The Plus @@ -217,7 +212,7 @@ clarified that`t` is the last `t` in the sentence. "c.+t" => The fat cat sat on the mat. -[Test the regular expression](https://regex101.com/r/Dzf9Aa/1) +[Uji Ekspresi Reguler](https://regex101.com/r/Dzf9Aa/1) ### 2.3.3 The Question Mark @@ -230,13 +225,13 @@ For example, the regular expression `[T]?he` means: Optional uppercase "[T]he" => The car is parked in the garage. -[Test the regular expression](https://regex101.com/r/cIg9zm/1) +[Uji Ekspresi Reguler](https://regex101.com/r/cIg9zm/1) 
 "[T]?he" => The car is parked in the garage.
-[Test the regular expression](https://regex101.com/r/kPpO2x/1) +[Uji Ekspresi Reguler](https://regex101.com/r/kPpO2x/1) ## 2.4 Braces @@ -249,7 +244,7 @@ repeated. For example, the regular expression `[0-9]{2,3}` means: Match at least "[0-9]{2,3}" => The number was 9.9997 but we rounded it off to 10.0. -[Test the regular expression](https://regex101.com/r/juM86s/1) +[Uji Ekspresi Reguler](https://regex101.com/r/juM86s/1) We can leave out the second number. For example, the regular expression `[0-9]{2,}` means: Match 2 or more digits. If we also remove the comma, the @@ -259,13 +254,13 @@ regular expression `[0-9]{3}` means: Match exactly 3 digits. "[0-9]{2,}" => The number was 9.9997 but we rounded it off to 10.0. -[Test the regular expression](https://regex101.com/r/Gdy4w5/1) +[Uji Ekspresi Reguler](https://regex101.com/r/Gdy4w5/1) 
 "[0-9]{3}" => The number was 9.9997 but we rounded it off to 10.0.
-[Test the regular expression](https://regex101.com/r/Sivu30/1) +[Uji Ekspresi Reguler](https://regex101.com/r/Sivu30/1) ## 2.5 Capturing Groups @@ -282,7 +277,7 @@ For example, the regular expression `(c|g|p)ar` means: a lowercase `c`, "(c|g|p)ar" => The car is parked in the garage. -[Test the regular expression](https://regex101.com/r/tUxrBG/1) +[Uji Ekspresi Reguler](https://regex101.com/r/tUxrBG/1) Note that capturing groups do not only match, but also capture, the characters for use in the parent language. The parent language could be Python or JavaScript or virtually any @@ -299,7 +294,7 @@ within parentheses `(...)`. For example, the regular expression `(?:c|g|p)ar` is "(?:c|g|p)ar" => The car is parked in the garage. -[Test the regular expression](https://regex101.com/r/Rm7Me8/1) +[Uji Ekspresi Reguler](https://regex101.com/r/Rm7Me8/1) Non-capturing groups can come in handy when used in find-and-replace functionality or when mixed with capturing groups to keep the overview when producing any other kind of output. @@ -322,7 +317,7 @@ in parentheses can be met and it will match. "(T|t)he|car" => The car is parked in the garage. -[Test the regular expression](https://regex101.com/r/fBXyX0/1) +[Uji Ekspresi Reguler](https://regex101.com/r/fBXyX0/1) ## 2.7 Escaping Special Characters @@ -339,7 +334,7 @@ character. "(f|c|m)at\.?" => The fat cat sat on the mat. -[Test the regular expression](https://regex101.com/r/DOc5Nu/1) +[Uji Ekspresi Reguler](https://regex101.com/r/DOc5Nu/1) ## 2.8 Anchors @@ -364,13 +359,13 @@ lowercase `h`, followed by a lowercase `e`. "(T|t)he" => The car is parked in the garage. -[Test the regular expression](https://regex101.com/r/5ljjgB/1) +[Uji Ekspresi Reguler](https://regex101.com/r/5ljjgB/1) 
 "^(T|t)he" => The car is parked in the garage.
-[Test the regular expression](https://regex101.com/r/jXrKne/1) +[Uji Ekspresi Reguler](https://regex101.com/r/jXrKne/1) ### 2.8.2 The Dollar Sign @@ -383,13 +378,13 @@ character and the matcher must be at the end of the string. "(at\.)" => The fat cat. sat. on the mat. -[Test the regular expression](https://regex101.com/r/y4Au4D/1) +[Uji Ekspresi Reguler](https://regex101.com/r/y4Au4D/1) 
 "(at\.)$" => The fat cat. sat. on the mat.
-[Test the regular expression](https://regex101.com/r/t0AkOd/1) +[Uji Ekspresi Reguler](https://regex101.com/r/t0AkOd/1) ## 3. Shorthand Character Sets @@ -442,7 +437,7 @@ or `the` only if it's followed by the word `fat`. "(T|t)he(?=\sfat)" => The fat cat sat on the mat. -[Test the regular expression](https://regex101.com/r/IDDARt/1) +[Uji Ekspresi Reguler](https://regex101.com/r/IDDARt/1) ### 4.2 Negative Lookahead @@ -457,7 +452,7 @@ from the input string that are not followed by a space character and the word `f "(T|t)he(?!\sfat)" => The fat cat sat on the mat. -[Test the regular expression](https://regex101.com/r/V32Npg/1) +[Uji Ekspresi Reguler](https://regex101.com/r/V32Npg/1) ### 4.3 Positive Lookbehind @@ -470,7 +465,7 @@ from the input string that come after the word `The` or `the`. "(?<=(T|t)he\s)(fat|mat)" => The fat cat sat on the mat. -[Test the regular expression](https://regex101.com/r/avH165/1) +[Uji Ekspresi Reguler](https://regex101.com/r/avH165/1) ### 4.4 Negative Lookbehind @@ -483,7 +478,7 @@ string that are not after the word `The` or `the`. "(?<!(T|t)he\s)(cat)" => The cat sat on cat. -[Test the regular expression](https://regex101.com/r/8Efx5G/1) +[Uji Ekspresi Reguler](https://regex101.com/r/8Efx5G/1) ## 5. Flags @@ -510,13 +505,13 @@ whole input string. "The" => The fat cat sat on the mat. -[Test the regular expression](https://regex101.com/r/dpQyf9/1) +[Uji Ekspresi Reguler](https://regex101.com/r/dpQyf9/1) 
 "/The/gi" => The fat cat sat on the mat.
-[Test the regular expression](https://regex101.com/r/ahfiuh/1) +[Uji Ekspresi Reguler](https://regex101.com/r/ahfiuh/1) ### 5.2 Global Search @@ -530,13 +525,13 @@ the regular expression, it will now find all matches in the input string, not ju "/.(at)/" => The fat cat sat on the mat. -[Test the regular expression](https://regex101.com/r/jnk6gM/1) +[Uji Ekspresi Reguler](https://regex101.com/r/jnk6gM/1) 
 "/.(at)/g" => The fat cat sat on the mat.
-[Test the regular expression](https://regex101.com/r/dO1nef/1) +[Uji Ekspresi Reguler](https://regex101.com/r/dO1nef/1) ### 5.3 Multiline @@ -554,7 +549,7 @@ at the end of each line in a string. on the mat. -[Test the regular expression](https://regex101.com/r/hoGMkP/1) +[Uji Ekspresi Reguler](https://regex101.com/r/hoGMkP/1) 
 "/.at(.)?$/gm" => The fat
@@ -562,7 +557,7 @@ at the end of each line in a string.
                   on the mat.
-[Test the regular expression](https://regex101.com/r/E88WE2/1) +[Uji Ekspresi Reguler](https://regex101.com/r/E88WE2/1) ## 6. Greedy vs Lazy Matching By default, a regex will perform a greedy match, which means the match will be as long as @@ -572,13 +567,13 @@ possible. We can use `?` to match in a lazy way, which means the match should be "/(.*at)/" => The fat cat sat on the mat. -[Test the regular expression](https://regex101.com/r/AyAdgJ/1) +[Uji Ekspresi Reguler](https://regex101.com/r/AyAdgJ/1) 
 "/(.*?at)/" => The fat cat sat on the mat.
-[Test the regular expression](https://regex101.com/r/AyAdgJ/2) +[Uji Ekspresi Reguler](https://regex101.com/r/AyAdgJ/2) ## Contribution From 61e8aa7086ff5ea809cc97a8637627fc4ccce520 Mon Sep 17 00:00:00 2001 From: Ahmad Firdaus Date: Sat, 20 Sep 2025 22:59:25 +0700 Subject: [PATCH 4/4] add Indonesian translation --- README.md | 1 + translations/README-id.md | 463 +++++++++++++++++++------------------- 2 files changed, 231 insertions(+), 233 deletions(-) diff --git a/README.md b/README.md index 34ef8d6b..3d3bbd52 100644 --- a/README.md +++ b/README.md @@ -25,6 +25,7 @@ * [Русский](translations/README-ru.md) * [Tiếng Việt](translations/README-vn.md) * [فارسی](translations/README-fa.md) +* [Bahasa Indonesia](translations/README-id.md) ## What is Regular Expression? diff --git a/translations/README-id.md b/translations/README-id.md index 37937521..15a95ba3 100644 --- a/translations/README-id.md +++ b/translations/README-id.md @@ -25,8 +25,9 @@ * [Русский](translations/README-ru.md) * [Tiếng Việt](translations/README-vn.md) * [فارسی](translations/README-fa.md) +* [Bahasa Indonesia](translations/README-id.md) -## Apa Itu Ekspresi Reguler? +## Apakah Ekspresi Reguler Itu?

@@ -34,17 +35,16 @@

+> Ekspresi reguler adalah sekumpulan karakter atau simbol yang digunakan untuk mencari pola tertentu dalam teks. -> Ekspresi reguler ialah kumpulan dari karakter atau simbol yang digunakan untuk mencari pola tertentu dalam sebuah teks. +Ekspresi reguler merupakan pola yang dicocokkan dengan string subjek dari kiri ke kanan. Ekspresi reguler digunakan untuk mengganti teks dalam string, memvalidasi formulir, mengekstrak substring dari string berdasarkan kecocokan pola, dan masih banyak lagi. Istilah "ekspresi reguler" terdengar panjang, sehingga Anda biasanya akan menemukan istilah ini disingkat menjadi "regex" atau "regexp". -Sebuah ekspresi reguler adalah pola yang dicocokkan terhadap sebuah rangkaian subyek dari kiri ke kanan.Ekspresi reguler digunakan untuk menggantikan teks dalam sebuah rangkaian,memvaliadsi formulir, mengekstraksi sub-rangkaian dari rangkaian dengan berdasarkan pada kecocokan pola, dan masih banyak lagi - -Bayangkan lah Anda menulis sebuah aplikasi dan Anda ingin membuat aturan jika seorang pengguna memilih nama pengguna. Kita ingin mengizinkan nama pengguna mengandung huruf, angka, garis bawah dan tanda hubung. Kita juga ingin membatasi jumlah karakter dalam nama pengguna sehingga tidak terlihat jelek. Kita bisa menggunakan ekspresi reguler berikut untuk memvalidasi nama pengguna : +Bayangkan Anda sedang menulis aplikasi dan ingin membuat aturan ketika pengguna memilih nama pengguna. Kita ingin mengizinkan nama pengguna berisi huruf, angka, garis bawah, dan tanda hubung. Kita juga ingin membatasi jumlah karakter dalam nama pengguna agar tidak terlihat buruk. Kita dapat menggunakan ekspresi reguler berikut untuk memvalidasi nama pengguna:

Regular expression

-Ekspresi reguler di atas dapat menerima rangakaian kata `jo-hn_doe`,`jo-hn-doe` dan `john12_as`. Pola ini tidka cocok dengan `Jo` karena rangkaian ini menggandung huruf besar dan terlalu pendek. +Ekspresi reguler di atas dapat menerima string `john_doe`, `jo-hn_doe`, dan `john12_as`. Pola ini tidak cocok dengan `Jo` karena string tersebut mengandung huruf besar dan terlalu pendek. ## Daftar Isi : @@ -79,14 +79,14 @@ Ekspresi reguler di atas dapat menerima rangakaian kata `jo-hn_doe`,`jo-hn-doe` ## 1. Pencocokan Dasar -Sebuah ekspresi reguler hanyalah pola karakter yang kita gunakan untuk melakukan pencarian dalam teks. Sebagai contoh, ekspresi reguler `the` berarti: huruf `t`, diikuti oleh huruf `h`, diikuti oleh huruf `e`. +Ekspresi reguler hanyalah pola karakter yang kita gunakan untuk melakukan pencarian dalam teks. Sebagai contoh, ekspresi reguler `the` berarti: huruf `t`, diikuti oleh huruf `h`, diikuti oleh huruf `e`. 
 "the" => The fat cat sat on the mat.
[Uji Ekspresi Reguler](https://regex101.com/r/dmRygT/1) -Ekspresi reguler `123` akan cocok dengan string `123`. Ekspresi reguler dicocokkan dengan string masukan dengan cara membandingkan setiap karakter dalam ekspresi reguler dengan setiap karakter dalam string masukan, satu per satu. Biasanya, ekspresi reguler bersifat case-sensitive (peka terhadap huruf besar/kecil), sehingga ekspresi reguler `The` tidak akan cocok dengan string `the`. +Ekspresi reguler `123` akan cocok dengan string `123`. Ekspresi reguler dicocokkan dengan string masukan dengan membandingkan setiap karakter dalam ekspresi reguler dengan setiap karakter dalam string masukan, satu per satu. Biasanya, ekspresi reguler bersifat peka terhadap huruf besar/kecil (case-sensitive), sehingga ekspresi reguler `The` tidak akan cocok dengan string `the`. Ini berarti huruf besar dan huruf kecil dianggap berbeda dalam pencocokan pola menggunakan ekspresi reguler, kecuali jika diatur untuk mengabaikan perbedaan tersebut. @@ -96,34 +96,31 @@ Ini berarti huruf besar dan huruf kecil dianggap berbeda dalam pencocokan pola m [Uji Ekspresi Reguler](https://regex101.com/r/1paXsy/1) -## 2. Meta Characters +## 2. Karakter Meta -Meta characters are the building blocks of regular expressions. Meta -characters do not stand for themselves but instead are interpreted in some -special way. Some meta characters have a special meaning and are written inside -square brackets. The meta characters are as follows: +Karakter meta adalah blok bangunan dari ekspresi reguler. Karakter meta tidak berdiri sendiri tetapi diinterpretasikan dengan cara khusus. Beberapa karakter meta memiliki makna khusus dan ditulis di dalam tanda kurung siku. Berikut adalah karakter meta yang tersedia: -|Meta character|Description| +|Karakter Meta|Deskripsi| |:----:|----| -|.|Period matches any single character except a line break.| -|[ ]|Character class. Matches any character contained between the square brackets.| -|[^ ]|Negated character class. Matches any character that is not contained between the square brackets| -|*|Matches 0 or more repetitions of the preceding symbol.| -|+|Matches 1 or more repetitions of the preceding symbol.| -|?|Makes the preceding symbol optional.| -|{n,m}|Braces. Matches at least "n" but not more than "m" repetitions of the preceding symbol.| -|(xyz)|Character group. Matches the characters xyz in that exact order.| -|||Alternation. Matches either the characters before or the characters after the symbol.| -|\|Escapes the next character. This allows you to match reserved characters [ ] ( ) { } . * + ? ^ $ \ || -|^|Matches the beginning of the input.| -|$|Matches the end of the input.| - -## 2.1 The Full Stop - -The full stop `.` is the simplest example of a meta character. The meta character `.` -matches any single character. It will not match return or newline characters. -For example, the regular expression `.ar` means: any character, followed by the -letter `a`, followed by the letter `r`. +|.|Titik mencocokkan karakter tunggal apa pun kecuali jeda baris.| +|[ ]|Kelas karakter. Mencocokkan karakter apa pun yang terkandung di antara tanda kurung siku.| +|[^ ]|Kelas karakter yang dinegasikan. Mencocokkan karakter apa pun yang tidak terkandung di antara tanda kurung siku| +|*|Mencocokkan 0 atau lebih pengulangan dari simbol sebelumnya.| +|+|Mencocokkan 1 atau lebih pengulangan dari simbol sebelumnya.| +|?|Membuat simbol sebelumnya opsional.| +|{n,m}|Tanda kurung kurawal. Mencocokkan setidaknya "n" tetapi tidak lebih dari "m" pengulangan dari simbol sebelumnya.| +|(xyz)|Kelompok karakter. Mencocokkan karakter xyz dalam urutan yang tepat.| +|||Alternasi. Mencocokkan karakter sebelum atau karakter setelah simbol.| +|\|Meloloskan karakter berikutnya. Ini memungkinkan Anda mencocokkan karakter yang dipesan [ ] ( ) { } . * + ? ^ $ \ || +|^|Mencocokkan awal dari input.| +|$|Mencocokkan akhir dari input.| + +## 2.1 Titik + +Titik `.` adalah contoh paling sederhana dari karakter meta. Karakter meta `.` +mencocokkan karakter tunggal apa pun. Ini tidak akan mencocokkan karakter return atau newline. +Sebagai contoh, ekspresi reguler `.ar` berarti: karakter apa pun, diikuti oleh +huruf `a`, diikuti oleh huruf `r`. 
 ".ar" => The car parked in the garage.
@@ -131,13 +128,13 @@ letter `a`, followed by the letter `r`.
 
 [Uji Ekspresi Reguler](https://regex101.com/r/xc9GkU/1)
 
-## 2.2 Character Sets
+## 2.2 Set Karakter
 
-Character sets are also called character classes. Square brackets are used to
-specify character sets. Use a hyphen inside a character set to specify the
-characters' range. The order of the character range inside the square brackets
-doesn't matter. For example, the regular expression `[Tt]he` means: an uppercase
-`T` or lowercase `t`, followed by the letter `h`, followed by the letter `e`.
+Set karakter juga disebut kelas karakter. Tanda kurung siku digunakan untuk
+menentukan set karakter. Gunakan tanda hubung di dalam set karakter untuk menentukan
+rentang karakter. Urutan rentang karakter di dalam tanda kurung siku
+tidak masalah. Sebagai contoh, ekspresi reguler `[Tt]he` berarti: huruf besar
+`T` atau huruf kecil `t`, diikuti oleh huruf `h`, diikuti oleh huruf `e`.
 
 
 "[Tt]he" => The car parked in the garage.
@@ -145,9 +142,9 @@ doesn't matter. For example, the regular expression `[Tt]he` means: an uppercase
 
 [Uji Ekspresi Reguler](https://regex101.com/r/2ITLQ4/1)
 
-A period inside a character set, however, means a literal period. The regular
-expression `ar[.]` means: a lowercase character `a`, followed by the letter `r`,
-followed by a period `.` character.
+Namun, titik di dalam set karakter berarti titik literal. Ekspresi reguler
+`ar[.]` berarti: karakter huruf kecil `a`, diikuti oleh huruf `r`,
+diikuti oleh karakter titik `.`.
 
 
 "ar[.]" => A garage is a good place to park a car.
@@ -155,12 +152,12 @@ followed by a period `.` character.
 
 [Uji Ekspresi Reguler](https://regex101.com/r/wL3xtE/1)
 
-### 2.2.1 Negated Character Sets
+### 2.2.1 Set Karakter yang Dinegasikan
 
-In general, the caret symbol represents the start of the string, but when it is
-typed after the opening square bracket it negates the character set. For
-example, the regular expression `[^c]ar` means: any character except `c`,
-followed by the character `a`, followed by the letter `r`.
+Secara umum, simbol caret mewakili awal dari string, tetapi ketika ditulis
+setelah tanda kurung siku pembuka, itu menegasikan set karakter. Sebagai
+contoh, ekspresi reguler `[^c]ar` berarti: karakter apa pun kecuali `c`,
+diikuti oleh karakter `a`, diikuti oleh huruf `r`.
 
 
 "[^c]ar" => The car parked in the garage.
@@ -168,19 +165,19 @@ followed by the character `a`, followed by the letter `r`.
 
 [Uji Ekspresi Reguler](https://regex101.com/r/nNNlq3/1)
 
-## 2.3 Repetitions
+## 2.3 Perulangan
 
-The meta characters `+`, `*` or `?` are used to specify how many times a
-subpattern can occur. These meta characters act differently in different
-situations.
+Karakter meta `+`, `*` atau `?` digunakan untuk menentukan berapa kali
+subpola dapat terjadi. Karakter meta ini bertindak berbeda dalam situasi
+yang berbeda.
 
-### 2.3.1 The Star
+### 2.3.1 Tanda Bintang
 
-The `*` symbol matches zero or more repetitions of the preceding matcher. The
-regular expression `a*` means: zero or more repetitions of the preceding lowercase
-character `a`. But if it appears after a character set or class then it finds
-the repetitions of the whole character set. For example, the regular expression
-`[a-z]*` means: any number of lowercase letters in a row.
+Simbol `*` mencocokkan nol atau lebih pengulangan dari pencocok sebelumnya. Ekspresi reguler
+`a*` berarti: nol atau lebih pengulangan dari karakter huruf kecil sebelumnya
+`a`. Namun, jika muncul setelah set karakter atau kelas, maka itu menemukan
+pengulangan dari seluruh set karakter. Sebagai contoh, ekspresi reguler
+`[a-z]*` berarti: sejumlah huruf kecil dalam barisan.
 
 
 "[a-z]*" => The car parked in the garage #21.
@@ -188,12 +185,12 @@ the repetitions of the whole character set. For example, the regular expression
 
 [Uji Ekspresi Reguler](https://regex101.com/r/7m8me5/1)
 
-The `*` symbol can be used with the meta character `.` to match any string of
-characters `.*`. The `*` symbol can be used with the whitespace character `\s`
-to match a string of whitespace characters. For example, the expression
-`\s*cat\s*` means: zero or more spaces, followed by a lowercase `c`,
-followed by a lowercase `a`, followed by a lowercase `t`,
-followed by zero or more spaces.
+Simbol `*` dapat digunakan dengan karakter meta `.` untuk mencocokkan string karakter apa pun
+`.*`. Simbol `*` juga dapat digunakan dengan karakter spasi `\s`
+untuk mencocokkan string karakter spasi. Sebagai contoh, ekspresi
+`\s*cat\s*` berarti: nol atau lebih spasi, diikuti oleh huruf kecil `c`,
+diikuti oleh huruf kecil `a`, diikuti oleh huruf kecil `t`,
+diikuti oleh nol atau lebih spasi.
 
 
 "\s*cat\s*" => The fat cat sat on the concatenation.
@@ -201,12 +198,12 @@ followed by zero or more spaces.
 
 [Uji Ekspresi Reguler](https://regex101.com/r/gGrwuz/1)
 
-### 2.3.2 The Plus
+### 2.3.2 Tanda Tambah
 
-The `+` symbol matches one or more repetitions of the preceding character. For
-example, the regular expression `c.+t` means: a lowercase `c`, followed by
-at least one character, followed by a lowercase `t`. It needs to be
-clarified that`t` is the last `t` in the sentence.
+Simbol `+` mencocokkan satu atau lebih pengulangan dari karakter sebelumnya. Sebagai
+contoh, ekspresi reguler `c.+t` berarti: huruf kecil `c`, diikuti oleh
+setidaknya satu karakter, diikuti oleh huruf kecil `t`. Perlu
+dijelaskan bahwa `t` adalah `t` terakhir dalam kalimat.
 
 
 "c.+t" => The fat cat sat on the mat.
@@ -214,15 +211,15 @@ clarified that`t` is the last `t` in the sentence.
 
 [Uji Ekspresi Reguler](https://regex101.com/r/Dzf9Aa/1)
 
-### 2.3.3 The Question Mark
+### 2.3.3 Tanda Tanya
 
-In regular expressions, the meta character `?` makes the preceding character
-optional. This symbol matches zero or one instance of the preceding character.
-For example, the regular expression `[T]?he` means: Optional uppercase
-`T`, followed by a lowercase `h`, followed by a lowercase `e`.
+Dalam ekspresi reguler, karakter meta `?` membuat karakter sebelumnya
+opsional. Simbol ini mencocokkan nol atau satu instance dari karakter sebelumnya.
+Sebagai contoh, ekspresi reguler `[T]?he` berarti: Opsional huruf besar
+`T`, diikuti oleh huruf kecil `h`, diikuti oleh huruf kecil `e`.
 
 
-"[T]he" => The car is parked in the garage.
+"[T]?he" => The car is parked in the garage.
 

 
 [Uji Ekspresi Reguler](https://regex101.com/r/cIg9zm/1)
@@ -233,12 +230,12 @@ For example, the regular expression `[T]?he` means: Optional uppercase
 
 [Uji Ekspresi Reguler](https://regex101.com/r/kPpO2x/1)
 
-## 2.4 Braces
+## 2.4 Tanda Kurung Kurawal
 
-In regular expressions, braces (also called quantifiers) are used to
-specify the number of times that a character or a group of characters can be
-repeated. For example, the regular expression `[0-9]{2,3}` means: Match at least
-2 digits, but not more than 3, ranging from 0 to 9.
+Dalam ekspresi reguler, tanda kurung kurawal (juga disebut quantifier) digunakan untuk
+menentukan berapa kali karakter atau kelompok karakter dapat
+diulang. Sebagai contoh, ekspresi reguler `[0-9]{2,3}` berarti: Cocokkan setidaknya
+2 digit, tetapi tidak lebih dari 3, berkisar dari 0 hingga 9.
 
 
 "[0-9]{2,3}" => The number was 9.9997 but we rounded it off to 10.0.
@@ -246,9 +243,9 @@ repeated. For example, the regular expression `[0-9]{2,3}` means: Match at least
 
 [Uji Ekspresi Reguler](https://regex101.com/r/juM86s/1)
 
-We can leave out the second number. For example, the regular expression
-`[0-9]{2,}` means: Match 2 or more digits. If we also remove the comma, the
-regular expression `[0-9]{3}` means: Match exactly 3 digits.
+Kita dapat menghilangkan angka kedua. Sebagai contoh, ekspresi reguler
+`[0-9]{2,}` berarti: Cocokkan 2 atau lebih digit. Jika kita juga menghapus koma, ekspresi reguler
+`[0-9]{3}` berarti: Cocokkan tepat 3 digit.
 
 
 "[0-9]{2,}" => The number was 9.9997 but we rounded it off to 10.0.
@@ -262,16 +259,16 @@ regular expression `[0-9]{3}` means: Match exactly 3 digits.
 
 [Uji Ekspresi Reguler](https://regex101.com/r/Sivu30/1)
 
-## 2.5 Capturing Groups
+## 2.5 Kelompok Penangkapan
 
-A capturing group is a group of subpatterns that is written inside parentheses 
-`(...)`. As discussed before, in regular expressions, if we put a quantifier 
-after a character then it will repeat the preceding character. But if we put a quantifier
-after a capturing group then it repeats the whole capturing group. For example,
-the regular expression `(ab)*` matches zero or more repetitions of the character
-"ab". We can also use the alternation `|` meta character inside a capturing group.
-For example, the regular expression `(c|g|p)ar` means: a lowercase `c`,
-`g` or `p`, followed by `a`, followed by `r`.
+Kelompok penangkapan adalah kelompok subpola yang ditulis di dalam tanda kurung 
+`(...)`. Seperti yang dibahas sebelumnya, dalam ekspresi reguler, jika kita meletakkan quantifier 
+setelah karakter maka itu akan mengulang karakter sebelumnya. Namun, jika kita meletakkan quantifier
+setelah kelompok penangkapan maka itu mengulang seluruh kelompok penangkapan. Sebagai contoh,
+ekspresi reguler `(ab)*` mencocokkan nol atau lebih pengulangan dari karakter
+"ab". Kita juga dapat menggunakan alternasi `|` karakter meta di dalam kelompok penangkapan.
+Sebagai contoh, ekspresi reguler `(c|g|p)ar` berarti: huruf kecil `c`,
+`g` atau `p`, diikuti oleh `a`, diikuti oleh `r`.
 
 
 "(c|g|p)ar" => The car is parked in the garage.
@@ -279,16 +276,16 @@ For example, the regular expression `(c|g|p)ar` means: a lowercase `c`,
 
 [Uji Ekspresi Reguler](https://regex101.com/r/tUxrBG/1)
 
-Note that capturing groups do not only match, but also capture, the characters for use in 
-the parent language. The parent language could be Python or JavaScript or virtually any
-language that implements regular expressions in a function definition.
+Perhatikan bahwa kelompok penangkapan tidak hanya mencocokkan, tetapi juga menangkap karakter untuk digunakan dalam 
+bahasa induk. Bahasa induk dapat berupa Python, JavaScript, atau hampir semua
+bahasa yang mengimplementasikan ekspresi reguler dalam definisi fungsi.
 
-### 2.5.1 Non-Capturing Groups
+### 2.5.1 Kelompok Non-Penangkapan
 
-A non-capturing group is a capturing group that matches the characters but 
-does not capture the group. A non-capturing group is denoted by a `?` followed by a `:` 
-within parentheses `(...)`. For example, the regular expression `(?:c|g|p)ar` is similar to 
-`(c|g|p)ar` in that it matches the same characters but will not create a capture group.
+Kelompok non-penangkapan adalah kelompok penangkapan yang mencocokkan karakter tetapi 
+tidak menangkap kelompok. Kelompok non-penangkapan dilambangkan dengan `?` diikuti oleh `:` 
+di dalam tanda kurung `(...)`. Sebagai contoh, ekspresi reguler `(?:c|g|p)ar` mirip dengan 
+`(c|g|p)ar` dalam hal itu mencocokkan karakter yang sama tetapi tidak akan membuat kelompok penangkapan.
 
 
 "(?:c|g|p)ar" => The car is parked in the garage.
@@ -296,22 +293,22 @@ within parentheses `(...)`. For example, the regular expression `(?:c|g|p)ar` is
 
 [Uji Ekspresi Reguler](https://regex101.com/r/Rm7Me8/1)
 
-Non-capturing groups can come in handy when used in find-and-replace functionality or 
-when mixed with capturing groups to keep the overview when producing any other kind of output. 
-See also [4. Lookaround](#4-lookaround).
+Kelompok non-penangkapan dapat berguna ketika digunakan dalam fungsionalitas find-and-replace atau 
+ketika dicampur dengan kelompok penangkapan untuk menjaga gambaran ketika menghasilkan jenis output lainnya. 
+Lihat juga [4. Lookaround](#4-lookaround).
 
-## 2.6 Alternation
+## 2.6 Alternasi
 
-In a regular expression, the vertical bar `|` is used to define alternation.
-Alternation is like an OR statement between multiple expressions. Now, you may be
-thinking that character sets and alternation work the same way. But the big
-difference between character sets and alternation is that character sets work at the
-character level but alternation works at the expression level. For example, the
-regular expression `(T|t)he|car` means: either (an uppercase `T` or a lowercase
-`t`, followed by a lowercase `h`, followed by a lowercase `e`) OR
-(a lowercase `c`, followed by a lowercase `a`, followed by
-a lowercase `r`). Note that I included the parentheses for clarity, to show that either expression
-in parentheses can be met and it will match.
+Dalam ekspresi reguler, batang vertikal `|` digunakan untuk mendefinisikan alternasi.
+Alternasi seperti pernyataan OR antara beberapa ekspresi. Sekarang, Anda mungkin
+berpikir bahwa set karakter dan alternasi bekerja dengan cara yang sama. Namun, perbedaan besar
+antara set karakter dan alternasi adalah bahwa set karakter bekerja pada
+tingkat karakter tetapi alternasi bekerja pada tingkat ekspresi. Sebagai contoh, ekspresi reguler
+`(T|t)he|car` berarti: baik (huruf besar `T` atau huruf kecil
+`t`, diikuti oleh huruf kecil `h`, diikuti oleh huruf kecil `e`) ATAU
+(huruf kecil `c`, diikuti oleh huruf kecil `a`, diikuti oleh
+huruf kecil `r`). Perhatikan bahwa saya menyertakan tanda kurung untuk kejelasan, untuk menunjukkan bahwa ekspresi mana pun
+dalam tanda kurung dapat dipenuhi dan itu akan cocok.
 
 
 "(T|t)he|car" => The car is parked in the garage.
@@ -319,16 +316,16 @@ in parentheses can be met and it will match.
 
 [Uji Ekspresi Reguler](https://regex101.com/r/fBXyX0/1)
 
-## 2.7 Escaping Special Characters
+## 2.7 Meloloskan Karakter Khusus
 
-A backslash `\` is used in regular expressions to escape the next character. This
-allows us to include reserved characters such as `{ } [ ] / \ + * . $ ^ | ?` as matching characters. To use one of these special character as a matching character, prepend it with `\`.
+Backslash `\` digunakan dalam ekspresi reguler untuk meloloskan karakter berikutnya. Ini
+memungkinkan kita untuk menyertakan karakter yang dipesan seperti `{ } [ ] / \ + * . $ ^ | ?` sebagai karakter pencocokan. Untuk menggunakan salah satu karakter khusus ini sebagai karakter pencocokan, tambahkan `\` di depannya.
 
-For example, the regular expression `.` is used to match any character except a
-newline. Now, to match `.` in an input string, the regular expression
-`(f|c|m)at\.?` means: a lowercase `f`, `c` or `m`, followed by a lowercase
-`a`, followed by a lowercase `t`, followed by an optional `.`
-character.
+Sebagai contoh, ekspresi reguler `.` digunakan untuk mencocokkan karakter apa pun kecuali
+newline. Sekarang, untuk mencocokkan `.` dalam string input, ekspresi reguler
+`(f|c|m)at\.?` berarti: huruf kecil `f`, `c` atau `m`, diikuti oleh huruf kecil
+`a`, diikuti oleh huruf kecil `t`, diikuti oleh opsional `.`
+karakter.
 
 
 "(f|c|m)at\.?" => The fat cat sat on the mat.
@@ -336,24 +333,24 @@ character.
 
 [Uji Ekspresi Reguler](https://regex101.com/r/DOc5Nu/1)
 
-## 2.8 Anchors
+## 2.8 Penanda Posisi
 
-In regular expressions, we use anchors to check if the matching symbol is the
-starting symbol or ending symbol of the input string. Anchors are of two types:
-The first type is the caret `^` that checks if the matching character is the first
-character of the input and the second type is the dollar sign `$` which checks if a matching
-character is the last character of the input string.
+Dalam ekspresi reguler, kita menggunakan penanda posisi untuk memeriksa apakah simbol pencocokan adalah
+simbol awal atau simbol akhir dari string input. Penanda posisi terdiri dari dua jenis:
+Jenis pertama adalah caret `^` yang memeriksa apakah karakter pencocokan adalah karakter pertama
+dari input dan jenis kedua adalah tanda dolar `$` yang memeriksa apakah karakter pencocokan
+adalah karakter terakhir dari string input.
 
-### 2.8.1 The Caret
+### 2.8.1 Tanda Karat (Caret)
 
-The caret symbol `^` is used to check if a matching character is the first character
-of the input string. If we apply the following regular expression `^a` (meaning 'a' must be
-the starting character) to the string `abc`, it will match `a`. But if we apply
-the regular expression `^b` to the above string, it will not match anything.
-Because in the string `abc`, the "b" is not the starting character. Let's take a look
-at another regular expression `^(T|t)he` which means: an uppercase `T` or
-a lowercase `t` must be the first character in the string, followed by a
-lowercase `h`, followed by a lowercase `e`.
+Simbol caret `^` digunakan untuk memeriksa apakah karakter pencocokan adalah karakter pertama
+dari string input. Jika kita menerapkan ekspresi reguler berikut `^a` (berarti 'a' harus
+menjadi karakter awal) ke string `abc`, itu akan mencocokkan `a`. Namun, jika kita menerapkan
+ekspresi reguler `^b` ke string di atas, itu tidak akan mencocokkan apa pun.
+Karena dalam string `abc`, "b" bukan karakter awal. Mari kita lihat
+ekspresi reguler lain `^(T|t)he` yang berarti: huruf besar `T` atau
+huruf kecil `t` harus menjadi karakter pertama dalam string, diikuti oleh
+huruf kecil `h`, diikuti oleh huruf kecil `e`.
 
 
 "(T|t)he" => The car is parked in the garage.
@@ -367,12 +364,12 @@ lowercase `h`, followed by a lowercase `e`.
 
 [Uji Ekspresi Reguler](https://regex101.com/r/jXrKne/1)
 
-### 2.8.2 The Dollar Sign
+### 2.8.2 Tanda Dolar
 
-The dollar sign `$` is used to check if a matching character is the last character
-in the string. For example, the regular expression `(at\.)$` means: a
-lowercase `a`, followed by a lowercase `t`, followed by a `.`
-character and the matcher must be at the end of the string.
+Tanda dolar `$` digunakan untuk memeriksa apakah karakter pencocokan adalah karakter terakhir
+dalam string. Sebagai contoh, ekspresi reguler `(at\.)$` berarti: huruf kecil
+`a`, diikuti oleh huruf kecil `t`, diikuti oleh karakter
+`.` dan pencocok harus berada di akhir string.
 
 
 "(at\.)" => The fat cat. sat. on the mat.
@@ -386,52 +383,52 @@ character and the matcher must be at the end of the string.
 
 [Uji Ekspresi Reguler](https://regex101.com/r/t0AkOd/1)
 
-##  3. Shorthand Character Sets
+## 3. Set Karakter Singkatan
 
-There are a number of convenient shorthands for commonly used character sets/
-regular expressions:
+Ada sejumlah singkatan yang nyaman untuk set karakter yang umum digunakan/
+ekspresi reguler:
 
-|Shorthand|Description|
+|Singkatan|Deskripsi|
 |:----:|----|
-|.|Any character except new line|
-|\w|Matches alphanumeric characters: `[a-zA-Z0-9_]`|
-|\W|Matches non-alphanumeric characters: `[^\w]`|
-|\d|Matches digits: `[0-9]`|
-|\D|Matches non-digits: `[^\d]`|
-|\s|Matches whitespace characters: `[\t\n\f\r\p{Z}]`|
-|\S|Matches non-whitespace characters: `[^\s]`|
+|.|Karakter apa pun kecuali baris baru|
+|\w|Mencocokkan karakter alfanumerik: `[a-zA-Z0-9_]`|
+|\W|Mencocokkan karakter non-alfanumerik: `[^\w]`|
+|\d|Mencocokkan digit: `[0-9]`|
+|\D|Mencocokkan non-digit: `[^\d]`|
+|\s|Mencocokkan karakter spasi: `[\t\n\f\r\p{Z}]`|
+|\S|Mencocokkan karakter non-spasi: `[^\s]`|
 
 ## 4. Lookarounds
 
-Lookbehinds and lookaheads (also called lookarounds) are specific types of
-***non-capturing groups*** (used to match a pattern but without including it in the matching
-list). Lookarounds are used when we a pattern must be
-preceded or followed by another pattern. For example, imagine we want to get all
-numbers that are preceded by the `$` character from the string
-`$4.44 and $10.88`. We will use the following regular expression `(?<=\$)[0-9\.]*`
-which means: get all the numbers which contain the `.` character and are preceded
-by the `$` character. These are the lookarounds that are used in regular
-expressions:
-
-|Symbol|Description|
+Lookbehinds dan lookaheads (juga disebut lookarounds) adalah jenis khusus dari
+***kelompok non-penangkapan*** (digunakan untuk mencocokkan pola tetapi tanpa menyertakannya dalam daftar
+pencocokan). Lookarounds digunakan ketika pola harus
+didahului atau diikuti oleh pola lain. Sebagai contoh, bayangkan kita ingin mendapatkan semua
+angka yang didahului oleh karakter `$` dari string
+`$4.44 and $10.88`. Kita akan menggunakan ekspresi reguler berikut `(?<=\$)[0-9\.]*`
+yang berarti: dapatkan semua angka yang mengandung karakter `.` dan didahului
+oleh karakter `$`. Berikut adalah lookarounds yang digunakan dalam ekspresi
+reguler:
+
+|Simbol|Deskripsi|
 |:----:|----|
-|?=|Positive Lookahead|
-|?!|Negative Lookahead|
-|?<=|Positive Lookbehind|
-|?
 "(T|t)he(?=\sfat)" => The fat cat sat on the mat.
@@ -439,14 +436,14 @@ or `the` only if it's followed by the word `fat`.
 
 [Uji Ekspresi Reguler](https://regex101.com/r/IDDARt/1)
 
-### 4.2 Negative Lookahead
+### 4.2 Negatif Lookahead
 
-Negative lookaheads are used when we need to get all matches from an input string
-that are not followed by a certain pattern. A negative lookahead is written the same way as a
-positive lookahead. The only difference is, instead of an equals sign `=`, we
-use an exclamation mark `!` to indicate negation i.e. `(?!...)`. Let's take a look at the following
-regular expression `(T|t)he(?!\sfat)` which means: get all `The` or `the` words
-from the input string that are not followed by a space character and the word `fat`.
+Negatif lookahead digunakan ketika kita perlu mendapatkan semua pencocokan dari string input
+yang tidak diikuti oleh pola tertentu. Negatif lookahead ditulis dengan cara yang sama seperti
+positif lookahead. Satu-satunya perbedaan adalah, alih-alih tanda sama dengan `=`, kita
+menggunakan tanda seru `!` untuk menunjukkan negasi yaitu `(?!...)`. Mari kita lihat ekspresi reguler berikut
+`(T|t)he(?!\sfat)` yang berarti: dapatkan semua kata `The` atau `the`
+dari string input yang tidak diikuti oleh karakter spasi dan kata `fat`.
 
 
 "(T|t)he(?!\sfat)" => The fat cat sat on the mat.
@@ -454,12 +451,12 @@ from the input string that are not followed by a space character and the word `f
 
 [Uji Ekspresi Reguler](https://regex101.com/r/V32Npg/1)
 
-### 4.3 Positive Lookbehind
+### 4.3 Positif Lookbehind
 
-Positive lookbehinds are used to get all the matches that are preceded by a
-specific pattern. Positive lookbehinds are written `(?<=...)`. For example, the
-regular expression `(?<=(T|t)he\s)(fat|mat)` means: get all `fat` or `mat` words
-from the input string that come after the word `The` or `the`.
+Positif lookbehind digunakan untuk mendapatkan semua pencocokan yang didahului oleh
+pola tertentu. Positif lookbehind ditulis `(?<=...)`. Sebagai contoh, ekspresi reguler
+`(?<=(T|t)he\s)(fat|mat)` berarti: dapatkan semua kata `fat` atau `mat`
+dari string input yang datang setelah kata `The` atau `the`.
 
 
 "(?<=(T|t)he\s)(fat|mat)" => The fat cat sat on the mat.
@@ -467,39 +464,39 @@ from the input string that come after the word `The` or `the`.
 
 [Uji Ekspresi Reguler](https://regex101.com/r/avH165/1)
 
-### 4.4 Negative Lookbehind
+### 4.4 Negatif Lookbehind
 
-Negative lookbehinds are used to get all the matches that are not preceded by a
-specific pattern. Negative lookbehinds are written `(?
-"(?<!(T|t)he\s)(cat)" => The cat sat on cat.
+"(? The cat sat on cat.
 

 
 [Uji Ekspresi Reguler](https://regex101.com/r/8Efx5G/1)
 
 ## 5. Flags
 
-Flags are also called modifiers because they modify the output of a regular
-expression. These flags can be used in any order or combination, and are an
-integral part of the RegExp.
+Flags juga disebut modifier karena mereka memodifikasi output dari ekspresi
+reguler. Flags ini dapat digunakan dalam urutan atau kombinasi apa pun, dan merupakan
+bagian integral dari RegExp.
 
-|Flag|Description|
+|Flag|Deskripsi|
 |:----:|----|
-|i|Case insensitive: Match will be case-insensitive.|
-|g|Global Search: Match all instances, not just the first.|
-|m|Multiline: Anchor meta characters work on each line.|
+|i|Tidak peka huruf: Pencocokan akan tidak peka terhadap huruf besar/kecil.|
+|g|Pencarian Global: Cocokkan semua instance, bukan hanya yang pertama.|
+|m|Multiline: Karakter meta anchor bekerja pada setiap baris.|
 
-### 5.1 Case Insensitive
+### 5.1 Tidak Peka Huruf
 
-The `i` modifier is used to perform case-insensitive matching. For example, the
-regular expression `/The/gi` means: an uppercase `T`, followed by a lowercase
-`h`, followed by an `e`. And at the end of regular expression
-the `i` flag tells the regular expression engine to ignore the case. As you can
-see, we also provided `g` flag because we want to search for the pattern in the
-whole input string.
+Modifier `i` digunakan untuk melakukan pencocokan yang tidak peka terhadap huruf. Sebagai contoh, ekspresi reguler
+`/The/gi` berarti: huruf besar `T`, diikuti oleh huruf kecil
+`h`, diikuti oleh `e`. Dan di akhir ekspresi reguler
+flag `i` memberitahu mesin ekspresi reguler untuk mengabaikan huruf besar/kecil. Seperti yang Anda bisa
+lihat, kita juga menyediakan flag `g` karena kita ingin mencari pola dalam
+seluruh string input.
 
 
 "The" => The fat cat sat on the mat.
@@ -513,13 +510,13 @@ whole input string.
 
 [Uji Ekspresi Reguler](https://regex101.com/r/ahfiuh/1)
 
-### 5.2 Global Search
+### 5.2 Pencarian Global
 
-The `g` modifier is used to perform a global match (finds all matches rather than
-stopping after the first match). For example, the regular expression`/.(at)/g`
-means: any character except a new line, followed by a lowercase `a`,
-followed by a lowercase `t`. Because we provided the `g` flag at the end of
-the regular expression, it will now find all matches in the input string, not just the first one (which is the default behavior).
+Modifier `g` digunakan untuk melakukan pencocokan global (menemukan semua pencocokan daripada
+berhenti setelah pencocokan pertama). Sebagai contoh, ekspresi reguler `/.(at)/g`
+berarti: karakter apa pun kecuali baris baru, diikuti oleh huruf kecil `a`,
+diikuti oleh huruf kecil `t`. Karena kita menyediakan flag `g` di akhir
+ekspresi reguler, sekarang akan menemukan semua pencocokan dalam string input, bukan hanya yang pertama (yang merupakan perilaku default).
 
 
 "/.(at)/" => The fat cat sat on the mat.
@@ -533,15 +530,15 @@ the regular expression, it will now find all matches in the input string, not ju
 
 [Uji Ekspresi Reguler](https://regex101.com/r/dO1nef/1)
 
-### 5.3 Multiline
+### 5.3 Baris Berganda
 
-The `m` modifier is used to perform a multi-line match. As we discussed earlier,
-anchors `(^, $)` are used to check if a pattern is at the beginning of the input or
-the end. But if we want the anchors to work on each line, we use
-the `m` flag. For example, the regular expression `/at(.)?$/gm` means: a lowercase
-`a`, followed by a lowercase `t` and, optionally, anything except
-a new line. And because of the `m` flag, the regular expression engine now matches patterns
-at the end of each line in a string.
+Modifier `m` digunakan untuk melakukan pencocokan multi-baris. Seperti yang kita bahas sebelumnya,
+anchor `(^, $)` digunakan untuk memeriksa apakah pola berada di awal input atau
+di akhir. Tetapi jika kita ingin anchor bekerja pada setiap baris, kita menggunakan
+flag `m`. Sebagai contoh, ekspresi reguler `/at(.)?$/gm` berarti: huruf kecil
+`a`, diikuti oleh huruf kecil `t` dan, secara opsional, apa pun kecuali
+baris baru. Dan karena flag `m`, mesin ekspresi reguler sekarang mencocokkan pola
+di akhir setiap baris dalam string.
 
 
 "/.at(.)?$/" => The fat
@@ -559,9 +556,9 @@ at the end of each line in a string.
 
 [Uji Ekspresi Reguler](https://regex101.com/r/E88WE2/1)
 
-## 6. Greedy vs Lazy Matching
-By default, a regex will perform a greedy match, which means the match will be as long as
-possible. We can use `?` to match in a lazy way, which means the match should be as short as possible.
+## 6. Pencocokan Serakah vs Malas
+Secara default, regex akan melakukan pencocokan serakah (greedy), yang berarti pencocokan akan selama
+mungkin. Kita dapat menggunakan `?` untuk mencocokkan dengan cara malas (lazy), yang berarti pencocokan harus sesingkat mungkin.
 
 
 "/(.*at)/" => The fat cat sat on the mat. 

@@ -576,13 +573,13 @@ possible. We can use `?` to match in a lazy way, which means the match should be
 [Uji Ekspresi Reguler](https://regex101.com/r/AyAdgJ/2)
 
 
-## Contribution
+## Kontribusi
 
-* Open a pull request with improvements
-* Discuss ideas in issues
-* Spread the word
-* Reach out with any feedback [![Twitter URL](https://img.shields.io/twitter/url/https/twitter.com/ziishaned.svg?style=social&label=Follow%20%40ziishaned)](https://twitter.com/ziishaned)
+* Buka pull request dengan perbaikan
+* Diskusikan ide dalam issues
+* Sebarkan informasi
+* Hubungi dengan feedback apa pun [![Twitter URL](https://img.shields.io/twitter/url/https/twitter.com/ziishaned.svg?style=social&label=Follow%20%40ziishaned)](https://twitter.com/ziishaned)
 
-## License
+## Lisensi
 
 MIT © [Zeeshan Ahmad](https://twitter.com/ziishaned)