TypeScript-Lernhinweise: Typeingrenzung

let x = [0, 1, null] // Zahl

let x = Math.random() < 0,5 ? 100 : "HalloWort" // Zahl|Zeichenfolge

let x: Tier[] = [neues Nashorn(), neuer Elefant(), neue Schlange()]; // Nashorn | Elefant | Schlange

// Union-Typ Typ Typen = Zahl | Zeichenfolge

Funktion typeFn(Typ: Typen, Eingabe: Zeichenfolge): Zeichenfolge {
  // Wenn Sie dies schreiben, müssen Sie den Typ des Typs bestimmen}

let x:Zahl|Zeichenfolge = 1
x="gebunden"

Funktion typeFn(Typ: Zahl | Zeichenfolge, Eingabe: Zeichenfolge) {
  // Fehleroperator + kann nicht auf String angewendet werden 
  gibt neues Array zurück (Typ + 1).join("") + Eingabe
}

Funktion typeFn(Typ: Zahl | Zeichenfolge, Eingabe: Zeichenfolge) {
  // Typschutz wenn (Typ von Typ === 'Zahl') {
    gibt neues Array zurück (Typ + 1).join(" ") + Eingabe
  }
  Rückgabetyp + Eingabe
}

"Schnur"
"Nummer"
"bigint" // ES10 fügt "boolean" hinzu
"Symbol" // ES6 fügt "undefined" hinzu
"Objekt"
"Funktion"

Funktion strOrName(str: string | string[] | null) {
  wenn (Typ von str === 'Objekt') {
    für (const s von str) {
      // Fehler melden, da str null sein könnte
      Konsole.log(s)
    }
  } sonst wenn (Typ von str === 'Zeichenfolge') {
    console.log(str)
  } anders {
    //......
  }
}

0
NAN
""
0n // Bigint-Version von 0 null
undefiniert

// Verwende den wahren Wert um zu entscheiden, ob (str && typeof strs === 'object') {
  für (const s von strs) {
    Konsole.log(s)
  }
}

Funktion valOrName(Werte: Zahl[] | undefiniert, Filter: Zahl): Zahl[] | undefiniert {
  wenn (!Werte) {
    Rückgabewerte
  } anders {
    Rückgabewerte.Filter(x => x > Filter)
  }
}

Funktion strOrNum(x: Zeichenfolge | Zahl, y: Zeichenfolge | Boolescher Wert) {
  wenn (x === y) {
    // Zeichenfolge
  } anders {
    // Zeichenfolge|Zahl
  }
}

Funktion strOrName(str: string | string[] | null) {
  wenn (str !== null) {
    wenn (Typ von str === 'Objekt') {
      für (const s von str) {
        konsole.log(s) // []
      }
    } sonst wenn (Typ von str === 'Zeichenfolge') {
      console.log(str) // Zeichenfolge
    } anders {
      // .....
    }
  }
}

Schnittstellentypen {
  Wert: Zahl | null | undefiniert
}

Funktion valOrType(Typ: Typen, val: Zahl) {
  // null und undefined sind beide falsch und können nur Zahlen sein
  wenn (Typ.Wert != null) {
    Typ.Wert *= Wert
  }
}

Schnittstelle A { a: Zahl };
Schnittstelle B { b: Zeichenfolge };

Funktion foo(x: A | B) {
    wenn ("a" in x) {
        Rückgabe xa;
    }
    Rückgabe xb;
}

Funktion dateInval(x: Datum | Zeichenfolge) {
  wenn (x Instanz von Datum) {
    // Datum
  } anders {
    // Zeichenfolge
  }
}

Funktion Beispiel() {
  let x: Zeichenfolge | Zahl | Boolescher Wert
  x = Math.random() < 0,5
  wenn (Math.random() < 0,5) {
    x = 'hallo' // Zeichenfolge
  } anders {
    x = 100 // Zahl
  }
  return x; // Zeichenfolge|Zahl
}

Schnittstelle Form {
  Art: "Kreis" | "Quadrat",
  Redius?: Zahl
  Seitenlänge?: Zahl
}

// Fehlerfunktion getArea(shape: Shape) {
	returniere Math.PI * shape.redius ** 2
}
// Eingrenzung oder Fehlerfunktion getArea(shape: Shape) {
  wenn (Form.Art === 'Kreis') {
    returniere Math.PI * shape.redius ** 2
  }
}
//Verwenden einer Assertion ungleich NULL-Funktion getArea(shape: Shape) {
  wenn (Form.Art === 'Kreis') {
    gib Math.PI * Form.redius zurück! ** 2
  }
}

Schnittstelle Kreis {
  Art: "Kreis";
  Redius: Zahl;
}

Schnittstelle Quadrat {
  Art: "Quadrat";
  Redius: Zahl;
}

Typ Form = Kreis | Quadrat

Funktion getArea(Form: Form) {
  if (shape.kind === 'cirle') { // schmal return Math.PI * shape.redius ** 2
  }
}

// oder Funktion getArea(shape: Shape) {
  Schalter (Form.Art) {
    Fall "Kreis":
      returniere Math.PI * shape.redius ** 2
    Fall "Quadrat":
      returniere Form.Seitenlänge ** 2
    Standard:
      const _example: nie = Form
      returniere _Beispiel
  }
}