Appendix - Special characters in TS

1. _ Number separator

   The delimiter _ does not change the value of a numeric literal, but the logical grouping makes it easier to read the numbers at a glance.

   const inhabitantsOfMunich = 1_464_301;
   const bytes = 0b1111_10101011_11110000_00001101;

   Usage restrictions:

   1. You can only add the _ separator between two numbers. The following example is illegal:

      3_.141592 // Error
      1_e10 // Error
      _126301 //Error
      126301_ // Error
      0_b111111000 // Error
      123__456 // Error, multiple _ delimiters cannot be used continuously.

      
      

   2. The function that parses numbers does not support separators.

      Number('123_456') //NaN
      parseInt('123_456') //123
      parseFloat('123_456') //123

   
   

2. #XXX Private Field

   ECMAScript private fields have been supported since TypeScript 3.8. Unlike regular properties (even properties declared with the private modifier), the rules are:

   1. Private fields start with the # character, sometimes we call them private names;
   2. Each private field name is uniquely limited to the class it contains;
   3. TypeScript accessibility modifiers (such as public or private) cannot be used on private fields;
   4. Private fields cannot be accessed outside the containing class, or even detected.

   class Person {
     #name: string; //Private field
     constructor(name: string) {
       this.#name = name;
     }
     greet() {
       console.log(`Hello, my name is ${this.#name}!`);
     }
   }
      
   let semlinker = new Person("Semlinker");
   semlinker.#name; // Property '#name' is not accessible outside class 'Person'.

   The difference between private fields and private:

   Private properties and methods can be accessed in some special ways. like:

   class Person {
     constructor(private name: string){}
   }
      
   let person = new Person("Semlinker");
   console.log(person.name); //Property 'name' is private and only accessible within class 'Person'.
   console.log((person as any).name); //Can be accessed normally!

   This is because after private is compiled into ES5 code, it becomes:

   var Person = /** @class */ (function () {
       function Person(name) {
         this.name = name;
       }
       return Person;
   }());
      
   var person = new Person("Semlinker");
   console.log(person.name);

   The private fields are different after compilation.

   
   

3. ! Non-null assertion (section 11)

4. ?. Optional Chaining (Section 11)

5. ?? Null value coalescing operator (Section 11)

6. ?: optional attribute (section 9)

7. Tool Type (Section 13)

8. & intersection (Section 10)

9. | union (Section 4)

10. <type> Syntax: assertion (section 11) or generics (section 12)