Do primeiro mostrar()
ao código avançado.

Começando: seu primeiro programa

Todo arquivo JLScript usa a extensão .jls. O primeiro objetivo é entender a ideia mais simples da linguagem: executar instruções em ordem.

mostrar("Olá, mundo!")
mostrar("Meu primeiro programa em JLScript")

Variáveis e valores

Uma variável guarda um valor para ser reutilizado. O JLScript possui as formas va, let e ins. A semântica exata de cada forma deve acompanhar a versão atual da linguagem, mas todas aparecem no parser atual como formas de declaração.

va nome = "Lucas"
let idade = 20
ins ativo = true

mostrar(nome)
mostrar(idade)
mostrar(ativo)

Os valores básicos que você encontrará com frequência são texto, números, booleanos e null.

va linguagem = "JLScript"
va versao = 2
va preco = 19.90
va online = true
va resultado = null

Operadores e expressões

Expressões combinam valores com operadores. O parser atual trabalha com aritmética, comparações, lógica, unários e incremento/decremento.

va a = 10
va b = 3

mostrar(a + b)
mostrar(a - b)
mostrar(a * b)
mostrar(a / b)
mostrar(a % b)

mostrar(a > b)
mostrar(a == b)
mostrar(a != b)

va idade = 20
va autorizado = true

se (idade >= 18 && autorizado) {{
    mostrar("Acesso permitido")
}}

Condições: se/senao e if/else

Condições escolhem qual bloco será executado. O JLScript aceita formas em português e inglês. Dentro de uma mesma estrutura, mantenha o idioma consistente.

va idade = 20

se (idade >= 18) {{
    mostrar("Maior de idade")
}} senao {{
    mostrar("Menor de idade")
}}

va idade = 20

if (idade >= 18) {{
    mostrar("Adulto")
}} else {{
    mostrar("Menor")
}}

Encadeando condições

va nota = 8

se (nota >= 9) {{
    mostrar("Excelente")
}} senao se (nota >= 7) {{
    mostrar("Aprovado")
}} senao {{
    mostrar("Reprovado")
}}

Repetição: enquanto/while e para/for

Laços permitem repetir código. Use enquanto/while quando a repetição depende de uma condição. Use para/for quando existe uma progressão clara.

va numero = 1

enquanto (numero <= 5) {{
    mostrar(numero)
    numero++
}}

para (va i = 0; i < 5; i++) {{
    mostrar(i)
}}

Interrompendo ou pulando

para (va i = 0; i < 10; i++) {{
    se (i == 3) {{
        continuar
    }}

    se (i == 8) {{
        pare
    }}

    mostrar(i)
}}

Funções

Funções agrupam lógica reutilizável. Elas recebem parâmetros e podem devolver um resultado usando retorne.

func soma(a, b) {{
    retorne a + b
}}

va total = soma(10, 5)
mostrar(total)

Parâmetros padrão

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

saudacao()
saudacao("Lucas")

Argumentos nomeados

O parser aceita argumentos nomeados com = ou :. Isso deixa chamadas longas bem mais fáceis de ler.

func criarUsuario(nome, idade, ativo = true) {{
    mostrar(nome)
    mostrar(idade)
    mostrar(ativo)
}}

criarUsuario(
    nome = "Lucas",
    idade = 20,
    ativo = true
)

Função anônima

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

mostrar(dobro(10))

Listas e objetos

Listas guardam vários valores em sequência. Objetos agrupam dados por propriedades.

va linguagens = [
    "JLScript",
    "Python",
    "JavaScript"
]

mostrar(linguagens[0])

va usuario = {{
    nome: "Lucas",
    idade: 20,
    programador: true
}}

mostrar(usuario.nome)
mostrar(usuario.idade)

Escolha múltipla: escolha/switch

Quando uma variável pode cair em vários casos bem definidos, escolha ou switch deixa o fluxo mais legível.

va opcao = 2

escolha (opcao) {{
    caso 1 {{
        mostrar("Cadastrar")
    }}

    caso 2 {{
        mostrar("Entrar")
    }}

    padrao {{
        mostrar("Opção inválida")
    }}
}}

Na forma inglesa, use switch, case e default.

Tratamento de erros

Blocos de tratamento permitem reagir a falhas sem encerrar toda a lógica de forma desorganizada.

tente {{
    mostrar("Executando operação")
}} capture (erro) {{
    mostrar("Ocorreu um erro")
    mostrar(erro)
}} finalmente {{
    mostrar("Processo finalizado")
}}

A versão inglesa usa try, catch e finally.

Imports e módulos

Recursos maiores ficam em módulos. O formato atual usa # para módulos oficiais.

import #math

Você pode importar mais de um módulo:

import [
    #math,
    #json,
    #file
]

Alias

import #database como db

va banco = db.sqlite("app.db")

Tempo e durações

JLScript possui suporte nativo a unidades de duração, o que deixa temporizadores mais legíveis.

esperar(500 ms)
esperar(2 segundos)
esperar(1 minuto)

Executar depois

tempo.depois(2 segundos, func() {{
    mostrar("Executado depois")
}})

Executar repetidamente

va timer = tempo.cada(1 segundo, func() {{
    mostrar("tick")
}})

APIs e HTTP

No nível avançado, o módulo #api fornece recursos de servidor e cliente HTTP. A API pública pode evoluir entre versões, então sempre use a documentação correspondente ao seu build.

import #api

va app = api.criar(3000)

app.get("/", func(req, res) {{
    res.enviar("Olá pelo JLScript")
}})

app.iniciar()

Consumindo uma API

import #api

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

mostrar(resposta)

Banco de dados

Com #database, o código pode trabalhar com armazenamento persistente. Um exemplo de entrada é SQLite.

import #database como db

va banco = db.sqlite("app.db")

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

O ponto importante aqui não é decorar SQL. É perceber como import, alias, objetos e chamadas de método trabalham juntos no mesmo programa.

Conectores e dispositivos

Os módulos #connector e #mobile permitem trabalhar com conexões e dispositivos suportados.

import #connector
import #mobile

va conexao = connector.adb(
    "192.168.1.2",
    5555,
    timeout = 20 segundos
)

va celular = mobile.conectar(conexao)

mostrar(celular.estatisticas())

UI e Style

O JLScript também possui uma camada para interfaces. A ideia é descrever estrutura e estilo sem abandonar a linguagem.

import [
    #ui,
    #style
]

va app = ui.janela()

app.titulo("Meu App")

app.ui({{
    main(class="app") {{
        h1("Bem-vindo")

        p("Interface criada com JLScript")

        button(class="acao") {{
            text = "Entrar"
        }}
    }}
}})

app.style({{
    background("#101010"),
    color("#ffffff")
}})

app.abrir()

Pensando como programador: escopo e organização

Chegar ao avançado não é aprender mais palavras-chave. É organizar melhor o código.

func calcularTotal(preco, quantidade) {{
    va subtotal = preco * quantidade

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

    retorne subtotal
}}

va total = calcularTotal(30, 4)

mostrar(total)

O valor subtotal pertence à função. O restante do programa usa apenas a interface pública da função: parâmetros e retorno. Essa separação reduz bugs e facilita manutenção.

Projeto final: juntando os conceitos

Este exemplo reúne módulos, banco, função, condição, objeto, callback e servidor HTTP.

import [
    #api,
    #database
]

va banco = database.sqlite("usuarios.db")

func criarUsuario(nome, idade) {{
    se (nome == null) {{
        retorne false
    }}

    banco.executar(
        "INSERT INTO usuarios (nome, idade) VALUES (?, ?)"
    )

    retorne true
}}

va app = api.criar(3000)

app.get("/", func(req, res) {{
    res.enviar({{
        linguagem: "JLScript",
        status: "online"
    }})
}})

app.iniciar()

mostrar("Servidor iniciado")

A partir daqui, o próximo nível é separar arquivos, criar módulos próprios, testar funções, organizar bibliotecas e usar o IntelliSense para navegar pelo projeto.

Mapa de estudo

Uma ordem boa para estudar JLScript sem transformar seu cérebro em uma pilha de stack traces: