Fix description of regex flags

Author: Josh-Cena

files/en-us/web/javascript/reference/global_objects/regexp/dotall/index.md

@@ -1,8 +1,7 @@
 ---
-title: RegExp.prototype.dotAll
+title: get RegExp.prototype.dotAll
 slug: Web/JavaScript/Reference/Global_Objects/RegExp/dotAll
 tags:
-  - Draft
   - JavaScript
   - Property
   - Prototype
@@ -14,15 +13,13 @@ browser-compat: javascript.builtins.RegExp.dotAll
 ---
 {{JSRef}}
 
-The **`dotAll`** property indicates whether or not the `s` flag is used with the regular expression. `dotAll` is a read-only property of an individual regular expression instance.
+The **`dotAll`** accessor property indicates whether or not the `s` flag is used with the regular expression.
 
 {{EmbedInteractiveExample("pages/js/regexp-prototype-dotall.html")}}
 
-{{JS_Property_Attributes(0, 0, 1)}}
-
 ## Description
 
-The value of `dotAll` is a {{JSxRef("Boolean")}} and `true` if the `s` flag was used; otherwise, `false`. The `s` flag indicates that the dot special character (`.`) should additionally match the following line terminator ("newline") characters in a string, which it would not match otherwise:
+`RegExp.prototype.dotAll` is a getter-only property that returns `true` if the `s` flag was used; otherwise, `false`. The `s` flag indicates that the dot special character (`.`) should additionally match the following line terminator ("newline") characters in a string, which it would not match otherwise:
 
 - U+000A LINE FEED (LF) (`\n`)
 - U+000D CARRIAGE RETURN (CR) (`\r`)
@@ -35,20 +32,20 @@ You cannot change this property directly.
 
 ## Examples
 
-### Using `dotAll`
+### Using dotAll
 
 ```js
 const str1 = 'bar\nexample foo example';
 
-const regex1 = new RegExp('bar.example','s');
+const regex1 = /bar.example/s;
 
 console.log(regex1.dotAll); // Output: true
 
-console.log(str1.replace(regex1,'')); // Output: foo example
+console.log(str1.replace(regex1, '')); // Output: foo example
 
 const str2 = 'bar\nexample foo example';
 
-const regex2 = new RegExp('bar.example');
+const regex2 = /bar.example/;
 
 console.log(regex2.dotAll); // Output: false
 

files/en-us/web/javascript/reference/global_objects/regexp/flags/index.md

@@ -1,5 +1,5 @@
 ---
-title: RegExp.prototype.flags
+title: get RegExp.prototype.flags
 slug: Web/JavaScript/Reference/Global_Objects/RegExp/flags
 tags:
   - ECMAScript 2015
@@ -14,15 +14,17 @@ browser-compat: javascript.builtins.RegExp.flags
 ---
 {{JSRef}}
 
-The **`flags`** property returns a string consisting of the [flags](/en-US/docs/Web/JavaScript/Guide/Regular_Expressions#advanced_searching_with_flags) of the current regular expression object.
+The **`flags`** accessor property represents the [flags](/en-US/docs/Web/JavaScript/Guide/Regular_Expressions#advanced_searching_with_flags) of the current regular expression object.
 
 {{EmbedInteractiveExample("pages/js/regexp-prototype-flags.html")}}
 
-{{JS_Property_Attributes(0, 0, 1)}}
-
 ## Description
 
-Flags in the `flags` property are sorted alphabetically (from left to right, e.g. `"gimsuy"`).
+`RegExp.prototype.flags` is a getter-only property that returns a string. Flags in the `flags` property are sorted alphabetically (from left to right, e.g. `"dgimsuy"`). It actually invokes the other flag accessors ([`hasIndices`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/hasIndices), [`global`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/global), etc.) one-by-one and concatenates the results.
+
+All built-in functions read the `flags` property instead of reading individual flag accessors.
+
+You cannot change this property directly.
 
 ## Examples
 

files/en-us/web/javascript/reference/global_objects/regexp/global/index.md

@@ -1,5 +1,5 @@
 ---
-title: RegExp.prototype.global
+title: get RegExp.prototype.global
 slug: Web/JavaScript/Reference/Global_Objects/RegExp/global
 tags:
   - JavaScript
@@ -12,13 +12,15 @@ browser-compat: javascript.builtins.RegExp.global
 ---
 {{JSRef}}
 
-The **`global`** property indicates whether or not the `g` flag is used with the regular expression. `global` is a read-only property of an individual regular expression instance.
+The **`global`** accessor property indicates whether or not the `g` flag is used with the regular expression.
 
-{{EmbedInteractiveExample("pages/js/regexp-prototype-global.html")}}{{js_property_attributes(0, 0, 1)}}
+{{EmbedInteractiveExample("pages/js/regexp-prototype-global.html")}}
 
 ## Description
 
-The value of `global` is a {{jsxref("Boolean")}} and `true` if the `g` flag was used; otherwise, `false`. The `g` flag indicates that the regular expression should be tested against all possible matches in a string. A regular expression defined as both `global` (`g`) and `sticky` (`y`) will ignore the `global` flag and perform sticky matches.
+`RegExp.prototype.global` is a getter-only property that returns `true` if the `g` flag was used; otherwise, `false`. The `g` flag indicates that the regular expression should be tested against all possible matches in a string. Each call to [`exec()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/exec) will update its [`lastIndex`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/lastIndex) property, so that the next call to `exec()` will start at the next character.
+
+Some methods, such as [`String.prototype.matchAll()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/matchAll) and [`String.prototype.replaceAll()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replaceAll), will validate that, if the parameter is a regex, it is global. The regex's [`@@match`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/@@match) and [`@@replace`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/@@replace) methods (called by [`String.prototype.match()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/match) and [`String.prototype.replace()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace)) would also have different behaviors when the regex is global.
 
 You cannot change this property directly.
 
@@ -27,7 +29,7 @@ You cannot change this property directly.
 ### Using global
 
 ```js
-const regex = new RegExp('foo', 'g');
+const regex = /foo/g;
 
 console.log(regex.global);  // true
 
@@ -37,7 +39,7 @@ const str1 = str.replace(regex, '');
 
 console.log(str1);  // Output: example
 
-const regex1 = new RegExp('foo');
+const regex1 = /foo/;
 
 const str2 = str.replace(regex1, '');
 

files/en-us/web/javascript/reference/global_objects/regexp/hasindices/index.md

@@ -1,8 +1,7 @@
 ---
-title: RegExp.prototype.hasIndices
+title: get RegExp.prototype.hasIndices
 slug: Web/JavaScript/Reference/Global_Objects/RegExp/hasIndices
 tags:
-  - Draft
   - JavaScript
   - Property
   - Prototype
@@ -13,26 +12,24 @@ browser-compat: javascript.builtins.RegExp.hasIndices
 ---
 {{JSRef}}
 
-The **`hasIndices`** property indicates whether or not the `d` flag is used with the regular expression. `hasIndices` is a read-only property of an individual regular expression instance.
+The **`hasIndices`** accessor property indicates whether or not the `d` flag is used with the regular expression.
 
 {{EmbedInteractiveExample("pages/js/regexp-prototype-hasindices.html")}}
 
-{{JS_Property_Attributes(0, 0, 1)}}
-
 ## Description
 
-The value of `hasIndices` is a {{JSxRef("Boolean")}} and `true` if the `d` flag was used; otherwise, `false`. The `d` flag indicates that the result of a regular expression match should contain the start and end indices of the substrings of each capture group.
+`RegExp.prototype.hasIndices` is a getter-only property that returns `true` if the `d` flag was used; otherwise, `false`. The `d` flag indicates that the result of a regular expression match should contain the start and end indices of the substrings of each capture group. It does not change the regex's interpretation or matching behavior in any way, but only enables additional information in the matching result.
 
 You cannot change this property directly.
 
 ## Examples
 
-### Using `hasIndices`
+### Using hasIndices
 
 ```js
 const str1 = 'foo bar foo';
 
-const regex1 = new RegExp('foo', 'gd');
+const regex1 = /foo/gd;
 
 console.log(regex1.hasIndices); // Output: true
 
@@ -41,7 +38,7 @@ console.log(regex1.exec(str1).indices[0]); // Output: Array [8, 11]
 
 const str2 = 'foo bar foo';
 
-const regex2 = new RegExp('foo');
+const regex2 = /foo/;
 
 console.log(regex2.hasIndices); // Output: false
 

files/en-us/web/javascript/reference/global_objects/regexp/ignorecase/index.md

@@ -1,5 +1,5 @@
 ---
-title: RegExp.prototype.ignoreCase
+title: get RegExp.prototype.ignoreCase
 slug: Web/JavaScript/Reference/Global_Objects/RegExp/ignoreCase
 tags:
   - JavaScript
@@ -12,13 +12,13 @@ browser-compat: javascript.builtins.RegExp.ignoreCase
 ---
 {{JSRef}}
 
-The **`ignoreCase`** property indicates whether or not the `i` flag is used with the regular expression. `ignoreCase` is a read-only property of an individual regular expression instance.
+The **`ignoreCase`** accessor property indicates whether or not the `i` flag is used with the regular expression.
 
-{{EmbedInteractiveExample("pages/js/regexp-prototype-ignorecase.html")}}{{js_property_attributes(0, 0, 1)}}
+{{EmbedInteractiveExample("pages/js/regexp-prototype-ignorecase.html")}}
 
 ## Description
 
-The value of `ignoreCase` is a {{jsxref("Boolean")}} and `true` if the `i` flag was used; otherwise, `false`. The `i` flag indicates that case should be ignored while attempting a match in a string.
+`RegExp.prototype.ignoreCase` is a getter-only property that returns `true` if the `i` flag was used; otherwise, `false`. The `i` flag indicates that case should be ignored while attempting a match in a string.
 
 You cannot change this property directly.
 
@@ -27,7 +27,7 @@ You cannot change this property directly.
 ### Using ignoreCase
 
 ```js
-const regex = new RegExp('foo', 'i');
+const regex = /foo/i;
 
 console.log(regex.ignoreCase); // true
 ```

files/en-us/web/javascript/reference/global_objects/regexp/multiline/index.md

@@ -1,5 +1,5 @@
 ---
-title: RegExp.prototype.multiline
+title: get RegExp.prototype.multiline
 slug: Web/JavaScript/Reference/Global_Objects/RegExp/multiline
 tags:
   - JavaScript
@@ -12,13 +12,13 @@ browser-compat: javascript.builtins.RegExp.multiline
 ---
 {{JSRef}}
 
-The **`multiline`** property indicates whether or not the `m` flag is used with the regular expression. `multiline` is a read-only property of an individual regular expression instance.
+The **`multiline`** accessor property indicates whether or not the `m` flag is used with the regular expression.
 
-{{EmbedInteractiveExample("pages/js/regexp-prototype-multiline.html", "taller")}}{{js_property_attributes(0, 0, 1)}}
+{{EmbedInteractiveExample("pages/js/regexp-prototype-multiline.html", "taller")}
 
 ## Description
 
-The value of `multiline` is a {{jsxref("Boolean")}} and is true if the `m` flag was used; otherwise, false. The `m` flag indicates that a multiline input string should be treated as multiple lines. For example, if `m` is used, `^` and `$` change from matching at only the start or end of the entire string to the start or end of any line within the string.
+`RegExp.prototype.multiline` is a getter-only property that returns `true` if the `m` flag was used; otherwise, `false`. The `m` flag indicates that a multiline input string should be treated as multiple lines. For example, if `m` is used, `^` and `$` change from matching at only the start or end of the entire string to the start or end of any line within the string.
 
 You cannot change this property directly.
 
@@ -27,7 +27,7 @@ You cannot change this property directly.
 ### Using multiline
 
 ```js
-const regex = new RegExp('foo', 'm');
+const regex = /foo/m;
 
 console.log(regex.multiline); // true
 ```

files/en-us/web/javascript/reference/global_objects/regexp/sticky/index.md

@@ -1,5 +1,5 @@
 ---
-title: RegExp.prototype.sticky
+title: get RegExp.prototype.sticky
 slug: Web/JavaScript/Reference/Global_Objects/RegExp/sticky
 tags:
   - ECMAScript 2015
@@ -14,15 +14,19 @@ browser-compat: javascript.builtins.RegExp.sticky
 ---
 {{JSRef}}
 
-The **`sticky`** property reflects whether or not the search is sticky (searches in strings only from the index indicated by the {{jsxref("RegExp.lastIndex", "lastIndex")}} property of this regular expression). `sticky` is a read-only property of an individual regular expression object.
+The **`sticky`** accessor property indicates whether or not the `y` flag is used with the regular expression.
 
-{{EmbedInteractiveExample("pages/js/regexp-prototype-sticky.html", "taller")}}{{js_property_attributes(0, 0, 1)}}
+{{EmbedInteractiveExample("pages/js/regexp-prototype-sticky.html", "taller")}}
 
 ## Description
 
-The value of `sticky` is a {{jsxref("Boolean")}} and true if the `y` flag was used; otherwise, false. The `y` flag indicates that it matches only from the index indicated by the {{jsxref("RegExp.lastIndex", "lastIndex")}} property of this regular expression in the target string (and does not attempt to match from any later indexes). A regular expression defined as both `sticky` and `global` ignores the `global` flag.
+`RegExp.prototype.sticky` is a getter-only property that returns `true` if the `y` flag was used; otherwise, `false`. The `y` flag indicates that it matches only from the index indicated by the {{jsxref("RegExp.lastIndex", "lastIndex")}} property of this regular expression in the target string (and does not attempt to match from any later indexes).
 
-You cannot change this property directly. It is read-only.
+When the [`exec()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/exec) method is called and the regex fails to match at the current position indicated by {{jsxref("RegExp.lastIndex", "lastIndex")}}, a global regex will continue to attempt at the next character, while a sticky regex immediately returns `null` and resets `lastIndex` to 0. When the match succeeds, `lastIndex` is advanced to the end of the match, just like global regexps do. When `lastIndex` is out of bounds of the currently matched string, it's reset to 0, just like global regexps do.
+
+For the [`exec()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/exec) method, a regex that's both sticky and [global](/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/global) behaves the same as a sticky and non-global regex. However, due to many other methods special-casing the behavior of global regexps, the global flag is, in general, orthogonal to the sticky flag. For more information about how each individual regex-related method (such as [`String.prototype.match()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/match) and [`String.prototype.replace()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace)) interact with the sticky and global flags, see their respective pages.
+
+You cannot change this property directly.
 
 ## Examples
 

files/en-us/web/javascript/reference/global_objects/regexp/unicode/index.md

@@ -1,5 +1,5 @@
 ---
-title: RegExp.prototype.unicode
+title: get RegExp.prototype.unicode
 slug: Web/JavaScript/Reference/Global_Objects/RegExp/unicode
 tags:
   - ECMAScript 2015
@@ -13,22 +13,26 @@ browser-compat: javascript.builtins.RegExp.unicode
 ---
 {{JSRef}}
 
-The **`unicode`** property indicates whether or not the `u` flag is used with a regular expression. `unicode` is a read-only property of an individual regular expression instance.
+The **`unicode`** accessor property indicates whether or not the `u` flag is used with the regular expression.
 
-{{EmbedInteractiveExample("pages/js/regexp-prototype-unicode.html", "taller")}}{{js_property_attributes(0, 0, 1)}}
+{{EmbedInteractiveExample("pages/js/regexp-prototype-unicode.html", "taller")}}
 
 ## Description
 
-The value of `unicode` is a {{jsxref("Boolean")}} and `true` if the `u` flag was used; otherwise `false`. The `u` flag enables various Unicode-related features. With the "u" flag, any Unicode code point escapes will be interpreted as such, for example.
+`RegExp.prototype.unicode` is a getter-only property that returns `true` if the `u` flag was used; otherwise, `false`. The `u` flag enables various Unicode-related features. With the "u" flag:
 
-You cannot change this property directly. It is read-only.
+- Any [Unicode codepoint escapes](/en-US/docs/Web/JavaScript/Guide/Regular_Expressions/Unicode_Property_Escapes) (`\u{xxxx}`, `\p{UnicodePropertyValue}`) will be interpreted as such instead of literal characters.
+- Surrogate pairs will be interpreted as whole characters instead of two separate characters. For example, `/[😄]/u` would only match `"😄"` but not `"\ud83d"`.
+- When [`lastIndex`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/lastIndex) is automatically advanced (such as when calling [`exec()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/exec)), unicode regexps advance by Unicode codepoints instead of UTF-16 code units.
+
+You cannot change this property directly.
 
 ## Examples
 
 ### Using the unicode property
 
 ```js
-const regex = new RegExp('\u{61}', 'u');
+const regex = /\u{61}/u;
 
 console.log(regex.unicode); // true
 ```