DEV Community

JLScript
JLScript

Posted on

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

#jlscript #ai #opensource #devops

🧛 JLScript — Do Básico ao Avançado

Aprenda JLScript do primeiro mostrar() até APIs, banco de dados, dispositivos e interfaces.

JLScript, também chamado de JLS, é uma linguagem de programação criada com o objetivo de possuir uma sintaxe simples, legível e agradável para quem está começando, sem impedir a criação de projetos maiores.

Os arquivos da linguagem utilizam a extensão:

.jls
Enter fullscreen mode Exit fullscreen mode

Neste guia vamos começar absolutamente do zero.

No final, você já terá visto:

  • variáveis;
  • valores;
  • operadores;
  • condições;
  • loops;
  • funções;
  • listas;
  • objetos;
  • tratamento de erros;
  • módulos;
  • aliases;
  • tempo;
  • APIs;
  • banco de dados;
  • dispositivos;
  • interfaces gráficas;
  • organização de projetos.

1. Seu primeiro programa

Todo programador começa inevitavelmente imprimindo texto no terminal. A humanidade construiu compiladores, sistemas operacionais e inteligência artificial para, no fim, escrever "Olá, mundo!".

Em JLScript:

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

A função mostrar() envia um valor para a saída do programa.

Podemos executar várias instruções:

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

2. Variáveis

Variáveis são espaços usados para guardar informações.

No JLScript existem três formas principais de declaração:

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

Depois podemos utilizar os valores:

va linguagem = "JLScript"

mostrar(linguagem)
Enter fullscreen mode Exit fullscreen mode

Valores básicos

Texto 

va nome = "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

Valor vazio 

va resultado = null
Enter fullscreen mode Exit fullscreen mode

Podemos juntar tudo:

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

3. Operadores matemáticos

JLScript suporta operações matemáticas comuns.

va soma = 10 + 5
va subtracao = 10 - 5
va multiplicacao = 10 * 5
va divisao = 10 / 5
va resto = 10 % 3

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

Incremento 

va numero = 1

numero++

mostrar(numero)
Enter fullscreen mode Exit fullscreen mode

Decremento 

va numero = 10

numero--

mostrar(numero)
Enter fullscreen mode Exit fullscreen mode

4. Comparações

Comparações produzem normalmente um resultado verdadeiro ou falso.

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

Alguns operadores importantes:

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

5. Operadores lógicos

Também podemos juntar várias condições.

E 

va idade = 20
va autorizado = true

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

OU 

va admin = false
va moderador = true

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

NÃO 

va bloqueado = false

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

6. Condições

Condições permitem executar diferentes partes do programa.

se 

va idade = 20

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

se e senao 

va idade = 16

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

7. Condições em inglês

JLScript também possui estruturas equivalentes em inglês.

va idade = 20

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

Importante: mantenha o idioma da estrutura consistente.

Evite:

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

Prefira:

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

ou:

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

8. Várias condições

Podemos verificar mais de uma possibilidade.

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

9. Enquanto

Quando queremos repetir algo enquanto uma condição for verdadeira:

va numero = 1

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

    numero++
}
Enter fullscreen mode Exit fullscreen mode

Resultado esperado:

1
2
3
4
5
Enter fullscreen mode Exit fullscreen mode

Em inglês:

va numero = 1

while (numero <= 5) {
    mostrar(numero)

    numero++
}
Enter fullscreen mode Exit fullscreen mode

10. Para

Quando já sabemos como a repetição deve avançar, podemos utilizar para.

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

Em inglês:

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

11. Pare

Podemos interromper um loop.

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

    se (i == 5) {
        pare
    }

    mostrar(i)
}
Enter fullscreen mode Exit fullscreen mode

Quando i chegar a 5, o loop será interrompido.

Em inglês:

break
Enter fullscreen mode Exit fullscreen mode

12. Continuar

Podemos ignorar uma iteração específica.

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

    se (i == 5) {
        continuar
    }

    mostrar(i)
}
Enter fullscreen mode Exit fullscreen mode

Nesse exemplo, o número 5 não será mostrado.

Em inglês:

continue
Enter fullscreen mode Exit fullscreen mode

13. Funções

Funções permitem criar blocos reutilizáveis.

func saudacao() {
    mostrar("Olá!")
}

saudacao()
Enter fullscreen mode Exit fullscreen mode

Podemos receber parâmetros:

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

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

14. Retornando valores

Uma função também pode devolver um resultado.

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

Agora podemos utilizar:

va resultado = soma(10, 5)

mostrar(resultado)
Enter fullscreen mode Exit fullscreen mode

15. Forma curta de função

JLScript também suporta uma forma curta de declaração.

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

mostrar(soma(10, 5))
Enter fullscreen mode Exit fullscreen mode

16. Parâmetros padrão

Podemos definir valores que serão usados caso nenhum argumento seja informado.

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

saudacao()
Enter fullscreen mode Exit fullscreen mode

Resultado:

Olá Mundo
Enter fullscreen mode Exit fullscreen mode

Agora:

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

Resultado:

Olá Lucas
Enter fullscreen mode Exit fullscreen mode

17. Argumentos nomeados

JLScript permite deixar chamadas maiores mais legíveis.

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

Podemos chamar:

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

Assim fica muito mais fácil descobrir o significado de cada valor.

Compare:

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

com:

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

Em chamadas grandes, a segunda forma normalmente é muito mais clara.

18. Funções anônimas

Também podemos criar uma função sem nome.

va dobro = func(numero) {
    retorne numero * 2
}
Enter fullscreen mode Exit fullscreen mode

Utilizando:

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

Resultado:

20
Enter fullscreen mode Exit fullscreen mode

Funções anônimas ficam especialmente importantes quando começamos a trabalhar com callbacks.

19. Listas

Uma lista permite armazenar vários valores.

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

Podemos acessar um elemento:

mostrar(linguagens[0])
Enter fullscreen mode Exit fullscreen mode

Também podemos guardar números:

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

20. Objetos

Objetos agrupam informações relacionadas.

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

Acessando propriedades:

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

Isso é muito melhor do que criar:

va usuarioNome = "Lucas"
va usuarioIdade = 20
va usuarioProgramador = true
Enter fullscreen mode Exit fullscreen mode

principalmente quando o programa começa a crescer.

21. Escolha

Quando temos várias 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

A forma inglesa:

switch (opcao) {

    case 1 {
        mostrar("Cadastrar")
    }

    case 2 {
        mostrar("Entrar")
    }

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

22. Tratamento de erros

Programas reais falham.

Arquivo não existe, conexão cai, servidor some, usuário faz coisa inexplicável. Normal.

JLScript possui estruturas para tratamento de erros.

tente {

    mostrar("Executando operação")

} capture (erro) {

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

23. Finalmente

Podemos executar um bloco independentemente de ocorrer erro.

tente {

    mostrar("Executando")

} capture (erro) {

    mostrar("Erro encontrado")

} finalmente {

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

Em inglês:

try {

    mostrar("Executando")

} catch (error) {

    mostrar(error)

} finally {

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

24. Bibliotecas

Até agora usamos principalmente recursos básicos da linguagem.

Para funcionalidades maiores, JLScript possui módulos.

Importando:

import #math
Enter fullscreen mode Exit fullscreen mode

25. Vários imports

Podemos importar mais de um módulo:

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

26. Alias de biblioteca

Também podemos mudar o nome utilizado dentro do código.

import #database como db
Enter fullscreen mode Exit fullscreen mode

Agora:

db.
Enter fullscreen mode Exit fullscreen mode

representa o módulo #database.

Um IntelliSense correto deve entender isso.

Depois de:

db.
Enter fullscreen mode Exit fullscreen mode

ele deve mostrar somente recursos pertencentes ao módulo #database.

27. Tempo

JLScript possui suporte para trabalhar com durações de maneira legível.

esperar(2 segundos)
Enter fullscreen mode Exit fullscreen mode

Depois:

mostrar("Dois segundos passaram")
Enter fullscreen mode Exit fullscreen mode

Podemos utilizar outras unidades:

esperar(500 ms)

esperar(1 segundo)

esperar(2 minutos)

esperar(1 hora)
Enter fullscreen mode Exit fullscreen mode

28. Tempo atual

JLScript possui um objeto global relacionado ao tempo.

va agora = tempo.agora()

mostrar(agora)
Enter fullscreen mode Exit fullscreen mode

29. Executar algo depois

Podemos agendar uma função.

tempo.depois(2 segundos, func() {

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

Aqui aparece um conceito importante:

func() {
}
Enter fullscreen mode Exit fullscreen mode

é uma função anônima usada como callback.

30. Repetir automaticamente

Também podemos executar uma função em intervalos.

va timer = tempo.cada(1 segundo, func() {

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

31. Criando uma API

Agora começamos a entrar em recursos mais avançados.

Importamos:

import #api
Enter fullscreen mode Exit fullscreen mode

Criamos o servidor:

va app = api.criar(3000)
Enter fullscreen mode Exit fullscreen mode

Agora criamos uma rota:

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

    res.enviar("Olá pelo JLScript!")
})
Enter fullscreen mode Exit fullscreen mode

E iniciamos:

app.iniciar()
Enter fullscreen mode Exit fullscreen mode

Programa completo:

import #api

va app = api.criar(3000)

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

    res.enviar("Olá pelo JLScript!")
})

app.iniciar()
Enter fullscreen mode Exit fullscreen mode

32. Retornando objetos em uma API

Podemos trabalhar com dados estruturados.

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

    va usuario = {
        nome: "Lucas",
        linguagem: "JLScript",
        online: true
    }

    res.enviar(usuario)
})
Enter fullscreen mode Exit fullscreen mode

Aqui usamos juntos:

  • módulo;
  • rota;
  • callback;
  • objeto;
  • variável;
  • resposta HTTP.

33. Consumindo uma API

O módulo também pode ser usado para requisições HTTP.

import #api

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

mostrar(resposta)
Enter fullscreen mode Exit fullscreen mode

34. Banco de dados

Importamos:

import #database como db
Enter fullscreen mode Exit fullscreen mode

Agora abrimos SQLite:

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

Podemos executar uma instrução:

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

Programa:

import #database como db

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

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

35. Dispositivos

JLScript também possui recursos voltados a conexões e dispositivos.

import #connector
import #mobile
Enter fullscreen mode Exit fullscreen mode

Uma conexão ADB pode ser criada:

va conexao = connector.adb(
    "192.168.1.2",
    5555,
    timeout = 20 segundos
)
Enter fullscreen mode Exit fullscreen mode

Repare em:

timeout = 20 segundos
Enter fullscreen mode Exit fullscreen mode

Aqui utilizamos ao mesmo tempo:

  • argumento nomeado;
  • valor numérico;
  • unidade de tempo.

36. Mobile

Depois de obter a conexão:

va celular = mobile.conectar(conexao)
Enter fullscreen mode Exit fullscreen mode

Podemos trabalhar com o objeto retornado:

mostrar(celular.estatisticas())
Enter fullscreen mode Exit fullscreen mode

Código:

import #connector
import #mobile

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

va celular = mobile.conectar(conexao)

mostrar(celular.estatisticas())
Enter fullscreen mode Exit fullscreen mode

37. Criando interfaces

Agora podemos entrar em uma área diferente.

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

Criamos uma janela:

va app = ui.janela()
Enter fullscreen mode Exit fullscreen mode

Adicionamos um título:

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

38. Estrutura da interface

Podemos definir elementos:

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

Aqui começamos a trabalhar com uma sintaxe especializada para interfaces.

39. Estilo

Depois podemos aplicar estilo:

app.style({

    background("#101010"),

    color("#ffffff")
})
Enter fullscreen mode Exit fullscreen mode

40. Abrindo a janela

Por fim:

app.abrir()
Enter fullscreen mode Exit fullscreen mode

Aplicação completa:

import [
    #ui,
    #style
]

va app = ui.janela()

app.titulo("JLScript App")

app.ui({

    main(class="app") {

        h1("Bem-vindo")

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

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

app.style({

    background("#101010"),

    color("#ffffff")
})

app.abrir()
Enter fullscreen mode Exit fullscreen mode

41. Organizando funções

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

Na maioria das vezes significa dividir melhor o problema.

Ruim:

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

Podemos transformar essa lógica em 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

Agora:

va total = calcularTotal(30, 4)

mostrar(total)
Enter fullscreen mode Exit fullscreen mode

A lógica ficou reutilizável.

42. Escopo

Variáveis criadas dentro de uma função pertencem àquele contexto.

func calcular() {

    va resultado = 10 + 5

    mostrar(resultado)
}
Enter fullscreen mode Exit fullscreen mode

resultado existe dentro da função.

Esse conceito fica cada vez mais importante conforme o projeto cresce.

43. Juntando módulos

Podemos importar vários sistemas:

import [
    #api,
    #database,
    #json
]
Enter fullscreen mode Exit fullscreen mode

Agora o programa pode ter:

  • servidor;
  • banco;
  • processamento de dados.

44. Projeto maior

Vamos juntar vários conceitos.

import [
    #api,
    #database
]

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

Criamos uma função:

func criarUsuario(nome, idade) {

    se (nome == null) {
        retorne false
    }

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

    retorne true
}
Enter fullscreen mode Exit fullscreen mode

Agora criamos a API:

va app = api.criar(3000)
Enter fullscreen mode Exit fullscreen mode

Criamos uma rota:

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

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

E iniciamos:

app.iniciar()
Enter fullscreen mode Exit fullscreen mode

45. Projeto completo 

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")
Enter fullscreen mode Exit fullscreen mode

Neste exemplo utilizamos:

  • imports;
  • módulos;
  • banco de dados;
  • variáveis;
  • funções;
  • parâmetros;
  • condições;
  • retorno;
  • callbacks;
  • objetos;
  • API HTTP.

46. Do básico ao avançado

Você começou aqui:

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

Depois aprendeu:

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

Passou para:

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

Depois:

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

Até chegar em:

import #api
Enter fullscreen mode Exit fullscreen mode

e construir aplicações que podem trabalhar com:

  • APIs;
  • HTTP;
  • banco de dados;
  • arquivos;
  • JSON;
  • tempo;
  • rede;
  • dispositivos;
  • interfaces;
  • testes;
  • compilação.

🧛 Cores Dracula para JLScript

Para documentação e editores, uma identidade visual inspirada no Dracula Theme pode utilizar aproximadamente estas categorias:

Elemento JLScript Cor Dracula
se, senao, func, retorne, import Pink #ff79c6
Strings Yellow #f1fa8c
Números Purple #bd93f9
#api, #ui, #database Cyan #8be9fd
Funções nativas Green #50fa7b
Unidades de tempo Orange #ffb86c
Comentários Comment #6272a4
Texto normal Foreground #f8f8f2
Fundo Background #282a36

O arquivo Markdown não controla essas cores sozinho. O syntax highlighter do site/editor precisa possuir uma gramática JLScript e um tema Dracula.

📚 Ordem recomendada de estudo

  1. mostrar()
  2. valores
  3. variáveis
  4. operadores
  5. condições
  6. loops
  7. funções
  8. listas
  9. objetos
  10. tratamento de erros
  11. imports
  12. módulos
  13. tempo
  14. APIs
  15. banco de dados
  16. dispositivos
  17. UI
  18. organização de projetos

Conclusão

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

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

sem exigir uma quantidade absurda de conhecimento inicial.

Mas a mesma linguagem pode continuar acompanhando o programador quando ele começa a trabalhar com:

import #api
import #database
import #connector
import #ui
Enter fullscreen mode Exit fullscreen mode

A ideia não é apenas possuir uma sintaxe simples.

A ideia é criar um ecossistema no qual seja possível começar aprendendo programação e continuar evoluindo até construir aplicações maiores.

JLScript: simples para começar, poderosa para continuar.

Top comments (0)