DEV Community

Cover image for JLScript: Guia Completo da Sintaxe, do Básico ao Avançado
JLScript
JLScript

Posted on Edited on

JLScript: Guia Completo da Sintaxe, do Básico ao Avançado

JLScript 4.2.0

Do básico ao avançado

Um guia para aprender a linguagem entendendo o código, não apenas decorando sintaxe.

Variáveis · lógica · funções · coleções · arquivos · APIs · UI · Style · projetos reais


Antes de começar

JLScript, ou simplesmente JLS, é uma linguagem criada para ter uma sintaxe direta e legível, principalmente para quem está começando a programar, sem limitar quem quiser construir projetos maiores depois.

Os arquivos utilizam:

.jls
Enter fullscreen mode Exit fullscreen mode

Um programa pode ser tão simples quanto:

mostrar("Olá, mundo!")
Enter fullscreen mode Exit fullscreen mode

ou crescer até trabalhar com:

arquivos
APIs
JSON
banco de dados
terminal
processos
automação
interfaces
testes
rede
Enter fullscreen mode Exit fullscreen mode

Este guia começa do zero.

Não existe problema nenhum em nunca ter programado antes.

Também não existe necessidade de decorar tudo que aparece aqui.

A ideia é entender uma coisa por vez e começar a perceber como elas se conectam.


1. Seu primeiro programa

Existe uma tradição quase universal entre programadores: fazer o computador escrever "Olá, mundo!".

Em JLScript:

mostrar("Olá, mundo!")
Enter fullscreen mode Exit fullscreen mode

mostrar() envia um valor para a saída do programa.

Podemos executar mais de uma instrução:

mostrar("Olá!")
mostrar("Estou aprendendo JLScript")
mostrar("Meu primeiro programa está funcionando")
Enter fullscreen mode Exit fullscreen mode

Resultado:

Olá!
Estou aprendendo JLScript
Meu primeiro programa está funcionando
Enter fullscreen mode Exit fullscreen mode

A execução acontece de cima para baixo.

mostrar("Primeiro")
mostrar("Segundo")
mostrar("Terceiro")
Enter fullscreen mode Exit fullscreen mode

O programa não tenta adivinhar sua intenção.

Ele executa as instruções na ordem em que foram escritas.


2. Comentários

Comentários servem para explicar alguma parte do código sem executá-la.

// Este texto não será executado

mostrar("Olá")
Enter fullscreen mode Exit fullscreen mode

Evite comentários óbvios:

// Cria uma variável chamada idade
va idade = 20
Enter fullscreen mode Exit fullscreen mode

O próprio código já diz isso.

Comentários são mais úteis quando explicam por que alguma decisão existe:

// A API aceita no máximo 100 resultados por requisição.
va limite = 100
Enter fullscreen mode Exit fullscreen mode

3. Variáveis

Variáveis guardam valores.

va nome = "Lucas"
Enter fullscreen mode Exit fullscreen mode

Agora nome representa:

Lucas
Enter fullscreen mode Exit fullscreen mode

Então:

mostrar(nome)
Enter fullscreen mode Exit fullscreen mode

exibe:

Lucas
Enter fullscreen mode Exit fullscreen mode

JLScript possui três formas oficiais de declaração:

va nome = "Lucas"
let idade = 20
ins ativo = true
Enter fullscreen mode Exit fullscreen mode

Na versão atual da linguagem, elas fazem parte do mesmo sistema básico de declaração.

Para projetos escritos principalmente em português, usar va como padrão deixa o código mais consistente:

va nome = "Lucas"
va idade = 20
va ativo = true
Enter fullscreen mode Exit fullscreen mode

O mais importante não é ficar alternando entre va, let e ins.

É manter um padrão dentro do projeto.


4. Como escolher nomes

Um nome de variável deve explicar o que existe ali.

Evite:

va x = 20
va a = true
va coisa = "Lucas"
Enter fullscreen mode Exit fullscreen mode

Prefira:

va idade = 20
va usuarioAtivo = true
va nomeUsuario = "Lucas"
Enter fullscreen mode Exit fullscreen mode

Quando o projeto cresce, essa diferença deixa de ser estética e passa a economizar bastante tempo.


5. Valores básicos

Texto

va linguagem = "JLScript"
Enter fullscreen mode Exit fullscreen mode

Número inteiro

va idade = 20
Enter fullscreen mode Exit fullscreen mode

Número decimal

va preco = 19.90
Enter fullscreen mode Exit fullscreen mode

Booleano

va online = true
va bloqueado = false
Enter fullscreen mode Exit fullscreen mode

Booleanos representam normalmente uma resposta de:

sim / não
ligado / desligado
verdadeiro / falso
Enter fullscreen mode Exit fullscreen mode

Valor vazio

va resultado = null
Enter fullscreen mode Exit fullscreen mode

null representa ausência de um valor.


6. Juntando diferentes valores

va nome = "Lucas"
va idade = 20
va programador = true
va projeto = "JLScript"

mostrar(nome)
mostrar(idade)
mostrar(programador)
mostrar(projeto)
Enter fullscreen mode Exit fullscreen mode

Uma variável não precisa guardar apenas texto ou número.

Mais adiante veremos que ela também pode guardar:

lista
objeto
função
requisição
resposta
cor
estilo
conexão
Enter fullscreen mode Exit fullscreen mode

7. Operadores matemáticos

va soma = 10 + 5
va subtracao = 10 - 5
va multiplicacao = 10 * 5
va divisao = 10 / 5
va resto = 10 % 3
Enter fullscreen mode Exit fullscreen mode

Podemos mostrar os resultados:

mostrar(soma)
mostrar(subtracao)
mostrar(multiplicacao)
mostrar(divisao)
mostrar(resto)
Enter fullscreen mode Exit fullscreen mode

8. Incremento e decremento

Incrementar:

va numero = 1

numero++

mostrar(numero)
Enter fullscreen mode Exit fullscreen mode

Resultado:

2
Enter fullscreen mode Exit fullscreen mode

Decrementar:

va numero = 10

numero--

mostrar(numero)
Enter fullscreen mode Exit fullscreen mode

Resultado:

9
Enter fullscreen mode Exit fullscreen mode

Também existem operações acumulativas:

va numero = 10

numero += 5
numero -= 2
numero *= 3
numero /= 2
Enter fullscreen mode Exit fullscreen mode

9. Comparações

Comparações normalmente produzem true ou false.

va idade = 20

mostrar(idade > 18)
mostrar(idade < 18)
mostrar(idade >= 18)
mostrar(idade <= 18)
mostrar(idade == 20)
mostrar(idade != 20)
Enter fullscreen mode Exit fullscreen mode

Principais operadores:

Operador Significado
== igual
!= diferente
> maior
< menor
>= maior ou igual
<= menor ou igual

10. Operadores lógicos

Uma condição pode depender de mais de uma regra.

E

va idade = 20
va autorizado = true

se (idade >= 18 && autorizado) {
    mostrar("Entrada permitida")
}
Enter fullscreen mode Exit fullscreen mode

As duas condições precisam ser verdadeiras.


OU

va admin = false
va moderador = true

se (admin || moderador) {
    mostrar("Acesso permitido")
}
Enter fullscreen mode Exit fullscreen mode

Nesse caso, basta uma condição ser verdadeira.


NÃO

va bloqueado = false

se (!bloqueado) {
    mostrar("Usuário liberado")
}
Enter fullscreen mode Exit fullscreen mode

! inverte um booleano.


11. Condições

Condições permitem que o programa tome decisões.

va idade = 20

se (idade >= 18) {
    mostrar("Você é maior de idade")
}
Enter fullscreen mode Exit fullscreen mode

Com alternativa:

va idade = 16

se (idade >= 18) {
    mostrar("Maior de idade")
} senao {
    mostrar("Menor de idade")
}
Enter fullscreen mode Exit fullscreen mode

12. Português e inglês

JLScript possui aliases em partes da linguagem.

Em português:

se (idade >= 18) {
    mostrar("Adulto")
} senao {
    mostrar("Menor")
}
Enter fullscreen mode Exit fullscreen mode

Em inglês:

if (idade >= 18) {
    mostrar("Adulto")
} else {
    mostrar("Menor")
}
Enter fullscreen mode Exit fullscreen mode

Mantenha o idioma da estrutura consistente.

Evite:

se (idade >= 18) {
    mostrar("Ok")
} else {
    mostrar("Não")
}
Enter fullscreen mode Exit fullscreen mode

Prefira uma das duas formas completas.


13. Várias condições

va nota = 8

se (nota >= 9) {

    mostrar("Excelente")

} senao se (nota >= 7) {

    mostrar("Aprovado")

} senao se (nota >= 5) {

    mostrar("Recuperação")

} senao {

    mostrar("Reprovado")
}
Enter fullscreen mode Exit fullscreen mode

O programa testa as condições na ordem.

Quando encontra uma condição verdadeira, executa aquele bloco.


14. enquanto

Use enquanto quando algo deve continuar acontecendo enquanto uma condição permanecer verdadeira.

va numero = 1

enquanto (numero <= 5) {

    mostrar(numero)

    numero++
}
Enter fullscreen mode Exit fullscreen mode

Resultado:

1
2
3
4
5
Enter fullscreen mode Exit fullscreen mode

Em inglês:

while (numero <= 5) {
    mostrar(numero)
    numero++
}
Enter fullscreen mode Exit fullscreen mode

15. para

Quando sabemos como a repetição deve avançar:

para (va i = 0; i < 10; i++) {
    mostrar(i)
}
Enter fullscreen mode Exit fullscreen mode

Forma inglesa:

for (va i = 0; i < 10; i++) {
    mostrar(i)
}
Enter fullscreen mode Exit fullscreen mode

16. Interrompendo um loop

para (va i = 0; i < 10; i++) {

    se (i == 5) {
        pare
    }

    mostrar(i)
}
Enter fullscreen mode Exit fullscreen mode

Quando i chega em 5, o loop termina.

Alias:

pare / break
Enter fullscreen mode Exit fullscreen mode

17. Pulando uma repetição

para (va i = 0; i < 10; i++) {

    se (i == 5) {
        continuar
    }

    mostrar(i)
}
Enter fullscreen mode Exit fullscreen mode

O 5 não será mostrado, mas o loop continuará.

Alias:

continuar / continue
Enter fullscreen mode Exit fullscreen mode

18. Funções

Funções organizam tarefas que podem ser reutilizadas.

func saudacao() {
    mostrar("Olá!")
}
Enter fullscreen mode Exit fullscreen mode

Chamando:

saudacao()
Enter fullscreen mode Exit fullscreen mode

19. Parâmetros

func saudacao(nome) {
    mostrar("Olá, " + nome)
}

saudacao("Lucas")
Enter fullscreen mode Exit fullscreen mode

nome recebe o valor enviado na chamada.


20. Retorno

Uma função pode devolver um resultado:

func soma(a, b) {
    retorne a + b
}
Enter fullscreen mode Exit fullscreen mode

Depois:

va resultado = soma(10, 5)

mostrar(resultado)
Enter fullscreen mode Exit fullscreen mode

Resultado:

15
Enter fullscreen mode Exit fullscreen mode

21. Parâmetros padrão

func saudacao(nome = "Mundo") {
    mostrar("Olá, " + nome)
}
Enter fullscreen mode Exit fullscreen mode

Sem argumento:

saudacao()
Enter fullscreen mode Exit fullscreen mode

Resultado:

Olá, Mundo
Enter fullscreen mode Exit fullscreen mode

Com argumento:

saudacao("Lucas")
Enter fullscreen mode Exit fullscreen mode

Resultado:

Olá, Lucas
Enter fullscreen mode Exit fullscreen mode

22. Argumentos nomeados

Em chamadas maiores, podemos deixar claro o significado de cada valor.

func criarUsuario(nome, idade, ativo = true) {
    mostrar(nome)
    mostrar(idade)
    mostrar(ativo)
}
Enter fullscreen mode Exit fullscreen mode

Chamada comum:

criarUsuario("Lucas", 20, true)
Enter fullscreen mode Exit fullscreen mode

Chamada nomeada:

criarUsuario(
    nome = "Lucas",
    idade = 20,
    ativo = true
)
Enter fullscreen mode Exit fullscreen mode

Em funções com muitos parâmetros, a segunda forma costuma ser muito mais fácil de ler.


23. Funções anônimas

Uma função também pode ser guardada em uma variável.

va dobro = func(numero) {
    retorne numero * 2
}

mostrar(dobro(10))
Enter fullscreen mode Exit fullscreen mode

Resultado:

20
Enter fullscreen mode Exit fullscreen mode

Essas funções são particularmente úteis em callbacks.


24. Escopo

Uma variável criada dentro de uma função pertence àquele contexto.

func calcular() {

    va resultado = 10 + 5

    mostrar(resultado)
}
Enter fullscreen mode Exit fullscreen mode

resultado foi criado dentro da função.

Isso ajuda a evitar que todas as variáveis do programa fiquem misturadas.

Quanto maior o projeto, mais importante o conceito de escopo se torna.


25. Listas

Uma lista guarda vários valores.

va linguagens = [
    "JLScript",
    "Python",
    "JavaScript"
]
Enter fullscreen mode Exit fullscreen mode

Também podemos guardar números:

va numeros = [
    10,
    20,
    30,
    40
]
Enter fullscreen mode Exit fullscreen mode

Ou objetos:

va usuarios = [
    {
        nome: "Lucas",
        ativo: true
    },
    {
        nome: "Ana",
        ativo: false
    }
]
Enter fullscreen mode Exit fullscreen mode

26. Trabalhando com listas

Adicionar:

linguagens.adicionar("C++")
Enter fullscreen mode Exit fullscreen mode

Tamanho:

mostrar(linguagens.tamanho())
Enter fullscreen mode Exit fullscreen mode

Verificar:

mostrar(
    linguagens.contem("JLScript")
)
Enter fullscreen mode Exit fullscreen mode

Primeiro elemento:

mostrar(
    linguagens.primeiro()
)
Enter fullscreen mode Exit fullscreen mode

Último:

mostrar(
    linguagens.ultimo()
)
Enter fullscreen mode Exit fullscreen mode

27. Mapear

mapear() transforma os elementos.

va numeros = [1, 2, 3, 4]

va dobrados = numeros.mapear(
    func(numero) {
        retorne numero * 2
    }
)

mostrar(dobrados)
Enter fullscreen mode Exit fullscreen mode

Resultado:

[2, 4, 6, 8]
Enter fullscreen mode Exit fullscreen mode

28. Filtrar

va numeros = [1, 2, 3, 4, 5, 6]

va pares = numeros.filtrar(
    func(numero) {
        retorne numero % 2 == 0
    }
)

mostrar(pares)
Enter fullscreen mode Exit fullscreen mode

29. Reduzir

va numeros = [1, 2, 3, 4]

va total = numeros.reduzir(
    func(acumulador, numero) {
        retorne acumulador + numero
    },
    0
)

mostrar(total)
Enter fullscreen mode Exit fullscreen mode

Resultado:

10
Enter fullscreen mode Exit fullscreen mode

Esses três métodos aparecem bastante em programas que trabalham com dados:

mapear
filtrar
reduzir
Enter fullscreen mode Exit fullscreen mode

Não use porque parece “mais avançado”.

Use quando deixa a intenção do código mais clara.


30. Objetos

Objetos agrupam informações relacionadas.

va usuario = {
    nome: "Lucas",
    idade: 20,
    programador: true
}
Enter fullscreen mode Exit fullscreen mode

Acessando:

mostrar(usuario.nome)
mostrar(usuario.idade)
Enter fullscreen mode Exit fullscreen mode

Alterando:

usuario.nome = "Pedro"
Enter fullscreen mode Exit fullscreen mode

Objetos ajudam a evitar dezenas de variáveis soltas para representar uma única coisa.


31. Escolha múltipla

Quando temos opções bem definidas:

va opcao = 2

escolha (opcao) {

    caso 1 {
        mostrar("Cadastrar")
    }

    caso 2 {
        mostrar("Entrar")
    }

    caso 3 {
        mostrar("Sair")
    }

    padrao {
        mostrar("Opção inválida")
    }
}
Enter fullscreen mode Exit fullscreen mode

Forma inglesa:

switch (opcao) {

    case 1 {
        mostrar("Cadastrar")
    }

    case 2 {
        mostrar("Entrar")
    }

    default {
        mostrar("Opção inválida")
    }
}
Enter fullscreen mode Exit fullscreen mode

32. Tratamento de erros

Programas reais falham.

Um arquivo pode não existir.

Uma API pode ficar fora do ar.

Um usuário pode digitar algo completamente inesperado, porque aparentemente esse é um recurso nativo da espécie humana.

JLScript possui tratamento de erros.

tenta {

    mostrar("Executando operação")

} pegar (falha) {

    mostrar(falha.mensagem)
}
Enter fullscreen mode Exit fullscreen mode

Também existem aliases compatíveis com estruturas anteriores da linguagem.


33. fim

Um bloco pode ser executado independentemente do resultado:

tenta {

    mostrar("Executando")

} pegar (falha) {

    mostrar("Erro encontrado")

} fim {

    mostrar("Processo finalizado")
}
Enter fullscreen mode Exit fullscreen mode

Isso é útil para:

fechar conexão
liberar recurso
encerrar operação
registrar finalização
Enter fullscreen mode Exit fullscreen mode

34. Não esconda erros

Evite:

tenta {

    operacao()

} pegar (erro) {

    mostrar("erro")
}
Enter fullscreen mode Exit fullscreen mode

Você acabou de jogar fora justamente a informação que poderia explicar o problema.

Melhor:

tenta {

    operacao()

} pegar (erro) {

    mostrar(
        "A operação falhou: "
        + erro.mensagem
    )
}
Enter fullscreen mode Exit fullscreen mode

35. Bibliotecas

Recursos maiores podem ser organizados em módulos.

import #math
Enter fullscreen mode Exit fullscreen mode

Mais de um:

import [
    #math,
    #json,
    #fs
]
Enter fullscreen mode Exit fullscreen mode

36. Alias de biblioteca

import #database como db
Enter fullscreen mode Exit fullscreen mode

Agora:

db.
Enter fullscreen mode Exit fullscreen mode

representa #database.

Forma alternativa:

import #database as db
Enter fullscreen mode Exit fullscreen mode

Aliases deixam o código menor sem perder contexto.


37. Core e bibliotecas

Nem tudo precisa de import.

Recursos comuns podem fazer parte do Core.

Exemplo:

mostrar("Olá")
Enter fullscreen mode Exit fullscreen mode

Já recursos especializados normalmente entram por módulos:

import #math
import #database
import #ui
Enter fullscreen mode Exit fullscreen mode

A ideia é não obrigar o programador a importar meia linguagem para fazer uma tarefa simples.


38. Tempo

JLScript possui uma sintaxe voltada para durações.

esperar(2 segundos)
Enter fullscreen mode Exit fullscreen mode

Outros exemplos:

esperar(500 ms)

esperar(1 segundo)

esperar(2 minutos)

esperar(1 hora)
Enter fullscreen mode Exit fullscreen mode

Isso deixa a intenção mais clara do que obrigar alguém a lembrar quantos milissegundos existem em tudo.


39. Tempo atual

va agora = tempo.agora()

mostrar(agora)
Enter fullscreen mode Exit fullscreen mode

40. Executar depois

tempo.depois(
    2 segundos,

    func() {
        mostrar(
            "Executado depois de 2 segundos"
        )
    }
)
Enter fullscreen mode Exit fullscreen mode

Aqui usamos uma função anônima como callback.


41. Execução repetida

va timer = tempo.cada(
    1 segundo,

    func() {
        mostrar("tick")
    }
)
Enter fullscreen mode Exit fullscreen mode

Timers são úteis, mas devem ser usados com cuidado.

Não crie dezenas deles quando um único fluxo poderia resolver o problema.


42. Código assíncrono

Operações como rede podem levar tempo.

JLScript possui um fluxo assíncrono próprio.

fluxo func carregar() {

    va resultado = aguarda algumaOperacao()

    mostrar(resultado)
}
Enter fullscreen mode Exit fullscreen mode

Palavras principais:

fluxo
aguarda
tenta
pegar
fim
lanca
Enter fullscreen mode Exit fullscreen mode

43. Consumindo uma API

O cliente HTTP pode ser usado de forma nativa.

va backend = api(
    "https://api.exemplo.com"
)
Enter fullscreen mode Exit fullscreen mode

Agora podemos realizar:

GET
POST
PUT
PATCH
DELETE
Enter fullscreen mode Exit fullscreen mode

44. GET

fluxo func carregarUsuarios() {

    tenta {

        va res = aguarda api.get(
            "https://api.exemplo.com/usuarios"
        )

        se (!res.ok) {

            lanca erro(
                "HTTP " + str(res.status)
            )
        }

        mostrar(res.dados)

    } pegar (falha) {

        mostrar(falha.mensagem)
    }
}

carregarUsuarios()
Enter fullscreen mode Exit fullscreen mode

45. POST

fluxo func criarUsuario() {

    va usuarios = api(
        "https://api.exemplo.com/usuarios"
    )

    tenta {

        va res = aguarda usuarios.post({
            nome: "Lucas",
            idade: 20
        })

        se (!res.ok) {
            lanca erro(
                "HTTP " + str(res.status)
            )
        }

        mostrar(res.dados)

    } pegar (falha) {

        mostrar(falha.mensagem)
    }
}

criarUsuario()
Enter fullscreen mode Exit fullscreen mode

46. Resposta HTTP

Uma resposta possui informações importantes.

mostrar(res.status)
mostrar(res.ok)
mostrar(res.headers)
mostrar(res.dados)
Enter fullscreen mode Exit fullscreen mode

Não trate toda resposta diferente de 200 como se a internet tivesse explodido.

Um 404 ainda é uma resposta HTTP.

Uma falha de DNS, timeout ou conexão é outro tipo de problema.

Essa diferença importa.


47. Criando uma API

Para criar servidor, utilizamos #api.

import #api

va app = api.servidor({
    host: "127.0.0.1",
    port: 3000
})
Enter fullscreen mode Exit fullscreen mode

Criando rota:

app.get("/", func(req, res) {

    res.json({
        linguagem: "JLScript",
        status: "online"
    })
})
Enter fullscreen mode Exit fullscreen mode

Iniciando:

app.iniciar()
Enter fullscreen mode Exit fullscreen mode

48. GET com parâmetro

app.get(
    "/usuarios/:id",

    func(req, res) {

        va id = req.param("id")

        res.json({
            id: id
        })
    }
)
Enter fullscreen mode Exit fullscreen mode

49. POST no servidor

app.post(
    "/usuarios",

    func(req, res) {

        va usuario = req.json()

        res.status(201)

        res.json({
            criado: true,
            usuario: usuario
        })
    }
)
Enter fullscreen mode Exit fullscreen mode

50. Banco de dados

import #database como db

va banco = db.sqlite(
    "app.db"
)
Enter fullscreen mode Exit fullscreen mode

Criando uma tabela:

banco.executar(
    "CREATE TABLE usuarios (
        id INTEGER PRIMARY KEY,
        nome TEXT
    )"
)
Enter fullscreen mode Exit fullscreen mode

Quando o projeto cresce, não espalhe SQL aleatoriamente pelo código.

Centralize operações relacionadas ao banco.


51. Arquivos

Operações básicas podem ser simples:

arquivo.escrever(
    "dados.txt",
    "Olá JLScript"
)
Enter fullscreen mode Exit fullscreen mode

Lendo:

va conteudo = arquivo.ler(
    "dados.txt"
)

mostrar(conteudo)
Enter fullscreen mode Exit fullscreen mode

Verificando:

se (arquivo.existe("dados.txt")) {
    mostrar("Arquivo encontrado")
}
Enter fullscreen mode Exit fullscreen mode

Para filesystem mais avançado, utilize #fs.


52. Criando interfaces

import [
    #ui,
    #style
]
Enter fullscreen mode Exit fullscreen mode

Janela:

va app = ui.janela()

app.titulo(
    "Meu aplicativo"
)
Enter fullscreen mode Exit fullscreen mode

53. Estrutura da UI

app.ui({

    main(class="app") {

        h1("Bem-vindo")

        p(
            "Aplicação criada com JLScript"
        )

        button(
            class="acao"
        ) {
            text = "Entrar"
        }
    }
})
Enter fullscreen mode Exit fullscreen mode

A UI utiliza uma estrutura declarativa.

Você descreve o que existe na interface.

O renderer cuida da apresentação.


54. Body automático

Uma janela possui uma raiz de documento.

Você não precisa criar manualmente um body para cada interface.

Conceitualmente:

Janela
└── Documento
    └── Body
        └── elementos
Enter fullscreen mode Exit fullscreen mode

Isso deixa os arquivos menores e evita repetição desnecessária.


55. Style V3

#style não existe apenas para UI.

Ele está se tornando o sistema geral de apresentação da JLScript.

va status = "Servidor online"

status.style {
    cor: #50fa7b
    negrito: true
}

mostrar(status)
Enter fullscreen mode Exit fullscreen mode

status continua sendo uma String.

O estilo não muda o valor lógico.


56. Como Style funciona

Conceitualmente:

Value
↓
StyleMetadata
↓
Renderer
Enter fullscreen mode Exit fullscreen mode

O mesmo valor pode ser apresentado de formas diferentes dependendo do ambiente.

Terminal
JLShell
UI
Enter fullscreen mode Exit fullscreen mode

57. Style condicional

va online = true

va status = "Servidor"

status.style {

    se (online) {
        cor: #50fa7b
    } senao {
        cor: #ff5555
    }
}
Enter fullscreen mode Exit fullscreen mode

A lógica continua sendo a lógica normal da JLScript.

Não existe necessidade de aprender um segundo if apenas para estilo.


58. Contextos

status.style {

    cor: #50fa7b

    terminal {
        negrito: true
    }

    ui {
        tamanhoFonte: 18px
    }
}
Enter fullscreen mode Exit fullscreen mode

Assim o mesmo valor pode ter apresentação adequada para cada renderer.


59. Aplicação UI completa

import [
    #ui,
    #style
]

va app = ui.janela()

app.titulo("JLScript App")

app.ui({

    main(class="pagina") {

        h1("Bem-vindo")

        p(
            "Aplicação criada com JLScript"
        )

        input(
            placeholder="Digite seu nome"
        )

        button(
            class="primario"
        ) {
            text = "Continuar"
        }
    }
})

app.style({

    .pagina {
        padding = 24px
    }

    .primario {
        fundo = #7c3aed
        cor = #fff
        raio = 8px
    }
})

app.abrir()
Enter fullscreen mode Exit fullscreen mode

60. Organizando melhor o código

Programação avançada não significa escrever código mais complicado.

Na maioria das vezes significa separar melhor o problema.

Considere:

va preco = 30
va quantidade = 4

va subtotal = preco * quantidade

se (subtotal > 100) {
    subtotal = subtotal * 0.9
}

mostrar(subtotal)
Enter fullscreen mode Exit fullscreen mode

Funciona.

Mas podemos transformar a regra em uma função:

func calcularTotal(
    preco,
    quantidade
) {

    va subtotal =
        preco * quantidade

    se (subtotal > 100) {
        retorne subtotal * 0.9
    }

    retorne subtotal
}
Enter fullscreen mode Exit fullscreen mode

Depois:

va total = calcularTotal(
    30,
    4
)

mostrar(total)
Enter fullscreen mode Exit fullscreen mode

Agora a lógica tem nome e pode ser reutilizada.


61. Um projeto pequeno deve continuar pequeno

Não faça isso no primeiro dia:

src/
controllers/
services/
repositories/
models/
interfaces/
adapters/
factories/
providers/
utils/
helpers/
core/
domain/
Enter fullscreen mode Exit fullscreen mode

para um programa de 30 linhas.

Comece:

meu-projeto/
└── main.jls
Enter fullscreen mode Exit fullscreen mode

Quando realmente houver necessidade:

meu-projeto/
├── main.jls
├── usuarios.jls
├── config.jls
└── tests/
Enter fullscreen mode Exit fullscreen mode

Arquitetura deve resolver complexidade.

Não criar complexidade.


62. Pequeno projeto: calculadora

func calcular(a, operador, b) {

    se (operador == "+") {
        retorne a + b
    }

    se (operador == "-") {
        retorne a - b
    }

    se (operador == "*") {
        retorne a * b
    }

    se (operador == "/") {

        se (b == 0) {
            lanca erro(
                "Divisão por zero"
            )
        }

        retorne a / b
    }

    lanca erro(
        "Operador inválido"
    )
}

mostrar(
    calcular(10, "+", 5)
)
Enter fullscreen mode Exit fullscreen mode

63. Pequeno projeto: usuários ativos

va usuarios = [

    {
        nome: "Lucas",
        ativo: true
    },

    {
        nome: "Ana",
        ativo: false
    },

    {
        nome: "Pedro",
        ativo: true
    }
]

va ativos = usuarios.filtrar(
    func(usuario) {
        retorne usuario.ativo
    }
)

ativos.paraCada(
    func(usuario) {
        mostrar(usuario.nome)
    }
)
Enter fullscreen mode Exit fullscreen mode

64. Pequeno projeto: salvar configurações

va configuracao = {
    tema: "escuro",
    idioma: "pt-BR",
    notificacoes: true
}

arquivo.escrever(
    "config.json",
    configuracao.paraJson()
)
Enter fullscreen mode Exit fullscreen mode

Agora temos dados persistidos.

É um pequeno exemplo, mas já introduz uma ideia importante:

programa
↓
dados
↓
arquivo
↓
próxima execução
Enter fullscreen mode Exit fullscreen mode

65. Pequeno projeto: API

import #api

va app = api.servidor({
    host: "127.0.0.1",
    port: 3000
})

app.get("/", func(req, res) {

    res.json({
        nome: "Minha API",
        linguagem: "JLScript",
        status: "online"
    })
})

app.iniciar()

mostrar(
    "Servidor iniciado"
)
Enter fullscreen mode Exit fullscreen mode

66. Um projeto maior

Quando começamos a misturar:

API
banco
validação
arquivos
configuração
Enter fullscreen mode Exit fullscreen mode

separe responsabilidades.

Exemplo:

src/
├── main.jls
├── database.jls
├── usuarios.jls
├── config.jls
└── rotas.jls
Enter fullscreen mode Exit fullscreen mode

main.jls deve coordenar o programa.

Ele não precisa conter cada detalhe da aplicação.


67. Dicas para escrever código melhor

Dê bons nomes

Ruim:

va x = api(...)
Enter fullscreen mode Exit fullscreen mode

Melhor:

va usuariosApi = api(...)
Enter fullscreen mode Exit fullscreen mode

Evite funções gigantes

Uma função que:

lê arquivo
valida usuário
consulta API
salva banco
gera PDF
abre UI
Enter fullscreen mode Exit fullscreen mode

está provavelmente fazendo trabalho demais.


Não copie código sem necessidade

Se o mesmo trecho aparece cinco vezes, talvez exista uma função esperando para ser criada.


Valide dados externos

Nunca confie automaticamente em:

entrada do usuário
API
arquivo
banco
variável de ambiente
Enter fullscreen mode Exit fullscreen mode

Dados externos podem estar errados.


Não coloque senhas no código

Evite:

va senha =
    "minha-senha-super-secreta"
Enter fullscreen mode Exit fullscreen mode

Segredo dentro de código costuma acabar em:

Git
print
log
screenshot
backup
Enter fullscreen mode Exit fullscreen mode

Trate erros onde eles fazem sentido

Não coloque um único tenta envolvendo o programa inteiro apenas para impedir que ele pare.

Trate o erro perto da operação que pode falhar.


68. Como melhorar como programador

Uma das melhores coisas que você pode aprender não é uma linguagem.

É quebrar um problema grande em problemas pequenos.

Em vez de pensar:

“Como faço um sistema inteiro?”

pense:

Como recebo os dados?

Como valido?

Como salvo?

Como recupero?

Como mostro?

O que pode falhar?
Enter fullscreen mode Exit fullscreen mode

Essas perguntas transformam uma ideia enorme em tarefas que você consegue implementar uma por vez.


69. Leia código

Não leia apenas tutorial.

Leia:

seu próprio código antigo
bibliotecas
exemplos
testes
projetos pequenos
Enter fullscreen mode Exit fullscreen mode

Você aprende bastante vendo como outra pessoa resolveu um problema parecido.

Também aprende vendo o próprio código de três meses atrás e se perguntando quem deixou aquela pessoa programar.


70. Não tenha medo de apagar código

Código não vira patrimônio histórico só porque demorou duas horas para ser escrito.

Se encontrou uma forma mais simples e segura, refatore.

Manter um trecho ruim apenas porque “já funciona” costuma cobrar juros depois.


71. Faça mudanças pequenas

Melhor:

criar função
↓
executar
↓
testar
↓
continuar
Enter fullscreen mode Exit fullscreen mode

do que:

reescrever metade do projeto
↓
executar
↓
37 erros
↓
ninguém sabe onde começou
Enter fullscreen mode Exit fullscreen mode

72. Entenda antes de copiar

Copiar um código pode resolver o problema atual.

Entender o código ajuda a resolver os próximos dez.

Quando pegar um exemplo, tente responder:

O que entra?

O que sai?

Que variável muda?

Que função é chamada?

O que pode falhar?
Enter fullscreen mode Exit fullscreen mode

73. Aprenda a depurar

Quando algo não funcionar:

  1. leia o erro;
  2. descubra a linha;
  3. confira os valores;
  4. reduza o problema;
  5. teste uma parte isolada;
  6. só depois altere o código.

Não mude dez coisas ao mesmo tempo tentando acertar por sorte.

Às vezes funciona.

E aí fica pior, porque agora você não sabe qual das dez mudanças resolveu.


74. Não tente decorar a linguagem inteira

Você não precisa saber de cabeça cada método de List, Object, String ou cada comando do terminal.

Precisa saber que eles existem e saber consultar a documentação.

Um programador experiente não é uma enciclopédia offline.

Ele entende conceitos e encontra detalhes rapidamente.


75. Crie projetos

Depois de aprender:

variáveis
if
loops
funções
listas
objetos
Enter fullscreen mode Exit fullscreen mode

pare de estudar somente exemplos isolados.

Crie coisas.

Algumas ideias:

Projetos simples

  • calculadora;
  • lista de tarefas;
  • cadastro de nomes;
  • gerador de senha;
  • contador;
  • jogo de adivinhação;
  • conversor de unidades.

Projetos intermediários

  • sistema de notas;
  • gerenciador de arquivos;
  • CLI;
  • leitor de JSON;
  • organizador de pastas;
  • cliente de API;
  • gerador de relatório.

Projetos maiores

  • API;
  • painel com UI;
  • sistema com banco;
  • automação;
  • aplicativo desktop;
  • ferramenta de desenvolvimento;
  • biblioteca JLScript.

76. Checklist antes de considerar um código pronto

✓ O código está fácil de entender?

Os nomes explicam o que cada valor representa?

As funções possuem responsabilidade clara?

✓ Os erros são tratados?

Arquivo ausente?

API offline?

Dados inválidos?

✓ Existe código duplicado?

Se existe, talvez seja hora de extrair uma função.

✓ Existem dados sensíveis no código?

Senha, token e chave não deveriam estar hardcoded.

✓ O código foi realmente executado?

“Parece certo” não é teste.


77. Ordem recomendada de estudo

Eu estudaria JLScript nessa ordem:

1. mostrar()
2. valores
3. variáveis
4. operadores
5. comparações
6. condições
7. loops
8. funções
9. escopo
10. listas
11. objetos
12. callbacks
13. tratamento de erros
14. arquivos
15. imports
16. bibliotecas
17. tempo
18. async
19. consumo de APIs
20. criação de APIs
21. banco de dados
22. UI
23. Style
24. organização de projetos
25. testes
26. terminal e ferramentas
Enter fullscreen mode Exit fullscreen mode

Não existe necessidade de correr.

Uma base bem entendida vale muito mais do que chegar rápido em um assunto avançado sem saber o que está acontecendo.


78. Cores da documentação

A identidade visual da linguagem pode utilizar uma paleta inspirada no Dracula Theme.

Elemento JLScript Cor
keywords #ff79c6
strings #f1fa8c
números #bd93f9
módulos #8be9fd
funções #50fa7b
tempo #ffb86c
comentários #6272a4
texto #f8f8f2
fundo #282a36

O Markdown do GitHub não pinta automaticamente cada token.

O editor ou site precisa possuir a gramática JLScript e um syntax highlighter compatível.


79. Do primeiro programa até um projeto real

Você começa:

mostrar("Olá, mundo!")
Enter fullscreen mode Exit fullscreen mode

Depois aprende:

va nome = "Lucas"
Enter fullscreen mode Exit fullscreen mode

Começa a tomar decisões:

se (idade >= 18) {
    mostrar("Maior")
}
Enter fullscreen mode Exit fullscreen mode

Cria funções:

func soma(a, b) {
    retorne a + b
}
Enter fullscreen mode Exit fullscreen mode

Trabalha com dados:

va usuarios = [
    {
        nome: "Lucas"
    }
]
Enter fullscreen mode Exit fullscreen mode

Consome serviços:

va backend =
    api("https://api.exemplo.com")
Enter fullscreen mode Exit fullscreen mode

Constrói servidor:

import #api
Enter fullscreen mode Exit fullscreen mode

E pode chegar a:

import [
    #database,
    #ui,
    #style
]
Enter fullscreen mode Exit fullscreen mode

A linguagem não muda de objetivo quando o programa cresce.

O que cresce é a forma como você organiza as ideias.


80. Conclusão

JLScript foi criada para permitir que alguém comece com:

mostrar("Olá")
Enter fullscreen mode Exit fullscreen mode

sem precisar aprender uma quantidade absurda de conceitos antes de conseguir fazer alguma coisa.

Mas simplicidade no começo não significa limitar o que vem depois.

A mesma base pode evoluir para:

scripts
automação
CLIs
APIs
banco de dados
interfaces
aplicações
bibliotecas
ferramentas
Enter fullscreen mode Exit fullscreen mode

O objetivo nunca foi apenas criar palavras em português para coisas que já existem.

A ideia é construir uma linguagem em que os conceitos sejam claros o suficiente para quem está começando e continuem fazendo sentido quando essa pessoa começar a criar projetos maiores.

E talvez essa seja a parte mais importante deste guia:

Você não precisa saber tudo para começar.

Precisa começar, errar, entender o erro e continuar construindo.

JLScript

Simples para começar. Completa o bastante para continuar.

Versão 4.2.0

Top comments (0)