docs: replace var with const in rule examples

Tanujkanti4441 · Tanujkanti4441 · commit 6242c1f7692f · 2025-02-28T22:35:57.000+05:30
diff --git a/docs/src/rules/no-implicit-coercion.md b/docs/src/rules/no-implicit-coercion.md
@@ -11,26 +11,26 @@ Some of them might be hard to read and understand.
 Such as:
 
 ```js
-var b = !!foo;
-var b = ~foo.indexOf(".");
-var n = +foo;
-var n = -(-foo);
-var n = foo - 0;
-var n = 1 * foo;
-var s = "" + foo;
+const b = !!foo;
+const b1 = ~foo.indexOf(".");
+const n = +foo;
+const n1 = -(-foo);
+const n2 = foo - 0;
+const n3 = 1 * foo;
+const s = "" + foo;
 foo += ``;
 ```
 
 Those can be replaced with the following code:
 
 ```js
-var b = Boolean(foo);
-var b = foo.indexOf(".") !== -1;
-var n = Number(foo);
-var n = Number(foo);
-var n = Number(foo);
-var n = Number(foo);
-var s = String(foo);
+const b = Boolean(foo);
+const b1 = foo.indexOf(".") !== -1;
+const n = Number(foo);
+const n1 = Number(foo);
+const n2 = Number(foo);
+const n3 = Number(foo);
+const s = String(foo);
 foo = String(foo);
 ```
 
@@ -59,8 +59,8 @@ Examples of **incorrect** code for the default `{ "boolean": true }` option:
 ```js
 /*eslint no-implicit-coercion: "error"*/
 
-var b = !!foo;
-var b = ~foo.indexOf(".");
+const b = !!foo;
+const b1 = ~foo.indexOf(".");
 // bitwise not is incorrect only with `indexOf`/`lastIndexOf` method calling.
 ```
 
@@ -73,10 +73,10 @@ Examples of **correct** code for the default `{ "boolean": true }` option:
 ```js
 /*eslint no-implicit-coercion: "error"*/
 
-var b = Boolean(foo);
-var b = foo.indexOf(".") !== -1;
+const b = Boolean(foo);
+const b1 = foo.indexOf(".") !== -1;
 
-var n = ~foo; // This is a just bitwise not.
+const n = ~foo; // This is a just bitwise not.
 ```
 
 :::
@@ -90,10 +90,10 @@ Examples of **incorrect** code for the default `{ "number": true }` option:
 ```js
 /*eslint no-implicit-coercion: "error"*/
 
-var n = +foo;
-var n = -(-foo);
-var n = foo - 0;
-var n = 1 * foo;
+const n = +foo;
+const n1 = -(-foo);
+const n2 = foo - 0;
+const n3 = 1 * foo;
 ```
 
 :::
@@ -105,11 +105,11 @@ Examples of **correct** code for the default `{ "number": true }` option:
 ```js
 /*eslint no-implicit-coercion: "error"*/
 
-var n = Number(foo);
-var n = parseFloat(foo);
-var n = parseInt(foo, 10);
+const n = Number(foo);
+const n1 = parseFloat(foo);
+const n2 = parseInt(foo, 10);
 
-var n = foo * 1/4; // `* 1` is allowed when followed by the `/` operator
+const n3 = foo * 1/4; // `* 1` is allowed when followed by the `/` operator
 ```
 
 :::
@@ -123,8 +123,8 @@ Examples of **incorrect** code for the default `{ "string": true }` option:
 ```js
 /*eslint no-implicit-coercion: "error"*/
 
-var s = "" + foo;
-var s = `` + foo;
+const s = "" + foo;
+const s1 = `` + foo;
 foo += "";
 foo += ``;
 ```
@@ -138,7 +138,7 @@ Examples of **correct** code for the default `{ "string": true }` option:
 ```js
 /*eslint no-implicit-coercion: "error"*/
 
-var s = String(foo);
+const s = String(foo);
 foo = String(foo);
 ```
 
@@ -155,7 +155,7 @@ Examples of **incorrect** code for the `{ "disallowTemplateShorthand": true }` o
 ```js
 /*eslint no-implicit-coercion: ["error", { "disallowTemplateShorthand": true }]*/
 
-var s = `${foo}`;
+const s = `${foo}`;
 ```
 
 :::
@@ -167,15 +167,15 @@ Examples of **correct** code for the `{ "disallowTemplateShorthand": true }` opt
 ```js
 /*eslint no-implicit-coercion: ["error", { "disallowTemplateShorthand": true }]*/
 
-var s = String(foo);
+const s = String(foo);
 
-var s = `a${foo}`;
+const s1 = `a${foo}`;
 
-var s = `${foo}b`;
+const s2 = `${foo}b`;
 
-var s = `${foo}${bar}`;
+const s3 = `${foo}${bar}`;
 
-var s = tag`${foo}`;
+const s4 = tag`${foo}`;
 ```
 
 :::
@@ -187,7 +187,7 @@ Examples of **correct** code for the default `{ "disallowTemplateShorthand": fal
 ```js
 /*eslint no-implicit-coercion: ["error", { "disallowTemplateShorthand": false }]*/
 
-var s = `${foo}`;
+const s = `${foo}`;
 ```
 
 :::
@@ -203,8 +203,8 @@ Examples of **correct** code for the sample `{ "allow": ["!!", "~"] }` option:
 ```js
 /*eslint no-implicit-coercion: [2, { "allow": ["!!", "~"] } ]*/
 
-var b = !!foo;
-var b = ~foo.indexOf(".");
+const b = !!foo;
+const b1 = ~foo.indexOf(".");
 ```
 
 :::
diff --git a/docs/src/rules/no-inline-comments.md b/docs/src/rules/no-inline-comments.md
@@ -18,16 +18,16 @@ Examples of **incorrect** code for this rule:
 ```js
 /*eslint no-inline-comments: "error"*/
 
-var a = 1; // declaring a to 1
+const a = 1; // declaring a to 1
 
 function getRandomNumber(){
     return 4; // chosen by fair dice roll.
               // guaranteed to be random.
 }
 
-/* A block comment before code */ var b = 2;
+/* A block comment before code */ const b = 2;
 
-var c = 3; /* A block comment after code */
+const c = 3; /* A block comment after code */
 ```
 
 :::
@@ -40,9 +40,9 @@ Examples of **correct** code for this rule:
 /*eslint no-inline-comments: "error"*/
 
 // This is a comment above a line of code
-var foo = 5;
+const foo = 5;
 
-var bar = 5;
+const bar = 5;
 //This is a comment below a line of code
 ```
 
@@ -59,9 +59,9 @@ Examples of **incorrect** code for this rule:
 ```jsx
 /*eslint no-inline-comments: "error"*/
 
-var foo = <div>{ /* On the same line with other code */ }<h1>Some heading</h1></div>;
+const foo = <div>{ /* On the same line with other code */ }<h1>Some heading</h1></div>;
 
-var bar = (
+const bar = (
     <div>
     {   // These braces are not just for the comment, so it can't be on the same line
         baz
@@ -79,14 +79,14 @@ Examples of **correct** code for this rule:
 ```jsx
 /*eslint no-inline-comments: "error"*/
 
-var foo = (
+const foo = (
     <div>
       {/* These braces are just for this comment and there is nothing else on this line */}
       <h1>Some heading</h1>
     </div>
 )
 
-var bar = (
+const bar = (
     <div>
     {
         // There is nothing else on this line
@@ -95,7 +95,7 @@ var bar = (
     </div>
 );
 
-var quux = (
+const quux = (
     <div>
       {/*
         Multiline
@@ -133,7 +133,7 @@ Examples of **incorrect** code for the `ignorePattern` option:
 ```js
 /*eslint no-inline-comments: ["error", { "ignorePattern": "something" }] */
 
-var foo = 4; // other thing
+const foo = 4; // other thing
 ```
 
 :::
diff --git a/docs/src/rules/no-invalid-this.md b/docs/src/rules/no-invalid-this.md
@@ -66,7 +66,7 @@ function foo() {
     baz(() => this);
 }
 
-var foo = function() {
+const bar = function() {
     this.a = 0;
     baz(() => this);
 };
@@ -76,7 +76,7 @@ foo(function() {
     baz(() => this);
 });
 
-var obj = {
+const obj = {
     aaa: function() {
         return function foo() {
             // There is in a method `aaa`, but `foo` is not a method.
@@ -120,28 +120,28 @@ class Bar {
     }
 }
 
-var obj = {
+const obj = {
     foo: function foo() {
         // OK, this is in a method (this function is on object literal).
         this.a = 0;
     }
 };
 
-var obj = {
+const obj1 = {
     foo() {
         // OK, this is in a method (this function is on object literal).
         this.a = 0;
     }
 };
 
-var obj = {
+const obj2 = {
     get foo() {
         // OK, this is in a method (this function is on object literal).
         return this.a;
     }
 };
 
-var obj = Object.create(null, {
+const obj3 = Object.create(null, {
     foo: {value: function foo() {
         // OK, this is in a method (this function is on object literal).
         this.a = 0;
@@ -207,7 +207,7 @@ class Baz {
     }
 }
 
-var foo = (function foo() {
+const bar = (function foo() {
     // OK, the `bind` method of this function is called directly.
     this.a = 0;
 }).bind(obj);
@@ -252,11 +252,11 @@ function Foo() {
     this.a = 0;
 }
 
-var bar = function Foo() {
+const bar = function Foo() {
     this.a = 0;
 }
 
-var Bar = function() {
+const Bar = function() {
     this.a = 0;
 };
 
diff --git a/docs/src/rules/no-multi-str.md b/docs/src/rules/no-multi-str.md
@@ -7,7 +7,7 @@ rule_type: suggestion
 It's possible to create multiline strings in JavaScript by using a slash before a newline, such as:
 
 ```js
-var x = "Line 1 \
+const x = "Line 1 \
          Line 2";
 ```
 
@@ -24,7 +24,7 @@ Examples of **incorrect** code for this rule:
 ```js
 /*eslint no-multi-str: "error"*/
 
-var x = "some very \
+const x = "some very \
 long text";
 ```
 
@@ -37,9 +37,9 @@ Examples of **correct** code for this rule:
 ```js
 /*eslint no-multi-str: "error"*/
 
-var x = "some very long text";
+const x = "some very long text";
 
-var x = "some very " +
+const y = "some very " +
         "long text";
 ```
 
diff --git a/docs/src/rules/no-new-func.md b/docs/src/rules/no-new-func.md
@@ -7,11 +7,11 @@ rule_type: suggestion
 It's possible to create functions in JavaScript from strings at runtime using the `Function` constructor, such as:
 
 ```js
-var x = new Function("a", "b", "return a + b");
-var x = Function("a", "b", "return a + b");
-var x = Function.call(null, "a", "b", "return a + b");
-var x = Function.apply(null, ["a", "b", "return a + b"]);
-var x = Function.bind(null, "a", "b", "return a + b")();
+const a = new Function("a", "b", "return a + b");
+const b = Function("a", "b", "return a + b");
+const c = Function.call(null, "a", "b", "return a + b");
+const d = Function.apply(null, ["a", "b", "return a + b"]);
+const x = Function.bind(null, "a", "b", "return a + b")();
 ```
 
 This is considered by many to be a bad practice due to the difficulty in debugging and reading these types of functions. In addition, Content-Security-Policy (CSP) directives may disallow the use of `eval()` and similar methods for creating code from strings.
@@ -27,12 +27,12 @@ Examples of **incorrect** code for this rule:
 ```js
 /*eslint no-new-func: "error"*/
 
-var x = new Function("a", "b", "return a + b");
-var x = Function("a", "b", "return a + b");
-var x = Function.call(null, "a", "b", "return a + b");
-var x = Function.apply(null, ["a", "b", "return a + b"]);
-var x = Function.bind(null, "a", "b", "return a + b")();
-var f = Function.bind(null, "a", "b", "return a + b"); // assuming that the result of Function.bind(...) will be eventually called.
+const a = new Function("a", "b", "return a + b");
+const b = Function("a", "b", "return a + b");
+const c = Function.call(null, "a", "b", "return a + b");
+const d = Function.apply(null, ["a", "b", "return a + b"]);
+const x = Function.bind(null, "a", "b", "return a + b")();
+const y = Function.bind(null, "a", "b", "return a + b"); // assuming that the result of Function.bind(...) will be eventually called.
 ```
 
 :::
@@ -44,7 +44,7 @@ Examples of **correct** code for this rule:
 ```js
 /*eslint no-new-func: "error"*/
 
-var x = function (a, b) {
+const x = function (a, b) {
     return a + b;
 };
 ```
