Utilisation d'alias de type (type)
Pour résoudre le problème selon lequel la définition du type d'union est trop longue
Utiliser des alias de type
type myname = number | string
function hander1 ( name: myname) {
console . log ( name)
if ( typeof name === 'string' ) {
console . log ( name. length)
}
}
function hander2 ( x: number , y: number , z? : number ) {
}
type myx = {
x: number , y: number , z? : number }
function hander3 ( mytype: myx) {
}
Utilisation des déclarations d'interface
Le mot-clé est déclaré à l'aide de l'interface
Par rapport aux alias de type, less =
interface myX2 {
x: number
y: number
z? : number
}
function hander4 ( mytype: myX2) {
}
La différence entre les deux:
Les alias de type sont très similaires aux déclarations d'interface et peuvent être utilisés arbitrairement lors de la définition d'objets.
Différence principale:
Le type de type est utilisé dans une gamme plus large
type définit un alias, et deux alias avec le même nom ne sont pas autorisés
type myname = number | string
1. Les types d'interface ne peuvent être utilisés que pour déclarer des objets
2. Lorsqu'un type d'interface déclare un objet, il peut être déclaré plusieurs fois
3. Les types d'interface prennent en charge l'héritage
4. Le type d'interface prend en charge l'implémentation par la classe
interface myX2 {
x: number
y: number
}
interface myX2 {
z? : number
}
function hander4 ( mytype: myX2) {
}
interface myX2 {
x: number
y: number
}
interface myX3 extends myX2 {
z? : number
}
function hander5 ( mytype: myX3) {
console . log ( mytype. x, mytype. y, mytype. z)
}
hander5 ( {
x: 1 , y: 2 , z: 3 } )
type d'union et type d'intersection
type de syndicat
ts nous permet d'utiliser une variété d'opérateurs pour créer de nouveaux types à partir de types existants
type d'union Type composé de deux types ou plus
La représentation peut être n'importe lequel de ces types de valeurs
Chaque type d'un type d'union est appelé membre de l'union.
function hander ( name: number | string ) {
console . log ( name)
}
hander ( 1 )
hander ( "123" )
let nainfo: number | string = "abc"
nainfo = 1
nainfo = "123"
function hander1 ( name: number | string ) {
console . log ( name)
if ( typeof name === 'string' ) {
console . log ( name. length)
}
}
hander1 ( 1 )
hander1 ( "123" )
Avis:
Après avoir pris la valeur du type d’union, puisqu’il peut être de n’importe quel type, comment l’utiliser ?
Semblable à l'obtention d'un nombre, certaines méthodes de chaîne ne peuvent pas être utilisées
résoudre:
Vous devez utiliser la collection réduite, c'est-à-dire la réduction de type, et déduire un type plus spécifique basé sur le code réduit
type croisé
Les types qui se croisent indiquent que plusieurs types de conditions doivent être remplies
Les types d'intersection utilisent l'esperluette
type myY = number & string
type myY2 = number & string
interface myX2 {
x: number
y: number
}
interface myX3 {
z? : number
p : ( ) => void
}
const info: myX2 & myX3 = {
x: 1 ,
y: 2 ,
p : ( ) => {
console . log ( "方法" )
}
}
assertion de type
Parfois, ts ne peut pas obtenir d'informations spécifiques sur le type de quota, et pour le moment, une assertion de type est requise
TS autorise uniquement la conversion des assertions de type en versions plus ou moins spécifiques du type, cette règle empêche les conversions impossibles.
Obtenir l'élément DOM
const imgE1 = document. querySelector ( "img" )
if ( imgE1 != null ) {
imgE1. src = ""
}
const imgE2 = document. querySelector ( ".img" ) as HTMLImageElement
imgE2. src = ""
Pareil, comme ça. Les assertions de type deviennent moins spécifiques comme
const num = 12
const num2 = num as any
Vous pouvez également continuer et affirmer des types moins spécifiques pour être plus précis
Cependant, de telles affirmations ne sont pas prises en charge, ce qui présente des risques potentiels pour la sécurité.
const num = 12
const num2 = num as any
const num3 = num2 as string
assertion de type non nulle
Lorsque la valeur transmise peut être indéfinie, la méthode ne peut pas être exécutée pour le moment
En utilisant le symbole !, vous devez vous assurer qu'un certain identifiant a une valeur, et vous pouvez ignorer sa détection par TS au stade de la compilation.
interface hander {
name: string ,
age: number ,
size? : number
}
const info: hander= {
name: "乞力马扎罗" ,
age: 18
}
console . log ( info?. size)
if ( info. size) {
info. size= 23
}
info! . size= 23
console . log ( info. size)
Utilisation de types littéraux
Traitez la valeur attribuée comme un type et utilisez uniquement des littéraux lorsque vous l'utilisez
Cela n'a pas beaucoup de sens par défaut, mais il est possible d'unir plusieurs types ensemble, vous ne pouvez être que l'un des nôtres.
type numtype = "left" | "top" | "up"
const num3: numtype = "left"
type requestype = "get" | "post"
function reqest ( url: string , method: requestype) {
}
reqest ( 'http//xxx.com' , 'get' )
type requestype = "get" | "post"
function reqest ( url: string , method: requestype) {
}
const hander= {
url: 'xxx' ,
method: 'post'
}
reqest ( 'http//xxx.com' , hander. method as "post" )
const hander1 : {
url: string , method: 'post' } = {
url: 'xxx' ,
method: 'post'
} as const
reqest ( 'http//xxx.com' , hander1. method)
const hander2= {
url: 'xxx' ,
method: 'post'
} as const
reqest ( 'http//xxx.com' , hander2. method)
type rétrécissement (type rétrécissement)
Vous pouvez modifier le chemin d'exécution de ts en utilisant une instruction de jugement similaire à la suivante
if ( info. size) {
info. size= 23
}
Des déclarations comme celle-ci sont également appelées gardes de type
Dans un chemin d'exécution donné, les types plus petits que ceux déclarés peuvent être restreints, un processus appelé rétrécissement.
Types courants de protection
typeof, vérifiez le type renvoyé
type requestype = "get" | "post"
function reqest ( url: string , method: requestype) {
if ( typeof url === 'string' ) {
console . log ( url)
}
}
Rétrécissement égal (=== et !== et ==, etc.), jugement littéral
type requestype = "get" | "post"
function reqest ( url: string , method: requestype) {
if ( method=== "get" ) {
console . log ( method)
}
}
instanceof, indiquant s'il s'agit d'une instance de ceci
function reqest ( data: string | Date) {
if ( data instanceof Date ) {
console . log ( data. getTime ( ) )
}
}
in , utilisé pour déterminer si un objet possède une propriété avec un nom, l'opérateur in
etc…
Types de fonctions TypeScript
expression de type de fonction
Les expressions de types de fonctions peuvent être écrites pour représenter les types de fonctions
En ts, le nom du paramètre formel dans le type de fonction ne peut pas être omis
const fun : ( num2: number ) => number = ( arg: number ) : number => {
return 123
}
type funtype = ( num2: number ) => number
const fun2: funtype = ( arg: number ) => {
return 123
}
function cals ( func) {
const num1 = 12
const num2 = 13
const res = func ( num1, num2)
}
function func1 ( num1, num2) {
return num1 + num2
}
cals ( func1)
type calstype = ( num1: number , num2: number ) => number
function cals1 ( func: calstype) {
const num1 = 12
const num2 = 13
const res = func ( num1, num2)
}
function func2 ( num1: number , num2: number ) {
return num1 * num2
}
cals1 ( func2)
Détection de règles internes
interface gule {
name: string
age: number
}
const p = {
name: "山头" ,
age: 12 ,
size: '大'
}
const info: gule = p
signature d'appel de fonction
En js, en plus d'être appelées, les fonctions peuvent également avoir des valeurs d'attribut
Les expressions de type ne prennent pas en charge la déclaration de propriétés
Lorsque vous voulez une fonction avec des propriétés, écrivez une signature d'appel dans un type d'objet
type obj2 = ( num1: number ) => number
interface obj {
name: string
age: number
( num1: number ) : number
}
const func: obj = ( num1: number ) : number => {
return 123
}
func ( 123 )
Comment les choisir ?
Si vous décrivez simplement le type de fonction lui-même (le type de fonction peut être appelé), utilisez une expression de fonction
Si vous décrivez la fonction comme un objet pouvant être appelé et possédant également d'autres propriétés, utilisez la signature d'appel de fonction
type de paramètre facultatif
Les paramètres facultatifs doivent être placés après les paramètres requis
function fun ( x: number , y? : number ) {
console . log ( x, y)
if ( y!= undefined ) {
console . log ( y)
}
}
fun ( 1 )
la valeur par défaut du paramètre
function fun ( x: number , y= 100 ) {
console . log ( x, y)
if ( y!= undefined ) {
console . log ( y)
}
}
fun ( 1 )
paramètres restants
La syntaxe des paramètres rest nous permet de représenter un nombre indéfini de paramètres sous forme de tableau.
En utilisant les paramètres restants, nous pouvons définir une fonction qui calcule une somme dont les paramètres formels ne sont pas fixes.
function sum ( first, ... args) {
console . log ( first) ;
console . log ( args) ;
}
sum ( 10 , 20 , 30 ) ;
function fun ( ... arrs: ( string | number ) [ ] ) {
}
fun ( 1 , 2 , 3 , '4' )
surcharge de fonctions
En ts, vous pouvez écrire différentes fonctions surchargées pour indiquer que la fonction peut être appelée de différentes manières
Généralement, deux ou plusieurs signatures surchargées sont écrites. Ensuite, écrivez une fonction générale et implémentez
function add2 ( n1: number , n2: number ) : number
function add2 ( n1: string , n2: string ) : string
function add2 ( n1: any , n2: any ) {
return n1 + n2
}
console . log ( add2 ( 1 , 2 ) )
console . log ( add2 ( "1" , "2" ) )
Surcharge de fonctions - type d'union (usage préféré)
Utilisez les types d’union là où vous le pouvez
function add2 ( arg: string | any [ ] ) {
return arg. length
}
console . log ( add2 ( "123" ) )