Uso de alias de tipo (tipo)
Para resolver el problema de que la definición del tipo de unión es demasiado larga
Usar alias de tipo
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) {
}
Uso de declaraciones de interfaz.
La palabra clave se declara mediante la interfaz.
En comparación con los alias de tipo, less =
interface myX2 {
x: number
y: number
z? : number
}
function hander4 ( mytype: myX2) {
}
La diferencia entre los dos:
Los alias de tipo son muy similares a las declaraciones de interfaz y se pueden usar arbitrariamente al definir objetos.
Diferencia principal:
El tipo de tipo se utiliza en una gama más amplia.
El tipo define un alias y no se permiten dos alias con el mismo nombre.
type myname = number | string
1. Los tipos de interfaz solo se pueden utilizar para declarar objetos.
2. Cuando un tipo de interfaz declara un objeto, se puede declarar varias veces.
3. Los tipos de interfaz admiten la herencia
4. El tipo de interfaz admite la implementación por parte de la clase.
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 } )
tipo de unión y tipo de intersección
tipo de unión
ts nos permite utilizar una variedad de operadores para construir nuevos tipos a partir de tipos existentes
tipo de unión Un tipo compuesto por dos o más tipos.
La representación puede ser cualquiera de estos tipos de valores.
Cada tipo en un tipo de unión se llama miembro de la unión.
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" )
Aviso:
Después de tomar el valor del tipo de unión, ya que puede ser de cualquier tipo, ¿cómo usarlo?
De manera similar a obtener un número, algunos métodos de cadena no se pueden usar
resolver:
Debe utilizar la colección reducida, es decir, la reducción de tipos, e inferir un tipo más específico en función del código reducido.
tipo cruz
Los tipos que se cruzan indican que se deben cumplir múltiples tipos de condiciones
Los tipos de intersección utilizan el signo comercial.
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 ( "方法" )
}
}
tipo aserción
A veces, ts no puede obtener información de tipo de cuota específica y, en este momento, se requiere una afirmación de tipo.
TS solo permite que las afirmaciones de tipo se conviertan a versiones más específicas o menos específicas del tipo; esta regla evita conversiones imposibles
Obtener elemento DOM
const imgE1 = document. querySelector ( "img" )
if ( imgE1 != null ) {
imgE1. src = ""
}
const imgE2 = document. querySelector ( ".img" ) as HTMLImageElement
imgE2. src = ""
Parecidos, así. Las afirmaciones de tipo se vuelven menos específicas como
const num = 12
const num2 = num as any
También puedes seguir adelante y afirmar tipos menos específicos para ser más específicos.
Sin embargo, esta afirmación de ida y vuelta no es compatible, lo que tiene riesgos potenciales para la seguridad.
const num = 12
const num2 = num as any
const num3 = num2 as string
aserción de tipo no nulo
Cuando el valor pasado puede no estar definido, el método no se puede ejecutar en este momento
¡Al usar el símbolo!, debe asegurarse de que un determinado identificador tenga un valor y puede omitir la detección del mismo por parte de TS en la etapa de compilación.
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)
Uso de tipos literales
Trate el valor asignado como un tipo y solo use literales cuando lo use
No tiene mucho sentido de forma predeterminada, pero es posible unir varios tipos, solo puedes ser uno de nosotros.
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)
tipo de estrechamiento (tipo de estrechamiento)
Puede cambiar la ruta de ejecución de ts utilizando una declaración de juicio similar a la siguiente
if ( info. size) {
info. size= 23
}
Declaraciones como esta también se llaman guardias de tipo.
En una ruta de ejecución determinada, los tipos que son más pequeños de lo que fueron declarados se pueden reducir, un proceso llamado reducción
Tipos comunes de protección
typeof, verifique el tipo devuelto
type requestype = "get" | "post"
function reqest ( url: string , method: requestype) {
if ( typeof url === 'string' ) {
console . log ( url)
}
}
Estrechamiento igual (=== y !== y ==, etc.), juicio literal
type requestype = "get" | "post"
function reqest ( url: string , method: requestype) {
if ( method=== "get" ) {
console . log ( method)
}
}
instancia de, indicando si es una instancia de este
function reqest ( data: string | Date) {
if ( data instanceof Date ) {
console . log ( data. getTime ( ) )
}
}
in, usado para determinar si un objeto tiene una propiedad con un nombre, el operador in
etc…
Tipos de funciones de TypeScript
expresión de tipo de función
Las expresiones de tipos de funciones se pueden escribir para representar tipos de funciones.
En ts, el nombre del parámetro formal en el tipo de función no se puede omitir
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)
Detección de reglas internas
interface gule {
name: string
age: number
}
const p = {
name: "山头" ,
age: 12 ,
size: '大'
}
const info: gule = p
firma de llamada de función
En js, además de ser llamadas, las funciones también pueden tener valores de atributos
Las expresiones de tipo no admiten la declaración de propiedades.
Cuando desee una función con propiedades, escriba una firma de llamada en un tipo de objeto
type obj2 = ( num1: number ) => number
interface obj {
name: string
age: number
( num1: number ) : number
}
const func: obj = ( num1: number ) : number => {
return 123
}
func ( 123 )
¿Cómo elegirlos?
Si simplemente describe el tipo de función en sí (se puede llamar al tipo de función), use una expresión de función
Si describe la función como un objeto que se puede llamar y también tiene otras propiedades, use la firma de llamada de función
tipo de parámetro opcional
Los parámetros opcionales deben colocarse después de los parámetros requeridos.
function fun ( x: number , y? : number ) {
console . log ( x, y)
if ( y!= undefined ) {
console . log ( y)
}
}
fun ( 1 )
el valor predeterminado del parámetro
function fun ( x: number , y= 100 ) {
console . log ( x, y)
if ( y!= undefined ) {
console . log ( y)
}
}
fun ( 1 )
parámetros restantes
La sintaxis de parámetros restantes nos permite representar un número indefinido de parámetros como una matriz.
Usando los parámetros restantes, podemos definir una función que calcule una suma cuyos parámetros formales no sean fijos.
function sum ( first, ... args) {
console . log ( first) ;
console . log ( args) ;
}
sum ( 10 , 20 , 30 ) ;
function fun ( ... arrs: ( string | number ) [ ] ) {
}
fun ( 1 , 2 , 3 , '4' )
sobrecarga de funciones
En ts, puede escribir diferentes funciones sobrecargadas para indicar que la función se puede llamar de diferentes maneras.
Generalmente se escriben dos o más firmas sobrecargadas. Luego escribe una función general e implementa
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" ) )
Sobrecarga de funciones: tipo de unión (uso preferido)
Utilice tipos de unión donde pueda
function add2 ( arg: string | any [ ] ) {
return arg. length
}
console . log ( add2 ( "123" ) )