O MelScript é uma linguagem de programação web projetada para facilitar o desenvolvimento de aplicações interativas e dinâmicas. Com uma sintaxe simples e poderosa, o MelScript permite criar páginas web responsivas e funcionais, integrando facilmente elementos visuais e lógicos. Ele é ideal para desenvolvedores que buscam uma ferramenta eficiente para criar interfaces de usuário intuitivas e personalizadas, utilizando recursos avançados como manipulação de DOM e interações com APIs externas de forma direta e eficiente.
O MelScript é uma homenagem à cachorra Mel de Ravy NS, o criador da linguagem. O desenvolvimento do MelScript começou em 13 de junho de 2024, com o objetivo de tornar a programação web acessível e poderosa para todos os desenvolvedores. Ao todo, existem 73 palavras-chave no MelScript, cada uma desempenhando um papel fundamental na criação de aplicações dinâmicas e interativas. Mel, a cachorra, infelizmente faleceu, mas sua memória vive através desta linguagem de programação.
Abaixo está uma imagem que representa o MelScript:
Para executar MelScript, é necessário incluir o HTML apropriado no seu projeto. Abaixo está um exemplo de HTML que inclui o script da biblioteca MelScript a partir do link especificado e um código MelScript dentro da tag <mel></mel>.
<!DOCTYPE html>
<html lang="pt-br">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Exemplo MelScript</title>
<script src="https://mel-script.vercel.app/Rec/1.0.3"></script>
<!-- ou -->
<script src="https://mel-script.netlify.app/Rec/1.0.3"></script>
</head>
<body>
<mel>
imprimir("Olá, mundo!");
</mel>
</body>
</html>
Você deve escolher apenas um dos links para incluir o script da biblioteca MelScript, seja da Vercel ou da Netlify. Incluir ambos os links simultaneamente pode causar conflitos e erros de execução devido a duplicidade de definições e funções. Escolha o que for mais conveniente para seu ambiente de desenvolvimento ou o que apresentar melhor desempenho e estabilidade em seus testes.
HTML (HyperText Markup Language) é a linguagem padrão usada para criar páginas da web. Ele define a estrutura e o conteúdo de um documento web por meio de uma série de elementos e tags que descrevem diferentes partes da página, como cabeçalhos, parágrafos, links, imagens e muito mais. O HTML é a espinha dorsal de qualquer site e trabalha em conjunto com CSS (Cascading Style Sheets) e JavaScript para criar páginas web interativas e visualmente atraentes.
Um documento HTML começa com a declaração <!DOCTYPE html>, que informa ao navegador que o documento está em HTML5. O elemento <html> contém todo o conteúdo da página, dividido em duas seções principais: <head> e <body>. A seção <head> inclui metadados sobre o documento, como o conjunto de caracteres, o título da página e links para scripts e folhas de estilo. A seção <body> contém o conteúdo visível da página, como texto, imagens, vídeos e outros elementos multimídia.
Incorporar scripts de bibliotecas como MelScript é feito na seção <head> usando a tag <script>. Isso permite que você adicione funcionalidades avançadas e interatividade à sua página web, tornando-a mais dinâmica e responsiva.
Para especificar o idioma no código MelScript, você pode utilizar um dos seguintes métodos:
MEL_SCRIPT_LANG: Defina o idioma do script MELScript configurando o atributo MEL_SCRIPT_LANG. Use "en" para inglês ou "pt-br" para português. Exemplo:
MEL_SCRIPT_LANG = "pt-br" // ou "en" para inglês
lang no elemento mel: Alternativamente, você pode definir o idioma diretamente no elemento <mel> usando o atributo lang. Exemplo:
<mel lang="pt-br">
// Seu código MELScript aqui
</mel>
Explicação: Esses métodos garantem que o código MelScript seja interpretado conforme o idioma desejado, facilitando a compreensão e a execução dos scripts.
Exemplo do uso da função `imprimir()` para exibir uma mensagem.
imprimir("Olá, mundo!");
Explicação: A função `imprimir()` é usada para exibir uma mensagem na saída. Neste exemplo, ela imprime "Olá, mundo!".
Exemplo do uso da função `imprimir()` com posicionamento e cor especificados.
imprimir("Olá, mundo!")
.posicao(100, 50)
.cor("#ff0000");
Explicação:
A função `imprimir()` pode ser estendida com os métodos `.posicao(x, y)` para definir a posição do texto na tela e `.cor()` para especificar a cor do texto.
Neste exemplo, "Olá, mundo!" é impresso na posição (100, 50) da tela com a cor vermelha (#ff0000).
Exemplo de uso das funções img, vid, aud e exb com imprimir().
// uso do img para imprimir uma imagem
imprimir({ img: "MelScript.jpg" })
// uso do vid para imprimir um vídeo
imprimir({ vid: "mov.mp4" })
// uso do aud para imprimir um áudio
imprimir({ aud: "horse.ogg" })
// uso do exb para imprimir imagem, áudio, vídeo
imprimir({ exb: "150.jpg" })
Explicação:
imprimir({ img: "MelScript.jpg" }): Imprime uma imagem.imprimir({ vid: "mov.mp4" }): Imprime um vídeo.imprimir({ aud: "horse.ogg" }): Imprime um áudio.imprimir({ exb: "150.jpg" }): Imprime uma imagem, áudio ou vídeo.Exemplo de como definir uma variável e atribuir um valor a ela.
variavel = "Olá, mundo!";
imprimir(variavel);
Explicação: Neste exemplo, a variável `variavel` é definida e recebe o valor `"Olá, mundo!"`. Em seguida, o conteúdo da variável é impresso usando a função `imprimir()`.
Exemplo que verifica se um usuário está logado e imprime uma mensagem apropriada.
usuarioEstaLogado = verdadeiro; // Definindo se o usuário está logado como verdadeiro
se(usuarioEstaLogado) { // Inicia uma verificação condicional para saber se o usuário está logado
imprimir("Bem-vindo ao sistema!"); // Imprime uma mensagem de boas-vindas
} senao { // Se a condição for falsa
imprimir("Faça login para acessar."); // Imprime uma mensagem solicitando login
}
Explicação: O `se` é usado para avaliar uma condição (nesse caso, se o usuário está logado). Se a condição for verdadeira (`senao`), uma ação é executada (imprimir uma mensagem de boas-vindas). Se a condição for falsa (`senao`), outra ação é executada (imprimir uma mensagem para fazer login).
O `se` é uma estrutura condicional usada para avaliar uma condição e decidir qual bloco de código deve ser executado com base no resultado dessa avaliação.
No exemplo abaixo, o `se` verifica se o usuário está logado e, se a condição for satisfeita, exibe uma mensagem de boas-vindas.
usuarioEstaLogado = verdadeiro;
se(usuarioEstaLogado) { // Inicia a verificação condicional
imprimir("Bem-vindo ao sistema!"); // Ação a ser executada
}
Este exemplo demonstra como usar as estruturas condicionais `se`, `senao`, e `senao se` para lidar com diferentes condições e executar ações apropriadas.
usuarioEstaLogado = nulo; // Definindo o estado de login como nulo
se(usuarioEstaLogado) { // Inicia uma verificação condicional para saber se o usuário está logado
imprimir("Bem-vindo ao sistema!"); // Imprime uma mensagem de boas-vindas
} senao se(usuarioEstaLogado === nulo) { // Se a condição no 'se' for falsa e a nova condição for verdadeira (usuarioEstaLogado é nulo)
imprimir("Erro: estado de login indefinido."); // Imprime uma mensagem de erro
} senao { // Se nenhuma das condições anteriores for verdadeira
imprimir("Faça login para acessar."); // Imprime uma mensagem solicitando login
}
Explicação:
Funções em MelScript permitem encapsular blocos de código para reutilização. Veja como definir uma função simples que imprime uma mensagem:
funcao imprimirMensagem(mensagem) {
imprimir("Mensagem recebida: " , mensagem);
}
Explicação:
1. funcao imprimirMensagem(mensagem) {: Aqui é declarada uma função chamada imprimirMensagem que aceita um parâmetro mensagem.
2. imprimir("Mensagem recebida: " , mensagem);: Dentro da função, utilizamos imprimir() para exibir a mensagem recebida, concatenada com o texto "Mensagem recebida: ".
Exemplo de um loop `enquanto`, que executa repetidamente enquanto a condição especificada for verdadeira.
i = 0;
enquanto(() => {
retornar i < 5;
}).efetue(() => {
imprimir("Iteração " , i);
i++;
});
Explicação: A estrutura `enquanto` avalia a condição `i < 5`. Enquanto essa condição for verdadeira, o bloco de código dentro de `.efetue` é executado repetidamente, incrementando o valor de `i` e imprimindo a iteração atual.
Exemplo de como lidar com exceções usando `tentar`, `pegar` e `final`.
tentar(() => {
senha = "123n5";
se(senha.tamanho < 6){
lancar novo Erro("A senha deve ter pelo menos 6 caracteres.");
}
imprimir("Senha válida");
})
.pegar((erro) => {
imprimir("Erro capturado: " , erro.message);
})
.final(() => {
imprimir("Bloco final executado.");
});
Explicação: O bloco `tentar` é usado para envolver código que pode gerar exceções. Se uma exceção for lançada dentro do bloco `tentar`, o bloco `pegar` captura a exceção e executa um tratamento específico para ela. O bloco `final` é opcional e sempre é executado, independentemente de ocorrer ou não uma exceção.
Exemplo de como usar uma função de retrochamada em MelScript.
funcao oi(h, retro) {
retrochamada(h, retro);
}
funcao exibirMensagem(mensagem) {
imprimir("Mensagem recebida: " , mensagem);
}
mensagem = "Olá, mundo!";
oi(mensagem, exibirMensagem);
Explicação: Neste exemplo, a função `oi` é definida para aceitar dois argumentos: `h`, que é a mensagem a ser processada, e `retro`, que é a função de retrochamada. Dentro de `oi`, a função `retrochamada` é chamada com `h` e `retro`, realizando a retrochamada. A função `exibirMensagem` é a função de retrochamada passada para `oi`, que simplesmente imprime a mensagem recebida usando `imprimir()`.
Exemplo de uso do `para` para iterar e imprimir uma mensagem múltiplas vezes.
para(
0, // Início: começando de 0
i => i < 5, // Condição: enquanto i for menor que 5
i => i , 1, // Incremento: incrementando i em 1 a cada iteração
i => imprimir("Oi, " , i) // Corpo do loop: imprimir "Oi," seguido pelo valor de i
);
Explicação: O `para` é utilizado para realizar um loop controlado, com os parâmetros especificados dentro dos parênteses. Neste exemplo, ele começa em 0, continua enquanto i for menor que 5, incrementa i em 1 a cada iteração, e imprime "Oi," seguido pelo valor de i.
O `_iMSE()` é usado para executar código MelScript diretamente.
valor = "imprimir('oi')"
_iMSE(valor)
Explicação:
1. valor = "imprimir('oi')": Define uma variável `valor` que contém uma string com código MelScript para imprimir "oi".
2. _iMSE(valor): Chama a função `_iMSE()` passando `valor` como argumento para executar o código MelScript contido na variável.
3. O código dentro do bloco `mel` é executado diretamente, resultando na impressão de "oi" na saída.
Exemplo de como definir e instanciar objetos usando "esse" e "novo".
funcao Pessoa(nome, idade) {
esse.nome = nome;
esse.idade = idade;
}
pessoa1 = novo Pessoa('Maria', 30);
imprimir(pessoa1.nome);
imprimir(pessoa1.idade);
pessoa2 = novo Pessoa('João', 25);
imprimir(pessoa2.nome);
imprimir(pessoa2.idade);
Explicação:
Aqui, a função `Pessoa` é definida para criar objetos do tipo pessoa com propriedades `nome` e `idade`.
Usando `esse.nome = nome;` e `esse.idade = idade;`, definimos as propriedades do objeto dentro da função construtora.
Depois, criamos duas instâncias (`pessoa1` e `pessoa2`) usando `novo Pessoa('nome', idade);`.
Em seguida, imprimimos o nome e a idade de cada pessoa usando `imprimir(pessoa1.nome);`, `imprimir(pessoa1.idade);`, `imprimir(pessoa2.nome);` e `imprimir(pessoa2.idade);`.
Exemplo que mostra como acessar e utilizar a constante `MEL_SCRIPT_VERSAO`.
imprimir("Versão atual do MelScript: " , MEL_SCRIPT_VERSAO);
Explicação:
Aqui, a constante `MEL_SCRIPT_VERSAO` é acessada diretamente para imprimir a versão atual do MelScript.
Exemplo de como criar um elemento <p> dinamicamente usando `criar.doc.elemento()`.
criar.doc.elemento('p', 'Este é um parágrafo criado dinamicamente pelo criar.doc.elemento()');
Explicação:
Este código demonstra como criar dinamicamente um elemento <p> no documento HTML utilizando `criar.doc.elemento()`, inserindo o conteúdo "Este é um parágrafo criado dinamicamente pelo criar.doc.elemento()".
Exemplo de como inserir um script no documento usando `criar.doc.escrever()`.
criar.doc.escrever('<script>console.error("n")</script>');
Explicação:
Este código mostra como inserir dinamicamente um script no documento HTML usando `criar.doc.escrever()`, mas ele será exibido como texto sem ser executado.
Exemplo de como criar um botão e definir um evento de clique usando `criar.botao()` e `EventoClick()`.
criar.botao("btn", "Clique aqui").corFundo("branco").cor("preto").posicao(200, 200);
EventoClick('btn', () => {
imprimir("Botão clicado!");
});
Explicação:
Este código cria dinamicamente um botão com ID "btn", texto "Clique aqui", cor de fundo branca, cor de texto preta e posicionamento em (200, 200) pixels na página. Também define um evento de clique para imprimir "Botão clicado!" quando o botão for clicado.
Exemplo de como definir e utilizar uma classe em MelScript.
classe Pessoa {
// Método construtor
construtor(nome, idade) {
esse.nome = nome;
esse.idade = idade;
}
// Método para imprimir informações da pessoa
apresentar() {
imprimir("Nome: " , esse.nome , ", Idade: " , esse.idade);
}
}
// Criando instâncias da classe Pessoa
pessoa1 = novo Pessoa('Maria', 30);
pessoa2 = novo Pessoa('João', 25);
// Chamando método para apresentar as informações das pessoas
pessoa1.apresentar();
pessoa2.apresentar();
Explicação:
Aqui, uma classe `Pessoa` é definida usando a palavra-chave `classe`.
O método construtor `construtor(nome, idade)` é usado para inicializar os atributos `nome` e `idade` de cada objeto `Pessoa` criado.
O método `apresentar()` é definido para imprimir as informações da pessoa (nome e idade).
Depois, duas instâncias (`pessoa1` e `pessoa2`) da classe `Pessoa` são criadas usando `novo Pessoa('nome', idade);`.
Finalmente, chamamos o método `apresentar()` de cada instância para imprimir as informações das pessoas criadas.
Exemplo que demonstra como lançar e capturar uma exceção usando `lancar` e `pegar`.
funcao validarIdade(idade) {
se(idade < 18).entao(() => {
lancar novo Erro("A idade mínima é 18 anos.");
});
imprimir("Idade válida: " , idade);
}
tentar(() => {
validarIdade(20); // Chamando a função com uma idade válida
})
.pegar((erro) => {
imprimir("Erro capturado: " , erro.message);
})
.final(() => {
imprimir("Bloco final executado.");
});
Explicação:
1. A função `validarIdade(idade)` é definida para verificar se a idade fornecida é maior ou igual a 18 anos. Se não for, uma exceção é lançada usando `lancar novo Erro("mensagem")`.
2. O bloco `tentar` é usado para envolver o código que pode gerar uma exceção. Aqui, chamamos `validarIdade(20)`, que é uma idade válida.
3. Se uma exceção for lançada dentro do bloco `tentar`, o bloco `pegar` captura a exceção e executa um tratamento específico para ela, imprimindo uma mensagem de erro com `imprimir("Erro capturado: " , erro.message)`.
4. O bloco `final` é opcional e sempre é executado, independentemente de ocorrer ou não uma exceção, imprimindo "Bloco final executado.".
funcao calcularAreaRetangulo(base, altura) {
area = base * altura;
retornar area;
}
largura = 5;
altura = 3;
areaCalculada = calcularAreaRetangulo(largura, altura);
imprimir("A área do retângulo com largura " , largura , " e altura " , altura , " é: " , areaCalculada);
Explicação:
1. A função `calcularAreaRetangulo(base, altura)` recebe dois parâmetros: `base` e `altura`.
2. Dentro da função, a variável `area` é calculada multiplicando `base` por `altura`.
3. A palavra-chave `retornar` é usada para retornar o valor da `area` para onde a função foi chamada.
4. Fora da função, as variáveis `largura` e `altura` são definidas como 5 e 3, respectivamente.
5. Chamamos a função `calcularAreaRetangulo(largura, altura)` passando `largura` e `altura` como argumentos. O resultado é armazenado na variável `areaCalculada`.
6. Finalmente, usamos `imprimir()` para exibir a mensagem contendo a área calculada do retângulo.
funcao Pessoa(nome, idade) {
esse.nome = nome;
esse.idade = idade;
}
// Adicionando um método ao protótipo Pessoa
Pessoa.prototipo.apresentar = funcao() {
imprimir("Olá, eu sou " , esse.nome , " e tenho " , esse.idade , " anos.");
}
// Criando um objeto Funcionario que herda de Pessoa
Funcionario = novo Pessoa("João", 30);
// Adicionando propriedades específicas de Funcionario
Funcionario.cargo = "Desenvolvedor";
Funcionario.salario = 5000;
// Adicionando métodos específicos de Funcionario
Funcionario.trabalhar = funcao() {
imprimir(esse.nome , " está trabalhando como " , esse.cargo);
}
// Usando métodos herdados do protótipo Pessoa
Funcionario.apresentar();
// Usando métodos específicos de Funcionario
Funcionario.trabalhar();
Explicação:
1. `Pessoa` é definido como um protótipo usando uma função construtora que aceita `nome` e `idade` como parâmetros. Dentro da função construtora, `esse` refere-se ao objeto atual sendo criado.
2. Um método `apresentar` é adicionado ao protótipo `Pessoa`, que imprime uma mensagem com o nome e a idade da pessoa.
3. `Funcionario` é criado usando `novo Pessoa("João", 30)`, herdando assim as propriedades `nome` e `idade` de `Pessoa`.
4. Propriedades adicionais como `cargo` e `salario` são atribuídas diretamente a `Funcionario`.
5. Um método específico de `Funcionario`, `trabalhar`, é definido para imprimir o nome e o cargo do funcionário.
6. `Funcionario.apresentar()` invoca o método `apresentar` herdado de `Pessoa`, que imprime uma mensagem com o nome e a idade de `Funcionario`.
7. `Funcionario.trabalhar()` invoca o método `trabalhar` específico de `Funcionario`, que imprime uma mensagem indicando que `Funcionario` está trabalhando.
// Exemplo 1: Uso de verdadeiro e falso em uma condição
idade = 25;
se(idade >= 18){
imprimir("Você é maior de idade.");
}
senao{
imprimir("Você é menor de idade.");
}
// Exemplo 2: Atribuição de valores booleanos
podeDirigir = verdadeiro;
precisaAutorizacao = falso;
// Exemplo 3: Retornando valores booleanos de funções
funcao verificarIdade(idade) {
retornar idade >= 18;
}
maiorDeIdade = verificarIdade(20);
imprimir("É maior de idade? " , maiorDeIdade);
Explicação:
1. Em MelScript, `verdadeiro` e `falso` são usados principalmente em estruturas condicionais (`se`) para avaliar expressões booleanas. No exemplo 1, `verdadeiro` é utilizado para verificar se a idade é maior ou igual a 18 anos, enquanto `falso` é usado no bloco `senao`.
2. Na segunda parte do exemplo, `verdadeiro` e `falso` são atribuídos diretamente a variáveis `podeDirigir` e `precisaAutorizacao`, respectivamente. Isso é comum ao definir estados lógicos ou flags.
3. No exemplo 3, uma função `verificarIdade` é definida para retornar `verdadeiro` se a idade passada como argumento for maior ou igual a 18, caso contrário, ela retorna `falso`. O resultado da função é então impresso para mostrar se a idade é considerada maior de idade.
expressao = "5 + 3 * 2";
resultado = avaliar(expressao);
imprimir("Resultado da expressão '" , expressao , "': " , resultado);
Explicação:
1. `expressao` é uma string contendo a expressão matemática "5 , 3 * 2".
2. `avaliar(expressao)` é usado para calcular o resultado da expressão.
3. O resultado é armazenado na variável `resultado`.
4. `imprimir("Resultado da expressão '" , expressao , "': " , resultado)` exibe o resultado calculado na saída.
texto = "Olá, mundo!";
novoTexto = substituir(texto, "mundo", "amigo");
imprimir("Texto original: " , texto);
imprimir("Novo texto: " , novoTexto);
Explicação:
1. `texto` é inicializado com a string `"Olá, mundo!"`.
2. `substituir(texto, "mundo", "amigo")` é usado para substituir a palavra `"mundo"` por `"amigo"` na string `texto`.
3. O resultado da substituição é armazenado na variável `novoTexto`.
4. `imprimir("Texto original: " , texto)` exibe a string original.
5. `imprimir("Novo texto: " , novoTexto)` exibe a string após a substituição.
Exemplo de uso das funções TempoLimite e loop.
// Função que será executada após o tempo limite
funcao mostrarMensagem() {
imprimir("Tempo limite atingido!");
}
// Chama a função mostrarMensagem após 3 segundos (3000 milissegundos)
TempoLimite(3000, mostrarMensagem);
// Função que será executada em loop
funcao executarAcao() {
imprimir("Ação executada no loop!");
}
// Cria um loop que executa a função executarAcao a cada 2 segundos (2000 milissegundos)
meuLoop = loop(executarAcao, 2000);
// Inicia o loop
meuLoop.iniciar();
// Pausa o loop após 5 segundos
TempoLimite(5000, funcao() {
imprimir("Loop pausado!");
meuLoop.pausar();
});
// Retoma o loop após mais 5 segundos
TempoLimite(10000, funcao() {
imprimir("Loop retomado!");
meuLoop.retomar();
});
// Altera o tempo de execução do loop para 1 segundo após mais 5 segundos
TempoLimite(15000, funcao() {
imprimir("Tempo do loop alterado para 1 segundo!");
meuLoop.alterarTempo(1000);
});
Explicação:
TempoLimite(3000, mostrarMensagem);: Define uma função que será executada após 3 segundos.loop(executarAcao, 2000);: Cria um loop que executa uma função a cada 2 segundos.meuLoop.iniciar();: Inicia o loop.meuLoop.pausar();: Pausa o loop.meuLoop.retomar();: Retoma o loop.meuLoop.alterarTempo(1000);: Altera o intervalo de tempo do loop para 1 segundo.Exemplo de uso das funções obt.Dia, obt.Hora, obt.Mes, obt.Segundos, obt.Minuto, obt.Navegador.Versao e obt.Navegador.Nome.
funcao mostrarInformacoes() {
info = `
Hora: ${obt.Hora}:${obt.Minuto}:${obt.Segundos}
Data: ${obt.Dia}/${obt.Mes}/${obt.Ano}
Navegador: ${obt.Navegador.Nome}
Versão do Navegador: ${obt.Navegador.Versao}
`;
imprimir(info);
}
mostrarInformacoes()
Explicação:
obt.Hora: Retorna a hora atual.obt.Minuto: Retorna o minuto atual.obt.Segundos: Retorna os segundos atuais.obt.Dia: Retorna o dia atual.obt.Mes: Retorna o mês atual.obt.Ano: Retorna o ano atual.obt.Navegador.Nome: Retorna o nome do navegador.obt.Navegador.Versao: Retorna a versão do navegador.Exemplo de uso das funções analisarInteiro e analisarFlutuante.
numeroString1 = "42";
numeroInteiro = analisarInteiro(numeroString1);
imprimir(numeroInteiro);
numeroString2 = "3.14";
numeroFlutuante = analisarFlutuante(numeroString2);
imprimir(numeroFlutuante);
Explicação:
analisarInteiro: Converte uma string em um número inteiro.analisarFlutuante: Converte uma string em um número flutuante.Exemplo do uso da função `buscarId()` para buscar um elemento pelo seu ID.
criar.doc.buscarId("pai");
Explicação: A função `buscarId()` é usada para buscar um elemento pelo seu ID no documento. Neste exemplo, ela busca o elemento com o ID "pai".
Exemplo do uso da função `paraCada()` para iterar sobre uma lista de números.
numeros = [1, 2, 3, 4, 5];
numeros.paraCada(funcao(numero, indice, array) {
imprimir(`Número: ${numero}, Índice: ${indice}`);
});
Explicação: A função `paraCada()` é usada para iterar sobre cada elemento de uma lista. Neste exemplo, ela percorre a lista de números e imprime cada número junto com seu índice.
Exemplo do uso da função `alerta()` para exibir uma mensagem de alerta.
alerta("Esta é uma mensagem de alerta!");
Explicação: A função `alerta()` é usada para exibir uma mensagem de alerta ao usuário. Neste exemplo, ela exibe "Esta é uma mensagem de alerta!".
Exemplo do uso da sintaxe de tipagem para definir variáveis com tipos e valores.
// Definindo variáveis com tipagem
Tip Nome = string:"João"; // Tipo String
Tip Idade = numero:30; // Tipo Número
Tip Altura = numero:1.75; // Tipo Decimal
Tip Ativo = boleano:true; // Tipo Booleano
Tip Configuracao = objeto:{ chave: "valor" }; // Tipo Objeto
Tip Itens = array:[1, 2, 3]; // Tipo Array
Tip Desconhecido = desconhecido; // Tipo Undefined
Tip Simbolo = simbolo; // Tipo Symbol
Tip GrandeNumero = bigint:123456789012345678901234567890; // Tipo BigInt
Explicação: A sintaxe `Tip Nome = tipo:valor;` é usada para definir variáveis com um tipo específico e um valor inicial. Neste exemplo:
Tip Nome = string:"João"; define uma variável `Nome` do tipo `String` com o valor `"João"`.Tip Idade = numero:30; define uma variável `Idade` do tipo `Número` com o valor `30`.Tip Altura = numero:1.75; define uma variável `Altura` do tipo `Decimal` com o valor `1.75`.Tip Ativo = boleano:true; define uma variável `Ativo` do tipo `Booleano` com o valor `true`.Tip Configuracao = objeto:{ chave: "valor" }; define uma variável `Configuracao` do tipo `Objeto` com um valor de chave-valor.Tip Itens = array:[1, 2, 3]; define uma variável `Itens` do tipo `Array` com valores `[1, 2, 3]`.Tip Desconhecido = desconhecido; define uma variável `Desconhecido` do tipo `Undefined`.Tip Simbolo = simbolo; define uma variável `Simbolo` do tipo `Symbol`.Tip GrandeNumero = bigint:123456789012345678901234567890; define uma variável `GrandeNumero` do tipo `BigInt` com um valor muito grande.Exemplo do uso da palavra-chave global para definir variáveis globais.
// Usar a variável global antes de declará-la
imprimir(nome2);
// Declarar a variável global
global nome2 = "ravy";
imprimir(nome2);
// Outro exemplo: declarar uma variável global e atribuir um valor
global idade;
idade = 30;
imprimir(idade);
Explicação: A palavra-chave global é utilizada para declarar variáveis globais que podem ser acessadas em qualquer parte do script. No exemplo acima, nome2 é usado antes de ser declarado globalmente, e depois é definido com o valor "ravy". Em seguida, idade é declarada globalmente e atribuída com o valor 30. Isso demonstra que as variáveis globais podem ser usadas em qualquer parte do código, mesmo antes de sua declaração efetiva.
A seguir, estão algumas funções matemáticas fornecidas pela biblioteca Mat, com exemplos de uso e descrições.
// Gera um número aleatório
Mat.rnd();
// Arredonda 4.7 para o inteiro mais próximo (5)
Mat.rd(4.7);
// Arredonda 4.7 para baixo (4)
Mat.ch(4.7);
// Arredonda 4.2 para cima (5)
Mat.tp(4.2);
// Calcula o seno de 30 graus (0.5)
Mat.sin(Mat.PI / 6);
// Calcula o cosseno de 60 graus (0.5)
Mat.cos(Mat.PI / 3);
// Calcula a tangente de 45 graus (1)
Mat.tan(Mat.PI / 4);
// Calcula a raiz quadrada de 16 (4)
Mat.sqrt(16);
// Calcula 2 elevado a 3 (8)
Mat.pow(2, 3);
// Calcula o logaritmo natural de 10 (aproximadamente 2.3026)
Mat.logNL(10);
// Calcula o valor absoluto de -5 (5)
Mat.abs(-5);
// Retorna o maior número (7)
Mat.max(1, 3, 5, 7);
// Retorna o menor número (1)
Mat.min(1, 3, 5, 7);
// Retorna o valor de π (3.14159...)
Mat.Pi;
Explicação: A biblioteca Mat fornece várias funções matemáticas úteis:
Mat.rnd(); - Gera um número aleatório.Mat.rd(valor); - Arredonda valor para o inteiro mais próximo.Mat.ch(valor); - Arredonda valor para baixo.Mat.tp(valor); - Arredonda valor para cima.Mat.sin(angulo); - Calcula o seno de um ângulo (em radianos).Mat.cos(angulo); - Calcula o cosseno de um ângulo (em radianos).Mat.tan(angulo); - Calcula a tangente de um ângulo (em radianos).Mat.sqrt(valor); - Calcula a raiz quadrada de valor.Mat.pow(base, expoente); - Calcula base elevado a expoente.Mat.logNL(valor); - Calcula o logaritmo natural de valor.Mat.abs(valor); - Calcula o valor absoluto de valor.Mat.max(...valores); - Retorna o maior valor entre os fornecidos.Mat.min(...valores); - Retorna o menor valor entre os fornecidos.Mat.Pi; - Retorna o valor de π (aproximadamente 3.14159).abrir()A função abrir() é usada para abrir recursos, como URLs de APIs, e retorna um objeto que permite encadear operações como usar e tratarErro.
// Suponha que você tenha uma URL de API que retorna um JSON
url = 'https://api.exemplo.com/dados';
// Chama a função abrir com a URL
abrir(url)
.usar(data => {
imprimir('Dados recebidos:', data);
// Faça algo com os dados recebidos
})
.tratarErro(error => {
imprimir('Ocorreu um erro:', error);
// Lida com o erro
});
usar()A função usar() é utilizada para processar os dados recebidos de um recurso aberto, como uma resposta de API. Ela é chamada após abrir e permite manipular os dados recebidos.
usar(data => {
imprimir('Dados recebidos:', data);
// Faça algo com os dados recebidos
});
tratarErro()A função tratarErro() é usada para lidar com erros que ocorrem durante a execução de operações assíncronas. Ela é chamada após abrir e usar para capturar e tratar erros.
tratarErro(error => {
imprimir('Ocorreu um erro:', error);
// Lida com o erro
});
Explicação: Estas funções são projetadas para manipular recursos de forma segura e tratar erros de forma eficiente:
abrir(url); - Abre um recurso, como uma URL de API, e retorna um objeto para encadear operações.usar(função); - Processa os dados recebidos de um recurso aberto, permitindo manipular esses dados.tratarErro(função); - Lida com erros que possam ocorrer durante a execução das operações.Exemplo do uso da função importar() para carregar e processar um arquivo de código.
importar("caminho/para/o/arquivo.mel");
Explicação: A função importar() é usada para carregar e processar um arquivo de código MelScript. Neste exemplo, ela carrega o arquivo localizado em "caminho/para/o/arquivo.mel".
Exemplo do uso da função Evento() para adicionar um ouvinte de evento a um elemento HTML.
Evento("clique", "#meuBotao", ()=>{
imprimir("Botão clicado!");
});
Explicação: A função Evento() é usada para associar um evento específico a um elemento HTML. Neste exemplo, a função registra um ouvinte para o evento de clique em um botão identificado pelo seletor #meuBotao. Quando o botão é clicado, a função de callback é executada e uma mensagem é exibida no console.
clique - Ocorre quando um único clique é realizado.dbclique - Ocorre quando dois cliques consecutivos são realizados.iniciar - Ocorre quando a página é carregada.mouseSobre - Ocorre quando o mouse passa sobre um elemento.mouseFora - Ocorre quando o mouse sai de um elemento.enviar - Ocorre quando um formulário é enviado.mudar - Ocorre quando o valor de um elemento de entrada muda.redimensionar - Ocorre quando a janela do navegador é redimensionada.rolagem - Ocorre quando a página é rolada.teclaPressionada - Ocorre quando uma tecla é pressionada.Para usar a função Evento(), você precisa especificar o tipo de evento, o seletor do elemento HTML (se aplicável), e uma função de callback que será executada quando o evento ocorrer.
Exemplo do uso da propriedade valor para acessar o valor de um elemento HTML.
criar.input("texto", "meuInput");
input = criar.doc.buscarId("meuInput");
imprimir(input.valor);
Explicação: Use input.valor para acessar o valor de um elemento identificado por buscarId. No exemplo acima, o valor do campo de entrada é impresso.
Exemplo de como usar a função criar.input() para criar e estilizar um campo de entrada HTML.
criar.input("texto", "meuInput", "Valor inicial", "Digite aqui...");
Explicação: A função criar.input() cria um campo de entrada HTML com o tipo especificado, um ID opcional, um valor inicial e um placeholder. Ela aplica estilos básicos e adiciona o campo ao corpo da página.
texto - Campo de texto simples.senha - Campo para senha.numero - Campo para números.data - Campo para datas.email - Campo para endereços de e-mail.hora - Campo para horas.telefone - Campo para números de telefone.url - Campo para URLs.arquivo - Campo para seleção de arquivos.cor - Campo para seleção de cores.intervalo - Campo para seleção de intervalos.busca - Campo de busca.escondido - Campo oculto.mes - Campo para seleção de meses.semana - Campo para seleção de semanas.caixaselecao - Campo de seleção (checkbox).radio - Campo de seleção por rádio.enviar - Botão de envio.reiniciar - Botão de reinício.imagem - Botão de imagem.botao - Botão genérico.Exemplo de como usar a função converterTipo para converter o tipo de um valor.
valor = "123";
imprimir(valor.converterTipo("numero")); // Exibe 123 como número
valor = "true";
imprimir(valor.converterTipo("booleano")); // Exibe true como booleano
valor = "2024-08-16";
imprimir(valor.converterTipo("data")); // Exibe a data correspondente
Explicação: A função converterTipo permite converter o valor de um objeto para um tipo específico, como string, número, booleano, objeto, array ou data. O tipo desejado é passado como argumento para a função.
string - Converte o valor para uma string.numero - Converte o valor para um número. Se a conversão falhar, retorna NaN.booleano - Converte o valor para um booleano. Valores como "true" e "false" são convertidos corretamente.objeto - Converte o valor para um objeto. Se o valor for null, retorna null.array - Converte o valor para um array. Se o valor já for um array, retorna-o; caso contrário, coloca o valor em um array.data - Converte o valor para uma data. Se a conversão falhar, retorna null.O método reduzir() é utilizado para reduzir um array a um único valor, aplicando uma função acumuladora a cada elemento. No exemplo abaixo, somamos todos os valores de um array e calculamos a média.
numeros = [10, 20, 30, 40, 50];
// Reduz o array somando todos os valores
soma = numeros.reduzir((acumulador, valorAtual) => {
retornar acumulador + valorAtual; // Adiciona o valor atual ao acumulador
}, 0);
media = soma / numeros .tamanho; // Calcula a média
imprimir(media); // Imprime a média
O método mapear() cria um novo array com os resultados da aplicação de uma função a cada elemento do array original. O exemplo abaixo calcula o quadrado de cada número.
numbers = [1, 2, 3, 4, 5];
// Mapeia os números para seus quadrados
squaredNumbers = numbers.mapear(num => num * num);
imprimir(squaredNumbers); // Imprime o array com números elevados ao quadrado
O método filtro() retorna um novo array contendo apenas os elementos que satisfazem a condição especificada. No exemplo abaixo, selecionamos os números pares.
numbers = [1, 2, 3, 4, 5];
// Filtra os números para obter apenas os pares
evenNumbers = numbers.filtro(num => num % 2 === 0);
imprimir(evenNumbers); // Imprime os números pares
O método empurrar() adiciona um ou mais elementos ao final de um array. O exemplo abaixo adiciona "kiwi" ao final do array de frutas.
frutas = ['maçã', 'banana', 'laranja'];
// Adiciona "kiwi" ao final do array
frutas.empurrar("kiwi");
imprimir(frutas); // Imprime o array com o novo elemento
O método encontrar() retorna o primeiro elemento que satisfaz a condição fornecida. O exemplo abaixo encontra o primeiro número maior que 3.
números = [1, 2, 3, 4, 5];
// Encontra o primeiro número maior que 3
encontrado = números.encontrar(x => x > 3);
imprimir(encontrado); // Imprime o número encontrado
O método remover() elimina o último elemento de um array. No exemplo abaixo, removemos o último elemento do array de frutas.
frutas = ['maçã', 'banana', 'laranja'];
// Remove o último elemento do array
removido = frutas.remover();
imprimir(removido); // Imprime o elemento removido
imprimir(frutas); // Imprime o array atualizado
O método juntar() converte um array em uma string, unindo os elementos com o delimitador especificado. No exemplo abaixo, os elementos são unidos com ' - '.
frutas = ['maçã', 'banana', 'laranja'];
// Junta os elementos do array com ' - ' como delimitador
resultado = frutas.juntar(' - ');
imprimir(resultado); // Imprime a string resultante
O método inserir() adiciona um ou mais elementos no início de um array e retorna o novo comprimento do array. O exemplo abaixo adiciona "maçã" e "kiwi" ao início do array de frutas.
frutas = ['banana', 'laranja'];
// Insere "maçã" e "kiwi" no início do array
comprimento = frutas.inserir('maçã', 'kiwi');
imprimir(frutas); // Imprime o array com os novos elementos
imprimir(comprimento); // Imprime o comprimento do array após a inserção
O método removerInicio() remove o primeiro elemento de um array e o retorna. No exemplo abaixo, removemos o primeiro elemento do array de frutas.
frutas = ['maçã', 'banana', 'laranja'];
// Remove o primeiro elemento do array
removido = frutas.removerInicio();
imprimir(removido); // Imprime o elemento removido
imprimir(frutas); // Imprime o array atualizado
O método fatiar() extrai uma parte de um array com base nos índices fornecidos. No exemplo abaixo, obtemos uma fatia do array de frutas do índice 1 ao 3 (exclusivo).
frutas = ['maçã', 'banana', 'laranja'];
// Extrai uma fatia do array do índice 1 ao 3
parte = frutas.fatiar(1, 3);
imprimir(parte); // Imprime a fatia do array
O método concatenar() combina dois ou mais arrays ou valores em um único array. No exemplo abaixo, concatenamos um array adicional com o array de frutas.
frutas = ['maçã', 'banana'];
maisFrutas = frutas.concatenar('laranja', ['kiwi']);
imprimir(maisFrutas); // Imprime o array concatenado
O método intercalar() insere elementos em uma posição específica do array, deslocando os elementos existentes. No exemplo abaixo, inserimos "kiwi" e "manga" na posição 1.
frutas = ['maçã', 'banana', 'laranja'];
// Intercala "kiwi" e "manga" na posição 1
removidos = frutas.intercalar(1, 1, 'kiwi', 'manga');
imprimir(removidos); // Imprime os elementos removidos
imprimir(frutas); // Imprime o array atualizado
O método organizar() ordena os elementos de um array de acordo com a função de comparação fornecida. No exemplo abaixo, organizamos um array de números em ordem crescente.
numeros = [5, 3, 8, 1, 2];
// Organiza o array em ordem crescente
numeros.organizar((a, b) => a - b);
imprimir(numeros); // Imprime o array organizado
O método JSON.stringificar() converte um objeto MelScript em uma string JSON, que é um formato de texto padrão para representar dados estruturados. No exemplo abaixo, convertendo um objeto que contém várias propriedades e aninhamentos em uma string JSON.
obj = {
nome: "Alice",
idade: 25,
hobbies: ["ler", "viajar"],
ativo: verdadeiro,
endereco: {
cidade: "Rio de Janeiro",
estado: "RJ"
}
};
// Converte o objeto em uma string JSON
jsonString = JSON.stringificar(obj);
imprimir(jsonString); // Imprime a string JSON resultante
Explicação: A função JSON.stringificar() é usada para converter um objeto MelScript em uma string JSON. Isso é útil para enviar dados para um servidor ou armazenar dados em formato de texto. No exemplo acima, o objeto obj é transformado em uma string JSON, que é então impressa.
Exemplo do uso do método paraMaiusculas() para converter uma string para maiúsculas.
texto = "olá, mundo!";
imprimir(texto.paraMaiusculas()); // Saída: "OLÁ, MUNDO!"
Explicação: O método paraMaiusculas() converte todos os caracteres da string para maiúsculas. Neste exemplo, a string "olá, mundo!" é transformada em "OLÁ, MUNDO!".
Exemplo do uso do método paraMinusculas() para converter uma string para minúsculas.
texto = "OLÁ, MUNDO!";
imprimir(texto.paraMinusculas()); // Saída: "olá, mundo!"
Explicação: O método paraMinusculas() converte todos os caracteres da string para minúsculas. Neste exemplo, a string "OLÁ, MUNDO!" é transformada em "olá, mundo!".
Exemplo do uso do método paraString() para converter números e outros tipos para string.
numero = 123456.789;
imprimir(numero.paraString()); // Saída: "123456.789"
booleano = verdadeiro;
imprimir(booleano.paraString()); // Saída: "true"
objeto = { chave: "valor", numero: 42 };
imprimir(objeto.paraString()); // Saída: '{"chave":"valor","numero":42}'
Explicação: O método paraString() converte diferentes tipos de dados para uma representação em string. Neste exemplo, um número, um valor booleano e um objeto são convertidos para strings. O número 123456.789 é convertido para "123456.789", o booleano true é convertido para "true" e o objeto é convertido para sua representação JSON.
Exemplo do uso do método paraCorrigido() para formatar um número com um número específico de casas decimais.
numero = 123456.789;
imprimir(numero.paraCorrigido(2)); // Saída: "123456.79"
Explicação: O método paraCorrigido() formata o número com o número especificado de casas decimais. Neste exemplo, o número 123456.789 é formatado com 2 casas decimais, resultando em "123456.79".
Exemplo do uso do método paraExponencial() para converter um número para notação exponencial.
numero = 123456.789;
imprimir(numero.paraExponencial(2)); // Saída: "1.23e+5"
Explicação: O método paraExponencial() converte o número para a notação exponencial com o número especificado de casas decimais. Neste exemplo, o número 123456.789 é convertido para "1.23e+5" com 2 casas decimais.
Exemplo do uso do método paraPrecisao() para ajustar o número para uma precisão especificada de dígitos.
numero = 123456.789;
imprimir(numero.paraPrecisao(6)); // Saída: "123456.8"
Explicação: O método paraPrecisao() ajusta o número para uma precisão especificada de dígitos. Neste exemplo, o número 123456.789 é arredondado para "123456.8" com precisão de 6 dígitos.
Exemplo do uso do método paraLocalString() para formatar números e datas conforme as convenções locais.
numero = 123456.789;
imprimir(numero.paraLocalString('pt-BR')); // Saída: "123.456,789"
data = novo Data('2024-08-17T10:00:00Z');
imprimir(data.paraLocalString('pt-BR')); // Saída: "17/08/2024 07:00:00"
array = [123456.789, 98765.432];
imprimir(array.paraLocalString('en-US')); // Saída: "123,456.789,98,765.432"
Explicação: O método paraLocalString() formata números e datas conforme as convenções locais especificadas. No exemplo, o número 123456.789 é formatado para o padrão brasileiro, resultando em "123.456,789". A data é formatada para "17/08/2024 07:00:00" no padrão brasileiro, e o array é formatado para o padrão dos EUA, resultando em "123,456.789,98,765.432".
Exemplo do uso da função obt.Bateria.Nivel() para obter o nível da bateria.
obt.Bateria.Nivel((erro, valor) => {
se(erro) =>
imprimir("Erro ao obter nível da bateria:", erro);
senao =>
imprimir("Nível da bateria:", valor , "%");
});
Explicação: A função obt.Bateria.Nivel() é usada para obter o nível atual da bateria. Neste exemplo, ela chama uma função de retorno que processa o resultado, exibindo o nível da bateria ou um erro, se ocorrer.
Exemplo do uso da função buscarSeletor() para selecionar e manipular um elemento HTML.
elemento = criar.doc.buscarSeletor("#meuElemento");
se(elemento) =>
elemento.textoConteudo = "Texto atualizado com buscarSeletor()";
senao =>
imprimir("Elemento não encontrado!");
Explicação: A função criar.doc
buscarSeletor() é usada para selecionar um elemento HTML pelo seu seletor CSS. Neste exemplo, ela seleciona o elemento com o ID "meuElemento" e atualiza o seu conteúdo de texto. Se o elemento não for encontrado, um erro é exibido no console.
Exemplo do uso da função obt.Navegador.IPLocal() para obter o endereço IP local.
obt.Navegador.IPLocal((ip) => {
imprimir("Endereço IP Local:", ip);
});
Explicação: A função obt.Navegador.IPLocal() é usada para obter o endereço IP local do navegador. Neste exemplo, ela chama uma função de retorno que processa o resultado, exibindo o IP local obtido.
Exemplo do uso da propriedade textoConteudo para definir ou obter o conteúdo de texto de um elemento HTML.
elemento = criar.doc.buscarSeletor("#meuElemento");
se(elemento) =>
elemento.textoConteudo = "Texto atualizado com buscarSeletor()";
senao =>
imprimir("Elemento não encontrado!");
Explicação: A propriedade textoConteudo é usada para definir ou obter o conteúdo de texto de um elemento HTML. Neste exemplo, o conteúdo de texto do elemento selecionado é atualizado para "Texto atualizado com buscarSeletor()". Se o elemento não for encontrado, uma mensagem de erro será exibida no console.
O objeto Navegador fornece métodos para manipulação da navegação e rolagem da página. Veja como usar cada um desses métodos:
// Redireciona para uma nova URL
Navegador.rediricionar("https://exemplo.com");
// Volta para a página anterior
Navegador.voltar();
// Avança para a próxima página
Navegador.avancar();
// Recarrega a página atual
Navegador.atualizar();
// Fecha a janela atual
Navegador.fechar();
// Rola a página para a posição (x, y)
Navegador.rolarPara(0, 500);
// Rola a página por um deslocamento (dx, dy)
Navegador.rolarPor(0, 100);
Explicação:
Navegador.rediricionar(url): Redireciona o navegador para a URL especificada em url.Navegador.voltar(): Navega para a página anterior no histórico do navegador.Navegador.avancar(): Navega para a próxima página no histórico do navegador.Navegador.atualizar(): Recarrega a página atual.Navegador.fechar(): Fecha a janela do navegador atual.Navegador.rolarPara(x, y): Rola a página até a posição especificada pelas coordenadas (x, y).Navegador.rolarPor(dx, dy): Rola a página pelo deslocamento especificado (dx, dy).A função areaTexto é utilizada para criar uma área de texto personalizável em uma página web. Abaixo estão os parâmetros que a função aceita:
// Exemplo de chamada da função areaTexto
criar.areaTexto('meuTexto', 'Texto inicial', 'Digite aqui...', 5, 30);
Parâmetros da função criar.areaTexto:
id: String - O identificador único para o elemento de textarea.valor: String - O texto inicial que será exibido na área de texto.placeholder: String - O texto que será exibido quando a área de texto estiver vazia.linhas: Number (opcional) - O número de linhas visíveis na área de texto. O padrão é 5.colunas: Number (opcional) - O número de colunas visíveis na área de texto. O padrão é 30.Explicação: A função criar.areaTexto cria uma área de texto com os parâmetros fornecidos para personalizar o comportamento e a aparência do elemento de textarea na página web.
A função CopiarTexto(texto) é usada para copiar o conteúdo de texto para a área de transferência. Veja como usar a função em conjunto com outros elementos de interface:
// Cria uma área de texto com o ID 'ent' e um texto inicial
criar.areaTexto('ent', null, "Texto para ser copiado");
// Cria um botão com o ID 'btn' e o texto 'COPIAR'
criar.botao('btn', "COPIAR")
.corFundo("azul");
// Define um evento de clique para o botão
EventoClick('btn', () => {
CopiarTexto(ent.valor);
});
Explicação:
criar.areaTexto('ent', null, "Texto para ser copiado"): Cria uma área de texto com o ID 'ent' e define um texto inicial que será exibido na área de texto.criar.botao('btn', "COPIAR").corFundo("azul"): Cria um botão com o ID 'btn' e o texto 'COPIAR'. O botão tem a cor de fundo azul.EventoClick('btn', () => { CopiarTexto(ent.valor); }): Define um evento de clique para o botão com o ID 'btn'. Quando o botão é clicado, o conteúdo da área de texto com o ID 'ent' é copiado para a área de transferência usando a função CopiarTexto.Observação: A função CopiarTexto(texto) deve ser definida para realizar a ação de copiar o texto fornecido para a área de transferência.
A função estiloGrafico permite configurar estilos gráficos de um elemento HTML com base em um objeto de configuração. Veja a seguir uma explicação dos parâmetros e como a função aplica os estilos:
// Exemplo de uso da função estiloGrafico
criar.botao('btn',"Botão")
btn.estiloGrafico({
Cor: 'vermelho',
CorFundo: 'azul',
Tamanho: [200, 100],
Posicao: [50, 50]
});
Parâmetros da função estiloGrafico:
Cor: String - Define a cor do texto do elemento. Exemplo: 'vermelho'.CorFundo: String - Define a cor de fundo do elemento. Exemplo: 'azul'.Tamanho: Array - Define o tamanho do elemento com largura e altura em pixels. Exemplo: [200, 100].Posicao: Array - Define a posição do elemento com coordenadas X e Y em pixels. Exemplo: [50, 50].Explicação: A função estiloGrafico configura o estilo visual do elemento HTML, permitindo a personalização de cor do texto, cor de fundo, tamanho e posição com base nos parâmetros fornecidos.
obt.Laterna.Ligar() e obt.Laterna.Desligar()Esses métodos permitem ligar e desligar a lanterna do dispositivo, oferecendo controle direto sobre o hardware da lanterna. Veja os exemplos abaixo para entender o funcionamento.
// Exemplo de uso da função obt.Laterna.Ligar()
obt.Laterna.Ligar(); // Liga a lanterna do dispositivo
// Exemplo de uso da função obt.Laterna.Desligar()
obt.Laterna.Desligar(); // Desliga a lanterna do dispositivo
Explicação:
obt.Laterna.Ligar(): Liga a lanterna do dispositivo, permitindo que ela ilumine. Pode ser usado em situações onde o controle da luz é necessário, como em aplicativos de utilidades ou funcionalidades de emergência.obt.Laterna.Desligar(): Desliga a lanterna do dispositivo, apagando a luz quando não for mais necessária.Contexto: Esses métodos são úteis para aplicativos que precisam controlar diretamente a lanterna do dispositivo, como aplicativos de lanterna ou outros que requerem o uso do flash do dispositivo como fonte de luz.
Na nova versão 1.0.3 RFZ do MelScript, "RFZ" significa "Recriado do Zero". Esta versão foi necessária devido à descoberta de bugs significativos no código anterior. Além disso, houve a complicação de que o MelScript estava sendo desenvolvido em um único editor que travou, resultando na perda completa do código e deixando-o com falhas. Assim, a versão RFZ foi uma reescrita completa para corrigir esses problemas e garantir um funcionamento mais estável e confiável do MelScript.
A versão 1.0.3 RFZ do MelScript foi lançada no dia 8 de agosto de 2024, às 21h07.
O MelScript é uma linguagem de programação web que honra a memória de Mel, a cachorra de Ravy NS. Desde seu início em 8 de agosto de 2024, o MelScript tem se destacado por sua simplicidade e poder, permitindo que desenvolvedores de todos os níveis criem aplicações web interativas e dinâmicas. Com suas 73 palavras-chave, o MelScript oferece uma ampla gama de funcionalidades, facilitando a criação de interfaces de usuário personalizadas e eficientes. Através do MelScript, Ravy NS busca tornar a programação web mais acessível e intuitiva, perpetuando o legado de sua amada cachorra Mel.