DEV Community: Matheus de Gondra

[Boost]

Matheus de Gondra — Sun, 12 Apr 2026 12:10:08 +0000

Paul J. Lucas

Jan 18 '24

auto in C23

Comments

6 min read

Liguagem C moderna e suas versões

Matheus de Gondra — Fri, 20 Mar 2026 17:34:21 +0000

Se você estuda programação você deve ter visto ou ao menos ouvido falar sobre a linguagem C. Essa linguagem que muitos não entenderam nada ao ver a primeira vez e já sofreram muitos com o uso de ponteiro e gerenciamento de memória manual.

Ao procurar sobre tutoriais ou na faculdade, muitas vezes é ensinado a versão ANSI C ou ISO C. Essa é uma versão bem antiga do C, mas assim como toda linguagem de programação o C foi se modernizando ao decorrer do tempo.

Nesse artigo eu quero comentar um pouco dessas versões que acabei descobrindo sobre elas ao fazer um projeto em C para a faculdade.

C89/C90

A linguagem C foi criada por Dennis Ritchie em 1972. E em 1989 o instituto norte-americano de padrões (ANSI) definiu as especificações para a linguagem C. Posteriormente, essa especificação sofreu pequenas mudanças na organização do documento pela Organização Internacional de Padrões (ISO). Esses padrões da linguagem ficaram conhecidos, respectivamente, como C89 e C90.

Essa versão da linguagem permite uma alta portabilidade da linguagem e é usado em sistemas legados e sistema embarcados sem suporte para versões modernas.

O ISO C ou C90 possui algumas características que são que todas as variáveis devem ser declaradas no inicio de um bloco de código.

main.c

#include <stdio.h>

int main() {
    int x = 5;

    printf("O valor de x é: %d\n", x);

    int y = 10;

    printf("O valor de y é: %d\n", y);

    return 0;
}

Para compilar para C90 vamos usar a flag -std=c90 e -pedantic para o alerta aparecer ou -pedantic-errors para transforma o alerta em erro e impedir a compilação.

gcc main.c -std=c90 -pedantic-errors 
main.c: In function ‘main’:
main.c:8:5: error: ISO C90 forbids mixed declarations and code [-Wdeclaration-after-statement]
    8 |     int y = 10;
      |     ^~~

No C90 não havia comentário de uma linha com o // apenas blocos de comentário com /* */. Usar comentários com // gera um erro de compilação.

main.c

int main() {
    /* comentario no C89/C90 */

    // isso gera erro
    return 0;
}

gcc main.c -std=c90                 
main.c: In function ‘main’:
main.c:4:5: error: C++ style comments are not allowed in ISO C90
    4 |     // isso gera erro
      |     ^
main.c:4:5: note: (this will be reported only once per input file)

O loop for não permitia que você declarasse a variável dentro dele. Ela deveria ser declarada antes, e como dito, no inicio do bloco.

#include <stdio.h>

int main() {
    /* correto no C89/C90 */
    int i;

    for (i = 0; i < 10; i++) {
        printf("Hello, World! %d\n", i);
    }

    /* erro no C89/C90 */
    for (int j = 0; j < 10; j++) {
        printf("Hello, World! %d\n", j);
    }

    return 0;
}

gcc main.c -std=c90 
main.c: In function ‘main’:
main.c:12:5: error: ‘for’ loop initial declarations are only allowed in C99 or C11 mode
   12 |     for (int j = 0; j < 10; j++) {
      |     ^~~
main.c:12:5: note: use option ‘-std=c99’, ‘-std=gnu99’, ‘-std=c11’ or ‘-std=gnu11’ to compile your code

C99

Em 1999, a linguagem C recebeu uma revisão e surgiu a versão conhecida como C99. Essa versão trouxe muitas melhorias a linguagem.

Uma das mudanças e que agora variáveis não precisavam mais estar no inicio do bloco e a variável de controle do for poderia ser declarada dentro dele. Também era possível usar comentário com //.

O C99 trouxe os tipos booleanos para a linguagem através do cabeçalho stdbool.h. Ou seja, quando disserem que C não tem tipo booleano, saiba que ele tem desde da versão C99!

main.c

#include <stdio.h>
#include <stdbool.h> // adiciona suporte a booleanos

int main() {
    bool reagiu_ao_post = true; // exemplo de variável booleana

    if (!reagiu_ao_post) {
        printf("Deixe sua reação ao post!\n");
    } else {
        printf("Obrigado por reagir ao post!\n");
    }

    return 0;
}

gcc main.c -std=c99 -o main && ./main
Obrigado por reagir ao post!

Outra adição é tipos inteiros com tamanho padronizados. Pois, o tipo int poderia ter tamanhos diferentes dependendo do compilador e da arquitetura do sistema. Quando você tem pouca memória, como em sistemas embarcados, essa variação pode te fazer consumir mais memória do que você acha que está ou estar com memória sobrando por ter um inteiro menor do que você achava.

O C99 adicionou o cabeçalho stdint.h com esses novos tipos inteiros:

int8_t: inteiro com sinal de 8 bits ou 1 byte. Armazena de -128 até 127.
uint8_t: inteiro sem sinal de 8 bits ou 1 byte. Armazena de 0 até 255.
int16_t: inteiro com sinal de 16 bits ou 2 bytes. Armazena de -32.768 até 32.767.
uint16_t: inteiro sem sinal de 16 bits ou 2 bytes. Armazena de 0 até 65.535.
int32_t: inteiro com sinal de 32 bits ou 4 bytes. Armazena de -2.147.483.648 até 2.147.483.647.
uint32_t: inteiro sem sinal de 32 bits ou 4 bytes. Armazena de 0 até 4.294.967.295.
int64_t: inteiro com sinal de 64 bits ou 8 bytes. Armazena de -9.223.372.036.854.775.808 até 9.223.372.036.854.775.807.
uint64_t: inteiro sem sinal de 64 bits ou 8 bytes. Armazena de 0 até 18.446.744.073.709.551.615.

E temos o cabeçalho inttypes.h que adicionar macros de formatação para lidar com a coleta e impressão desses tipos.

Para a impressão temos macros que são formadas com o seguinte padrão:

PRI: significa que é um print do valor
formato: formato para inteiros usado no printf como d para inteiro com sinal e u para sem sinal ou x para hexadecimal.
tamanho: tamanhos dos tipos do stdint.h como 8, 16, 32 ou 64

main.c

#include <stdio.h>
#include <stdint.h>
#include <inttypes.h>

int main() {
    int8_t num = INT8_MAX; // inteiro de 8 bits com sinal
    uint8_t unum = UINT8_MAX; // inteiro de 8 bits sem sinal

    int16_t num16 = INT16_MAX; // inteiro de 16 bits com sinal
    uint16_t unum16 = UINT16_MAX; // inteiro de 16 bits sem sinal

    int32_t num32 = INT32_MAX; // inteiro de 32 bits com sinal
    uint32_t unum32 = UINT32_MAX; // inteiro de 32 bits sem sinal

    int64_t num64 = INT64_MAX; // inteiro de 64 bits com sinal
    uint64_t unum64 = UINT64_MAX; // inteiro de 64 bits sem sinal

    // O compilador junta as strings literal na compilação
    printf("int8_t:   %" PRId8 "\n", num);
    printf("int16_t:  %" PRId16 "\n", num16);
    printf("int32_t:  %" PRId32 "\n", num32);
    printf("int64_t:  %" PRId64 "\n", num64);
    printf("uint8_t:  %" PRIu8 "\n", unum);
    printf("uint16_t: %" PRIu16 "\n", unum16);
    printf("uint32_t: %" PRIu32 "\n", unum32);
    printf("uint64_t: %" PRIu64 "\n", unum64);

    return 0;
}

gcc main.c -std=c99 -o main && ./main
int8_t:   127
int16_t:  32767
int32_t:  2147483647
int64_t:  9223372036854775807
uint8_t:  255
uint16_t: 65535
uint32_t: 4294967295
uint64_t: 18446744073709551615

Temos uma macro para escanear valores do usuário. Essas macros segue o seguinte formato:

SCN: significa que é um sca*n* do valor
formato: formato para inteiros usado no scanf como d para inteiro com sinal e u para sem sinal ou x para hexadecimal.
tamanho: tamanhos dos tipos do stdint.h como 8, 16, 32 ou 64

main.c

#include <stdio.h>
#include <stdint.h>
#include <inttypes.h>

int main(){
    int8_t age;

    printf("Digite sua idade: ");
    scanf("%" SCNd8, &age);

    printf("Voce tem %" PRId8 " anos.\n", age);

    return 0;
}

gcc main.c -std=c99 -o main && ./main
Digite sua idade: 25
Voce tem 25 anos.

O C99 adicionou versões mais seguras de algumas funções como a fnprintf para ser usada no lugar da sprintf que poderia causar um estouro de buffer.

main.c

#include <stdio.h>

int main() {
    char buffer[30];
    char string[] = "Linguagem C";

    /*
     Causa um buffer overflow, pois a string formatada é maior que o tamanho do buffer

    sprintf(buffer, "Escrevendo a string formatada %s.", string); 

    */

    // Evita o buffer overflow, pois limita a escrita ao tamanho do buffer
    snprintf(buffer, sizeof(buffer), "formatada %s.", string); 

    printf("%s\n", buffer);

    return 0;
}

gcc main.c -std=c99 -o main && ./main
formatada Linguagem C.

Foi adicionado também um suporte matemático melhor com complex.h para lidar com números complexos. Uma api genérica com macros do tgmath.h que chama a função correta de acordo com o tipo passado, por exemplo a macro sin() chama as funções especificas para cada tipo, como sin() para double, sinf() para float, etc. E foi adicionado mais funções para math.h

main.c

#include <complex.h>
#include <tgmath.h>

int main() {
    double x = 10.0f;
    float y = 10.0f;
    double complex z = 2.0 * I;

    sin(x);  // chama sin(x)
    sin(y);  // chama sinf(y)
    sin(z);  // chama csin(z)

    return 0;
}

C11

Em 2011 uma nova versão estável da linguagem C, chamada C11. Essa versão trouxe um suporte nativo a threads e operações atômicas.

Antes, para usar threads no C era necessário usar o Posix Threads no Linux com o pthreads.h e a Windows API no Windows com o windows.h. No C11 foi adicionado o cabeçalho threads.h para trabalhar com threads e stdatomic.h para operações atômicas, evitando condições de corrida.

main.c

#include <stdio.h>
#include <stdlib.h> // para macro EXIT_SUCCESS
#include <threads.h>
#include <stdatomic.h>

int incrementar_contador(void* arg) {
    atomic_int *contador = (atomic_int*) arg;

    for (int i = 0; i < 100; i++) {
        atomic_fetch_add(contador, 1); // incrementa o contador 100 vezes
    }

    return EXIT_SUCCESS; // retorna 0 de forma mais clara, indicando sucesso
}

int main() {
    const int num_threads = 10;
    atomic_int contador = 0;
    thrd_t threads[num_threads];


    // cria as threads para incrementar o contador
    for (int i = 0; i < num_threads; i++) {
        // cria a thread passando incrementar_contador para ser executado nela com a parâmetro da função sendo o contador
        thrd_create(&threads[i], incrementar_contador, &contador);
    }

    // aguarda as threads terminarem
    for (int i = 0; i < num_threads; i++) {
        thrd_join(threads[i], NULL);
    }

    printf("Valor final do contador: %d\n", contador);

    return EXIT_SUCCESS;
}

gcc main.c -std=c11 -o main && ./main
Valor final do contador: 1000

O C11 introduziu o _Generic que retorna instruções baseado no tipo passado para ele.

Você passa a expressão no primeiro argumento e dependendo do tipo da expressão ele retorna algo.

_Generic(expressao, tipo1: instrucao1, tipo2: instrucao2, ..., tipoN: instrucaoN)

Isso nos permite cria macros genéricas. Por exemplo, uma macro print_arr para printar qualquer tipo de array. A macro irá receber o array e o tamanho e dependendo do tipo do array irá retornar a função correta para printar e irá executar ela.

main.c

#include <stdio.h>

// o \ permite quebrar linha nas macros
#define print_arr(arr, size) _Generic((arr), \
    int*: print_arr_int, \
    double*: print_arr_double, \
    char*: print_arr_char, \
    float*: print_arr_float \
)(arr, size) // _Generic retorna uma função e executamos passando arr e size

void print_arr_int(int *arr, int size) {
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

void print_arr_double(double *arr, int size) {
    for (int i = 0; i < size; i++) {
        printf("%.2lf ", arr[i]);
    }
    printf("\n");
}

void print_arr_char(char *arr, int size) {
    for (int i = 0; i < size; i++) {
        printf("%c ", arr[i]);
    }
    printf("\n");
}

void print_arr_float(float *arr, int size) {
    for (int i = 0; i < size; i++) {
        printf("%.2f ", arr[i]);
    }
    printf("\n");
}

int main() {
    char char_arr[6] = {'H', 'e', 'l', 'l', 'o', '\0'};
    int int_arr[6] = {1, 2, 3, 4, 5, 6};
    double double_arr[6] = {1.1, 2.2, 3.3, 4.4, 5.5, 6.6};
    float float_arr[6] = {1.1f, 2.2f, 3.3f, 4.4f, 5.5f, 6.6f};

    print_arr(char_arr, 6);
    print_arr(int_arr, 6);
    print_arr(double_arr, 6);
    print_arr(float_arr, 6);

    return 0;
}

gcc main.c -std=c11 -o main && ./main
H e l l o  
1 2 3 4 5 6
1.10 2.20 3.30 4.40 5.50 6.60
1.10 2.20 3.30 4.40 5.50 6.60

Temos asserções estáticas com o _Static_assert para fazer verificações em tempo de compilação em vez de tempo de execução.

main.c

#include <stdlib.h>

// Garante em tempo de compilação que o int tenha 4 bytes
_Static_assert(sizeof(int) != 4, "O compilador nao suporta inteiros de 4 bytes");


int main() {

    return 0;
}

 gcc main.c -std=c11 -o main && ./main
main.c:5:1: error: static assertion failed: "O compilador n\37777777703\37777777643o suporta inteiros de 4 
bytes"
    5 | _Static_assert(sizeof(int) != 4, "O compilador nao suporta inteiros de 4 bytes");
      | ^~~~~~~~~~~~~~

C17

O C17 é uma versão que não trouxe novas funcionalidades. Essa versão focou em correções de bug da versão C11.

C23

Esse é a versão mais atual da linguagem C, lançada em 2023, o C23 trouxe grandes mudanças trazendo funcionalidades que deixaram o C mais próximo ao C++.

Uma dessas mudança é que os tipos booleanos se tornaram padrão e você não precisa mais incluir o cabeçalho stdbool.h para usar no seu código.

#include <stdio.h>
#include <stdlib.h>

int main() {
    bool isValid = false;

    isValid = 10 == 10;
    if (isValid) {
        printf("O valor e valido: %d\n", isValid);
    } else {
        printf("O valor nao e valido: %d\n", isValid);
    }

    return EXIT_SUCCESS;
}

gcc main.c -std=c23 -o main  && ./main
O valor e valido: 1

Foi introduzido na linguagem o nullptr que, como no C++, faz um ponteiro apontar para nada. Antes era usado a macro NULL, mas em alguns casos essa macro poderia causar comportamentos inesperados.

A macro NULL geralmente é expandida para 0 ou (void *)0. Se NULL fosse passado para um _Generic ele seria tratado como int ou void *. Já o nullptr é um novo tipo para representar um valor de um ponteiro nulo e não seria confundido com outro tipo

#include <stdio.h>
#include <stdlib.h>

int main() {
    _Generic(NULL, 
        int: printf("NULL e um inteiro\n"),
        int*: printf("NULL e um ponteiro do tipo int\n"), 
        void*: printf("NULL e um ponteiro do tipo void\n"), 
        default: printf("NULL e de um tipo desconhecido\n")
    );

    _Generic(nullptr, 
        int: printf("nullptr e um inteiro\n"),
        int*: printf("nullptr e um ponteiro do tipo int\n"), 
        void*: printf("nullptr e um ponteiro do tipo void\n"), 
        default: printf("nullptr e de um tipo desconhecido\n")
    );

    return EXIT_SUCCESS;
}

gcc main.c -std=c23 -o main  && ./main
NULL e um ponteiro do tipo void
nullptr e de um tipo desconhecido

No C23 a palavra chave auto foi redefinida. Antes o auto era um modificador para indicar que a variável tinha armazenamento automático na stack, servia como a contrapartida do static. Mas, isso já era o padrão de uma variável e usar o auto era uma redundância.

// as duas declarações são a mesma coisa
int valor = 10;
auto int outro_valor = 10;

A partir do C23, você pode usar o auto para inferir o tipo na variável. Há também o typeof que serve para inferir o tipo em uma variável.

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>

typedef struct { 
    char *name;
    uint8_t age;
} User;

int main() {
    auto age = 10; // infere o tipo int
    auto name = "Fulano"; // infere o tipo const char* (string literal)

    User user = { .name = name, .age = age };
    // typeof infere o tipo da variável user e cria user2 com o mesmo tipo
    typeof(user) user2 = { .name = "Ciclano", .age = 20 }; 

    printf("User 1: %s, Age: %d\n", user.name, user.age);
    printf("User 2: %s, Age: %d\n", user2.name, user2.age);

    return EXIT_SUCCESS;
}

gcc main.c -std=c23 -o main  && ./main
User 1: Fulano, Age: 25
User 2: Ciclano, Age: 20

Temos o constexpr que cria uma constante. Diferente do const que é avaliado em tempo de execução o constexpr é avaliado em tempo de compilação.

#include <stdio.h>
#include <stdlib.h>

int main() {
    // VALUE é resolvido em tempo de compilação, permitindo a definição de um array de tamanho fixo
    // usar `const` daria um erro, pois `const` é resolvido em tempo de execução
    // e o tamanho do array precisa ser conhecido em tempo de compilação
    constexpr int VALUE = 4;
    int arr[VALUE] = { 1, 2, 3, 4 };

    for (int i = 0; i < VALUE; ++i) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    return EXIT_SUCCESS;
}

gcc main.c -std=c23 -o main  && ./main
1 2 3 4

C23 adicionou o prefixo 0b para declarar números binários literais e uso do ' para separar os dígitos dos números, facilitando a leitura.

#include <stdio.h>
#include <stdlib.h>

int main() {
    int binario = 0b101; // O prefixo "0b" indica que o número é binário
    printf("O valor do binario 0b101 e: %d\n", binario);

    int milhao = 1'000'000; // O apóstrofo é usado como separador de dígitos para melhorar a legibilidade
    printf("O valor do milhao e: %d\n", milhao);

    return EXIT_SUCCESS;
}

gcc main.c -std=c23 -o main  && ./main
O valor do binario 0b101 e: 5
O valor do milhao e: 1000000

A inicialização segura de array, union e struct mudou um pouco. Antes para fazer a inicialização de valores de uma struct, union ou array você usava {0} e no C23 isso foi simplificado para {}.

#include <stdio.h>
#include <stdlib.h>

struct ProdutoEstoque {
    int id_produto;
    float preco;
    char nome[50];
    int *historico_movimentacoes;
};

void print_produto(struct ProdutoEstoque *produto) {
    printf("ID: %d\n", produto->id_produto);
    printf("Preco: %.2f\n", produto->preco);
    printf("Nome: '%s'\n", produto->nome);

    if (produto->historico_movimentacoes == NULL) {
        printf("Ponteiro de historico inicializado como nulo de forma segura.\n");
    }
}

int main() {
    // Inicialização segura antes do C23
    struct ProdutoEstoque novo_item = {0}; 

    // Inicialização segura usando a nova sintaxe do C23
    struct ProdutoEstoque outro_item = {};

    print_produto(&novo_item);
    print_produto(&outro_item);

    return EXIT_SUCCESS;
}

gcc main.c -std=c23 -o main && ./main
ID: 0
Preco: 0.00
Nome: ''
Ponteiro de historico inicializado como nulo de forma segura.
ID: 0
Preco: 0.00
Nome: ''
Ponteiro de historico inicializado como nulo de forma segura.

Versão do compilador

Mostrei algumas funcionalidades de cada versão do C, mas como eu sei qual versão o meu compilador está usando?

Existe uma macro chamada __STDC_VERSION__ que armazena um número inteiro do tipo long que indica a versão do C usada na compilação. O valor dessa macro é o ano mais o mês de lançamento da versão. Usando a flag -std mudamos a versão do C usada na compilação e o valor dessa macro também é mudado.

#include <stdio.h>
#include <stdlib.h>

/* 
O C89/C90 não define __STDC_VERSION__ então se for C89/C90
compilamos o primeiro main, caso contrário compilamos o segundo main
*/
#ifndef __STDC_VERSION__

int main() {
    printf("C89/C90\n");
    return EXIT_SUCCESS;
}

#else

int main() {
    switch (__STDC_VERSION__) {
        case 202311L: // ano 2023 + mês 11 = 202311
            printf("C23\n");
            break;

        case 201710L: // ano 2017 + mês 10 = 201710
            printf("C17\n");
            break;

        case 201112L: // ano 2011 + mês 12 = 201112
            printf("C11\n");
            break;

        case 199901L: // ano 1999 + mês 01 = 199901
            printf("C99\n");
            break;
    }

    return EXIT_SUCCESS;
}
#endif

gcc main.c -std=c89 -o main && ./main
C89/C90

gcc main.c -std=c99 -o main && ./main
C99

gcc main.c -std=c11 -o main && ./main
C11

gcc main.c -std=c17 -o main && ./main
C17

gcc main.c -std=c23 -o main && ./main
C23

Eu estou usando o gcc versão 15.2.0, que adota o C23 como padrão ao compilar. Se eu tirar a flag -std e compilar terei "C23" como saída.

gcc main.c -o main && ./main
C23

Java: a classe String

Matheus de Gondra — Mon, 23 Feb 2026 17:48:31 +0000

Java é uma linguagem com tipos primitivos para representar números, como int e long, representar valores booleanos, com o boolean, e representar caracteres, com o char. Mas, como o java representar uma palavra ou um texto?

Array de caracteres

Uma palavra é um conjunto de letra e o java tem o tipo char para representar uma letra. Então, podemos representar uma palavra usando um array de char.

char[] letras = { 'H', 'e', 'l', 'l', 'o' };
for (char letra : letras) {
  System.out.print(letra); // Hello
}

Isso funciona. Mas, não é desse jeito que o java representa um texto. Esse código está mais parecido com um código C.

Classe String

O java não possui um tipo primitivo para representar um texto. Ele usa uma classe chamada String.

A classe String criar uma string imutável e para criar uma string é só usar as aspas "".

String palavra = "Hello";
System.out.println(palavra); // Hello

Como é uma classe, também podemos usar o operador new.

String palavra = new String("Hello");
System.out.println(palavra); // Hello

Porém, não devemos usar o new para criar uma String, porque o java otimiza as strings criando um Pool de Strings.

String Pool

Toda vez que criamos um nova string um novo objeto é criado na memoria heap. Usando string literais " " o java consegue otimizar a memória criando a string dentro de um pool de strings.

O String Pool é uma área que o java cria dentro da memória heap para reutilizar objetos String.

Quando você cria uma string literal, usando aspas, o java primeiro verifica se essa string existe no String Pool. Se não existir ele cria o objeto e devolve a referência para ele, se existir ele só devolve a referência. Isso permite reutilizar objetos String diminuindo o consumo de memória.

Usando o operador new, a string é criada na memória heap, mas fora do String Pool. Com isso, mesmo que você tenta duas strings iguais elas serão objetos diferentes.

String s1 = "Hello";

// a string "Hello" já existe no String Pool então apenas retorna a referência
String s2 = "Hello";

// Um novo objeto é criado fora do String Pool
String s3 = new String("Hello");

// comparando as referências
System.out.println(s1 == s2); // true
System.out.println(s1 == s3); // false

Métodos

Como eu disse, a string no java é um objeto. Isso significa que ela possuí métodos que nos ajudam na manipulação.

Por ser imutável, toda manipulação gera uma nova string em vez de mudar a string anterior. Por isso, os métodos da classe String sempre retornam algo.

String nome = "Fulano";
String nomeMaiusculo = nome.toUpperCase();
String nomeMinusculo = nome.toLowerCase();

System.out.println(nome); // Fulano
System.out.println(nomeMaiusculo); // FULANO
System.out.println(nomeMinusculo); // fulano

A classe String possui vários métodos, esses são alguns deles:

boolean isEmpty(): verifica se a string é vazia.
boolean isBlank(): verifica se a string é vazia ou se só tem espaço vazio.
boolean startsWith(String prefixo): verifica se a string começa com o prefixo
boolean endsWith(String sufixo): verifica se a string termina com o sufixo.
String trim(): retorna uma string sem os espaço vazios no inicio e no fim dela.
int length(): retorna o tamanho da string.

Conclusão

Espero que ao final dessa leitura você tenha entendido melhor sobre como o java faz para representar textos e como a classe String funciona por baixo dos panos.

Preparando uma API NodeJS para produção

Matheus de Gondra — Mon, 05 Jan 2026 18:33:54 +0000

Hoje vou mostrar o que deve ser feito para preparar sua aplicação NodeJS para o ambiente de produção. Mas, antes vamos criar um projeto para isso.

Iniciando projeto

A versão do NodeJS que estarei usando é v22.17.0 e usarei o pnpm na versão v10.18.3 como o gerenciador de pacotes, mas você pode usar o npm ou o yarn se preferir.

Vamos iniciar um projeto com o comando init para gerar o package.json

pnpm init

Vou adicionar a chave "type": "module" para usarmos o ES Modules nos nossos arquivos.

{
  "name": "node-prod",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "type": "module", // Usando ES Modules
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "packageManager": "pnpm@10.18.3"
}

Instalando dependências

Vamos criar API REST, então precisamos instalar algumas dependências no projeto. Vamos ter dependências de produção, que ficam em dependencies e dependências de desenvolvimento, que ficam em devDependencies, tudo isso listado no package.json.

Vamos começar instalando as dependências de produção

express: criação do servidor HTTP
pino: geração de logs
@prisma/client: cliente do banco de dados
@prisma/adapter-pg: adaptador do postgres para o prisma client
pg: driver do banco PostgreSQL
dotenv: para acessar as variáveis de ambiente no .env
express-rate-limit: middleware contra ataque de força bruta
cors: middleware para configurar o CORS
helmet: middleware para adicionar cabeçalhos de segurança

pnpm add express pino @prisma/client @prisma/adapter-pg pg dotenv express-rate-limit cors helmet

Essas são as dependências que serão usadas no ambiente de produção. Agora vamos instalar as dependências que serão usadas apenas no ambiente de desenvolvimento.

typescript: superset do javascript que adiciona tipagem estática
prisma: biblioteca de ORM
tsx: para executar código typescript
@tsconfig/node22: configuração do typescript para o NodeJS v22
pino-pretty: para melhor visualização dos logs em desenvolvimento
@types/pg: tipagem do pg
@types/node: tipagem do NodeJS
@types/express: tipagem do express
@types/cors: tipagem do cors

pnpm add -D typescript prisma tsx @tsconfig/node22 @types/pg @types/node @types/express @types/cors pino-pretty

No pnpm há uma particularidade, algumas biblioteca têm um script postinstall que o pnpm bloqueia por segurança. Para desbloquear isso você precisa usar o comando pnpm approve-builds e escolher quais libs você permite rodar o script postinstall e digita y para rodar os scripts de postinstall.

Com isso, um arquivo pnpm-workspace.yaml também será criado listando as bibliotecas que podem executar o postinstall.

onlyBuiltDependencies:
  - '@prisma/engines'
  - esbuild
  - prisma

O package.json ficou assim.

{
  "name": "node-prod",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "type": "module",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "packageManager": "pnpm@10.18.3",
  "dependencies": {
    "@prisma/adapter-pg": "^7.2.0",
    "@prisma/client": "^7.2.0",
    "cors": "^2.8.5",
    "dotenv": "^17.2.3",
    "express": "^5.2.1",
    "express-rate-limit": "^8.2.1",
    "helmet": "^8.1.0",
    "pg": "^8.16.3",
    "pino": "^10.1.0"
  },
  "devDependencies": {
    "@tsconfig/node22": "^22.0.5",
    "@types/cors": "^2.8.19",
    "@types/express": "^5.0.6",
    "@types/node": "^25.0.3",
    "@types/pg": "^8.16.0",
    "pino-pretty": "^13.1.3",
    "prisma": "^7.2.0",
    "tsx": "^4.21.0",
    "typescript": "^5.9.3"
  }
}

Configurando typescript

Agora vamos configurar o typescript. Use o comando tsc --init para criar o arquivo tsconfig.json. E vamos usar a configuração que instalamos com o @tsconfig/node22, vamos definir o diretório de que irá ser gerado com o código compilado como dist e não vamos permitir a compilação se houver erros. Vamos usar o include para incluir tudo de src na pasta dist quando for gerada, se não seria criada uma pasta src dentro da pasta dist.

pnpm tsc --init

tsconfig.json

{
  "extends": "@tsconfig/node22/tsconfig.json",
  "compilerOptions": {
    "outDir": "dist",
    "noEmitOnError": true
  },
  "include": ["src"]
}

Variáveis de ambiente

Agora vamos criar nossos arquivos typescript. Vamos começar com um arquivo src/env.ts para centralizar as variáveis de ambiente que usaremos.

export const env = {
  port: Number(process.env.PORT) || 3000,
  isProduction: process.env.NODE_ENV === "production",
  databaseUrl: process.env.DATABASE_URL,
  logLevel: process.env.LOG_LEVEL || "info"
};

Logger da aplicação

Agora vamos criar o logger para a nossa aplicação. Usaremos o pino que instalamos antes para isso. Vamos criar o arquivo src/logger.ts.

Na configuração do logger iremos definir o nível de log, para que mensagem de log que estejam abaixo daquele nível não apareçam. E vamos usar o pino-pretty quando não estivermos em ambiente de produção.

import pino from "pino";
import { env } from "./env.js";

export const logger = pino({
  level: env.logLevel,
  transport: env.isProduction ? undefined : { target: "pino-pretty" }
});

Banco de dados

Para a comunicação com o banco de dados vamos usar o Prisma como biblioteca de ORM e o PostgreSQL como banco de dados.

Primeiro precisamos configurar o prisma com o comando init do prisma.

pnpm prisma init

Esse comando irá criar o prisma/schema.prisma onde temos os esquemas, .env onde ficará as variáveis de ambiente, .gitignore para impedir que alguns arquivos sejam salvos pelo git e o prisma.config.ts onde terá a configuração da CLI do prisma.

No prisma/schema.prisma vamos criar a tabela de usuários. Usarei o @map para mudar o nome da coluna no banco e @@map para mudar o nome da tabela no banco.

generator client {
  provider = "prisma-client"
  output   = "../src/generated/prisma"
}

datasource db {
  provider = "postgresql"
}

model User {
  id        Int      @id @default(autoincrement())
  name      String
  email     String   @unique
  createdAt DateTime @default(now()) @map("created_at")
  updatedAt DateTime @updatedAt @map("updated_at")

  @@map("users")
}

Salve o arquivo e defina a URL de conexão com o banco de dados no arquivo .env e após isso gere a migração e os arquivos do prisma

// criando a migração
pnpm prisma migrate dev --name create-table-users


// gerando o PrismaClient
pnpm prisma generate

O prisma generate irá criar o diretório src/generated/prisma onde ficam os tipos definidos no schema.prisma e o PrismaClient que será usado para fazer as query no banco.

O próximo passo é criar o arquivo src/db.ts para criar uma instância do PrismaClient.

import { PrismaPg } from "@prisma/adapter-pg";
import { env } from "./env.js";
import { PrismaClient } from "./generated/prisma/client.js";

const adapter = new PrismaPg({ connectionString: env.databaseUrl! });
export const db = new PrismaClient({ adapter });

Rotas da aplicação

Vamos criar algumas rotas para testarmos a aplicação. Colocaremos logs para saber o que está acontecendo também.

import { Router } from "express";
import { logger } from "./logger.js";
import { db } from "./db.js";
import { PrismaClientKnownRequestError } from "./generated/prisma/internal/prismaNamespace.js";

const router = Router();

router.get("/", (req, res) => {
  logger.info({ route: "/" }, "Health check endpoint called");

  res.json({ status: "OK" });
});

router.post("/users", async (req, res) => {
  const childLogger = logger.child({ route: "/users", method: "POST" });

  try {
    const { name, email } = req.body;

    childLogger.debug({ data: { name, email } }, "Creating new user");

    const newUser = await db.user.create({
      data: {
        name,
        email
      }
    });

    childLogger.info({ userId: newUser.id }, "New user created");

    res.status(201).json(newUser);
  } catch (error) {
    childLogger.error({ error, route: "/users" }, "Error creating user");

    res.status(500).json({ error: "Internal Server Error" });
  }
});

router.get("/users", async (req, res) => {
  const childLogger = logger.child({ route: "/users", method: "GET" });

  try {
    const users = await db.user.findMany();

    childLogger.info({ userCount: users.length }, "Fetched users successfully");

    res.json(users);

  } catch (error) {
    childLogger.error({ error }, "Error fetching users");

    res.status(500).json({ error: "Internal Server Error" });
  }
});

router.delete("/users/:id", async (req, res) => {
  const childLogger = logger.child({ route: "/users/:id", method: "DELETE" });

  try {
    const userId = Number(req.params.id);

    childLogger.debug({ userId }, "Deleting user");

    await db.user.delete({
      where: { id: userId }
    });

    childLogger.info({ userId }, "User deleted successfully");

    res.status(204).send();
  } catch (error) {
    if (error instanceof PrismaClientKnownRequestError && error.code === "P2025") {
      childLogger.warn({ error }, "User not found for deletion");

      return res.status(404).json({ error: "User not found" });
    }

    childLogger.error({ error }, "Error deleting user");

    res.status(500).json({ error: "Internal Server Error" });
  }
});

export { router };

Servidor

Com tudo isso vamos montar nosso arquivo principal src/server.ts onde iremos criar o servidor e iniciá-lo.

import cors from "cors";
import express, { json } from "express";
import rateLimit from "express-rate-limit";
import helmet from "helmet";
import { env } from "./env.js";
import { logger } from "./logger.js";
import { router } from "./routes.js";

const app = express();

// middleware para parsear JSON
app.use(json());

// middleware de segurança
const oneMinute = 60 * 1000;
app.use(
    helmet(),
    cors({
        origin: "*", // ajuste conforme necessário
        methods: ["GET", "POST", "PUT", "DELETE", "OPTIONS"],
        allowedHeaders: ["Content-Type", "Authorization"]
    }),
    rateLimit({
        windowMs: 15 * oneMinute,
        max: 100
    })
);

// rotas
app.use(router);

app.listen(env.port, () => logger.info(`Server is running on port ${env.port}`));

Scripts

Vamos criar os scripts start, dev e build e vamos definir o arquivo de entrada na chave main do package.json

"main": "dist/server.js",
"scripts": {
    "start": "node --env-file-if-exists=.env .",
    "dev": "tsx --env-file-if-exists=.env src/server.ts",
    "build": "tsc"
  }

Testando

Inicie a aplicação em modo de desenvolvimento com o script dev e vamos iniciar com o nível de log como debug para ver todos os logs que foram criados.

.env

DATABASE_URL="postgresql://dev:dev@localhost:5432/node_prod_post"
NODE_ENV="development"
PORT=3000
LOG_LEVEL="debug"

pnpm dev

Irei fazer as requisições para a API usando a extensão do VSCode REST Client usando um arquivo client.http

@baseUrl = http://localhost:3000

GET {{baseUrl}}

###
POST {{baseUrl}}/users
Content-Type: application/json

{
    "name": "John Doe",
    "email": "john@email.com"
}

###
GET {{baseUrl}}/users

###
DELETE {{baseUrl}}/users/1

Fiz algumas requisições e os logs estão sendo gerados corretamente.

Preparando para produção

O código funciona em ambiente de desenvolvimento. Mas, em produção não teremos código typescript sendo executado ou nenhuma dependência de desenvolvimento instalada.

Primeiro vamos compilar o código para javascript usando o script build. Isso irá gerar uma pasta dist com o código compilado.

Agora vamos definir as variáveis de ambiente que serão usadas em produção que são a URL do banco de produção, o nível de log como "warn" e a NODE_ENV como "production" para ativar otimizações das bibliotecas.

DATABASE_URL="postgresql://dev:dev@localhost:5432/node_prod_post_production"
NODE_ENV="production"
PORT=3000
LOG_LEVEL="warn"

Como eu adicionei uma URL para outro banco de dados, preciso rodar as migrações para gerar as tabelas. Para produção, o prisma tem o comando prisma migrate deploy

pnpm prisma migrate deploy

Por fim, vamos desinstalar as dependências de desenvolvimento.

pnpm i --prod

Agora podemos iniciar o projeto com o script start.

pnpm start

O projeto iniciará silenciosamente no terminal. Como definimos o nível como 'warn', apenas avisos e erros críticos serão exibidos, evitando poluição visual e excesso de uso de disco em produção.

Outra mudança é que os logs são impressos em formato JSON. Embora seja difícil para humanos lerem, esse formato é ideal para ferramentas de monitoramento (como Datadog, CloudWatch ou Elastic Stack) indexarem e processarem as informações.

Um ponto que deve ser levado em conta é que nesse projeto o script start eu usei a flag --env-file-if-exists para usar o arquivo .env para definir as variáveis de ambiente, mas em um ambiente real as variáveis de ambiente não são definidas em um arquivo e sim injetadas diretamente no ambiente.

Conclusão

Com essas configurações, transformamos um simples setup de desenvolvimento em uma aplicação pronta para o mundo real. A diferença entre um projeto amador e um profissional muitas vezes está nesses detalhes: a remoção de dependências desnecessárias, a compilação correta do TypeScript e a estruturação de logs em JSON para ferramentas de observabilidade.

Streams o que são e como usar no NodeJS

Matheus de Gondra — Fri, 10 Oct 2025 16:45:03 +0000

Netflix, Prime Video, Crunchyroll todos serviços de streaming, mas você sabe o que uma stream? E mais, você sabe o que uma stream no NodeJS?

Streams

Pensei na Netflix, você não espera um episódio inteiro de uma série baixar para você começar a assistir, por que você está consumindo uma stream de um vídeo.

Uma stream é um fluxo de dados. Em vez de você consumir um dado inteiro de uma vez, como um conteúdo de um arquivo ou um vídeo, você consume o dado em partes.

Memória

Mas, por que eu preciso consumir os dados em partes em vez de consumir tudo de uma vez?

Hoje pode não parece tanto, mas memória era algo escasso. Então quando você criava software, o quanto de memória era usado era uma grande preocupação. Se você precisasse criar um software que para inicializar ele consumisse 30MB de memória e analisasse um arquivo que tivesse 2GB de tamanho o seu software pararia de funcionar por não ter memória suficiente para carregar um arquivo tão grande.

Agora se fosse utilizado um stream em vez de carregar o arquivo completamente não teria esse problema de falta de memoria, pois a arquivo seria enviado em partes, chamadas chunk, e processado a medida que chegam.

Streams no NodeJS

O NodeJS possui um módulo para trabalhar com streams desde a primeira versão: node:stream.

O NodeJS possui 3 tipos de streams diferentes:

Readable Stream

Esse tipo de stream é utilizado quando queremos ler de uma fonte de dados. A stream pode operar em dois modos:

flowing mode: nesse modo os dados são lidos automaticamente através de eventos "data"
paused mode: nesse modo o método read() deve ser chamado explicitamente para ler cada dado da stream.

Por padrão toda Readable Stream começa no paused mode, mas isso pode ser mudado ao chamar o métodos resume(), pipe() ou criando um handler para evento data.

Para criar uma stream de leitura (readable) precisamos importar Readable do módulo node:stream e podemos usar o método from() que recebe um Iterable ou um AsyncIterable.

As streams herdam da classe EventEmitter então podemos usar o método on para lidar com eventos da stream. Alguns eventos que ocorrem com uma Readable Stream são:

data: dados são recebidos.
end: todos os dados foram lidos. Não há mais dados para consumir.
close: a stream foi fechada.
error: algum erro ocorreu durante o fluxo de dados

import { Readable } from "node:stream";

const readableStream = Readable.from([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);

readableStream.on("data", (chunk) => {
    console.log("Dado recebido:", chunk);

    if (chunk === 7) {
        // Simula uma condição para fechar a stream
        if (Math.random() > 0.5) {
            // fecha a stream sem erro (evento "close")
            readableStream.destroy();
        } else {
            // fecha a stream com erro (evento "error")
            readableStream.destroy(new Error("Erro forçado na stream"));
        }
    }
});

readableStream.on("end", () => {
    console.log("Todos os dados consumidos.");
});

readableStream.on("close", () => {
    console.log("Stream foi fechada.");
});

readableStream.on("error", (err) => {
    console.error("Erro na stream:", err);
});

Se for necessário criar sua própria Readable Stream personalizada, você precisa implementar a interface da classe Readable. Isso pode ser feito herdando a classe Readable e implementando o método _read().

import { Readable } from "node:stream";

class MyStream extends Readable {
    data = [1, 2, 3, 4, 5];

       constructor(options = {}) {
          super(options);
       }

    _read() {
        const chunk = this.data.shift();
        if (chunk) {
            const dataToSend = String(chunk);
            this.push(dataToSend); // envia os dados do tipo string ou Buffer
            return;
        }

        this.push(null); // sinaliza o fim da stream
    }
}

const myStream = new MyStream();

myStream.on("data", (chunk) => {
    // Os dados chegam como um tipo Buffer
    console.log(chunk.toString()); // convertendo para string
});

Para casos mais simples pode ser diretamente uma instancia de Readable e implementando o método read().

import { Readable } from "node:stream";

const data = [1, 2, 3, 4, 5];

const myStream = new Readable({
    read() {
        const chunk = data.shift();
        if (chunk) {
            const dataToSend = String(chunk);
            this.push(dataToSend);
            return;
        }
    }
});

myStream.on("data", (chunk) => {
    console.log(chunk.toString());
});

Writable Stream

Esse tipo de stream é utilizado quando queremos escrever dados em algum lugar.

Para criar uma stream de escrita (writable), importamos Writable do módulo node:stream e criamos uma instância com um método write().

O método write() recebe 3 argumentos:

chunk: os dados que serão escritos em algum lugar. O chunk é uma variável do tipo Buffer.
encoding: a codificação usada.
callback: função para continuar o fluxo ou parar caso tenho um error.

import { Writable } from "node:stream";

const writableStream = new Writable({
    write(chunk, _encoding, callback) {
        console.log("Dado recebido:", chunk.toString());

        callback();
    }
});

writableStream.write("Olá");
writableStream.write("Mundo!");

Streams operam com string, Buffer, TypedArray ou DataView. Caso seja necessário trabalhar com outros tipos é preciso usar objectMode: true.

import { Writable } from "node:stream";

const writableStream = new Writable({
    objectMode: true,
    write(chunk, _encoding, callback) {
                // chunk agora é um object
        console.log("Dado recebido:", chunk);

        callback();
    }
});

writableStream.write({ message: "Olá" });
writableStream.write({ message: "Mundo!" });

Para criar uma writable stream customizada é necessário herdar de Writable e implementar o método _write e/ou _writev.

import { Writable } from "node:stream";

class MyStream extends Writable {
    constructor(options = {}) {
        super(options);
    }

    _write(chunk, _encoding, callback) {
        console.log("Dado recebido:", chunk);
        callback();
    }
}

const writableStream = new MyStream({ objectMode: true });

writableStream.write("Olá");
writableStream.write({ message: "Mundo!" });

Duplex e Transform Stream

As duplex streams são streams que implementam o protocolo Readable e Writable, ou seja, ela funciona como uma stream de escrita e leitura.

Dentro das Duplex streams, temos as Transform streams que são streams de transformação. Essas são usadas quando queremos manipular um dados que está passando pelo nossa stream.

Vamos a um exemplo, vamos criar uma stream de leitura (readable) e conectar a uma stream de transformação (transform) usando o método pipe e vamos mandar para o console usando o process.stdout que é uma stream de escrita.

import { Readable, Transform } from "node:stream";

const dados = ["javascript", "nodejs", "java", "elixir", "c++"];
const readableStream = Readable.from(dados);

const transformStream = new Transform({
    transform(chunk, _encoding, callback) {
        const dado = chunk.toString();
        const dadoTransformado = `${dado.toUpperCase()}\n`;

        // callback recebe dois parâmetros: erro e o dado transformado
        callback(null, dadoTransformado);
    }
});

// o método pipe conecta streams
readableStream.pipe(transformStream).pipe(process.stdout);

Resumindo: lemos os dados com uma readable stream, transformamos os dados com uma stream duplex stream (Transform) e escrevemos o conteúdo no console usando uma writable stream (process.stdout).

Por que usar?

Vamos usar numa situação mais real para você entender o porquê usar uma stream no NodeJS.

Vamos fazer a análise de uma base de dados csv, baixei uma base de dados sobre o preço do combustível.

Vamos usar o node:fs para ler o arquivo e escrever no console.

import fs from "node:fs"

const arquivo = fs.readFileSync("ca-2004-01.csv");
const linhas = arquivo.toString().split("\n");
linhas.map(linha => {
  console.log(linha);
});

node index.js

Ao rodar o código funciona perfeitamente.

Vamos tentar novamente, mas limitaremos a memória usada pelo programa para 100MB. Afinal, não teremos gigas de memória em todo ambiente de execução.

node --max-old-space-size=100 index.js

Dessa vez tivemos um erro do motor v8, usado pelo NodeJS para executar o javascript, por falta de memória para o nosso programa.

Agora vamos usar as streams. O módulo node:fs tem uma função para ler um arquivo como uma stream.

import fs from "node:fs"

const readableStream = fs.createReadStream("ca-2004-01.csv");

readableStream.pipe(process.stdout);

node --max-old-space-size=100 index.js

Agora o código funcionou e você vai ver os dados no console.

No primeiro caso, como limitamos a memória do nosso programa, ele quebra ao carregar o arquivo, porque ele precisa de mais de 100MB para isso.

Já com streams lemos e processamos o arquivo em partes e não todo de uma vez. Carregamos 64KB do arquivo e mandamos escrever no console, depois carregamos mais 64KB e mandamos para o console e repetimos até o fim dos dados. Com isso, não usamos o nosso limite de 100MB inteiro e o programa finaliza com sucesso.

[Boost]

Matheus de Gondra — Tue, 30 Sep 2025 10:16:12 +0000

C++ Addons no Node.js

Ryan Vieira ・ Dec 2 '24

#node #javascript #cpp #programming

Exception vs Error no Java

Matheus de Gondra — Sat, 23 Aug 2025 12:56:49 +0000

Introdução

Ao estudar sobre java você pode ter se deparado com o conceito de Exception (exceção) e Error (erro). Mas, qual a diferença entre eles?

As duas classes, Error e Exception, são subclasses da Throwable. Isso permite que elas sejam lançadas com throw para mudar o fluxo da aplicação.

Mas o uso dessas duas classes são diferentes

Error

A classe, e as subclasses, de Error representam erros do ambiente de execução JVM. Esses tipos de erros não devem ser tratados pelo programador e sim pelos programadores da JVM.

Algumas classes que herdam de Error são:

VirtualMachineError -> Erro na JVM
StackOverflowError -> Erro de estouro de pilha
OutOfMemoryError -> Erro de falta de memoria para alocar um objeto

Exception

As exceções são um tipo de erro diferente, elas são fluxos alternativos do seu programa. O programador pode e deve lidar com elas ao desenvolver um software.

Fluxos de falha, que são diferentes de erro, são representados pelas exceções. Por exemplo, ao ler um arquivo há dois fluxos possíveis: O arquivo existe e é possível ler (caso de sucesso) ou o arquivo pode não existir (caso de falha). Isso não é um erro é um fluxo de falha e nesses casos ocorre de uma exceção IOException ser lançada.

Programadores devem lidar com os casos de falha capturando as exceções com um bloco try/catch ou try/catch/finally.

Algumas classes que herdam de Exception são:

IOException -> exceção ao lidar com arquivos
RuntimeException -> exceção que ocorre no momento de execução
NumberFormatException -> exceção ao converter string que não são números

Generics Typescript

Matheus de Gondra — Tue, 05 Aug 2025 18:13:14 +0000

Os Generics é uma forma de tipagem que permite que você indique o tipo da classe ou função no momento que for usar. Isso te da mais flexibilidade ao criar e usar tipos.

Funções

Vamos imaginar que temos uma simples função que recebe um argumento qualquer e retorna esse argumento.

function foo(arg) {
    return arg;
}

Como estamos usando o typescript, vamos definir os tipos dessa função e do seu argumento. Mas, como podemos receber qualquer argumento a primeira coisa que poderiamos pensar é usar o tipo any.

function foo(arg: any): any {
    return arg;
}

Isso funciona, mas usar any é como usar javascript, não vamos ter uma tipagem que nos ajude no desenvolvimento. Para deixar a função com uma boa tipagem e com flexibilidade no tipo, podemos usar o Generic.

Para usar o Generic numa função basta colocar <> após o nome da função. E dentro do <> definir o tipo genérico, geralmente usamos a letra T (primeira letra de type). Feito isso é só usar o tipo genérico nos argumentos e/ou no retorno da função.

// Criamos um tipo T que será definido ao usar a função
function foo<T>(arg: T): T {
    return arg;
}


foo<number>(20); // definindo o tipo T como number
foo<string>('20'); // definindo o tipo T como string

// O typescript é capaz de inferir o tipo T já que sabe o tipo do argumento
foo(20);
foo('20');

// Erro de compilação
foo<number>('20'); // espera um number e não uma string
foo<string>([20]); // espera uma string e não um array de number

Ao usar um tipo genérico, não estamos limitados a usar apenas um tipo. Vamos criar um nova função que irá criar um Map. Um Map é uma estrutura com chave (key) e valor (value). Então vamos ter dois tipos genéricos K (primeira letra de key) e V (primeira letra de value).

// Função genérica para criar um Map
function createMap<K, V>(): Map<K, V> {
    return new Map<K, V>();
}

// Cria um Map com chaves do tipo string e valores do tipo number
const myMap = createMap<string, number>()

myMap.set("one", 1);
myMap.set("two", 2);

// Usando a inferencia de tipos do TypeScript
// O TypeScript infere o tipo da variável na função createMap
const otherMap: Map<number, number> = createMap();

otherMap.set(1, 100);
otherMap.set(2, 200);

// Erro de compilação: 

myMap.set("three", [3]); // O valor deve ser um number e não um array de number
otherMap.set(3, [300]); // O valor deve ser um number

Classes

Assim como podemos ter funções genéricas, também podemos ter classes genéricas. Para isso basta colocar <> após o nome da classe e definir os tipos genéricos dentro do <>

Pegando a inspiração do Java, vamos criar uma classe genérica List para armazenar tipos genéricos.

// Definindo que a classe receberá um tipo genérico T
class List<T> {
    private items: T[] = []; // Array para armazenar os itens do tipo T

    add(item: T): void {
        this.items.push(item);
    }

    get(index: number): T | undefined {
        return this.items[index];
    }
}

// Definindo o tipo T ao usar a classe
const ages = new List<number>(); // lista de idade
const names = new List<string>(); // lista de nomes

ages.add(18);
ages.add(22);
names.add("Alice");
names.add("Bob");

console.log(ages.get(0)); // 18
console.log(names.get(1)); // Bob

// Erro de compilação
names.add(30); // names só aceita strings
ages.add("Charlie"); // ages só aceita números

Em classes, não precisamos que toda a classe seja genérica, podemos apenas definir um método como genérico.

class MapFactory {

    // Apenas o método é genérico
    createMap<K, V>(): Map<K, V> {
        return new Map<K, V>();
    }
}

const mapFactory = new MapFactory();
const myMap = mapFactory.createMap<string, number>();

myMap.set("key1", 1);

// Usando inferência de tipo
const otherMap: Map<string, boolean> = mapFactory.createMap();

otherMap.set("notification", true);
otherMap.set("alert", false);

Genéricos Restritos

Há momentos que precisamos da flexibilidade de tipo do Generic, mas não flexível demais.

Vamos ver esse caso: precisamos criar uma função genérica, para aceitar vários tipos de objetos, mas esse objetos tem que ter o campo size.

Para aceita vários tipos de objetos podemos usar o Generic ao criar a função.

function getSize<T>(obj: T): number {
    // Erro de compilação: Property 'size' does not exist on type 'T'.
    return obj.size; 
}

O tipo genérico, como o nome já diz, é genérico! Então não sabemos se ele sempre terá o campo size: number.

Pensando nesses problemas podemos restringir o tipo T, tornando ele menos genérico para esse caso.

type SizeType = {
    size: number;
};

function getSize<T extends SizeType>(obj: T): number {
    // O compilador agora sabe que T possui o campo size
    return obj.size;
}

Usando o extends ao definir o tipo dizemos para o compilador que o tipo T é um tipo genérico, mas ele também tem que ser do tipo SizeType.

class MyArray {
    size: number;

    constructor(size: number) {
        this.size = size;
    }
}

class MyStack {
    size: number;

    constructor(size: number) {
        this.size = size;
    }
}

class User {
    name: string;
    age: number;

    constructor(name: string, age: number) {
        this.name = name;
        this.age = age;
    }
}

type SizeType = {
    size: number;
};

function getSize<T extends SizeType>(obj: T): number {
    return obj.size;
}

const myArray = new MyArray(10);
const myStack = new MyStack(5);
const user = new User("Alice", 30);

console.log(getSize(myArray)); // Output: 10
console.log(getSize(myStack)); // Output: 5

// Erro de compilação
// User não satisfaz o tipo SizeType para ser usado no getSize
console.log(getSize(user));

Outro caso que podemos usar genéricos restritos

function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
    return obj[key];
}

Vamos entender o que está acontecendo. Temos uma função que recebe dois tipos genéricos: T e K. O keyof retorna todas as chaves de um tipo, então o K está restrito as chaves do T, ou seja, só aceita as chaves do objeto T.

function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
    return obj[key];
}

// retorna a propriedade name do objeto
getProperty({ name: "Foo", age: 30 }, "name"); // "Foo"

// retorna a propriedade 1 do objeto
getProperty({ 1: "Bar" }, 1); // "Bar"

// retorna a propriedade "size" de um objeto Map
getProperty(new Map([["name", "Foo"], ["age", "30"]]), "size"); // 2

Tipos primitivos no Java

Matheus de Gondra — Thu, 31 Jul 2025 15:36:15 +0000

Java é uma linguagem de programação que possui uma tipagem estática e forte. Isso quer dizer que os tipos devem ser definidos em momento de compilação. Por isso, vou apresentar os tipos primitivos que a linguagem possui.

Números

O Java representa números usando 6 tipos diferentes: byte, short, int, long, float e double.

Inteiros

Dentre os tipos que representam números no Java, os números inteiros são representados pelos tipos byte, short, int e long. A diferença entre eles está no tamanho e na capacidade de armazenamento.

byte -> Ocupa um tamanho de 1 bytes (8 bits), 1 bit para o sinal e 7 bits para o número. Ou seja, pode armazenar do número -128 até 127.
short -> Ocupa um tamanho de 2 bytes (16 bits), 1 bit para o sinal e 15 bits para o número. Ou seja, pode armazenar do número -32768 até 32767. O dobro de bytes de armazenamento em relação ao tipo byte.
int -> Ocupa um tamanho de 4 bytes (32 bits), 1 bit para o sinal e 31 bits para o número. Ou seja, pode armazenar do número -2^31 até 2^31 - 1. O dobro de bytes de armazenamento em relação ao tipo short.
long -> Ocupa um tamanho de 8 bytes (64 bits), 1 bit para o sinal e 63 bits para o número. Ou seja, pode armazenar do número -2^63 até 2^63 - 1. O dobro de bytes de armazenamento em relação ao tipo int.

Caso você ultrapasse o limite superior do tipo da variável ela irá voltar o ciclo para o limite inferior dela e vice e versa.

public class Main {
    public static void main(String[] args) {
        byte b = (byte) 127;
        System.out.println("Máximo byte: " + b); // 127
        b++; // ultrapassa o limite somando 1
        System.out.println("Mínimo byte: " + b); // -128

        short s = (short) 32767;
        System.out.println("Máximo short: " + s); // 32767
        s++; // ultrapassa o limite somando 1
        System.out.println("Mínimo short: " + s); // -32768

        int i = 2147483647;
        System.out.println("Máximo int: " + i); // 2147483647
        i++; // ultrapassa o limite somando 1
        System.out.println("Mínimo int: " + i); // -2147483648

        long l = 9223372036854775807L;
        System.out.println("Máximo long: " + l); // 9223372036854775807
        l++; // ultrapassa o limite somando 1
        System.out.println("Mínimo long: " + l); // -9223372036854775808
    }
}

Ponto flutuante

Caso você precise armazenar números com casas decimais, ponto flutuante, o java oferece os tipos float e double.

float -> Ocupa um tamanho de 4 bytes (32 bits), 1 bit de sinal, 8 bits para o expoente (número antes da vírgula) e 23 bits para o decimal (parte depois da vírgula.
double -> Ocupa um tamanho de 8 bytes (64 bits), 1 bit de sinal, 11 bits para o expoente (número antes da vírgula) e 52 bits para o decimal (parte depois da vírgula.

public class Main {
    public static void main(String[] args) {
        float f = Float.MAX_VALUE;

        System.out.println("Máximo float: " + f); // 3.4028235E38

        f = Float.MAX_EXPONENT;
        System.out.println("Máximo exponente float: " + f); // 1.7976931348623157E308

        f = Float.MIN_VALUE;
        System.out.println("Mínimo float: " + f); // 127.0

        f = Float.MIN_EXPONENT;
        System.out.println("Mínimo exponente float: " + f); // -126.0

        double d = Double.MAX_VALUE;

        System.out.println("Máximo double: " + d); // 1.7976931348623157E308

        d = Double.MAX_EXPONENT;
        System.out.println("Máximo exponente double: " + d); // 1023.0

        d = Double.MIN_VALUE;
        System.out.println("Mínimo double: " + d); // 4.9E-324

        d = Double.MIN_EXPONENT;
        System.out.println("Mínimo exponente double: " + d); // -1022.0
    }
}

Booleanos

Para representar expressões booleanas, expressões que geram valores verdadeiro ou falso, existe o tipo boolean. Esse tipo ocupa o tamanho de 1 bit.

public class Main {
    public static void main(String[] args) {
        // valor booleano
        boolean condition = true;

        System.out.println(condition); // true;

        condition = false;
        System.out.println(condition); // false;

        // expressão booleana. Gera um valor booleano
        condition = 10 > 5;
        System.out.println(condition); // true;

        condition = 10 < 5;
        System.out.println(condition); // false;
    }
}

Caracteres

O último tipo primitivo do java é o char esse tipo é usado para armazenar um único caractere. Esse tipo ocupa um valor de 2 bytes (16 bits).

O char pode receber valor como um caracter entre aspas simples ou como o código numérico da tabela ASCII

public class Main {
    public static void main(String[] args) {
        char c = 'a';
        System.out.println("Caracter: " + c); // a

        c = 77; // código da letra 'M' em ASCII
        System.out.println("Caracter: " + c); // M
    }
}

Funções Geradoras e Geradoras Assíncronas em Javascript

Matheus de Gondra — Mon, 28 Jul 2025 16:36:56 +0000

Vou explicar e mostrar como usar funções geradoras e geradoras assíncronas no javascript. Mas, eu preciso explicar outras funcionalidades antes.

Iteradores

Um iterador (iterator) é um objeto que sabe como acessar uma coleção de dados, um por vez.

Criando um Iterador

Para criar um iterador você precisa que o objeto siga o protocolo iterator, ou seja, ele precisa ter um método next. Esse método deve retorna um objeto com as propriedades value, que terá o valor a ser acessado, e done que irá indicar se os dados acabaram.

const makeIterator = (array) => {
    let nextIndex = 0;

    const iterator = {
        // Implementado protocolo iterator
        next() {
            if (nextIndex < array.length) {
                return {
                    value: array[nextIndex++],
                    done: false
                }
            }

            return { done: true }
        }
    }

    return iterator;
}

A função makeIterator irá criar receber um array e irá retornar um iterador, objeto com o método next, para acessar os dados desse array.

Os dados podem ser acessados chamando o método next. Quando os dados acabarem você receberá um objeto com { done: true }

const array = [1, 2, 3, 4, 5];
const iterator = makeIterator(array);

console.log(iterator.next()); // { value: 1, done: false }
console.log(iterator.next()); // { value: 2, done: false }
console.log(iterator.next()); // { value: 3, done: false }
console.log(iterator.next()); // { value: 4, done: false }
console.log(iterator.next()); // { value: 5, done: false }
console.log(iterator.next()); // { done: true }
// Não há mais valores para iterar

Um iterador pode ser acessado mais facilmente através de laços de repetição como while, do...while, for.

{
    const array = [1, 2, 3, 4, 5];
    const iterator = makeIterator(array);

    console.log("while");
    let result = iterator.next();
    while (result.done === false) {
        console.log(result);
        result = iterator.next();
    }
}

{
    const array = [1, 2, 3, 4, 5];
    const iterator = makeIterator(array);

    console.log("do while")
    let result = iterator.next();
    do {
        console.log(result);
        result = iterator.next();
    } while (result.done === false);
}

{
    const array = [1, 2, 3, 4, 5];
    const iterator = makeIterator(array);

    console.log("for")
    for (let result = iterator.next(); result.done === false; result = iterator.next()) {
        console.log(result);
    }
}

Iterador assíncrono

Para dados assíncronos existe o iterador assíncrono que também possui o método next no seu protocolo, mas agora retorna uma Promise

const makeAsyncIterator = (array) => {
    let nextIndex = 0;

    const iterator = {
        // Ao criar um função com async ela já retorna um Promise por padrão
        async next() {
            if (nextIndex < array.length) {
                return {
                    value: array[nextIndex++],
                    done: false
                }
            }

            return { done: true }
        }
    }

    return iterator;
}

const array = [1, 2, 3, 4];
const asyncIterator = makeAsyncIterator(array);

const run = async () => {
    console.log(await asyncIterator.next()); // { value: 1, done: false }
    console.log(await asyncIterator.next()); // { value: 2, done: false }
    console.log(await asyncIterator.next()); // { value: 3, done: false }
    console.log(await asyncIterator.next()); // { value: 4, done: false }
    console.log(await asyncIterator.next()); // { done: true }
}

run()

Iteráveis

Um objeto é iterável (iterable) se ele tem o comportamento de iteração. objetos como Array, Map, TypedArray, Set, String, e aqueles que podem ser acessados com o loop for...of são iteráveis.

Criando um Iterável

Para criar um iterável o objeto precisa implementar o protocolo iterable. Para isso é preciso criar o método [Symbol.iterator]() que retorna um iterador (iterator).

Vamos modificar a nossa função makeIterator para o objeto itarador ser um iteravel também.

const makeIterator = (array) => {
    let nextIndex = 0;

    const iterator = {
        next() {
            if (nextIndex < array.length) {
                return {
                    value: array[nextIndex++],
                    done: false
                }
            }

            return { done: true }
        },
        // Implementando o protocolo iterable
        [Symbol.iterator]() {
            // precisamos retornar um iterator
            // então vamos retornar o próprio objeto
            return this;
        }
    }

    return iterator;
}

Agora nossa função retorna um objeto que é um iterador, implementa o protocolo iterator com o método next(), e um iteravel, implementa o protocolo iterable com o método [Symbol.iterator]().

Com um iteravel podemos percorrer ele em um loop for...of. Ou mesmo espalhar seus valores usando o spread operator (...).

{
    const array = ["Ana", "Matheus", "Gabriel", "Larissa", "João"];
    const iterator = makeIterator(array);

    console.log("for of")
    for (const value of iterator) {
        console.log(value);
        // Matheus
        // Ana
        // Gabriel
        // Larissa
        // João
    }
}

{
    const array = [{ id: 1 }, { id: 2 }, { id: 3 }, { id: 4 }, { id: 5 }];
    const iterator = makeIterator(array);

    console.log("spread operator")
    console.log([...iterator]);
    // [ { id: 1 }, { id: 2 }, { id: 3 }, { id: 4 }, { id: 5 } ]
}

Iterável assíncrono

Para dados assíncronos também temos o iterável assíncrono que segue o protocolo async iterable através do método [Symbol.asyncIterable]() que retorna um iterador assíncrono.

const makeAsyncIterator = (array) => {
    let nextIndex = 0;

    const iterator = {
        async next() {
            if (nextIndex < array.length) {
                return {
                    value: array[nextIndex++],
                    done: false
                }
            }

            return { done: true }
        },
        // Implementando o protocolo async iterable
        [Symbol.asyncIterator]() {
            // precisamos retornar um async iterator
            // então vamos retornar o próprio objeto
            return this;
        }
    }

    return iterator;
}

const array = [1, 2, 3, 4];
const asyncIterator = makeAsyncIterator(array);

const run = async () => {
    // Para iteráveis assíncronos usamos o for await...of
    for await (const value of asyncIterator) {
        console.log(value);
        // 1
        // 2
        // 3
        // 4
    }
};

run();

Função Geradora

Funções geradoras são um tipo especial de função. Elas retornar um objeto Generator que uma subclasse de Iterator. Basicamente a função retorna um objeto iterador que também implementa o protocolo iteravel. É uma forma mais fácil de criar um objeto itarador/iteravel. Ou seja, o objeto da classe Generator possui os métodos next() e [Symbom.iterator]().

Para criar uma função geradora é simples, basta usar a sintaxe function* e retornar os valores usando a palavra yield.

function* makeGenerator() {
    let value = 1;

    while (true) {
        // retorna o valor atual e incrementa 1
        yield value++;

        if (value >= 5) {
            // quando o valor atingir 5, a função geradora termina
            return;
        }
    }
}

Agora podemos criar um objeto Generator e usa-lo como iterador/iterável.

{
    const generator = makeGenerator();

    console.log(generator.next()); // { value: 1, done: false }
    console.log(generator.next()); // { value: 2, done: false }
    console.log(generator.next()); // { value: 3, done: false }
    console.log(generator.next()); // { value: 4, done: false }
    console.log(generator.next()); // { value: undefined, done: true }
}

{
    const generator = makeGenerator();
    const data = [...generator];
    console.log(data); // [ 1, 2, 3, 4 ]
}

{
    const generator = makeGenerator();
    for (const value of generator) {
        console.log(value);
        // 1
        // 2
        // 3
        // 4
    }
}

Exemplo de uso

Com a função geradora podemos gerar dados sobre demanda. Um uso simples da função geradora para criar a função de fibonacci.

function* fibonacci() {
  let a = 0;
  let b = 1;
  while (true) { // Sequência infinita
    yield a;
    [a, b] = [b, a + b];
  }
}

const fib = fibonacci();
console.log(fib.next().value); // 0
console.log(fib.next().value); // 1
console.log(fib.next().value); // 1
console.log(fib.next().value); // 2
console.log(fib.next().value); // 3
// ... e assim por diante, gerando valores apenas quando solicitados

Função Geradora Assíncrona

Se precisarmos trabalhar com dados assíncronos sob demanda, podemos usar a função geradora assíncrona. Assim como a função geradora sincrona, a assíncrona retorna valores sob demanda através do yield, só que dessa vez ela retorna uma Promise.

async function* makeAsyncGenerator() {
    let value = 1;

    while (true) {
        yield value++;

        if (value >= 5) {
            return;
        }
    }
}

E assim para consumir os dados é só chamar a função next que ela irá retorna uma Promise com o valor.

const run = async () => {
    const asyncGenerator = makeAsyncGenerator();

    console.log(await asyncGenerator.next()); // { value: 1, done: false }
    console.log(await asyncGenerator.next()); // { value: 2, done: false }
    console.log(await asyncGenerator.next()); // { value: 3, done: false }
    console.log(await asyncGenerator.next()); // { value: 4, done: false }
    console.log(await asyncGenerator.next()); // { value: undefined, done: true }
}

run();

Exemplo de uso

Um caso de uso interessante de geradores assíncronos é na manipulação de streams de dados no NodeJS. Onde você pode criar um gerador para transformar os dados dentro de um pipeline.

nomes.txt

Ana Silva
Carlos Oliveira
Mariana Santos
Pedro Almeida
Juliana Costa
Rafael Pereira
Camila Rodrigues
Bruno Fernandes
Larissa Martins
Diego Nascimento
Beatriz Lima
Gustavo Barbosa
Isabela Carvalho
Leonardo Souza
Fernanda Ribeiro
Thiago Cardoso
Natália Gomes
Alexandre Torres
Priscila

index.mjs

import { createReadStream } from "node:fs";
import { pipeline } from "node:stream/promises";

async function* asyncGenerator(stream) {
    // consumindo dados da stream
    for await (const chunk of stream) {
        const name = chunk.toString();

        // transformando o nome para maiúsculas
        const nameUpperCase = name.toUpperCase();

        // enviando o nome transformado para a próxima etapa do pipeline sob demanda
        yield nameUpperCase;
    }
}

const run = async () => {
    // Cria uma stream para ler os dados do arquivo nomes.txt
    const stream = createReadStream("nomes.txt", { encoding: "utf-8" });

    /**
     * pipeline é uma função que conecta uma série de streams
     * os dados são lidos da variavel stream
     * e mandando para a função geradora asyncGenerator
     * que transforma os dados e envia para a saída padrão (process.stdout)
     */
    await pipeline(
        stream,
        asyncGenerator,
        process.stdout
    );
};

run();

saída

> node index.mjs
ANA SILVA
CARLOS OLIVEIRA
MARIANA SANTOS
PEDRO ALMEIDA
JULIANA COSTA
RAFAEL PEREIRA
CAMILA RODRIGUES
BRUNO FERNANDES
LARISSA MARTINS
DIEGO NASCIMENTO
BEATRIZ LIMA
GUSTAVO BARBOSA
ISABELA CARVALHO
LEONARDO SOUZA
FERNANDA RIBEIRO
THIAGO CARDOSO
NATÁLIA GOMES
ALEXANDRE TORRES
PRISCILA

Validação de dados com Javascript

Matheus de Gondra — Thu, 30 Jan 2025 20:53:41 +0000

Introdução

Ao criar uma aplicação que recebe dados externos, seja através de um formulário, API ou CLI, é fundamental validar as informações. Afinal, não se pode esperar que os usuários sempre enviem os dados no formato esperado. Por isso, deve haver uma camada de validação para evitar erros e garantir que as informações recebidas estejam corretas.

Solução Nativa

Uma das formas de validar os dados é usando a própria linguagem para criar validações personalizadas.

Você pode criar classes específicas para cada tipo de validação presente na aplicação:

class IntegerValidation {
    #fieldName;

    constructor(fieldName) {
        this.#fieldName = fieldName;
    }

    validate(obj) {
        const field = Number(obj[this.#fieldName]);
        if (!Number.isInteger(field)) {
            return new Error(`O campo ${this.#fieldName} deve ser um inteiro.`);
        }
    }
}

const input = { "age": 10.3 };
const ageValidation = new IntegerValidation("age");

const error = ageValidation.validate(input);
if (error) {
    // Error: O campo age deve ser um inteiro.
    return res.status(400).json({ error: error.message });
}

// Se chegar aqui, a validação funcionou e os dados estão corretos.
return res.status(200).json({ message: "ok" });

Essa abordagem permite que você tenha total controle sobre as validações e possa reutilizá-las facilmente. Além disso, é possível criar um objeto composto de várias validações, facilitando a manutenção ao adicionar ou remover regras conforme necessário:

class ValidationComposite {
    #validations = [];

    constructor(validations) {
        this.#validations = validations;
    }

    validate(obj) {
        for (const validation of this.#validations) {
            const error = validation.validate(obj);
            if (error) {
                return error;
            }
        }
    }
}

const validations = [
    new RequiredField("name"),
    new RequiredField("age"),
    new RequiredField("password"),
    new IntegerValidation("age"),
    new NameValidation("name"),
    new PasswordValidation("password")
];
const validationComposite = new ValidationComposite(validations);
const input = {
    name: "Fulano",
    age: 24,
    password: "Senha@1234"
};

const error = validationComposite.validate(input);
if (error) {
    return res.status(404).json(error);
}

return res.status(200).json({ message: "ok" });

A desvantagem dessa abordagem é que você precisaria escrever manualmente todas as classes de validação, o que pode demandar tempo.

Uso de Bibliotecas

Se criar as validações do zero for trabalhoso demais, você pode utilizar bibliotecas que já fazem esse trabalho. Algumas das principais bibliotecas de validação em JavaScript são:

A sintaxe de uso dessas bibliotecas é bastante semelhante. Veja um exemplo utilizando Joi:

const Joi = require("joi"); 

const schema = Joi.object({
    name: Joi.string().min(3).required(),
    age: Joi.number().integer().min(18).required(),
    password: Joi.string().pattern(new RegExp('^[a-zA-Z0-9]{3,30}$')).required()
});

const input = {
    name: "Fulano",
    age: 24,
    password: "Senha@1234"
};

const result = schema.validate(input);
if (result.error) {
    return res.status(400).json({ error: result.error.details });
}

// Se a validação for bem-sucedida, os dados estarão em result.value
return res.status(200).json(result.value);

Conclusão

Independentemente da abordagem escolhida, o importante é garantir que sua aplicação valide adequadamente os dados recebidos, evitando problemas e melhorando a experiência do usuário final.

Comandos básicos do Terminal - Parte 2

Matheus de Gondra — Sat, 02 Sep 2023 16:46:26 +0000

Bom dia, boa tarde ou boa noite! Hoje vou trazer mais comandos do terminal para você não ter mais medo da "telinha preta". Caso você não tenha visto a primeira parte você pode dar uma olhada antes: Comandos básicos do terminal.

Remover diretórios
Escrever no terminal
Criar arquivos
Ler arquivos
Conclusão

Remover diretórios

No primeiro post trouxe muito comandos de manipulação de diretórios. Mas, um comando que não falei antes foi o comando para deletar diretórios.

Para essa tarefa temos o rmdir, remove directory ou remover diretório, em português. Seu uso é simples, apenas precisa dizer qual o diretório que deseja remover.

Temos dois diretórios, dir1 e dir2. O primeiro está vazio, já o segundo tem outro diretório dentro dele.

Windows

Linux

Vamos tentar apagar os dois usando o comando rmdir.

Windows

Linux

Podemos ver que o primeiro direitório, dir1, foi apagado sem problemas, mas o diretório dir2 não foi apagado e temos um erro avisando que o diretório não está vazio.

O comando rmdir só funciona para diretórios vazios. Se houver algum arquivo ou subdiretórios dentro do diretório que você deseja deletar o comando não funcionará.

Mas, caso você queira apagar um diretório que não está vazio você pode usar no Linux o comando rm com a flag r. Essa flag significa que o comando vai apagar tudo recursivamente.

Linux

No Windows para apagar diretórios que não estão vazios ainda usamos o rmdir, mas passamos a opção /S. O terminal irá perguntar se você tem certeza dessa ação e você pode responder s para sim e n para não. Se quiser pular essa confirmação você pode usar a opção /Q na hora de executar o comando.

Windows

Escrever no terminal

Para escrever algo no terminal podemos usar o comando echo. O que você passa para o comando irá aparecer no terminal logo em seguida.

Windows

Linux

Criar arquivos

Uma das formas que você pode criar arquivos pelo terminal é redirecionar a saída de um comando para um arquivo usando o > ou >>. O > irá criar um novo arquivo caso não exista, se o arquivo existir ele irá sobrescrever. Já o >> irá criar um novo arquivo caso não existe e se existir irá escrever no final dele.

Vamos usar o comando echo para escrever algo e salvar em um arquivo .txt.

Windows

Linux

Uma outra forma de criar arquivos no Linux é o comando touch. Basta dizer os arquivos que deseja criar e serão criado os arquivos sem conteúdo.

Ler arquivos

Para ler o conteúdo de um arquivo no Windows podemos usar o comando type. Esse comando lê o conteúdo de um arquivo e exibe no terminal. Vamos ler o arquivo.txt que criamos antes.

Windows

No Linux podemos usar o comando cat para ler um arquivo. E assim como o type no Windows o conteúdo do arquivo será exibido logo em seguida.

Linux

Conclusão

Bem chegamos ao fim desse post. Espero que eu tenha te ajudado a aprender um pouco mais sobre terminal. Eu fico por aqui e desejo boa sorte na sua jornada de aprendizado!