javascript - Typescript skapa egna typer med funktioner

Jag försöker skapa mina egna typer på vilka jag kan anropa funktioner med punktnotation.

till exempel:

let myOwnType: myByteType = 123211345;
myOwnType.toHumanReadable(2);

Jag vill arkivera samma beteende som nummer, array etc. Jag vill inte skapa min typ med hjälp av anropssignaturen eller konstruktorssignaturen

Så efter att ha tittat i TypeScript-biblioteket såg jag detta nummergränssnitt:

interface Number {
    /**
     * Returns a string representation of an object.
     * @param radix Specifies a radix for converting numeric values to strings. This value is only used for numbers.
     */
    toString(radix?: number): string;

    /**
     * Returns a string representing a number in fixed-point notation.
     * @param fractionDigits Number of digits after the decimal point. Must be in the range 0 - 20, inclusive.
     */
    toFixed(fractionDigits?: number): string;

    /**
     * Returns a string containing a number represented in exponential notation.
     * @param fractionDigits Number of digits after the decimal point. Must be in the range 0 - 20, inclusive.
     */
    toExponential(fractionDigits?: number): string;

    /**
     * Returns a string containing a number represented either in exponential or fixed-point notation with a specified number of digits.
     * @param precision Number of significant digits. Must be in the range 1 - 21, inclusive.
     */
    toPrecision(precision?: number): string;

    /** Returns the primitive value of the specified object. */
    valueOf(): number;
}

Problemet är att jag inte kunde hitta var och hur funktionskropparna definieras. Jag tänkte att det måste finnas en klass som implementerar gränssnittet eller något liknande.

Jag kom upp med att prova något liknande detta:

interface Bytes {
  toHumanReadable(decimals: number): bytesToHumanReadable;
  bytesAs(unit: string): string;
}


function bytesToHumanReadable (decimals: number) {
  // convert bytes to GB, TB etc..
}

Hur skulle jag kunna skapa mina egna typer och använda dem precis som en vanlig typ? Jag vet att gränssnittet inte heller fungerar men det var min första gissning.

Svar #1

Problemet är att jag inte kunde hitta var och hur funktionskropparna definieras.

De definieras av JavaScript-motorn, som en del av standardbiblioteket. Du hittar dem på Number.prototype. Så här fungerar det: När du försöker få tillgång till en egenskap på en primitiv (till exempel someNumber.toString()), letar JavaScript-motorn efter egenskapen på prototypen för den primitivas objekttyp (number => Number, string => String, osv.). Om du gör ett anrop, kör den metoden och skickar in antingen den primitiva (i strikt läge) eller ett objektpaket för den primitiva (i löst läge).

Du kan inte definiera din egen primitiva typ, det kan bara göras på JavaScript-specifikationsnivå.

Du skulle kunna skapa en Byte-klass och ha instanser av den, men de skulle vara objekt, inte primitiva typer.

class Byte {
    constructor(public value: number) {
    }
    yourMethodHere() {
        // ...
    }
}

Du kan också lägga till metoder till Number.prototype, även om det är bäst att inte göra det i någon biblioteks kod som du kan dela med andra. (Inom din egen app eller sida är det mestadels okej, se bara till att använda namn som är osannolika att användas av framtida funktioner i standardbiblioteket.)

Till exempel lägger detta till en toHex-metod för siffror:

// Adding it to the type
interface Number {
    toHex(): string;
}
// Adding the implementation
Object.defineProperty(Number.prototype, "toHex", {
    value() {
        return this.toString(16);
    },
    enumerable: false, // This is the default, but just for emphasis...
    writable: true,
    configurable: true
});

Live-exempel på lekplatsen

Svar #2

T.J. Crowder, bra svar, jag utvecklade lite på det

 interface myByteType extends Number {
      toHumanReadable?(): string;
     }

    // Adding the implementation
    Object.defineProperty(Number.prototype, "toHumanReadable", {
      value() {
          return this.toString(16);
      },
      enumerable: false, // This is the default, but just for emphasis...
      writable: true,
      configurable: true
    });

    let a: myByteType = 2124;
    a.toHumanReadable();

med frågeteckensyntaxen har du en lösning för att använda din egen typ med din definierade funktion !