├── .github └── CONTRIBUTING.md ├── .gitignore ├── docs ├── .vuepress │ ├── config.js │ ├── public │ │ └── images │ │ │ ├── a.png │ │ │ ├── icone.png │ │ │ ├── logo.png │ │ │ ├── logo_egua.svg │ │ │ └── picpay.jpeg │ └── styles │ │ └── palette.styl ├── README.md ├── egua │ ├── README.md │ ├── bibliotecas.md │ ├── classes.md │ ├── fluxo_controle.md │ ├── funcao.md │ ├── funcoes_integradas.md │ ├── operadores.md │ ├── tipos_dados.md │ └── variaveis.md └── logica │ └── README.md ├── package-lock.json └── package.json /.github/CONTRIBUTING.md: -------------------------------------------------------------------------------- 1 | # Guia de contribuição da Documentação 2 | 3 | Olá! Estamos muito felizes que você quer contribuir com nosso projeto. Antes de contribuir, por favor tenha certeza de seguir todas as recomendações. 4 | 5 | ## Introdução 6 | 7 | O desenvolvimento da documentação, assim como a sua utilização, possui uma estrutura que facilita a contribuição, visto que usamos o VuePress para gerar site estatico usando arquivos .md, por tanto essa facilidade só é garantida a partir de algumas práticas e regras que devem ser seguidas. Para facilitar a análise de pull requests e garantir a integridade da documentação e funcionalidade da mesma em cada commit, prezamos pela entrega continua, onde garantimos que o usuário possa entender o funcionamento e estrturua de nossa documentação e módulos. 8 | 9 | ## Montando ambiente 10 | 11 | ### Requisitos de sistema 12 | 13 | - Windows 10 com WSL ou Linux Ubuntu ou Linux mint >= 18.04 14 | - [Guia de instalação do WSL no Windows 10](https://docs.microsoft.com/pt-br/windows/wsl/install-win10) 15 | 16 | - Node.js versão LTS >= 10+ [link instalação] 17 | - [Guia de instalação do Node.js no WSL ou Linux](https://github.com/nodesource/distributions/blob/master/README.md#deb) 18 | 19 | - NPM >= 6 20 | > Vale lembrar que ainda não efetuamos testes para garantir o funcionamento no NPM 7. 21 | 22 | - VuePress 23 | ``` 24 | npm install -g vuepress 25 | ``` 26 | 27 | ## Como contribuir 28 | 29 | ### Contribuindo com a documentação 30 | Basta você fazer um Push do nosso [repositorio da documentação](https://github.com/eguatech/docs) e fazer as mudanças necessárias seguindo o vídeo tutorial abaixo: 31 | 32 | [![](https://img.youtube.com/vi/ZewlvNv6tAk/0.jpg)](https://youtu.be/ZewlvNv6tAk "") 33 | 34 | Vídeo tutorial em inglês para aprender o básico de VuePress: 35 | 36 | [![](https://img.youtube.com/vi/5Kqyhu_eIcw/hqdefault.jpg)](https://youtu.be/5Kqyhu_eIcw "") 37 | 38 | Outras recomendações: 39 | 40 | | Artigos | Vídeos | 41 | |---|---| 42 | | [Conheça o Vuepress](https://vuejs-brasil.com.br/conheca-o-vuepress/) | [Vuepress rápido e simples](https://youtu.be/Blwpr3nVQbk) | 43 | | [Como fazer um README.md BONITÃO](https://medium.com/@raullesteves/github-como-fazer-um-readme-md-bonit%C3%A3o-c85c8f154f8) | [Personalizando o README.md com markdown](https://www.youtube.com/watch?v=T70t3mDiwvg&ab_channel=ProfessorJos%C3%A9deAssis) | 44 | | [Mastering Markdown (Inglês)](https://guides.github.com/features/mastering-markdown/) | [Create An Amazing Profile ReadMe (Inglês)](https://www.youtube.com/watch?v=ECuqb5Tv9qI&ab_channel=codeSTACKr) | 45 | 46 | ### Rodar localmente e realizar teste 47 | Durante e após o seu desenvolvimento, recomendamos sempre executar os testes necessários. 48 | 49 | Para rodar o VuePress localmente em sua maquína: 50 | ```sh 51 | # NPM 52 | vuepress dev docs 53 | ``` 54 | 55 | Após o desenvolvimento ser concluído, é necessário ter a build do projeto, que é feita com o comando: 56 | ```sh 57 | npm run docs:build 58 | ``` 59 | 60 | Por fim, seu PR deve ser efetuado na branch `desenvolvimento` e solicitamos que você descreva com detalhes as modificações feitas na documentação. 61 | 62 | ## Resumo 63 | 64 | De maneira bem resumida eis o que precisa ser feito: 65 | 66 | - [ ] Montar o ambiente. 67 | 68 | - [ ] Efetuar as suas alterações. 69 | 70 | - [ ] Executar os testes locais. 71 | 72 | - [ ] Executar a build do projeto. 73 | 74 | - [ ] Fazer o Pull Request para a branch `desenvolvimento` 75 | 76 | ## Agradecimentos 77 | 78 | Desde já agradecemos de coração pela sua contribuição ao projeto. xD -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # node modules 2 | node_modules 3 | 4 | # MacOS desktop services store 5 | .DS_Store 6 | 7 | # Log files 8 | *.log 9 | 10 | # Meta files 11 | TODOs.md 12 | 13 | # Editors 14 | .idea 15 | 16 | # VuePress temp directory 17 | .temp 18 | 19 | # Docs dist directory 20 | /vuepress 21 | docs/.vuepress/dist/ 22 | 23 | # Typescript build dist 24 | packages/@vuepress/shared-utils/lib/ 25 | packages/@vuepress/shared-utils/types/ -------------------------------------------------------------------------------- /docs/.vuepress/config.js: -------------------------------------------------------------------------------- 1 | module.exports = { 2 | head: [ 3 | ['link', { rel: 'icon', href: '/images/logo_egua.svg' }] 4 | ], 5 | title: "Documentação | Linguagem Égua", 6 | description: "Programação simples e moderna em português", 7 | themeConfig: { 8 | nav: [ 9 | { text: "Home", link: '/' }, 10 | { text: "Égua", link: '/egua/' }, 11 | { text: "Lógica", link: '/logica/' }, 12 | { text: "Programar", link: 'https://egua.dev/idegua' } 13 | ], 14 | 15 | sidebar: { 16 | '/egua/': [ 17 | '', 18 | 'variaveis', 19 | 'tipos_dados', 20 | 'operadores', 21 | 'fluxo_controle', 22 | 'funcao', 23 | 'funcoes_integradas', 24 | 'bibliotecas', 25 | 'classes' 26 | ], 27 | '/logica/': [ 28 | '' 29 | ] 30 | }, 31 | logo: "/images/logo.png" 32 | }, 33 | base: "/docs/" 34 | } 35 | -------------------------------------------------------------------------------- /docs/.vuepress/public/images/a.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/eguadev/docs/59cc44f519aa2633e16087c9ca1e35d977a83c86/docs/.vuepress/public/images/a.png -------------------------------------------------------------------------------- /docs/.vuepress/public/images/icone.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/eguadev/docs/59cc44f519aa2633e16087c9ca1e35d977a83c86/docs/.vuepress/public/images/icone.png -------------------------------------------------------------------------------- /docs/.vuepress/public/images/logo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/eguadev/docs/59cc44f519aa2633e16087c9ca1e35d977a83c86/docs/.vuepress/public/images/logo.png -------------------------------------------------------------------------------- /docs/.vuepress/public/images/logo_egua.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | 5 | 8 | 9 | 10 | 14 | 15 | 16 | 17 | -------------------------------------------------------------------------------- /docs/.vuepress/public/images/picpay.jpeg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/eguadev/docs/59cc44f519aa2633e16087c9ca1e35d977a83c86/docs/.vuepress/public/images/picpay.jpeg -------------------------------------------------------------------------------- /docs/.vuepress/styles/palette.styl: -------------------------------------------------------------------------------- 1 | // colors 2 | $accentColor = #ff4b55 3 | $textColor = #000000 4 | $borderColor = #eaecef 5 | $codeBgColor = #282c34 6 | $arrowBgColor = #ccc 7 | $badgeTipColor = #ff4b55 8 | $badgeWarningColor = darken(#ffe564, 35%) 9 | $badgeErrorColor = #55D109 10 | 11 | // layout 12 | $navbarHeight = 3.6rem 13 | $sidebarWidth = 20rem 14 | $contentWidth = 740px 15 | $homePageWidth = 960px 16 | 17 | // responsive breakpoints 18 | $MQNarrow = 959px 19 | $MQMobile = 719px 20 | $MQMobileNarrow = 419px -------------------------------------------------------------------------------- /docs/README.md: -------------------------------------------------------------------------------- 1 | --- 2 | home: true 3 | heroImage: /images/logo.png 4 | actionText: Aprender → 5 | actionLink: /egua/ 6 | features: 7 | - title: Disponível na web 8 | details: Linguagem leve para ser executada no navegador. 9 | - title: Atualizada 10 | details: Constantes atualizações e melhorias em seu código aberto. 11 | - title: Plugar e Brincar 12 | details: É só entrar e programar, não precisar configurar nada. 13 | footer: Feito com ❤ em Belém do Pará. 14 | --- 15 | -------------------------------------------------------------------------------- /docs/egua/README.md: -------------------------------------------------------------------------------- 1 | --- 2 | description: Linguagem de Programação Égua 3 | --- 4 | 5 | # Égua 6 | 7 | Ao aprender a programar em égua, você estará adquirindo uma base sólida de conhecimentos fundamentais que são aplicáveis ​​a várias outras linguagens de programação. Através da linguagem égua, você aprenderá conceitos como variáveis, estruturas de controle (como condicionais e laços de repetição) e funções. Esses são blocos de construção essenciais em programação e são usados em várias linguagens. 8 | 9 | Uma das vantagens de começar a programar em égua é que ele possui uma sintaxe simplificada e regras claras. Isso torna mais fácil compreender e implementar algoritmos, permitindo que você se concentre nos conceitos fundamentais sem se preocupar com detalhes complexos da linguagem. 10 | 11 | Além disso, a IDEgua (interface online de prgramação da linguagem) oferece um ambiente de desenvolvimento amigável e de fácil acesso. Essa característica é especialmente útil para iniciantes, pois ajuda a entender o fluxo de execução e entender erros de forma mais intuitiva. 12 | 13 | ## Uso online 14 | A linguagem Egua pode ser executada de maneira online via navegador. 15 | 16 | 17 | 18 | 19 | 20 | ## Olá mundo 21 | 22 | Em Égua, o famoso "Olá, Mundo!" pode ser exibido com um simples trecho de código. Veja abaixo: 23 | 24 | ```js 25 | escreva("Olá, Mundo!"); 26 | ``` 27 | 28 | Nesse código, utilizamos a função `escreva()` para exibir a mensagem "Olá, Mundo!". 29 | 30 | Ao executar esse código, você verá a frase "Olá, Mundo!" sendo exibida na tela. Esse é um exemplo básico que demonstra como iniciar a programação em Égua. A partir daí, você pode prosseguir para a aprendizagem de conceitos mais avançados e começar a desenvolver programas mais completos. 31 | 32 | ## Comentários 33 | Comentários são trechos de texto que servem para adicionar explicações ou notas relevantes ao código. Eles são ignorados pelo interpretador durante a execução do programa. 34 | 35 | - Comentários de linha única: Iniciados com o caractere `//`, são utilizados para adicionar informações em uma única linha de código. 36 | 37 | Exemplo: 38 | ```js 39 | // Este é um comentário de linha única 40 | var idade = 10; // Outro comentário de linha única 41 | ``` 42 | 43 | Os comentários são úteis para tornar o código mais compreensível, documentar funcionalidades e facilitar a colaboração entre desenvolvedores. Eles não são executados e não afetam o funcionamento do programa. 44 | -------------------------------------------------------------------------------- /docs/egua/bibliotecas.md: -------------------------------------------------------------------------------- 1 | # Bibliotecas 2 | As bibliotecas padrão são conjuntos de funcionalidades internas à linguagem que podem ser utilizadas para estender suas capacidades. No entanto, essas bibliotecas não são carregadas automaticamente, é necessário importá-las explicitamente para utilizá-las. Isso ajuda a manter a linguagem mais leve e permite que você escolha quais recursos deseja usar em cada programa. 3 | 4 | ```js 5 | var tempo = importar("tempo"); 6 | 7 | escreva(tempo.tempo()); 8 | ``` 9 | 10 | Nesse exemplo, a biblioteca "tempo" foi importada e a função `tempo()` da biblioteca foi chamada para exibir o tempo atual. Cada biblioteca pode ter suas próprias funções e recursos específicos que podem ser usados em seu programa. 11 | 12 | Ao utilizar bibliotecas, você pode aproveitar o trabalho de outros desenvolvedores e economizar tempo e esforço, pois não precisa escrever tudo do zero. Além das bibliotecas padrão, existem bibliotecas de terceiros disponíveis que podem ser adicionadas ao seu projeto para expandir ainda mais as funcionalidades da linguagem. 13 | 14 | Explore as bibliotecas disponíveis e leia a documentação fornecida para entender como usar os recursos disponíveis. Isso permitirá que você escreva programas mais eficientes e poderosos, aproveitando ao máximo o ecossistema de bibliotecas disponíveis para a linguagem Egua. -------------------------------------------------------------------------------- /docs/egua/classes.md: -------------------------------------------------------------------------------- 1 | # Classes 2 | 3 | A linguagem Egua suporta a orientação a objetos de forma nativa, permitindo a criação e manipulação de classes, objetos, métodos e herança. 4 | 5 | ## Criando uma classe 6 | 7 | Uma classe é uma estrutura que define as características e comportamentos de um objeto. Em Egua, você pode criar uma classe usando a palavra-chave `classe` seguida pelo nome da classe. 8 | 9 | Exemplo: 10 | ```js 11 | classe Teste {} 12 | ``` 13 | 14 | ## Instanciando uma classe 15 | 16 | A instância de uma classe é criada através da chamada da classe, criando assim um objeto. Em Egua, para criar uma instância de uma classe, basta chamar o nome da classe seguido de parênteses. 17 | 18 | Exemplo: 19 | ```js 20 | classe Teste {} 21 | 22 | var teste = Teste(); 23 | escreva(teste); // Saída: "" 24 | ``` 25 | 26 | ## Métodos 27 | 28 | Os métodos são funções associadas a uma classe que definem os comportamentos do objeto. Em Egua, você pode definir métodos dentro de uma classe sem a palavra-chave `função`. Os métodos podem ser acessados através da instância do objeto usando o operador `.`. 29 | 30 | Exemplo: 31 | ```js 32 | classe Teste { 33 | testeFunção() { 34 | escreva("olá"); 35 | } 36 | } 37 | 38 | var teste = Teste(); 39 | teste.testeFunção(); // Saída: "olá" 40 | ``` 41 | 42 | ## Referência à instância (isto) 43 | 44 | Dentro de cada método de instância, você pode usar a palavra-chave `isto` para se referir à instância atual do objeto. Ela é uma referência auto-declarativa que permite acessar o estado e os métodos da instância. 45 | 46 | Exemplo: 47 | ```js 48 | classe Teste { 49 | construtor() { 50 | escreva(isto); 51 | } 52 | } 53 | 54 | var teste = Teste(); // Saída: "" 55 | ``` 56 | 57 | ## Estado do objeto 58 | 59 | O estado de um objeto se refere às variáveis que são atribuídas a ele. Em Egua, você pode definir o estado de um objeto usando a palavra-chave `isto` dentro de um método. Isso permite que cada instância do objeto tenha seu próprio estado. 60 | 61 | Exemplo: 62 | ```js 63 | classe Teste { 64 | testeFunção() { 65 | isto.a = 100; 66 | escreva(isto.a); // Saída: "100" 67 | } 68 | } 69 | 70 | var teste = Teste(); 71 | teste.testeFunção(); 72 | ``` 73 | 74 | ## Construtor 75 | 76 | O construtor é um método especial que é automaticamente chamado ao instanciar a classe. Ele é usado para inicializar o estado do objeto ou executar qualquer código de configuração necessário. 77 | 78 | Exemplo: 79 | ```js 80 | classe Teste { 81 | construtor() { 82 | escreva("começou"); 83 | } 84 | } 85 | 86 | var teste = Teste(); // Saída: "começou" 87 | ``` 88 | 89 | ## Herança 90 | 91 | Em Egua, é possível criar uma classe filha a partir de uma classe pai, herdando seus atributos e métodos. Isso permite reutilizar código existente e adicionar novos atributos e métodos específicos da classe filha. 92 | 93 | Exemplo: 94 | ```js 95 | classe Animal {} 96 | 97 | classe Cachorro herda Animal {} 98 | ``` 99 | 100 | ```js 101 | classe Animal { 102 | corre() { 103 | escreva("correndo"); 104 | } 105 | } 106 | 107 | classe Cachorro herda Animal {} 108 | 109 | var thor = Cachorro(); 110 | 111 | thor.corre(); // Saída: "correndo" 112 | ``` 113 | 114 | Também é possível ch 115 | 116 | amar um método pertencente à classe pai na classe filha usando a palavra-chave `super`. Isso permite acessar e executar o código da classe pai. 117 | 118 | Exemplo: 119 | ```js 120 | classe A { 121 | data(data) { 122 | escreva(data); 123 | } 124 | } 125 | 126 | classe B herda A { 127 | construtor(data) { 128 | super.data(data); 129 | } 130 | } 131 | 132 | var a = B("13/12/1981"); 133 | ``` 134 | 135 | Neste exemplo, a classe `B` herda da classe `A` e chama o método `data` da classe pai usando `super.data(data)` no construtor da classe `B`. Isso permite reutilizar o código existente na classe pai dentro da classe filha. -------------------------------------------------------------------------------- /docs/egua/fluxo_controle.md: -------------------------------------------------------------------------------- 1 | # Fluxo de Controle 2 | 3 | A programação envolve o controle de fluxo, que determina a ordem em que as instruções são executadas em um programa. A linguagem de programação égua oferece uma variedade de opções de controle de fluxo que permitem tomar decisões, repetir a execução de blocos de código e lidar com erros. 4 | 5 | ## Valores booleanos 6 | 7 | No controle de fluxo de todas as linguagens de programação, os valores booleanos desempenham um papel importante. Em égua, os valores booleanos são representados pelos termos "verdadeiro" e "falso". O controle de fluxo, como a instrução `se`, será executado somente se a condição for avaliada como verdadeira. Por exemplo, `se(verdadeiro){}` será executado porque a condição é verdadeira, enquanto `se(falso){}` não será executado porque a condição é falsa. 8 | 9 | ## Comparação de igualdade 10 | 11 | Para comparar se dois objetos são iguais em Egua, é necessário que sejam do mesmo tipo e tenham o mesmo valor. Essa comparação é avaliada como "verdadeira" se os valores forem iguais, e "falsa" caso contrário. Veja alguns exemplos: 12 | 13 | ```js 14 | 1 == 1; // Verdadeiro 15 | "1" == "1"; // Verdadeiro 16 | nulo == nulo; // Verdadeiro 17 | 18 | "1" == "2"; // Falso 19 | 1 == 2; // Falso 20 | 1 == "1"; // Falso 21 | ``` 22 | 23 | A comparação é baseada apenas na igualdade dos valores. 24 | 25 | ## Avaliação da veracidade 26 | 27 | Em égua, todos os tipos de dados, exceto "nulo" e "falso", são avaliados como verdadeiros. Veja alguns exemplos: 28 | 29 | ```js 30 | {}; // Verdadeiro 31 | 1; // Verdadeiro 32 | verdadeiro; // Verdadeiro 33 | []; // Verdadeiro 34 | 35 | 1 == '1'; // Falso devido à avaliação de falso 36 | nulo; // Falso 37 | falso; // Falso 38 | ``` 39 | 40 | ## Palavras-chave de controle 41 | 42 | A linguagem égua possui várias palavras-chave que auxiliam no controle de fluxo: 43 | 44 | - `e` - Retorna verdadeiro se ambos os valores forem verdadeiros. 45 | - `ou` - Retorna verdadeiro se pelo menos um dos valores for verdadeiro. 46 | - `em` - Retorna verdadeiro se o valor da esquerda estiver contido no valor da direita. 47 | 48 | ```js 49 | verdadeiro e verdadeiro; // Verdadeiro 50 | verdadeiro e falso; // Falso 51 | 52 | falso ou falso; // Falso 53 | verdadeiro ou falso; // Verdadeiro 54 | 55 | 'a' em ['b']; // Falso 56 | 'b' em ['b']; // Verdadeiro 57 | 'c' em 'abc'; // Verdadeiro 58 | 'chave' em {'chave': 'valor'}; 59 | ``` 60 | 61 | ## Se - Senão se - Senão 62 | 63 | A linguagem Egua fornece as instruções `se`, `senão se` e `senão` para controle de fluxo condicional eficiente. As instruções `senão se` e `senão` são opcionais e devem ser anexadas à instrução `se`. Você pode ter apenas uma instrução `senão se` adicional. Cada instrução é seguida por um bloco de código que será executado com base na condição da instrução. O bloco de código de uma instrução `se` é executado se a condição for avaliada como verdadeira. Caso contrário, as instruções `senão se` serão avaliadas em ordem, e se qualquer uma das condições for verdadeira, o bloco de código correspondente será executado. Somente um bloco `senão se` pode ser executado. Se a instrução `se` não for executada e nenhuma instrução `senão se` for executada, o bloco `senão` será executado, se fornecido. 64 | 65 | ```js 66 | // Exemplo: Imprime "sim" 67 | se (verdadeiro) { 68 | escreva('sim'); 69 | } 70 | 71 | // Exemplo: Imprime "correspondente 2" 72 | var a = 2; 73 | se (a == 1) { 74 | escreva('correspondente 1'); 75 | } senão se (a == 2) { 76 | escreva('correspondente 2'); 77 | } senão { 78 | escreva('sem valor correspondente'); 79 | } 80 | 81 | // Exemplo: Imprime "sem comparação" 82 | var a = 3; 83 | se (a == 1) { 84 | escreva('correspondente 1'); 85 | } senão se (a == 2) { 86 | escreva('correspondente 2'); 87 | } senão { 88 | escreva('Sem valor correspondente'); 89 | } 90 | ``` 91 | 92 | ## Enquanto 93 | 94 | A instrução `enquanto` em Egua é usada para criar um loop que executa repetidamente um bloco de código enquanto uma condição específica for avaliada como verdadeira. Antes de cada execução do bloco de código, a condição é verificada para determinar se o bloco deve continuar a ser executado. Se a condição for falsa no início, o bloco nunca será executado. 95 | 96 | ```js 97 | // Exemplo: Loop infinito 98 | enquanto (verdadeiro) { 99 | escreva("sim"); 100 | } 101 | ``` 102 | 103 | ## Para 104 | 105 | A instrução `para` é usada para criar um laço que executa um bloco de código um número específico de vezes. Ela possui quatro partes: um inicializador, uma condição, um passo e um corpo. Qualquer uma dessas partes pode ser deixada em branco. O inicializador é executado antes do laço `para`, a condição decide se o corpo deve ser executado, a passo é executada após cada execução do corpo e o corpo contém as instruções a serem repetidas. A instrução `para` é definida com o inicializador, a condição e a passo separados por ponto e vírgula, seguidos pelo bloco de código do corpo. 106 | 107 | ```js 108 | // Exemplo: Imprime números de 0 a 4 109 | // Inicializador, condição, passo 110 | para (var i = 0; i < 5; i = i + 1) { 111 | // Corpo 112 | escreva(i); 113 | } 114 | 115 | // Exemplo: Inicializador e passo omitidos 116 | // Imprime infinitamente porque a condição é sempre verdadeira 117 | para (; verdadeiro; ) { 118 | escreva("sim"); 119 | } 120 | ``` 121 | 122 | ## Faça - Enquanto 123 | 124 | A instrução `faça - enquanto` é usada para criar um laço que executa um bloco de código pelo menos uma vez e continua a executá-lo enquanto uma condição específica for avaliada como verdadeira. Primeiro, o bloco de código é executado e, em seguida, a condição é verificada. Se a condição for verdadeira, o bloco de código será executado novamente. Se a condição for falsa, o loop será encerrado. 125 | 126 | ```js 127 | // Exemplo: "sim" é escrito uma vez 128 | faça { 129 | escreva("sim"); 130 | } enquanto (falso); 131 | 132 | // Exemplo: Imprime números de 0 a 4 133 | var i = 0; 134 | faça { 135 | escreva(i); 136 | i = i + 1; 137 | } enquanto (i < 5); 138 | ``` 139 | 140 | ## Escolha - Caso 141 | 142 | As instruções `escolha` e `caso` são usadas para encadear várias condições e executar diferentes blocos de código com base em uma expressão de seleção. A expressão de seleção é avaliada e comparada aos valores de cada caso. Se houver uma correspondência, o bloco de código correspondente ao caso será executado. Se nenhum caso corresponder, o bloco de código padrão será executado, se fornecido. 143 | 144 | ```js 145 | // Exemplo: Imprime "correspondente à opção 2" 146 | escolha (1) { 147 | caso "1": 148 | escreva("correspondente à opção 1"); 149 | 150 | caso 1: 151 | escreva("correspondente à opção 2"); 152 | 153 | padrão: 154 | escreva("Sem opção correspondente"); 155 | } 156 | 157 | // Exemplo: Imprime "Sem opção correspondente" 158 | escolha (2) { 159 | caso "1": 160 | escreva("correspondente à opção 1"); 161 | 162 | caso 1: 163 | escreva("correspondente à opção 2"); 164 | 165 | padrão: 166 | escreva("Sem opção correspondente"); 167 | } 168 | ``` 169 | 170 | ## Tente - Pegue - Finalmente 171 | 172 | A estrutura `tente - pegue - finalmente` é usada para lidar com exceções ou erros que podem ocorrer durante a execução do código. O bloco `pegue` e o bloco `finalmente` são opcionais. Primeiro, o bloco `tente` é executado e, se ocorrer algum erro durante a execução, ele será capturado e o bloco `pegue` será executado. O bloco `tente` garante que os erros não interrompam o programa. Após a tentativa e, se fornecido, a execução do bloco `pegue`, o bloco `finalmente` é executado. 173 | 174 | ```js 175 | // Exemplo: Imprime "sucesso" e "pronto" 176 | tente { 177 | escreva("sucesso"); 178 | } pegue { 179 | escreva("pegue"); 180 | } finalmente { 181 | escreva("pronto"); 182 | } 183 | 184 | // Exemplo: Imprime "captura" e "pronto" 185 | tente { 186 | // Lança um erro 187 | 1 > "1"; 188 | 189 | escreva("sucesso"); 190 | } pegue { 191 | escreva("captura"); 192 | } finalmente { 193 | escreva("pronto"); 194 | } 195 | ``` 196 | 197 | Essas são as principais instruções de controle de fluxo em Egua. Com o entendimento dessas instruções, você pode criar programas mais complexos e controlar o fluxo de execução de maneira eficiente. -------------------------------------------------------------------------------- /docs/egua/funcao.md: -------------------------------------------------------------------------------- 1 | # Funções 2 | 3 | As funções são blocos de código que podem ser chamados e executados em diferentes partes de um programa. Elas ajudam a organizar o código, evitar repetições e facilitar a reutilização de trechos específicos de lógica. 4 | 5 | Existem dois tipos de funções em égua: funções padrão e funções anônimas. 6 | 7 | ## Função Padrão 8 | 9 | As funções padrão podem ser declaradas usando a palavra-chave `função`, seguida por um nome para a função, uma lista de parâmetros entre parênteses (cada elemento separado por vírgula) e um bloco de código delimitado por chaves. Veja um exemplo: 10 | 11 | ```js 12 | função saudação(nome) { 13 | escreva("Olá, " + nome + "!"); 14 | } 15 | 16 | saudação("Egua"); // Saída: Olá, Egua! 17 | ``` 18 | 19 | Nesse exemplo, declaramos a função `saudação` com um parâmetro `nome`. Dentro da função, usamos a instrução `escreva` para exibir uma mensagem de saudação, concatenando o nome passado como argumento. 20 | 21 | ## Função Anônima 22 | 23 | As funções anônimas são aquelas que não possuem um nome especificado. Elas são frequentemente usadas como variáveis ou passadas como argumentos para outras funções. Veja um exemplo do uso de uma função anônima na função `mapear()`: 24 | 25 | ```js 26 | var resultado = mapear([1, 2, 3], função(item) { 27 | retorna item * 2; 28 | }); 29 | 30 | escreva(resultado); // Saída: [2, 4, 6] 31 | ``` 32 | 33 | Nesse exemplo, usamos uma função anônima como argumento para a função `mapear()`. Essa função anônima recebe um parâmetro `item` e retorna o valor do item multiplicado por 2. A função `mapear()` aplica essa função anônima a cada elemento do vetor e retorna um novo vetor com os resultados. 34 | 35 | ## Chamada de Função 36 | 37 | Para executar uma função, é necessário realizar a chamada da função. A chamada de função envolve o uso do nome da função seguido por parênteses, e pode incluir argumentos, se a função esperar parâmetros. Veja um exemplo: 38 | 39 | ```js 40 | função saudação(nome) { 41 | escreva("Olá, " + nome + "!"); 42 | } 43 | 44 | saudação("Egua"); // Saída: Olá, Egua! 45 | ``` 46 | 47 | Nesse exemplo, chamamos a função `saudação` passando a string `"Egua"` como argumento. A função é executada, exibindo a mensagem "Olá, Egua!". 48 | 49 | ## Retorno de Função 50 | 51 | Uma função pode retornar um valor utilizando a palavra-chave `retorna`. Isso permite que o resultado da função seja utilizado em outras partes do programa. Veja exemplos de funções com retorno: 52 | 53 | ```js 54 | função soma(a, b) { 55 | retorna a + b; 56 | } 57 | 58 | var resultado = soma(2, 3); 59 | escreva(resultado); // Saída: 5 60 | ``` 61 | 62 | Nesse exemplo, a função `soma` recebe dois parâmetros `a` e `b` e retorna a soma dos valores. Ao chamar a função `soma(2, 3)`, o resultado é retornado e atribuído à variável `resultado`, que em seguida é exibida. 63 | 64 | Uma função também pode ter um fluxo de execução interrompido por uma instrução `retorna` sem valor. Isso encerra a execução da função imediatamente. Veja um exemplo: 65 | 66 | ```js 67 | função exibeA() { 68 | escreva("A"); 69 | retorna; 70 | escreva("B"); 71 | } 72 | 73 | exibeA(); // Saída: A 74 | ``` 75 | 76 | Nesse exemplo, a função `exibeA` exibe a letra "A" e, em seguida, a instrução `retorna` interrompe a execução da função, fazendo com que a linha `escreva("B")` nunca seja alcançada. -------------------------------------------------------------------------------- /docs/egua/funcoes_integradas.md: -------------------------------------------------------------------------------- 1 | # Funções Integradas 2 | 3 | As funções integradas da linguagem égua são ferramentas poderosas que podem ser usadas para realizar tarefas específicas. Aqui estão algumas funções internas comuns e suas descrições: 4 | 5 | ## Aleatório 6 | 7 | A função `aleatorio()` retorna um número aleatório entre 0 e 1. 8 | 9 | Exemplo: 10 | ```js 11 | var numeroAleatorio = aleatorio(); 12 | 13 | escreva(numeroAleatorio); 14 | // Saída: 0.8540051495195808 15 | ``` 16 | 17 | ## Aleatório Entre 18 | 19 | A função `aleatorioEntre(minimo, maximo)` retorna um número aleatório entre os valores `minimo` e `maximo`. O valor gerado nunca será igual ao número máximo passado para a função, sempre será um a menos. 20 | 21 | Exemplo: 22 | ```js 23 | var numeroAleatorio = aleatorioEntre(1, 9); 24 | 25 | escreva(numeroAleatorio); 26 | // Saída: um valor entre 1 e 8 27 | ``` 28 | 29 | ## Inteiro 30 | 31 | A função `inteiro(valor)` converte um número flutuante ou texto (que não contenha letras) em um número inteiro. 32 | 33 | Exemplo: 34 | ```js 35 | var testeTexto = "111"; 36 | 37 | escreva(111 + inteiro(testeTexto)); 38 | // Saída: 222 39 | ``` 40 | 41 | ## Mapear 42 | 43 | A função `mapear(vetor, funcao)` percorre um vetor e executa uma função para cada item desse vetor. Ela retorna um novo vetor contendo os resultados das chamadas da função para cada elemento do vetor original. 44 | 45 | Exemplo: 46 | ```js 47 | var array = [1, 2, 3]; 48 | 49 | var fn = função(valor) { 50 | retorna valor * 2; 51 | }; 52 | 53 | escreva(mapear(array, fn)); 54 | // Saída: [2, 4, 6] 55 | ``` 56 | 57 | ## Ordenar 58 | 59 | A função `ordenar(vetor)` é usada para ordenar os valores de um vetor em ordem crescente. Ela retorna o vetor ordenado. A função `ordenar()` só aceita vetores como entrada. 60 | 61 | Exemplo: 62 | ```js 63 | var vetorNomes = ["Lucas", "Heictor", "Julio", "Brennus", "Arleson"]; 64 | var vetorNumeros = [1, 2, 6, 7, 3, 4]; 65 | 66 | vetorNomes = ordenar(vetorNomes); 67 | escreva(vetorNomes); 68 | // Saída: Arleson, Brennus, Heictor, Julio, Lucas 69 | 70 | vetorNumeros = ordenar(vetorNumeros); 71 | escreva(vetorNumeros); 72 | // Saída: 1, 2, 3, 4, 6, 7 73 | ``` 74 | 75 | ## Real 76 | 77 | A função `real(valor)` converte um número inteiro ou texto (que não contenha letras) em um número flutuante. 78 | 79 | Exemplo: 80 | ```js 81 | var testeTexto = "504.69"; 82 | 83 | escreva(0.01 + real(testeTexto)); 84 | // Saída: 504.7 85 | ``` 86 | 87 | ## Tamanho 88 | 89 | A função `tamanho(valor)` retorna o número de elementos que compõem um vetor ou o tamanho de um texto. 90 | 91 | Exemplo: 92 | ```js 93 | var vetorNomes = ["Lucas", "Heictor", "Julio", "Brennus", "Arleson"]; 94 | var texto = "Egua"; 95 | 96 | escreva(tamanho(vetorNomes)); 97 | // Saída: 5 98 | 99 | escreva(tamanho(texto)); 100 | // Saída: 4 101 | ``` 102 | 103 | ## Texto 104 | 105 | A função `texto(valor)` converte números flutuantes ou inteiros em texto. 106 | 107 | Exemplo: 108 | ```js 109 | var testeNumero = 123; 110 | 111 | escreva("123" + texto(testeNumero)); 112 | // Saída: 123123 113 | ``` 114 | 115 | Essas funções internas são apenas algumas das muitas ferramentas disponíveis no Egua para ajudar na resolução de problemas e manipulação de dados. Ao explorar e entender essas funções, você terá mais recursos para criar programas poderosos e eficientes. -------------------------------------------------------------------------------- /docs/egua/operadores.md: -------------------------------------------------------------------------------- 1 | # Operadores 2 | 3 | Os operadores são elementos fundamentais nas linguagens de programação, pois permitem a manipulação e o processamento de dados. Existem diferentes tipos de operadores, como operadores matemáticos, operadores de comparação e operadores lógicos. Eles seguem uma hierarquia de prioridade, determinando a ordem em que as operações são executadas. 4 | 5 | Aqui estão os exemplos de operadores em égua: 6 | 7 | - `**` - Exponenciação: calcula a potência de um número. 8 | 9 | ```js 10 | var resultado = 2 ** 3; // resultado é igual a 8 11 | ``` 12 | 13 | - `*` - Multiplicação: realiza a multiplicação entre dois valores. 14 | 15 | ```js 16 | var resultado = 4 * 5; // resultado é igual a 20 17 | ``` 18 | 19 | - `/` - Divisão: realiza a divisão entre dois valores. 20 | 21 | ```js 22 | var resultado = 10 / 2; // resultado é igual a 5 23 | ``` 24 | 25 | - `+` - Adição: realiza a soma entre dois valores ou concatenação de strings. 26 | 27 | ```js 28 | var resultado = 3 + 4; // resultado é igual a 7 29 | 30 | var texto = "Olá, " + "mundo!"; // texto é igual a "Olá, mundo!" 31 | ``` 32 | 33 | - `-` - Subtração: realiza a subtração entre dois valores. 34 | 35 | ```js 36 | var resultado = 8 - 3; // resultado é igual a 5 37 | ``` 38 | 39 | - `%` - Resto da divisão (Módulo): retorna o resto da divisão entre dois valores. 40 | 41 | ```js 42 | var resultado = 10 % 3; // resultado é igual a 1 43 | ``` 44 | 45 | - `>` - Maior que: verifica se um valor é maior que outro. 46 | 47 | ```js 48 | var resultado = 5 > 3; // resultado é igual a verdadeiro 49 | ``` 50 | 51 | - `<` - Menor que: verifica se um valor é menor que outro. 52 | 53 | ```js 54 | var resultado = 2 < 4; // resultado é igual a verdadeiro 55 | ``` 56 | 57 | - `==` - Igual a: verifica se dois valores são iguais. 58 | 59 | ```js 60 | var resultado = 4 == "4"; // resultado é igual a verdadeiro 61 | ``` 62 | 63 | - `!=` - Diferente de: verifica se dois valores são diferentes. 64 | 65 | ```js 66 | var resultado = 3 != 5; // resultado é igual a verdadeiro 67 | ``` 68 | 69 | - `e` - E lógico: verifica se duas condições são verdadeiras. 70 | 71 | ```js 72 | var resultado = (5 > 3) e (2 < 4); // resultado é igual a verdadeiro 73 | ``` 74 | 75 | - `ou` - Ou lógico: verifica se pelo menos uma das condições é verdadeira. 76 | 77 | ```js 78 | var resultado = (5 > 3) ou (2 > 4); // resultado é igual a verdadeiro 79 | ``` 80 | 81 | Compreender a utilização e a ordem de prioridade dos operadores é essencial para construir expressões e executar cálculos de forma correta em seus programas. 82 | 83 | ### Operadores especiais 84 | 85 | Existem outros operadores especieais relacionados a manipulação bit a bit, como: 86 | 87 | - `<<` - Deslocamento bit a bit à esquerda; 88 | - `>>` - Deslocamento bit a bit à direita; 89 | - `&` - e bit a bit; 90 | - `^` - Ou exclusivo bit a bit; 91 | - `|` - Ou bit a bit; 92 | - `em` - em; 93 | 94 | ### Prioridade dos operadores 95 | 96 | Os operadores têm uma ordem clara de prioridade, semelhante à matemática, onde as operações são realizadas em uma ordem específica (ordenadas de cima para baixo com a maior precedência no topo). 97 | 98 | - `**` 99 | - `/`, `*` e `%` 100 | - `+` e `-` 101 | - `<<` e `>>` 102 | - `&` 103 | - `|` e `^` 104 | - `>` e `<` 105 | - `==` e `!=` 106 | - `em`, `e` e `ou` 107 | -------------------------------------------------------------------------------- /docs/egua/tipos_dados.md: -------------------------------------------------------------------------------- 1 | # Tipos de dados 2 | Ao iniciar sua jornada na programação, você será apresentado a um conceito fundamental: os tipos de dados. Os tipos de dados desempenham um papel essencial em qualquer linguagem de programação, pois determinam como a informação é armazenada e manipulada em um programa. 3 | 4 | Em termos simples, um tipo de dado é uma classificação atribuída a um valor ou variável que define as operações que podem ser realizadas com ele e a maneira como ele é representado na memória do computador. 5 | 6 | À medida que você avança em sua jornada de aprendizado da programação, explorará uma variedade de tipos de dados e aprenderá a manipulá-los de maneiras cada vez mais sofisticadas. Os tipos de dados são a base para construir programas poderosos e eficientes, e dominar seu uso é essencial para se tornar um programador habilidoso. 7 | 8 | Abaixo você aprenderá os tipos de dados em linguagem égua. 9 | 10 | ## Texto 11 | 12 | O texto é utilizado para representar sequências de caracteres e é delimitado por aspas duplas (`" "`) ou aspas simples (`' '`). Podemos acessar caracteres individuais em uma string utilizando a notação de índice. 13 | 14 | Exemplo: 15 | 16 | ```js 17 | var texto = "abc"; 18 | var texto2 = 'abc'; 19 | 20 | escreva("abc"[0]); // exibe "a" 21 | escreva(texto[-1]); // exibe "c" 22 | ``` 23 | 24 | 25 | ## Números 26 | 27 | Os números podem ser inteiros ou de ponto flutuante (números com casas decimais). Eles são utilizados para representar valores numéricos em um programa. 28 | 29 | Exemplo: 30 | 31 | ```js 32 | var numeroInteiro = 3; 33 | 34 | var numeroFlutuante = 8.5; 35 | ``` 36 | 37 | ## Listas 38 | 39 | As listas são coleções ordenadas de elementos. Elas são declaradas entre colchetes (`[]`) e os elementos são separados por vírgulas. Podemos acessar os elementos de uma lista utilizando a notação de índice. 40 | 41 | Exemplo: 42 | 43 | ```js 44 | var vetor = [1, "2"]; 45 | var vetorVazio = []; 46 | 47 | escreva([1, "2"][0]); // exibe 1 48 | escreva(vetor[2]); // sinaliza um erro por estar fora do tamanho do vetor 49 | 50 | var vetor = [1, "2"]; 51 | vetor[1] = 3; 52 | escreva(vetor); // exibe [1, 3] 53 | 54 | var vetor = [1, "2"]; 55 | vetor[2] = 3; 56 | escreva(vetor); // exibe [1, 2, 3] 57 | 58 | var vetor = [1, "2"]; 59 | vetor[3] = 3; 60 | escreva(vetor); // exibe [1, 2, nulo, 3] 61 | ``` 62 | 63 | ## Dicionários 64 | 65 | Os dicionários são estruturas de dados que associam valores a chaves únicas. Eles são úteis quando precisamos armazenar informações em pares chave-valor. Cada chave é única e mapeada para um valor correspondente. 66 | 67 | Exemplo: 68 | 69 | ```js 70 | var dicionario = {}; // declaração de dicionário vazio 71 | dicionario = {'a': 'b'}; // atribuição de um dicionário à variável 72 | escreva(dicionario['a']); // exibe 'b' 73 | 74 | var dicionario = {}; 75 | dicionario['a'] = 'b'; // retorna um novo dicionário {'a': 'b'} 76 | var dicionario = {'a': 1}; 77 | 78 | dicionario['a'] = 2; // retorna um novo dicionário {'a': 2} 79 | escreva(dicionario['a']); 80 | ``` 81 | 82 | ## Nulo 83 | 84 | O valor "nulo" representa uma estrutura de dados vazia, sem nenhum valor atribuído. É utilizado quando uma variável não possui um valor específico. 85 | 86 | Exemplo: 87 | 88 | ```js 89 | var variavel; 90 | escreva(variavel); // exibe "nulo" pois não possui valor atribuído 91 | 92 | var variavelNula = nulo; // também pode ser atribuído explicitamente o valor "nulo" 93 | ``` 94 | 95 | ## Booleanos 96 | 97 | Os valores booleanos representam a lógica verdadeiro ou falso. Eles são utilizados para expressar condições ou resultados de comparações. 98 | 99 | Exemplo: 100 | 101 | ```js 102 | var variavel1 = verdadeiro; 103 | var variavel0 = falso; 104 | ``` 105 | 106 | Compreender e utilizar corretamente esses tipos de dados é fundamental na programação, pois eles são os blocos de construção básicos para o desenvolvimento de programas mais complexos. -------------------------------------------------------------------------------- /docs/egua/variaveis.md: -------------------------------------------------------------------------------- 1 | # Variáveis 2 | 3 | As variáveis são uma das primeiras estruturas de dados que todo programador aprende ao começar a programar. Elas são caracterizadas por terem um nome e armazenarem valores em memória. 4 | 5 | Para declarar uma variável, utilizamos a palavra-chave `var` seguida pelo nome desejado e, opcionalmente, podemos atribuir um valor inicial. 6 | 7 | Exemplo de declaração de uma variável com valor inicial atribuído: 8 | 9 | ```js 10 | var variavel = "1"; 11 | ``` 12 | 13 | Uma das características das variáveis é que seus valores podem ser alterados ao longo do código sem a necessidade de sinalização especial. 14 | 15 | Exemplo de alteração de valor de uma variável: 16 | 17 | ```js 18 | var a = "1"; 19 | a = "2"; 20 | escreva(a); // exibe 2 21 | ``` 22 | 23 | No entanto, é importante ter em mente que as variáveis têm escopo, que é o contexto em que elas são criadas e podem ser utilizadas. 24 | 25 | Escopo é o contexto em que uma variável é definida e pode ser acessada em um programa. O escopo determina onde uma variável ou função é visível e utilizável. Existem escopos global e local. No escopo global, as variáveis podem ser acessadas de qualquer parte do programa. No escopo local, elas só podem ser acessadas dentro do bloco onde foram declaradas. Entender o escopo é importante para organizar e controlar o acesso aos dados em um programa, evitando conflitos e vazamento de variáveis. Em égua escopo é definido por `{ }` 26 | 27 | Variáveis declaradas no escopo geral podem ser acessadas por escopos internos, mas o contrário não é possível. 28 | 29 | Exemplo de escopo: 30 | 31 | ```js 32 | { 33 | var a = "1"; 34 | } 35 | 36 | escreva(a); // sinaliza um erro 37 | ``` 38 | 39 | ```js 40 | var a = "1"; 41 | { 42 | escreva(a); // exibe 1 43 | } 44 | ``` 45 | 46 | Uma característica interessante é que o escopo interno pode alterar variáveis do escopo externo sem a necessidade de uma nova declaração. 47 | 48 | Exemplo de alteração de variáveis em escopos: 49 | 50 | ```js 51 | var a = "1"; 52 | { 53 | a = "2"; 54 | } 55 | 56 | escreva(a); // exibe 2 57 | ``` 58 | 59 | ```js 60 | var a = "1"; 61 | { 62 | var a = "2"; 63 | escreva(a); // exibe 2 64 | } 65 | 66 | escreva(a); // exibe 1 67 | ``` 68 | 69 | Entender o conceito de variáveis e escopo é fundamental para o desenvolvimento de programas mais complexos. À medida que você avança na sua jornada de programação, outros tipos de variáveis e escopos também podem ser explorados. -------------------------------------------------------------------------------- /docs/logica/README.md: -------------------------------------------------------------------------------- 1 | --- 2 | description: Lógica de Programação 3 | --- 4 | 5 | # Lógica de Programação 6 | 7 | ## Introdução 8 | A lógica de programação é uma forma de pensar e estruturar o raciocínio para resolver problemas de maneira lógica e eficiente. É uma habilidade essencial para quem deseja programar, pois envolve a capacidade de organizar instruções de forma sequencial, tomar decisões baseadas em condições e repetir tarefas usando loops. 9 | 10 | Em essência, a lógica de programação envolve a criação de algoritmos, que são sequências de passos ou instruções que descrevem como resolver um problema específico. Esses algoritmos devem ser claros, precisos e capazes de serem executados por um computador. 11 | 12 | Para desenvolver uma lógica de programação sólida, é importante entender alguns conceitos fundamentais: 13 | 14 | 1. Sequência: A sequência é a ordem em que as instruções são executadas. Cada instrução é executada uma após a outra, seguindo uma ordem específica. 15 | 16 | 2. Decisão: A tomada de decisão envolve o uso de condicionais para verificar se uma determinada condição é verdadeira ou falsa. Com base no resultado, o programa pode executar diferentes conjuntos de instruções. 17 | 18 | 3. Repetição: A repetição é usada para executar um conjunto de instruções várias vezes. Ela permite que tarefas sejam automatizadas e que dados sejam processados de forma eficiente. 19 | 20 | 4. Decomposição: A decomposição envolve dividir um problema complexo em partes menores e mais gerenciáveis. Cada parte pode ser resolvida individualmente, simplificando o processo de solução como um todo. 21 | 22 | 5. Padrões de solução: Existem padrões comuns de solução para problemas recorrentes. Conhecer esses padrões pode ajudar na resolução mais eficiente de problemas, como o uso de loops para iterar sobre uma lista de elementos. 23 | 24 | Ao desenvolver a lógica de programação, é importante ter um bom entendimento do problema em questão, identificar as entradas e saídas necessárias, e planejar a sequência de passos necessários para resolver o problema de forma eficaz. 25 | 26 | Dominar a lógica de programação é essencial para escrever programas eficientes e de qualidade. Com uma boa base em lógica, será mais fácil aprender e utilizar diferentes linguagens de programação, bem como resolver problemas complexos de maneira estruturada e eficiente. 27 | 28 | ## Glossário 29 | Aqui estão alguns termos comuns na programação explicados de forma simples para iniciantes: 30 | 31 | Algoritmo: Um algoritmo é uma sequência de passos organizados e lógicos que descrevem como resolver um problema. É como uma receita que indica quais ações devem ser tomadas em uma determinada ordem para se alcançar um resultado desejado. 32 | 33 | Variável: Uma variável é um espaço de memória reservado para armazenar dados durante a execução do programa. Ela possui um nome e pode conter diferentes tipos de valores, como números, textos ou verdadeiro/falso. 34 | 35 | Constante: Uma constante é um valor fixo que não pode ser alterado durante a execução do programa. Ela é usada para representar informações que não devem ser modificadas, como o valor de Pi (3.14) ou o nome de um mês. 36 | 37 | Tipo de Dados: Os tipos de dados definem a natureza dos valores que uma variável pode armazenar. Alguns tipos comuns são: números inteiros (por exemplo, 5), números de ponto flutuante (por exemplo, 3.14), strings (cadeias de caracteres, como "Olá, mundo!") e booleanos (verdadeiro ou falso). 38 | 39 | Expressão: Uma expressão é uma combinação de valores, variáveis, operadores e funções que produz um resultado. Por exemplo, a expressão matemática "3 + 4" resulta em 7. Expressões podem ser usadas para realizar cálculos ou avaliar condições. 40 | 41 | Operador: Um operador é um símbolo ou palavra-chave que realiza uma operação em um ou mais valores. Por exemplo, o operador "+" realiza uma adição entre dois valores, e o operador "==" verifica se dois valores são iguais. 42 | 43 | Condicionais: As condicionais permitem que o programa tome decisões com base em condições específicas. A estrutura "if-else" é um exemplo comum de condicional, onde um bloco de código é executado se uma condição for verdadeira e outro bloco é executado se a condição for falsa. 44 | 45 | Loops: Os loops permitem que um bloco de código seja repetido várias vezes. Por exemplo, o loop "for" executa um conjunto de instruções um número específico de vezes, com base em uma condição. Isso é útil para processar listas de dados ou realizar tarefas repetitivas. 46 | 47 | Funções: As funções são blocos de código reutilizáveis que realizam uma tarefa específica. Elas recebem parâmetros, que são valores de entrada, executam um conjunto de instruções e podem retornar um valor. As funções permitem modularizar o código e facilitar sua manutenção. 48 | 49 | Parâmetros: Parâmetros são valores que podem ser passados para uma função quando ela é chamada. Eles permitem que a função receba dados externos e os utilize para realizar suas operações. Por exemplo, uma função de soma pode receber dois números como parâmetros. 50 | 51 | Argumentos: Argumentos são os valores reais passados para uma função quando ela é chamada. Esses valores são atribuídos aos parâmetros da função. Por exemplo, se uma função de soma recebe os números 3 e 5 como argumentos, ela retorna o valor 8. 52 | 53 | Escopo: O escopo define a visibilidade e acessibilidade de variáveis e funções em diferentes partes do programa. Variáveis e funções podem ter escopo global, sendo acessíveis em todo o programa, ou escopo local, sendo acessíveis apenas em um bloco específico de código. 54 | 55 | Ter uma compreensão básica desses termos é essencial para iniciar a jornada na programação. À medida que você avança no aprendizado, encontrará mais termos e conceitos que irão expandir seu conhecimento e capacidade de criar soluções mais complexas. 56 | 57 | -------------------------------------------------------------------------------- /package.json: -------------------------------------------------------------------------------- 1 | { 2 | "scripts": { 3 | "docs:dev": "vuepress dev docs", 4 | "docs:build": "vuepress build docs" 5 | }, 6 | "devDependencies": { 7 | "vuepress": "^1.9.10" 8 | } 9 | } 10 | --------------------------------------------------------------------------------