Typescript

async-await.md

• Basicamente, ele vai executar a primeira função para apenas após executar a próxima

1 modo

const resolver = (msg, timeout) => new Promise((resolve) => {
    console.log(msg);
    setTimeout(resolve, timeout);
});
resolver('First', 500)
    .then(() => resolver('Second', 500))
    .then(() => resolver('Third', 1000))
    .then(() => resolver('Fourth', 500));

2 modo

const resolver = (msg, timeout) => new Promise((resolve) => {
    console.log(msg);
    setTimeout(resolve, timeout);
});
async function run() {
    await resolver('First', 1000);
    await resolver('Second', 500);
    await resolver('Third', 1000);
    await resolver('Fourth', 500);
}
run();

class.md

expor class User {
  readonly login: string;
  readonly password: string;;
  email: string;
}

Typescript.md

Introdução

Possui as características do javascript mas podendo tipar
Por enquanto, ele transpila para javascript ao buildar

Tipagens

Boolean

let checar: boolean = true;

Number

É float, hexadecimal, decimal, binario e octal

let decimal: number = 7;

String

let texto: string = "assim";
texto = 'ou assim, mesma coisa';
text = "Adicionando" + variavel;

Template string

let textinho: string = `posso imprimir com isso também ${variavel}`;

Array

let array: number[] = [3, 24, 56];
let array2: Array<number> = [3, 24, 56];

Array Genérico:

let usuarios: any[] = [1, 'escrevendo', true];

Tupla

let elementos: [string, number];
elementos = ["texto", 3];
elementos[2] = "texto2";

console.log(elementos[0], elementos[2]);

Enum

cria variáveis constantes que podem ser referenciadas

let enum constantes {
   pi = 3.14,
   e = 2.73
}
console.log(constantes.pi);  -> 3.14

Any

Qualquer valor

let notSure: any = 5;
notSure = "talvez uma string";
notSure = false;

Funções

function func1(): void {
   console.log(função1);
}
function func2(): int {
   return 2;
}

Object

declare function create(o: object | null): void;

create({prop: 0});  //ok
create(null);       //ok

create(42);         //erro
create("string");   //erro
create(false);      //erro
create(undefined);  //erro

Null

let variavel: null = null;

Undefined

let variavel: undefined = undefined;

Never

Nunca retornar nada/a como um tratamento de erros

let function func(): never {
    throw new Error(mensagem);
}
let fucntion fail() {
    return error("Algo falhou");
}
function infiniteLoop(): never {
    while(true) {
    }
}

Posso falar pro compilador que tenho certeza que aquilo está certo:

let someValue: any = "this is a string";
let strLength: number = (<string>someValue).length;
          //ou
strLength: number = (someValue as string).length;

Type:

É criado um tipo de variável, como um objeto

type C = {a: number, b: boolean};

Vários tipos:

let tipos: string | number | Boolean = 12;
tipos = "texto";
tipos = true;

Proteção da variável:

public         -> global
protected   -> dentro do package
private        -> dentro da classe
default     -> 

Escopo da variável:

let           -> escopo local
var          -> escopo global
declare   -> mesmo que let, mas quer dizer que a variável já foi criada em outro lugar

Exemplos:

let [first, ...rest] = [1, 2, 3, 4];
console.log(first);     //1
console.log(rest);      //[2,3,4]

let [first] = [1, 2, 3, 4];
console.log(first);     //1

let [, second, , fourth] = [1, 2, 3, 4];

function func1(...args){
   soma: number = 0;
   for(i in args){
      soma += args[i];
   }
}