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
Um programa pode ser tão simples quanto:
mostrar("Olá, mundo!")
ou crescer até trabalhar com:
arquivos
APIs
JSON
banco de dados
terminal
processos
automação
interfaces
testes
rede
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!")
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")
Resultado:
Olá!
Estou aprendendo JLScript
Meu primeiro programa está funcionando
A execução acontece de cima para baixo.
mostrar("Primeiro")
mostrar("Segundo")
mostrar("Terceiro")
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á")
Evite comentários óbvios:
// Cria uma variável chamada idade
va idade = 20
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
3. Variáveis
Variáveis guardam valores.
va nome = "Lucas"
Agora nome representa:
Lucas
Então:
mostrar(nome)
exibe:
Lucas
JLScript possui três formas oficiais de declaração:
va nome = "Lucas"
let idade = 20
ins ativo = true
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
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"
Prefira:
va idade = 20
va usuarioAtivo = true
va nomeUsuario = "Lucas"
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"
Número inteiro
va idade = 20
Número decimal
va preco = 19.90
Booleano
va online = true
va bloqueado = false
Booleanos representam normalmente uma resposta de:
sim / não
ligado / desligado
verdadeiro / falso
Valor vazio
va resultado = null
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)
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
7. Operadores matemáticos
va soma = 10 + 5
va subtracao = 10 - 5
va multiplicacao = 10 * 5
va divisao = 10 / 5
va resto = 10 % 3
Podemos mostrar os resultados:
mostrar(soma)
mostrar(subtracao)
mostrar(multiplicacao)
mostrar(divisao)
mostrar(resto)
8. Incremento e decremento
Incrementar:
va numero = 1
numero++
mostrar(numero)
Resultado:
2
Decrementar:
va numero = 10
numero--
mostrar(numero)
Resultado:
9
Também existem operações acumulativas:
va numero = 10
numero += 5
numero -= 2
numero *= 3
numero /= 2
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)
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")
}
As duas condições precisam ser verdadeiras.
OU
va admin = false
va moderador = true
se (admin || moderador) {
mostrar("Acesso permitido")
}
Nesse caso, basta uma condição ser verdadeira.
NÃO
va bloqueado = false
se (!bloqueado) {
mostrar("Usuário liberado")
}
! 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")
}
Com alternativa:
va idade = 16
se (idade >= 18) {
mostrar("Maior de idade")
} senao {
mostrar("Menor de idade")
}
12. Português e inglês
JLScript possui aliases em partes da linguagem.
Em português:
se (idade >= 18) {
mostrar("Adulto")
} senao {
mostrar("Menor")
}
Em inglês:
if (idade >= 18) {
mostrar("Adulto")
} else {
mostrar("Menor")
}
Mantenha o idioma da estrutura consistente.
Evite:
se (idade >= 18) {
mostrar("Ok")
} else {
mostrar("Não")
}
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")
}
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++
}
Resultado:
1
2
3
4
5
Em inglês:
while (numero <= 5) {
mostrar(numero)
numero++
}
15. para
Quando sabemos como a repetição deve avançar:
para (va i = 0; i < 10; i++) {
mostrar(i)
}
Forma inglesa:
for (va i = 0; i < 10; i++) {
mostrar(i)
}
16. Interrompendo um loop
para (va i = 0; i < 10; i++) {
se (i == 5) {
pare
}
mostrar(i)
}
Quando i chega em 5, o loop termina.
Alias:
pare / break
17. Pulando uma repetição
para (va i = 0; i < 10; i++) {
se (i == 5) {
continuar
}
mostrar(i)
}
O 5 não será mostrado, mas o loop continuará.
Alias:
continuar / continue
18. Funções
Funções organizam tarefas que podem ser reutilizadas.
func saudacao() {
mostrar("Olá!")
}
Chamando:
saudacao()
19. Parâmetros
func saudacao(nome) {
mostrar("Olá, " + nome)
}
saudacao("Lucas")
nome recebe o valor enviado na chamada.
20. Retorno
Uma função pode devolver um resultado:
func soma(a, b) {
retorne a + b
}
Depois:
va resultado = soma(10, 5)
mostrar(resultado)
Resultado:
15
21. Parâmetros padrão
func saudacao(nome = "Mundo") {
mostrar("Olá, " + nome)
}
Sem argumento:
saudacao()
Resultado:
Olá, Mundo
Com argumento:
saudacao("Lucas")
Resultado:
Olá, Lucas
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)
}
Chamada comum:
criarUsuario("Lucas", 20, true)
Chamada nomeada:
criarUsuario(
nome = "Lucas",
idade = 20,
ativo = true
)
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))
Resultado:
20
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)
}
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"
]
Também podemos guardar números:
va numeros = [
10,
20,
30,
40
]
Ou objetos:
va usuarios = [
{
nome: "Lucas",
ativo: true
},
{
nome: "Ana",
ativo: false
}
]
26. Trabalhando com listas
Adicionar:
linguagens.adicionar("C++")
Tamanho:
mostrar(linguagens.tamanho())
Verificar:
mostrar(
linguagens.contem("JLScript")
)
Primeiro elemento:
mostrar(
linguagens.primeiro()
)
Último:
mostrar(
linguagens.ultimo()
)
27. Mapear
mapear() transforma os elementos.
va numeros = [1, 2, 3, 4]
va dobrados = numeros.mapear(
func(numero) {
retorne numero * 2
}
)
mostrar(dobrados)
Resultado:
[2, 4, 6, 8]
28. Filtrar
va numeros = [1, 2, 3, 4, 5, 6]
va pares = numeros.filtrar(
func(numero) {
retorne numero % 2 == 0
}
)
mostrar(pares)
29. Reduzir
va numeros = [1, 2, 3, 4]
va total = numeros.reduzir(
func(acumulador, numero) {
retorne acumulador + numero
},
0
)
mostrar(total)
Resultado:
10
Esses três métodos aparecem bastante em programas que trabalham com dados:
mapear
filtrar
reduzir
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
}
Acessando:
mostrar(usuario.nome)
mostrar(usuario.idade)
Alterando:
usuario.nome = "Pedro"
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")
}
}
Forma inglesa:
switch (opcao) {
case 1 {
mostrar("Cadastrar")
}
case 2 {
mostrar("Entrar")
}
default {
mostrar("Opção inválida")
}
}
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)
}
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")
}
Isso é útil para:
fechar conexão
liberar recurso
encerrar operação
registrar finalização
34. Não esconda erros
Evite:
tenta {
operacao()
} pegar (erro) {
mostrar("erro")
}
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
)
}
35. Bibliotecas
Recursos maiores podem ser organizados em módulos.
import #math
Mais de um:
import [
#math,
#json,
#fs
]
36. Alias de biblioteca
import #database como db
Agora:
db.
representa #database.
Forma alternativa:
import #database as db
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á")
Já recursos especializados normalmente entram por módulos:
import #math
import #database
import #ui
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)
Outros exemplos:
esperar(500 ms)
esperar(1 segundo)
esperar(2 minutos)
esperar(1 hora)
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)
40. Executar depois
tempo.depois(
2 segundos,
func() {
mostrar(
"Executado depois de 2 segundos"
)
}
)
Aqui usamos uma função anônima como callback.
41. Execução repetida
va timer = tempo.cada(
1 segundo,
func() {
mostrar("tick")
}
)
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)
}
Palavras principais:
fluxo
aguarda
tenta
pegar
fim
lanca
43. Consumindo uma API
O cliente HTTP pode ser usado de forma nativa.
va backend = api(
"https://api.exemplo.com"
)
Agora podemos realizar:
GET
POST
PUT
PATCH
DELETE
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()
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()
46. Resposta HTTP
Uma resposta possui informações importantes.
mostrar(res.status)
mostrar(res.ok)
mostrar(res.headers)
mostrar(res.dados)
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
})
Criando rota:
app.get("/", func(req, res) {
res.json({
linguagem: "JLScript",
status: "online"
})
})
Iniciando:
app.iniciar()
48. GET com parâmetro
app.get(
"/usuarios/:id",
func(req, res) {
va id = req.param("id")
res.json({
id: id
})
}
)
49. POST no servidor
app.post(
"/usuarios",
func(req, res) {
va usuario = req.json()
res.status(201)
res.json({
criado: true,
usuario: usuario
})
}
)
50. Banco de dados
import #database como db
va banco = db.sqlite(
"app.db"
)
Criando uma tabela:
banco.executar(
"CREATE TABLE usuarios (
id INTEGER PRIMARY KEY,
nome TEXT
)"
)
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"
)
Lendo:
va conteudo = arquivo.ler(
"dados.txt"
)
mostrar(conteudo)
Verificando:
se (arquivo.existe("dados.txt")) {
mostrar("Arquivo encontrado")
}
Para filesystem mais avançado, utilize #fs.
52. Criando interfaces
import [
#ui,
#style
]
Janela:
va app = ui.janela()
app.titulo(
"Meu aplicativo"
)
53. Estrutura da UI
app.ui({
main(class="app") {
h1("Bem-vindo")
p(
"Aplicação criada com JLScript"
)
button(
class="acao"
) {
text = "Entrar"
}
}
})
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
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)
status continua sendo uma String.
O estilo não muda o valor lógico.
56. Como Style funciona
Conceitualmente:
Value
↓
StyleMetadata
↓
Renderer
O mesmo valor pode ser apresentado de formas diferentes dependendo do ambiente.
Terminal
JLShell
UI
57. Style condicional
va online = true
va status = "Servidor"
status.style {
se (online) {
cor: #50fa7b
} senao {
cor: #ff5555
}
}
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
}
}
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()
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)
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
}
Depois:
va total = calcularTotal(
30,
4
)
mostrar(total)
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/
para um programa de 30 linhas.
Comece:
meu-projeto/
└── main.jls
Quando realmente houver necessidade:
meu-projeto/
├── main.jls
├── usuarios.jls
├── config.jls
└── tests/
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)
)
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)
}
)
64. Pequeno projeto: salvar configurações
va configuracao = {
tema: "escuro",
idioma: "pt-BR",
notificacoes: true
}
arquivo.escrever(
"config.json",
configuracao.paraJson()
)
Agora temos dados persistidos.
É um pequeno exemplo, mas já introduz uma ideia importante:
programa
↓
dados
↓
arquivo
↓
próxima execução
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"
)
66. Um projeto maior
Quando começamos a misturar:
API
banco
validação
arquivos
configuração
separe responsabilidades.
Exemplo:
src/
├── main.jls
├── database.jls
├── usuarios.jls
├── config.jls
└── rotas.jls
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(...)
Melhor:
va usuariosApi = api(...)
Evite funções gigantes
Uma função que:
lê arquivo
valida usuário
consulta API
salva banco
gera PDF
abre UI
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
Dados externos podem estar errados.
Não coloque senhas no código
Evite:
va senha =
"minha-senha-super-secreta"
Segredo dentro de código costuma acabar em:
Git
print
log
screenshot
backup
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?
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
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
do que:
reescrever metade do projeto
↓
executar
↓
37 erros
↓
ninguém sabe onde começou
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?
73. Aprenda a depurar
Quando algo não funcionar:
- leia o erro;
- descubra a linha;
- confira os valores;
- reduza o problema;
- teste uma parte isolada;
- 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
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
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!")
Depois aprende:
va nome = "Lucas"
Começa a tomar decisões:
se (idade >= 18) {
mostrar("Maior")
}
Cria funções:
func soma(a, b) {
retorne a + b
}
Trabalha com dados:
va usuarios = [
{
nome: "Lucas"
}
]
Consome serviços:
va backend =
api("https://api.exemplo.com")
Constrói servidor:
import #api
E pode chegar a:
import [
#database,
#ui,
#style
]
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á")
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
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)