Have been programing for over four decades. Each programmer needs to be responsible for documenting, testing and debugging what they have created - who else knows it better?

—Prem Sobel

Manual Latino 1.3.0 (English version)¶

Welcome to the documentation of Latino, the first functional programing language with Spanish syntax.

Author:	Melvin Guerrero
Translator:	Melvin Guerrero, Jesse De Lira, David Salomón
Version:	Latino 1.3.0

Getting Started¶

Categories¶

What’s new?: Discover whats new in this version of Latino 1.3.0

Operadores: Arithmetic, assignment, conditional, logical, relational operators, and more.

Tipos de Datos: Data types is a classification that defines the value associated with a variable or object.

Strings: Strings are used to store and manipulate text in Latino.

Módulos: A module is a file that contains a set of functions that you want to include in your application.

RegEx: A Regular Expression or RegEx is a sequence of characters that form a search pattern.

Base functions: They are predefined functions that help us perform certain tasks.

Glossary: List of libraries, reserved words and definitions in Latino.

External links¶

Youtube channel (Spanish only)

Latino on-line editor

Attention

This documentation is subject to modifications and updates because is still in development. Thank you.

Get Involved¶

This manual is open to anyone who wants to collaborate.

Please, if you which to help see the collaboration guide.

Introduction¶

Code in Spanish!

Who is this intended for?¶

This documentation is intended for all people that do or don’t know programming. It is not important if you have never programmed before or if you are an experienced programmer with desires to program in another language, this programming language is for you.

Learn with examples¶

A good example is worth more than 1,000 words. This documentation’s goal is to show through examples that are easy to understand and remember, helping you to learn and understand this programming language called Latino.

Learn at your pace¶

It is all up to you. In this documentation, the speed of learning is your choice. If you become overwhelmed, take a break and reread the material for a better understanding. Always assure yourself that you understand all of the examples before moving forward to the next module.

About Latino¶

What is Latino?¶

Latino is a fully functional programming language with Spanish syntax, starting in 2015.

This programming language is influenced by Python and Lua.

Latino can be used for:

Web development (server-side)
Database connectivity
Mathematics
System scripting

Why another programming language?¶

Latino was born from the need to increase education on computer science in Latin America; Therefore, students, as well as professionals, can get motivated to enter the world of programming and applications development with easy-to-learn syntax.

I code in English, why learning Latino?¶

There are not right answers to this question. If you enjoy experiencing new ways to program and like challenging yourself on a new adventure, then Latino will be a wonderful experience for you!

However, if you are a native Spanish speaker or speak a similar language such as Portuguese or Italian, this could be a great opportunity to learn an easy-to-learn programming language similar to your own language.

Advantages of this programming language¶

Latino is influenced by Python and Lua which provide great advantages when using.

Easy Syntax:
- Latino have a very clean syntax which does not require a semicolon (;) at the end of each line of code, which is the case of several programming languages such as Java, JavaScript, C/C++, and others.
High-level programming language:
- This means that this language looks gramatically similar to how we read and write. However, the Low-level languages are the ones that machinees understand, such as Binary code or Assembly language.
Portable:
- When we write code in Latino, it can be executed on whichever other platform in an easy and simple way. As opposed to other programming languages like the case of Visual Basic that only works on MS-Windows platforms.
Open source:
- Any person can download the source code of Latino, modify it, extend the existing libraries, and contribute to its development if they wish.

Who develops Latino?¶

Latino is a language that has recieved the support of Hispanic users around the world and they have contributed to the growth of this project. Users have helped by popularizing and contributing to the source code of the language.

This language was created by Primitivo Roman in 2015 with the version v0.1-alpha until its version v1.0 was launched in 2017.

Currently, the language is in continued development under the direction of Melvin Guerrero on the versions v1.1.0, v1.2.0, v1.3.0 from now on.

What are the plans for the future?¶

Latino continues its development to become an essential tool in the Latin America education and to be a good alternative in software development.

The development of this programming language looks forward to offering tools that allow the users to create object-oriented applications, mobile applications, videogames, and more!

Also as part of this language development, it looks for offering educational material of great quality, to thrive the motivation of using this language.

For example:

An accurate manual of great quality
Books for learning
Online course
Video tutorials

MS-Windows¶

The installation of Latino on Windows is no different from other programs, the process is the exact same. Download the latest version of Latino from the link below which is the lastest release from our GitHub repository.

Download

Download Latino Only for 64 bit systems

Once the Latino installation is downloaded, proceed to install it by double-clicking it
Accept the Terms of Use
Uncheck the option to create an icon on the desktop and select the option Add PATH
Proceed with the installation
Complete the installation, de-select the run Latino option.

Once the installation is complete, test to run Latino from the CMD to confirm that everything is properly installed. To do this, run CMD on Windows and type the command Latino and press Enter. If everything goes well, then CMD will run Latino as shown in the image.

Note

If in the process of installing Latino on MS-Windows causes any problems or conflicts, feel free to look for the solutions in the forum here

Debian - Ubuntu¶

To install Latino on Debian or Ubuntu , first open the console (Terminal) and execute the following commands:

sudo apt-get update
sudo apt-get install git bison flex cmake gcc g++
sudo apt-get install libcurl4-openssl-dev libhiredis-dev libjansson-dev
sudo apt-get install redis-server curl libgtk-3-dev
sudo apt-get install libreadline-dev libpthread-stubs0-dev

Note

The code above is LIBCURL4, not LIBCUR14

Once this is over, install Latino in your system

cd ~
sudo git clone --recursive https://github.com/lenguaje-latino/Latino
cd latino
sudo git submodule update --init --recursive
sudo cmake .
sudo make
sudo make install

… and ready! to run Latino we only need to write in our terminal the latino command

Note

If in the process of installing Latino on Debian or Ubuntu causes any problems or conflicts, feel free to look for the solutions here

Fedora - CentOS¶

To install Latino on Fedora or CentOS, first open the console (Terminal) and run the following commands:

sudo dnf update
sudo dnf install gcc-c++
sudo dnf install git bison flex cmake kernel-devel
sudo dnf install readline-devel

sudo dnf update
sudo dnf install gcc-c++
sudo dnf install gtk3-devel
sudo dnf install git bison flex cmake kernel-devel
sudo dnf install hiredis-devel
sudo dnf install readline-devel

sudo dnf update
sudo dnf install bison flex cmake gcc g++ libjansson-dev libcurl4-openssl-dev libhiredis-dev redis-server curl jansson-devel groupinstall "Development Tools" "Development Libraries" groupinstall "RPM Development Tools" redhat-lsb libgtk-3-dev gtk3-devel readline-devel

Once this is over, install Latino onto the machine

cd ~
sudo git clone --recursive https://github.com/lenguaje-latino/Latino
cd latino
sudo git submodule update --init --recursive
sudo cmake .
sudo make
sudo make install

… and ready to run Latino, just write in your terminal the command latino

Note

If installing Latino in Fedora or CentOS causes any problems or conflicts, feel free to look for solutions in the forum here

macOS-X¶

Download

Download Latino For Mac with Intel processors only, requires Mac OS X 10.4 or later.

Once the Latino installer has been downloaded, proceed with the installation
Double-click on our Latino-XXX-Darwin installation package.pkg
Double-click the icon of the package that appeared on our desktop on Mac
Double-click the installation package to start with the installation
Follow the instructions in the installation package until finished

Once you finish the installation, proceed to verify that Latino is properly installed by opening your Terminal and in it, write the command Latino

Note

If installing Latino on Mac causes any problems or conflicts, feel free to look for solutions in the forum here

Atom¶

Latino Syntax in Atom

In order to use Latino in Atom, these are the steps to follow:

Click on (File) > (Settings)
Click on (Install) > In the search engine, write Latino and press Enter and finally Install
and ready to go! You can now program in Atom with Latino.

Notepad++¶

Download

Download Latino-Notepad++

Latino Syntax in Notepad++

In order to use Latino in Notepad ++, these are the steps to follow:

Click on Language > Define Language
Click on Import
Select the file Latino.xml
Restart Notepad++ to take the settings. (Once you reopen the program, if the “Define Languages” window is still visible, you can remove it by clicking on Language > Define Language)
To activate the Latino Plugin, you only need to click on Language > Latino
and ready to go! You can now program in Notepad ++ with Latino.

Important

At this point, restart Notepad++

Sublime Text¶

Download

Download Latino-SublimeText

Latino Syntax in Sublime Text

In order to use Latino in Sublime Text, these are the steps to follow:

Click on Preferences > Browse Packages …
Once you open the folder, you have to drag and drop (or copy) the following files LATINO.tmLanguage and LATINO.YAML-tmLanguage
Restart Sublime Text to take the settings.
and ready to go! You can now program in Sublime Text with Latino

TextMate¶

Download

Download Latino-TextMate

Latino Syntax in TextMate

In order to use the Latin syntax in TextMate, these are the steps to follow:

Download the file latino.tmbundle
In TextMate, click on Bundles > Edit Bundles…
Once the window opens, click on File > Open…
Search for the file latino.tmbundle
Change the language type in TextMate
and ready to go! You can now program in TextMate with Latino

Vim¶

Download

Download Latino-Vim

Latino Syntax in Vim

In order to use the Latin syntax in Vim, these are the steps to follow:

Having Vim closed, go where you have Vim installed C:\Program Files (x86)\Vim\vim80
Once there, copy and paste the ftdetect, syntax and Ultisnips folders in the location above vim80
Accept and confirm when asked if we want to merge the files.
and ready to go! You can now program in Vim with Latino

VS Code¶

Latino Syntax in VS Code

In order to use Latino in VS Code, these are the steps to follow:

Click on Extensions or press the keyboard shortcut Ctrl+Shift+X
In the search bar, type Latino and press Enter, then Install
and ready to go! You can now program in VS Code with Latino

My First Program¶

This section of the manual is focused on giving the user a brief sample of some basic functions and operations that can be done in Latino.

To start with each of the examples, you will have to open the terminal of your OS and have Latino to run.

Note

To run Latino in the terminal, just type Latino and press the Enter key.

If you write Latino code in a text editor, save the document with the .lat extension.

~Example: archivo.lat

Hello World in Latino

In this example we are going to make a small program. When executed, it will show a message saying “Hello World, Latino!”

To show a message on the screen, use the following command and press Enter

escribir("Hello World, Latino!")

The result will be:

Hello World, Latino!

Print a number (entered by the user)

In this example, we’ll show you, how you can type and store values to a variable and later show it on the screen.

escribir("Enter a number:")
num=leer()    //here you create a variable and assign it to the function leer()
escribir("The number entered is: "..num)

Note

If you are writing the code directly in the terminal, you can write everything on one line, like this:

escribir("Enter a number:") num=leer() escribir("The number entered is: "..num)

The result will be:

Enter a number:
24
The number entered is: 24

Odd or Even in Latino

In this example, you are going to create a program that helps us identify when a number (entered by the user) is even or odd.

Example 1:

escribir("Enter a number:")
num=leer()
si (num % 2 == 0)     //True if the number is perfectly divisible by 2
  escribir("The number "..num.." is even")
sino
  escribir("The number "..num.." is odd")
fin

Note

If you are writing the code directly in the terminal, you can write everything on one line, like this:

escribir("Enter a number:") num=leer() si(num%2==0) escribir("The number "..num.." is even") sino escribir("The number "..num.." is odd") fin

The result will be:

Enter a number:
8
The number 8 is even

Example 2:

This is another way to create the same program but with a fewer lines of code:

escribir("Enter a number:")
num=leer()
escribir("The number "..num..(num%2==0)?" is even":" is odd")

The result will be:

Enter a number:
-7
The number  -7 is odd

Exchange two numbers between variable in Latino

In this example we will make a program that exchanges the values of two variables with each other.

Example 1:

firstNum = 2
secNum = 5
firstNum, secNum = secNum, firstNum  //Here, the values are exchanged
escribir("FirstNum:"..firstNum.." | SecondNum:"..secNum)

The result will be:

FirstNum:5 | SecondNum: 2

Example 2:

escribir("Enter the first number:")
firstNum=leer()
escribir("Enter the second number:")
secNum=leer()
tempVar=firstNum    //The value of the first variable is assigned to a temporary variable
firstNum=secNum     //The value of the second variable is assigned to the first variable
secNum=tempVar    //The value of the temporary variable is assigned to the second variable
escribir("After exchanging, the first variable is: "..firstNum)
escribir("and the second variable is:"..secNum)

The result will be:

Enter the first number:
1
Enter the second number:
2
After exchanging, the first variable is: 2
and the second variable is: 1

Example 3:

escribir("Enter the first number")
firstNum=leer()
escribir("Enter the second number")
secNum=leer()
//Exchanging process
firstNum=firstNum-secNum
secNum=firstNum+secNum
firstNum=secNum-firstNum
escribir("After exchanging, the first variable is "..firstNum)
escribir("and the second variable is"..secNum)

The result will be:

Enter the first number
10.25
Enter the second number
-12.5
After exchanging, the first variable is -12.5
and the second variable is 10.25

Identificar si el caracter es vocal o no en Latino

In this example, you are going to create a program that is capable of knowing if the value you enter is a vowel or a consonant.

escribir("Enter a letter")
alphabet=leer()
vowels=["a","A","e","E","i","I","o","O","u","U"]    //Vowels declaration

response = alphabet..", is not a vowel"

desde (i=0; i < lista.longitud(vowels); i++)
   si (alphabet==vowels[i])
      response = alphabet..", is a vowel"
   fin
fin

escribir (response)

The result will be:

Enter a letter
a
a, is a vowel

Comments¶

Like other programming languages, Latino has comments. These comments can be used to create notes that help explain some code that we have written or also use it to prevent the execution of any line of code when executing the program.

Single line comments¶

Single line comments can start with a # or // mark. Any text or code that is after these signs will be ignored by Latino (they will not be executed).

This example will use the one-line comment before each line of code:

//This line of code will show the message Hello world when executing the program
escribir ("Hello world")
#The following line of code will add the values and its result will be written on the screen
escribir (5+5)

This example uses a single line comment at the end of each line to explain the code:

x = 5            #We declare a variable with the name of X, and we have assigned it a value of 5
y = x + 2        #We declare a variable with the name of Y, and we have assigned the value of X plus 2
escribir (y)     //In this line of code we will write on the screen the value of Y which has the value of X + 2

Multi-line comments¶

Multi-line comments start with /* and end with * /. Any text or code that is within these signs will be ignored by Latino (they will not be executed)..

This example will use the multiline comment:

/*
 The following code
 repeat the same example we saw a moment ago above
 with the same variables X and Y as variables to use
*/

x = 5
y = x + 2
escribir (y)

Using comments to prevent code execution:¶

Using comments to prevent the execution of a line of code can be very useful when we are testing our code. Adding the # or // signs in front of any line of code will make this single line invisible to the program when it is run.

In this example, the // sign will be used to prevent the execution of the first line of code:

//escribir ("This code will NOT run")
escribir ("This code WILL run")

In this example, the execution of a code block with the multi-line comments will be prevented:

/*
This whole block of code being a comment
will not run when starting the program

x = 5
y = x + 2
escribir (y)
*/

Variables¶

Una variable es un espacio en la memoria, en el cual el programador asigna un valor determinado.

Las variables son representadas por un nombre que es asignado por el programador cuando se escribe el código fuente. Cada variable tiene un único nombre el cual no puede ser cambiado una vez esta variable tenga un valor asignado. Dos o más variables pueden tener el mismo valor o contenido, pero no el mismo nombre.

En este ejemplo X, Y y Z serán las variables:

x = 3
y = 5
z = x + y

En este ejemplo, se puede observar la siguiente explicación:

X es una variable, y esta almacena el valor de 3
Y es otra variable, y esta almacena el valor de 5
Z es otra variable, y esta almacena el valor de 8

Declaración (creación) de variables¶

Las variables de Latino deben ser identificadas por un nombre único.

Estos nombres pueden ser cortos (como X o Y) o pueden ser nombres mas descriptivos (como edad, nombre, valorTotal, etc.)

La regla general en Latino para crear nombres de variables son las siguientes:

Las variables SI pueden:¶

Empezar con un guión bajo _ o letras a-z o A-Z.

Contener caracteres en mayúsculas y minúsculas. (Latino es sensible a las mayúsculas y minúsculas, por lo que los identificadores con nombres similares pero con letras mayúsculas o minúsculas en ellas serán interpretadas como diferentes variables en Latino).

mensaje = "Hola Mundo"
Mensaje = "¡Hasta la vista baby!"

Las variables NO pueden:¶

No son validas las letras acentuadas u otros caracteres como la ñ.

Empezar por un número.

Empezar por un símbolo o alguna palabra reservada de Latino.

Declaraciones de múltiples variables¶

En Latino es posible asignar más de una variable en una sola línea de código. En Latino una declaración múltiple sólo será valida de la siguiente manera:

a, b, c = 1, 2, 3    #la variable a=1, b=2, y c=3
a, b, c = 1, 2       #la variable a=1, b=2, y c = nulo (vacío)
a, b = 1, 2, 3       #la variable a=1, b=2 se descarta el valor 3 ya que no fue asignado a una variable

Tipos de variables¶

Las variables en Latino pueden contener casi cualquier tipo de datos como cadenas, diccionarios, data, valores numéricos como el número 100 y valores alfanuméricos como un nombre de persona “José Martinez”.

En programación, los valores alfanuméricos (o textos) se los llaman Strings (por su nombre en inglés).

Los strings se escriben dentro de comillas simples o dobles. Sin embargo, los números se pueden escribir sin estas comillas.

pi = 3.14
persona = "Melvin Guerrero"
respuesta = "Hola!, buenos días!"

Variables numéricas¶

En este ejemplo precio1, precio2, y total, serán variables:

precio1 = 5
precio2 = 6
total = precio1 + precio2
escribir("El precio total es: " .. total)

Las variables de Latino son contenedores para almacenar variedades de datos:

En programación, también se usan las variables para guardar valores algebraicos (como es el caso de la variable precio1 y precio2).
En programación, también se usan las variables para guardar expresiones (como es el caso de total = precio1 + precio2).

Concatenar variables¶

En Latino, el símbolo + no es usado para concatenar datos, como sí es el caso de otros lenguajes de programación.

Este símbolo + solo es usado para sumar valores numéricos.

Para concatenar datos en Latino se utilizan los puntos dobles ..

x = 2 + 3                  //Aquí se están sumando los valores numéricos
y = 2 .. 3                 //Aquí se están concatenado los valores numéricos
escribir(x .. " " .. y)    //Aquí se están agregando las dos variables y se le añadió un espacio en blanco para separarlas

Si se desea concatenar valores alfanuméricos con valores u operaciones numéricas, se recomienda que se declaren en variables separadas y se concatenen en una nueva variable para ser escritas:

x = "Melvin"
y = 2 + 3
z = x..", "..y
escribir(z)    //El resultado será Melvin, 5

Constantes¶

A este tipo de variables se les llaman Constantes porque una vez el programa arranque, su valor no podrá ser reasignado por otro valor, como sí es el caso de las variables anteriores.

Cuando se declara una variable constante, se le debe asignar un valor al momento de declararla, ya que no pueden estar vacias ni se les puede cambiar ni asignar un valor después de que el programa arranque.

Las variables constantes se deben declarar escribiendo todo su nombre en mayúsculas.

PI = 3.14
VALOR_EXTRA = 9.8

Operadores¶

En Latino como en otros lenguajes de programación, tiene varios operadores para realizar tareas que incluyen operaciones aritméticas, condicionales y lógicos.

La precedencia de operadores en este lenguaje de programación es la misma que otros lenguajes como C, Lua y Python.

Latino tiene una amplia gama de operadores para realizar diversas operaciones. Para una mejor comprensión de los operadores, estos operadores se pueden clasificar como:

Operadores aritméticos

Operadores de incremento y decremento

Operadores de asignación

Operadores relacionales

Operadores lógicos

Operadores condicionales

Otros operadores

Note

En Latino estos operadores sólo se pueden usar con variables con valores numéricos, no alfanuméricos.

Operadores aritméticos¶

Los operadores aritméticos realizan operaciones matemáticas básicas tales como suma, resta, multiplicación y división en valores numéricos (constantes y variables).

Operador	Descripción
+	Suma
-	Resta
*	Multiplicación
/	División
%	Modulo (reminente de división)
^	Potencia

Puedes aprender más sobre estos operadores aritméticos en el capítulo de Aritmética

Operadores de incremento y decremento¶

En latino se encuentran dos operadores que incrementan y decrementan el valor numérico de un operando (constante o variable) por 1(uno).

Operador	Descripción
+ +	Incrementa el valor en 1 (valido sólo en post).
- -	Decrementa el valor en 1 (valido sólo en post).

Puedes aprender más sobre estos operadores en el capítulo de Aritmética

Operadores de asignación¶

Los operadores de asignación se usan para asignar un valor a una variable. El operador de asignación más común es = (signo de igual).

Operador	Ejemplo	Igual a
=	x = y	x = y
+=	x += y	x = x + y
-=	x -= y	x = x - y
*=	x *= y	x = x * y
/=	x /= y	x = x / y
%=	x %= y	x = x % y

El operador de asignación += agrega un valor a una variable.

x = 10        //Asignamos un valor a la variable X
x += 5        //Al valor que ya dispone la variable X, le sumamos un valor de 5
escribir(x)   //El resultado será 15

Puedes aprender más sobre estos operadores de asignación en el capítulo de Asignación

Operadores relacionales¶

En programación, un operador relacional verifica la relación entre dos operandos. Si la relación es verdadera, devuelve el valor verdadero; si la relación es falsa, devuelve el valor falso.

Los operadores relacionales se utilizan en la toma de decisiones y en los bucles.

Operador	Descripción
==	Igual que
!=	No igual que
>	Mayor que
<	Menor que
>=	Mayor o igual que
<=	Menor o igual que
~=	RegEx (Expresión Regular)

Puedes aprender más sobre estos operadores relacionales en el capítulo de Relacionales

Operadores lógicos¶

Los operadores lógicos se usan para determinar la lógica entre variables o valores y estos devuelven Verdadero o Falso, dependiendo si la expresión es verdadera o falsa.

Los operadores lógicos se utilizan comúnmente en la toma de decisiones en programación.

Operador	Descripción
&&	Y lógico. Sólo será verdadero si todos los operadores son verdaderos.
\|\|	Ó lógico. Será verdadero si sólo uno de los dos operadores es verdadero.
!	NO lógico. Sólo será verdadero si los operadores son falsos.

Puedes aprender más sobre estos operadores lógicos en el capítulo de Lógicos

Operadores condicionales¶

Un operador condicional es un operador ternario, es decir, funciona en tres operandos.

Sintaxis del operador condicional:

(Expresión condicional) ? expresión1 : expresión2

El operador condicional funciona de la siguiente manera:

La primera expresión condicional se evalúa primero. Esta expresión se evalúa si es verdadera o si es falsa.
Si la expresión condicional es verdadera, se evalúa la expresión1.
Si la expresión condicional es falsa, se evalúa la expresió2.

numero = -5                                                #Creamos una variable con un valor de -5
mensaje = (numero < 0) ? " es negativo" : " es positivo"   #Creamos una nueva variable y a esta le asignamos el operador condicional.
escribir ("El número " .. numero .. mensaje)               #El mensaje seria: El número -5 es negativo.

Otros operadores¶

Entre estos operadores podemos encontrar el operador de concatenación y el operador de acceso a miembros.

Operador de concatenación¶

El operador de concatenación está representado por doble punto (..).

Este operador se utiliza para concatenar(juntar) expresiones no relacionadas entre sí:

nombre = "Melvin"                              //Creamos una variable llamada nombre, con un valor alfanumérico Melvin
apellido = "Guerrero"                          //Creamos otra variable llamada apellido, con un valor alfanumérico Guerrero
escribir ("Hola! " .. nombre .." "..apellido)  #En el comando escribir() asignamos un texto de bienvenida y concatenamos nuestras variables dejando un espacio entre ellas.

Operador de acceso a miembro¶

El operador de acceso a miembro está representado por un solo punto .

Un claro ejemplo de su uso es cuando trabajamos con diccionarios y queremos acceder a sus propiedades ó cuando usamos librerías y queremos acceder a sus métodos.

/*
Estos son solo ejemplos representativos
de cuando se hace uso del operador de acceso a miembro.
*/

#librería (punto) método
cadena.longitud

#diccionario (punto) propiedad
persona.nombre

Arithmetic¶

Arithmetic operators¶

Arithmetic operators perform basic mathematical operations such as addition, subtraction, multiplication, and division on numeric values (constants and variables).

Operator	Description
+	Addition
-	Subtraction
*	Multiplication
/	Division
%	Modulo (Remainder)
^	Power (Exponential)

Examples:

A common arithmetic operation would be with two numbers.

With two literal numbers:

x = 100 + 50

or also with variables:

x = a + b

or also with expressions:

x = (100 + 50) * a

Addition¶

The sum operator(+):

x = 5
y = 2
z = x + y
escribir(z)    //The result would be 7

Substraction¶

The substaction operator (-):

x = 5
y = 2
z = x - y
escribir(z)    //The result would be 3

Multiplication¶

The multiplication operator (*):

x = 5
y = 2
z = x * y
escribir(z)    //The result would be 10

Division¶

The division operator (/):

x = 5
y = 2
z = x / y
escribir(z)    //The result would be 2.5

Modulo (Remainder)¶

The remainder operator (%):

x = 5
y = 2
z = x % y
escribir(z)    //The result would be 1

Power¶

The exponential operator (^):

x = 5
y = 2
z = x ^ y
escribir(z)    //The result would be 25

Note

For power calculations, you can achieve the same result using the math library mate.pot(x,y)

x = 5
y = 2
escribir(mate.pot(x,y))    //The result would be 25

Increment and decrement operators¶

Increment¶

The increment operator is represented by a double addition (+ +).

x = 5         //Declare a variable with value 5
x++           //The value of the variable X increments by 1
escribir(x)   //The result would be 6

Decrement¶

The decrement operator is represented by a double substraction (- -).

x = 5         //Declare a variable with value 5
x--           //The value of the variable X decrease by 1
escribir(x)   //The result would be 4

Precedence in Operators¶

In arithmetic, all operators (arithmetic, logical, and relational) have precedence rules that apply when several operators act together, and Latino makes use of those rules.

Arithmetic operators, such as multiplication and division, are performed before addition or subtraction.

To override these precedence rules, parentheses () can be used .

x = 100 + 50 * 3       //Returns 250
y = (100 + 50) * 3     //Returns 450
escribir ("Value of X: " .. x .. ", Value of Y: ".. y)

Assignment¶

Operator	Example	Equal to
=	x = y	x = y
+=	x += y	x = x + y
-=	x -= y	x = x - y
*=	x *= y	x = x * y
/=	x /= y	x = x / y
%=	x %= y	x = x % y

Operator =¶

The operator = assigns a value to the variable x

x = 100

Operator +=¶

The operator += sums the values of the variables x plus y and assigns them to the variable x

x = 10
y = 5
x += y
escribir(x)  //The result will be 15

Operator -=¶

The operator -= subtracts the values of the variables x minus y and assigns them to the variable x

x = 10
y = 5
x -= y
escribir(x)  //The result will be 5

Operator *=¶

The operator = multiplies the values of the variables x by y and assigns them to the variable x

x = 10
y = 5
x *= y
escribir(x)  //The result will be 50

Operator /=¶

The operator /= divides the values of the variables x by y and assigns them to the variable x

x = 10
y = 5
x /= y
escribir(x)  //The result will be 2

Operator %=¶

The operator %= returns the remainder (module) that divides the values of the variables x by y and assigns them to the variable x

x = 10
y = 5
x %= y
escribir(x)  //The result will be 0

Relacionales¶

En programación, un operador relacional verifica la relación entre dos operandos. Si la relación es verdadera, devuelve el valor verdadero; si la relación es falsa, devuelve el valor falso.

Los operadores relacionales se utilizan en la toma de decisiones y en los bucles (por su nombre en inglés).

Operador	Descripción
==	Igual que
!=	No igual que
>	Mayor que
<	Menor que
>=	Mayor o igual que
<=	Menor o igual que
~=	RegEx (Expresión Regular)

Los operadores relacionales y los operadores lógicos son utilizados para probar si una operación es verdadera o falsa.

Ejemplos:

Para los siguientes ejemplos supondremos que la variable x tiene un valor de 5

x = 5
escribir(x==8)    //El resultado sería falso

Operador	Descripción	Comparativa	Resultado
==	igual a	escribir(x == 8)	falso
		escribir(x == 5)	verdadero
!=	no igual	escribir(x != 8)	verdadero
		escribir(x != 5)	falso
>	mayor que	escribir(x > 8)	falso
<	menor que	escribir(x < 8)	verdadero
>=	mayor ó igual que	escribir(x >= 8)	falso
<=	menor ó igual que	escribir(x <= 8)	verdadero

Operador ~=

Este operador hace uso de las expresiones regulares(regular expression) en Latino.

Una expresión regular (regular expression ó RegEx, por su nombre en Ingles) es una secuencia de caracteres y estas forman un patrón de búsqueda.

/*
El operador ~= utiliza las expresiones regulares
en cadenas para hacer patrones de búsqueda.

La condicional SI, devolverá:
"x inicia con hola"
*/

x = "hola mundo"

si x ~= "^hola"
  escribir("x inicia con hola")
sino
  escribir("x NO inicia con hola")
fin

Note

Las Expresiones Regulares (RegEx) contienen un artículo dedicado a su uso en Latino el cual se puede encontrar aquí.

Lógicos¶

Los operadores lógicos se usan para determinar la lógica entre variables o valores y estos devuelven Verdadero o Falso, dependiendo si la expresión es verdadera o falsa.

Los operadores lógicos se utilizan comúnmente en la toma de decisiones en programación.

Operador	Descripción
&&	Y lógico: Sólo será verdadero si todos los operadores son verdaderos.
\|\|	Ó lógico: Será verdadero si sólo uno de los dos operadores es verdadero.
!	NO lógico: Sólo será verdadero si todos los operadores son falsos.

Ejemplo:

Para los siguientes ejemplos supondremos que la variable x=6 y la variable y=3.

Operador	Descripción	Ejecución	Resultado
&&	y lógico	escribir(x < 10 && y > 1)	Verdadero
\|\|	o lógico	escribir(x == 5 \|\| y == 5)	Falso
!	no lógico	escribir(!(x == y))	Verdadero

Tipos de Datos¶

Las computadoras a diferencia de los seres humanos, no reconocen ni saben la diferencia entre “1234” y “abcd”, por esta razón en programación se definieron los tipos de datos.

Un tipo de dato es una clasificación que define el valor asociado a una variable u objeto. Por lo general estos tipos de datos suelen estar almacenados en una variable, ya que estas pueden almacenar tipos de datos como: Numéricos, alfanuméricos, listas, diccionarios, entre otros.

A continuación se presenta una tabla con ejemplos de algunas clasificaciones para los tipos de datos en programación tanto para Latino y C.

Latino	Tipo de datos en C	Ejemplos
lógico	bool	verdadero ó falso
numérico (decimal)	double	1.69549875
cadena	char*	letras
lista (matriz)	array	agr1, agr2, agr3…
diccionario	struct	“propiedad”: “valor”
nulo	void	vacio (no data)

Tipos de datos: Lógico¶

Los tipos de datos lógicos (o booleans por su nombre en inglés) solo pueden tener dos valores: verdadero o falso.

//Es X igual a Y o será X igual a Z

x = 5
y = 5
z = 6
escribir(x == y)       // Devolverá un valor verdadero
escribir(x == z)       // Devolverá un valor falso

Tipos de datos: Numérico¶

Los tipos de datos numéricos son números asignados a una variable que se pueden escribir con o sin punto decimal.

num1 = 34.00
num2 = 34

Note

También se pueden escribir en notación científica, ejemplo:

x = 7 x 10 ² || y = 4.9 x 10 ⁹ || z = 5.5 x 10 ^-3 || n = 2.56 × 10 ^-6

x = (7*10^2)        //Devolverá 700
y = (4.9*10^9)      //Devolverá 4,900,000,000
z = (5.5*10^-3)     //Devolverá 0.0055
n = (2.56*10^-6)    //Devolverá 2.56e-06

Tipos de datos: Cadena¶

Los tipos de datos alfanuméricos (o strings por su nombre en inglés) son líneas de textos escritas entre comillas simples o dobles. Ejemplo “Bill Gates” ‘Steve Jobs’.

persona1 = "Bill Gates"                //Uso de comillas dobles
persona2 = 'Steve Jobs'                //Uso de comillas simples

respuesta1 = "Su nombre es 'Bill'"     //Uso de las comillas simples dentro de comillas dobles
respuesta2 = 'Su nombre es "Steve"'    //Uso de las comillas dobles dentro de comillas simples

Tipos de datos: Lista¶

Los tipos de datos de listas o matrices se escriben entre corchetes [ ] y sus elementos están separados por comas.

Las matrices son indexadas desde el número 0 (Cero) en adelante.

Esto significa que el número de índice del primer elemento será [0], y el segundo será [1], y así sucesivamente.

carro = ["Nissan", "Volvo", "BMW"]
escribir(carro[0])     //Devolverá Nissan

Tipos de datos: Diccionario¶

Los tipos de datos de diccionarios u objetos se escriben entre llaves { } y sus propiedades se escriben “propiedad” : “Valor” y cada propiedad con su valor están separadas por comas.

/*
En este ejemplo se creara un diccionario
con algunas propiedades para luego ser escritas en pantalla
*/

persona =  {"nombre": "Melvin", "apellido": "Guerrero", "edad": 50, "etimología": "Latino"}
escribir(persona.nombre)     //Devolverá Melvin

Nulo¶

En Latino los tipos de datos Nulos son nada. Se supone que es algo que no existe.

persona = nulo
escribir(persona)     //Devolverá un valor nulo

En Latino una variable con valor nulo no es igual a una variable con valor indefinido.

Las variables con valor indefinido son imposibles de declarar(crear) en Latino ya que las variables requieren ser asignadas a un valor al momento de estas ser declaradas, de lo contrario Latino solo las omitirá.

De todas maneras si se pueden llegar a crear variables con valor vacío de la siguiente manera:

persona = ""
escribir(persona)     //Devolverá un espacio en blanco

Diferencia entre un valor vacío y un nulo¶

Un valor vacío y un valor nulo en primera instancia puede que aparenten ser lo mismo ya que nos permite asignar un valor no definido a una variable, pero internamente son totalmente distintas.

x = ""              //Este valor al llevar comillas es una cadena
y = nulo            //Este valor es nulo
escribir(x == y)    //Devolverá un valor falso

Operador “tipo()”¶

En Latino podemos usar el operador tipo() para saber el tipo de dato que lleva un objeto o una variable.

x = ""
y = nulo
escribir(tipo(x))     //Devolverá un valor de cadena
escribir(tipo(y))     //Devolverá un valor nulo

Números¶

En diversos lenguajes de programación existen varias clasificaciones para los números entre ellas están integer, float, double y complex.

Latino trabaja solo con un tipo de número, los números que se escriben con decimal y los que no.

x = 3.14     //Número con decimal
y = 3        //Número sin decimal

Error

Las siguientes expresiones científicas no son reconocidas por Latino:

x = 123e5     //Expresión no reconocida
y = 123e-5    //Expresión no reconocida

Note

Latino dispone de una librería para matemáticas la cual puede ver aquí.

Decimales¶

Todos los números en Latino siempre serán reconocidos como decimales, tengan o no el punto decimal.

Esto lo podemos comprobar utilizando la función tipo( ) en Latino.

x = 3.14
y = 3

escribir(tipo(x))     //Devolverá decimal
escribir(tipo(y))     //Devolverá decimal

Los números también puede ser expresados como números negativos:

x = -3255522
y = -35.59

Note

Los números pasados de 15 dígitos son devueltos como expresión científica en Latino:

x = 999999999999999
y = 9999999999999999

escribir(x)     //Devolverá 999999999999999
escribir(y)     //Devolverá 1e+16

Números como cadedas(textos)¶

A diferencia de las cadenas los números no requieren ser escritos entre comillas, pero de serlo estas dejaran de ser números y pasaran a ser interpretadas como cadenas(textos).

x = 100       //X es un decimal
y = "100"     //Y es una cadena

Convertir cadenas a números¶

Latino puede convertir las cadenas numéricas a números con los operadores aritméticos:

x = "100"
y = "10"

escribir(x + y)     //Devolverá 110
escribir(x - y)     //Devolverá 90
escribir(x * y)     //Devolverá 1000
escribir(x / y)     //Devolverá 10

En Latino existe una funcion pre-definida llamada anumero( ) que de igualmanera nos convierte una cadena a número.

x = "100"
escribir(tipo(x))     //Devolverá cadena

x = anumero("100")
escribir(tipo(x))     //Devolverá decimal

Strings¶

Strings are used to store and manipulate text.

Strings are surrounded by single quotes ( ' ) or double quotes ( ‘ ).

escribir("hello")
escribir('hello')

Quotation marks can be used within a string, as long as they do not match the surrounding quotation marks.

escribir("His name is 'Melvin'")     //Returns: His name is 'Melvin'
escribir('His name is "Melvin"')     //Returns: His name is "Melvin"

Note

Latino has a library for managing strings, here.

Concatenate strings (texts)¶

To concatenate or join texts in Latino, double periods (..) are used , which unlike other programming languages which use the plus sign (+).

The double period (..) mark is not only useful to join texts, but also numbers.

x = "Hello World"
y = ", Latino"
escribir(x..y)     //Returns Hello World, Latino
escribir(1..2)     //Returns 12

Special characters¶

If strings are written in quotes, an error could occur with the following syntax:

escribir("Hello World, "Latino!" How are you?")

In the example above, the sentence would be cut to “Hello world,” and Latino would think the name Latino! is a variable, thus producing a syntax error.

The solution to this problem would be to use a backslash () .

The backslash () converts special characters to text:

/*
Returns:
Hello World, "Latino" How are you?
*/

escribir("Hello World, \"Latino!\" How are you?")

In addition to using the backslash to write texts, it is also used to indicate functions.

Below are the characters available for use in Latin.

Character table¶

Character	Description
\ ‘	Doubles quotes
\ '	Single quotes
\n	New line
\r	Carriage return
\b	Backspace
\t	Horizontal tab
\v	Vertical tab
\f	Form feed
\a	Beep
\0	Null character
\nnn	Character with octal value

Note

Special characters described in the table above were originally designed for typewriter, teletype, and fax.

Double quotation marks

/*
  Returns:
  Hello "world"
  */

  escribir("Hello \"world\"")

Single quotes

/*
Returns:
Hello 'world'
*/

escribir('Hello \'world\'')

New line¶

Character to use: \n

/*
Returns:
Hello
world
*/

escribir("Hello\nworld")

Carriage return¶

Character to use: \r

/*
Unlike \n, \r does not create a new line but returns the cursor to the starting point and continues typing. This makes an overwriting.

Returns:
Latinoundo,
*/

escribir("Hello World,\rLatino")

Note

To know the difference between \n and \r click here

Backspace¶

Character to use: \b

/*
This command removes the previous character.

Returns:
Holworld
*/

escribir("Hello\bworld")

Horizontal tab¶

Character to use: \t

/*
Returns:
Hello    world
*/

escribir("Hello\tworld")

Beep¶

Character to use: \a

/*
It will sound the PC Beep and returns:
Hello World
*/

escribir("Hello World\a")

Null character¶

Character to use: \0 *(zero)

/*
Delete all the text after the command until the closing of the quotation marks and returns:
Hello World Latino and happy new 2020
*/

year = "2020"
escribir("Hello World,\0 Latino! and happy new "..year)

Note

In the same way 0 being a null value, it can also be used in logical conditionals:

Example 1

/*
Returns:
The value is not null
*/

x = 5

si x != "\0"
  escribir ("The value is not null")
fin

Example 2

/*
Returns:
It is not null
*/

x = 5

si x == "\0"
  escribir ("It is null")
sino
  escribir ("It is not null")
fin

Character with octal value¶

Character to use: \nnn

/*
Returns:
Hello World
*/

text = "\110\157\154\141\040\155\165\156\144\157"
escribir(text)

Multiple line texts¶

We saw previously that strings can be linear texts, but they can also be multi-line texts.

To indicate when a string will be multi-line, just leave one of the quotation marks at the beginning and another at the end of the paragraph.

escribir("Sample multiple line text:
---------------------------------------
In this example we can observe
that Latino is perfectly capable of
process multi-line texts
as long as one of the two quotes
is at the beginning of the paragraph and another at the end")

Texts as arrays¶

As in many other programming languages, texts are arrays.

/*
Returns:
the letter "e"
*/

x = "Hello"
escribir(x[1])

Convert numbers to strings¶

In Latino there is a pre-defined function called acadena( ) that converts a number to a string (text).

x = 100
escribir(tipo(x))     //Returns decimal

x = acadena("100")
escribir(tipo(x))     //Returns string

Funciones¶

Una función es un bloque de código que realiza una tarea específica.

Una función se ejecuta cuando esta es invoca (llamada).

Una ventaja que propone crear y usar una función es la división de problemas complejos en pequeños componentes que hacen el programa mas fácil de entender y programar.

Cuando estamos programando y tenemos líneas de códigos que se repiten o necesitamos de ciertos códigos en más de una ocasión, la mejor forma de gestionar nuestro código es, creando funciones.

Sintaxis de función¶

Las funciones se definen con la palabra clave de funcion o la forma corta fun, seguido por el nombre de la función y terminando con paréntesis().

Ejemplo de sintaxis

funcion nombre1()
  #código
fin

fun nombre2()
  #código
fin

Los nombres de funciones SI pueden:¶

Los nombres de funciones pueden contener letras, dígitos, subrayados y signos de dólar.

Empezar con un guión bajo _ o letras a-z o A-Z.

Contener caracteres en mayúsculas y minúsculas. (Latino es sensible a las mayúsculas y minúsculas, por lo que los identificadores con nombres similares pero con letras mayúsculas o minúsculas en ellas serán interpretadas como diferentes funciones en Latino).

Los nombres de funciones NO pueden:¶

No puede existir más de una función con el mismo nombre.

No son validas las letras acentuadas u otros caracteres como la ñ.

Empezar por un número.

Empezar por un símbolo o alguna palabra reservada de Latino.

Note

En otras palabras los nombres de funciones se rigen por las mismas normas que los nombres de las variables.

Múltiples parámetros¶

Una función puede recibir tantos parámetros como queramos.

Los paréntesis pueden incluir nombres de parámetros y estos parámetros están separados por una coma ( , ). Ejemplo: (parámetro1, parámetro2, parámetro3, etc…)

Al usar más de un parámetro, los valores enviados a la función tienen que estar en el mismo orden que los parámetros asignados en ésta.

funcion nombreFuncion (argumento1, argumento2)
  resultado = argumento1 + argumento2
  retornar resultado
fin

Invocar una función¶

Para ejecutar el código dentro de una función primero hay que invocarla (llamar a la función).

Para llamar una función se hace escribiendo el nombre de la función y en paréntesis los parámetros que esta tenga (en caso de que haya alguno).

funcion hola()                        //Aquí creamos una función con el nombre de hola()
  escribir("Hola Mundo, Latino!")     //Aquí especificamos lo que queremos que la función haga, en este caso sería un mensaje de "Hola Mundo, Latino!"
fin                                   //Se concluye la función

hola()                                //aquí llamamos a la función a ser ejecutada y el código dentro de esta se ejecutara

Retornar función¶

El retornar los valores de una función nos ayuda a poder procesar de forma independiente valores enviados a esta sin interrumpir nuestro código.

Para que nuestra función pueda retornar valores es necesario que esta tenga sus parámetros asignados.

En Latino se puede regresar el valor de una función con las palabras claves regresar, retornar o la forma corta ret. La estructura de una función es la siguiente:

Palabras reservadas

regresar
retornar
ret

Ejemplo de código

funcion suma(a,b)               //creamos una función de nombre suma() y con dos parámetros los cuales serán a y b
  retornar a+b                  //asignamos el valor que deseamos devolver el cual será la suma de a+b
fin

resultado=suma(2,3)             //creamos una variable llamada resultado y en ella asignamos el nombre de la función la cual es suma() y le asignamos valores a los parámetros
escribir(resultado)             //El resultado será 5

Funciones como variables¶

Las funciones se pueden usar de la misma manera que las variables, en todos los tipos de fórmulas, asignaciones y cálculos.

/*En este ejemplo primero
crearemos una función la cual convertirá
el valor de fahrenheit a celsius
y posteriormente veremos cómo usar
directamente una función en vez de una variable*/

funcion convCelsius (fahrenheit)
  retornar (5/9) * (fahrenheit-32)
fin

//Aquí usamos una variable
x = convCelsius(77)
escribir("La temperatura es de "..x.." celsius")

//Aquí usamos directamente la función
escribir("La temperatura es de "..convCelsius(77).." celsius")

Parámetros de funciones¶

Toda función tiene una entrada y una salida de datos.

Las salidas de datos se hacen cuando el código de la función se termina de ejecutar y también cuando usamos el comando retornar.

Para la entrada de datos en una función hacemos uso de los parámetros.

Los parámetros de una función son iguales que las variables con la diferencia que solo funcionan en la función en donde estén declaradas.

/*En este ejemplo creamos una función,
a esta le enviamos el valor colectado por el comando leer()
este valor es enviado a la función por medio de la variable usuario
y es recibida en la función gracias al parámetro nombre*/

funcion bienvenida(nombre)
  escribir ("Bienvenido "..nombre)
fin

escribir("Hola como te llamas?")
usuario=leer()
bienvenida(usuario)

Lista (Arrays)¶

Las listas o arrays (también son conocidas como arreglos, matrices o vectores en otros lenguajes de programación) son variables que pueden almacenar múltiples valores al mismo tiempo y estos a su vez están organizados por índice.

Entre algunos de los tipos de datos que una lista puede simultáneamente almacenar pueden ser: lógicos, numéricos, cadenas, otras listas y/o diccionarios.

Note

Latino dispone de una librería para el manejo de listas, aquí.

¿Cúando y/o por qué usar una lista?¶

Una variable nos permite almacenar únicamente un tipo de dato en ella a la vez. Esto resulta ideal cuando se trabaja con operaciones simples pero no sería practico en grandes operaciones.

Ejemplo:

Si tenemos un grupo de artículos (una lista de marcas de carro, por ejemplo) y las almacenamos en variables, sería algo así:

carro1 = "Toyota"
carro2 = "Ford"
carro3 = "Peugeot"

Sin embargo, ¿qué pasaría si en vez de 3 marcas, tuviéramos 300 marcas y tuviéramos que buscar un valor en específico? Resultaría tedioso y poco practico tener que crear 300 variables con nombres distintos solo para almacenar un valor.

La solución sería usar una lista. Como se había explicado antes, una lista nos permiten almacenar varios valores en ella y acceder a ellos haciendo referencia a su número de índice.

Creación de una lista (array)¶

Las listas se definen (crean) entre corchetes [ ] y sus valores están separados por comas.

carros = ["Toyota", "Ford", "Peugeot"]

Las listas o array como vimos en el ejemplo anterior se pueden declarar en una sola línea, pero esto no es el único caso, también podemos declarar una lista en múltiples líneas de la siguiente manera:

carros = [
  "Toyota",
  "Ford",
  "Peugeot"
]

Acceder a los valores en una lista¶

Para acceder a los valores almacenados en una lista usamos su número de índice.

Estos números índices comienzan a contar desde el número 0 (cero) en adelante.

/*
A continuación definimos una lista
y encima marcaremos su número de índice
*/

//índice:    0        1         2 ...
carros = ["Toyota", "Ford", "Peugeot"]
escribir(carros[0])     //Devolverá Toyota

Índices con números negativos¶

Podemos utilizar también índices con números negativos.

La indexación negativa significa comenzar desde el final, -1 se refiere al último elemento, -2 se refiere al penúltimo elemento, -3 se refiere al antes penúltimo elemento, etc.

/*
A continuación definimos una lista
y encima marcaremos su número de índice negativo
*/

//índice:    0        -5       -4         -3        -2         -1
carros = ["Toyota", "Ford", "Peugeot", "Nissan", "Subaru", "Chevrolet"]
escribir(carros[-1])     //Devolverá Chevrolet

Mostrar carácter de un elemento¶

Anteriormente vimos que usando el número de índice podemos acceder al valor almacenado en una lista, pero también podemos únicamente mostrar un solo carácter de una lista usando doble índice.

Esta propiedad resulta bastante útil cuando se esta buscando palabras con letras específicas o carácteres específicos en los elementos de una lista.

/*
El orden de los índices para buscar un carácter
empezaría desde el número cero (0)

Si quisiéramos mostrar la segunda "t" de la marca Toyota
este valor sería el no. 4 ya que se empezaría a contar desde cero (0)
*/

carros = ["Toyota", "Ford", "Peugeot"]
escribir(carros[0][4])     //Devolverá la segunda "t" de Toyota
escribir(carros[2][3])     //Devolverá la "g" de Peugeot

Agregar un nuevo elemento¶

Para agregar un nuevo elemento a la lista solo basta con escribir el nombre de la lista más el nuevo número de índice.

carro = [
   "Toyota",           //Este sería el índice #0
   "Camry",            //Este sería el índice #1
]

carro[2] = 2011        //Creamos un nuevo índice #2 y le asignamos el valor de "2011"
escribir(carro[2])     //Devolverá 2011

Cambiar valor de elemento¶

Se puede cambiar el valor de un elemento con solo hacer referencia a la misma:

carros = [
  "Toyota",
  "Ford",
  "Peugeot"
]

carros[1] = "Ferrari"
escribir(carros[1])     //Devolverá Ferrari

Acceder a todos los valores de una lista¶

Para imprimir todos los valores de una lista solo hacemos mención del nombre de la lista sin número de índice.

carros = [
  "Toyota",
  "Ford",
  "Peugeot"
]

escribir(carros)     //Devolverá ["Toyota","Ford","Peugeot"]

Las listas pueden ser objetos¶

Las variables pueden ser objetos, y las listas son un tipo de variables. Debido a esto se puede almacenar diversos tipos de datos en una lista.

Las listas pueden almacenar funciones, otras listas o diccionarios si así se desea.

Anidar una función en una lista¶

funcion miCarro()
  retorno carro[0]..", "..carro[1]
fin

carro = [
   "Toyota",
   "Camry",
   "2011"
]

carro[3] = miCarro()   //Agregamos la función en un nuevo índice de la lista
escribir(carro[3])     //Devolverá Toyota, Camry

Anidar otras listas¶

La manera de llamar a una sub-lista de una lista es de la misma manera en la que se accede a los carácteres de un elemento que explicamos unos puntos más arriba de este articulo.

carros = [
   "Toyota",            //Este sería el índice 0
   "Ford",              //Este sería el índice 1
   "Peugeot"            //Este sería el índice 2
]

modelos = [
   "Camry",
   "Fiesta",
   "206"
]

carros[3] = modelos     //Agregamos la lista modelos en un nuevo índice
escribir(carros[3][1])   //Devolverá Fiesta

Anidar un diccionario a una lista¶

Si tenemos un diccionario anidado en una lista, para llamar un elemento del diccionario, escribimos el nombre de la lista con el número de índice en donde se encuentra el diccionario más la propiedad del diccionario:

//Creación de un diccionario
region = {
  "ciudad1" : "Santiago",
  "ciudad2" : "Bayamón",
  "ciudad3" : "Las Tunas"
}

//Creación de una lista
pais = [
   "Santo Domingo",
   "Puerto Rico",
   "Cuba"
]

pais[3] = region              //Agregamos el diccionario a la lista en un nuevo índice
escribir(pais[3].ciudad1)     //Devolverá Santiago

Diccionarios (Objetos)¶

Los diccionarios u objetos, también son llamados matrices asociativas, esto deben su nombre a que son colecciones que relacionan una propiedad (o llave) a un valor.

Las listas (arrays) almacenan sus valores organizados por índeces, pero este no es el caso de los diccionarios los cuales almacenan sus valores utilizando corchetes [ ].

Los diccionarios son una colección de valores almacenados sin orden y sin índeces. Esto es así porque los diccionarios se implementan como tablas hash, y a la hora de introducir una nueva propiedad (llave) en el diccionario se calcula el hash de la llave para después poder encontrar la entrada correspondiente rápidamente. Si se modificara su propiedad después de haber sido introducida en el diccionario, evidentemente, su hash también cambiaría y no podría ser encontrado.

Los diccionarios u objetos se declaran (crean) entre llaves { } y sus propiedades se escriben “propiedad” : “Valor” y cada propiedad con su valor están separadas por comas.

/*
En este ejemplo se creara un diccionario
con algunas propiedades para luego ser escritas en pantalla
*/

persona = {"nombre": "Melvin", "apellido": "Guerrero", "edad": 50, "etimología": "Latino"}
escribir(persona.nombre)     //Devolverá Melvin

En el ejemplo anterior se puede apreciar que los diccionarios realmente son variables, pero estas almacenan una mayor cantidad de valores.

Note

Latino dispone de una librería para el manejo de diccionarios, aquí.

Definir un diccionario¶

Los diccionarios u objetos como vimos en el ejemplo anterior se pueden declarar en una sola línea, pero esto no es el único caso, también podemos declarar un diccionario en múltiples líneas de la siguiente manera:

Declaración de un diccionario en una sola línea:

carro = {"marca":"Toyota", "modelo":"Camry", "anio":2011, "color":"Blanco"}

Declaración de un diccionario en múltiples líneas:

carro = {
  "marca"  : "Toyota",
  "modelo" : "Camry",
  "anio"   : 2011,
  "color"  : "Blanco"
}

Propiedades de un diccionario¶

En programación al conjunto de llave:valor se les llaman propiedades.

Propiedad (llave)	Valor de propiedad
marca	Toyota
modelo	Camry
anio	2011
color	Blanco

Invocar una propiedad (llave)¶

En Latino existen dos maneras para llamar a una propiedad de un diccionario.

Usaremos el ejemplo anterior como base:

escribir(carro.marca)         //Devolverá Toyota

escribir(carro["modelo"])     //Devolverá Camry

Cambiar valor de propiedad¶

Se puede cambiar el valor de una propiedad con solo hacer referencia a la misma:

carro = {
  "marca"  : "Toyota",
  "modelo" : "Camry",
  "anio"   : 2011,
  "color"  : "Blanco"
}

carro.color="Negro"
escribir(carro.color)     //Devolverá Negro

Métodos de un diccionario¶

Los diccionarios además de ser objetos con sus propiedades, también disponen de métodos.

Los métodos son acciones que se pueden realizar a un objeto. En otras palabras los métodos en realidad son funciones almacenadas en las propiedades del objeto.

persona = {
"nombre"   : "Melvin",
"apellido" : "Guerrero",
"edad"     : 50,
"completo" : funcion()
   retornar persona.nombre.." "..persona.apellido
 fin
 }

 escribir(persona.completo())     //Devolverá Melvin Guerrero

Invocar un método¶

Al igual que las propiedades los métodos se invocan de la misma manera, con la diferencia que estos requiere paréntesis ( ) al final del nombre.

escribir(persona.completo())

escribir(persona["completo"]())

Anidar diccionarios¶

Un diccionario no únicamente está compuesto por propiedades y métodos, también de otros diccionarios. A esto se lo llama diccionario anidado.

carros = {
  "carro1"   : {
    "marca"  : "Toyota",
    "modelo" : "Camry",
    "anio"   : "2011"
  },
  "carro2"   : {
    "marca"  : "Ford",
    "modelo" : "Fiesta",
    "anio"   : "2012"
  },
  "carro3"   : {
    "marca"  : "Peugeot",
    "modelo" : "206",
    "anio"   : "2009"
  }
}

escribir(carros.carro1.marca)     //Devolverá Toyota

De igual manera podemos anidar otros diccionarios ya existentes a un diccionario:

carro1 : {
  "marca"  : "Toyota",
  "modelo" : "Camry",
  "anio"   : "2011"
}
carro2 : {
  "marca"  : "Ford",
  "modelo" : "Fiesta",
  "anio"   : "2012"
}
carro3 : {
  "marca"  : "Peugeot",
  "modelo" : "206",
  "anio"   : "2009"
}

carros = {
  "carro1" : carro1,
  "carro2" : carro2,
  "carro3" : carro3
}

escribir(carros.carro3.marca)     //Devolverá Peugeot

Librería “dic”¶

La librería dic nos permite obtener más información sobre nuestro diccionario en Latino.

Longitud de un diccionario¶

Para obtener la Longitud de un diccionario usaremos el siguiente comando dic.longitud( ).

persona = {"nombre":"Melvin", "apellido":"Guerrero", "edad":50, "etimología":"Latino"}
escribir(dic.longitud(persona))     //Devolverá un valor de 4

Llaves de un diccionario¶

Para obtener las llaves (propiedades) que almacena un diccionario usaremos el siguiente comando dic.llaves( ).

persona = {"nombre":"Melvin", "apellido":"Guerrero", "edad":50, "etimología":"Latino"}
escribir(dic.llaves(persona))     //Devolverá ["nombre", "apellido", "edad", "etimología"]

Valores de un diccionario¶

Para obtener los valores almacenados en las propiedades de un diccionario usaremos el siguiente comando dic.valores( ), también podemos usar este otro comando que de igual manera hace lo mismo dic.vals( ).

persona = {"nombre":"Melvin", "apellido":"Guerrero", "edad":50, "etimología":"Latino"}
escribir(dic.vals(persona))     //Devolverá ["Melvin", "Guerrero", 50, "Latino"]

Agregar nuevas propiedades a un diccionario¶

Para agregar nuevas propiedades a un diccionario implementamos el siguiente código:

carro = {
  "marca"  : "Toyota",
  "modelo" : "Camry",
  "anio"   : 2011,
  "color"  : "Blanco"
}

carro["engranaje"]="Automatico"     //Aquí hemos agregado una nueva propiedad llama "engranaje" y está con un valor de "Automático"
carro.pais="USA"                    //También se puede agregar nuevas propiedades de esta manera
escribir(carro)                     //escribimos el nombre del diccionario para que se impriman todas sus propiedades y valores

Recorrer un diccionario¶

Podemos recorrer un diccionario utilizando el ciclo Desde (For Loop).

Éste es un ejemplo de cómo podríamos recorrer un diccionario que este a su vez imprima las llaves y valores almacenados:

carro = {
  "marca"  : "Toyota",
  "modelo" : "Camry",
  "anio"   : 2011,
  "color"  : "Blanco"
}

desde(i=0; i < dic.longitud(carro); i++)                          //Obtenemos la longitud del diccionario
  escribir(dic.llaves(carro)[i].." | "..dic.valores(carro)[i])    //Devolverá cada propiedad del diccionario con su valor
fin

Note

Por el momento en Latino 1.2.0 en la librería dic funciones como dic.copiar( ), dic.eliminar( ) y dic.existe( ) no están disponibles. Espere a futuros lanzamientos de Latino para ver sus novedades.

Condición Si (If)¶

En programación la condicional Si (If) ayuda al programador a ejecutar instrucciones cuando una condición lógica es cumplida.

Esta condicional evalúa una condición y si el resultado es verdadero ejecuta las instrucciones descritas en ella.

Latino tiene las siguientes declaraciones condicionales:

Comandos	Descripción
si	Inicio de la declaración condicional y esta ejecuta un bloque de código si su condición es verdadera.
osi	Esta ejecuta un nuevo bloque de código si la condicional anterior fue falsa.
sino	Esta ejecuta un bloque de código si las codiciones anterios son falsas.
fin	Marca el fin de la condicional lógica.

Las condiciones lógicas pueden contener expresiones matemáticas.

Expresión	Descripción
a == b	Es igual
a != b	No es igual
a < b	Menor que
a > b	Mayor que
a <= b	Menor o igual que
a >= b	Mayor o igual que
a <> b	Si es diferente

Condicional “si” (if)¶

Inicio de la declaración condicional y esta ejecuta un bloque de código si su condición es verdadera.

En esta declaración condicional solo se puede escribir el comando si una vez y es solo al principio, así también como el comando fin solo al final.

Ejemplo de sintaxis

si (condición lógica)
  #Bloque de código
fin

Ejemplo de código

/*
Si la condición se cumple
escribirá en pantalla la siguiente oración:
10 es mayor que 5
*/
x = 10
y = 5

si (x > y)
  escribir(x.." es mayor que "..y)
fin

Condicional “osi” (else if)¶

Esta ejecuta un nuevo bloque de código si la condicional anterior fue falsa.

El comando osi se puede repetir cuantas veces sean necesarias pero cada nuevo comando osi debe llegar una nueva condición lógica.

Ejemplo de sintaxis

si  condición lógica
  #bloque de código
osi condición lógica
  #bloque de código
fin

Ejemplo de código

/*
Si la condición se cumple
escribirá en pantalla la siguiente oración:
Y es menor
*/
x = 10
y = 5
z = 20

si x < y                      //Recuerde que los paréntesis en la condicional lógica es opcional.
  escribir("X es menor")
osi x > z
  escribir("X es mayor")
osi y < z
  escribir("Y es menor")
fin

Condicional “sino” (else)¶

Esta ejecuta un bloque de código si las codiciones anterios son falsas.

El comando sino solo se puede escribir una sola vez y debe ir después del comando si o después del comando osi.

El comando sino a diferencia del comando si y del comando osi no lleva condición lógica.

Ejemplo de sintaxis

si (condición lógica)
  #bloque de código
sino
  #bloque de código
fin

Ejemplo de código

/*
Si la condición se cumple
escribirá en pantalla la siguiente oración:
Ninguna condición lógica fue cumplida
*/
x = 10
y = 5
z = 20

si x < y
  escribir("X es menor")
osi x > z
  escribir("X es mayor")
osi y < z
  escribir("Y es menor")
sino
  escribir("Ninguna condición lógica fue cumplida")
fin

Condicional “si” lineal¶

Latino al ser un lenguaje de consola, su código se puede escribir en una sola línea, asi:

Este ejemplo también aplica para el comando osi y sino.

si x < y escribir("X es menor") fin

Anidar condición “si”¶

Una condicional si puede tener anidada otra condición si, si fuera necesario.

Esta nueva condición anidada puede ir en cualquier bloque de código, dentro del si, o del osi o también del sino

x = 40

si x > 10
  escribir("X es mayor que 10")
  si x > 20
    escribir("y mayor que 20")
  sino
    escribir("pero menor que 20")
  fin
fin

Operadores condicionales¶

En capítulos pasados ya habiamos hablado de los operadores condicionales. Aquí volveremos a repasar esta clase de operador.

El operadore condicional es puede implementar como una alternativa de la condicional si, ya que requiere de menos líneas de código para ejecutar su condicional lógica.

Sintaxis del operador condicional:

(Expresión condicional) ? expresión1 : expresión2

El operador condicional funciona de la siguiente manera:

La primera expresión condicional se evalúa primero. Esta expresión se evalúa si es verdadera o si es falsa.
Si la expresión condicional es verdadera, se evalúa la expresión1.
Si la expresión condicional es falsa, se evalúa la expresió2.

numero = -5                                                #Creamos una variable con un valor de -5
mensaje = (numero < 0) ? " es negativo" : " es positivo"   #Creamos una nueva variable y a esta le asignamos el operador condicional.
escribir ("El número " .. numero .. mensaje)               #El mensaje seria: El número -5 es negativo.

Operadores lógicos¶

En capítulos pasados vimos que los operadores lógicos son el Y lógico, el Ó lógico y el No lógico.

Estos al igual que las expresiones matemáticas también se pueden utilizar en la condicional si.

“Y” lógico¶

El Y lógico se expresa así: &&

x = 10
y = 5
z = 20

si x > y && z > x
  escribir ("Ambas condiciones se cumplieron")
fin

“Ó” lógico¶

El Ó lógico se expresa así: ||

x = 10
y = 5

si x > 100 || y < 30
  escribir ("Una condición se cumplió")
fin

“No” lógico¶

El No lógico se expresa así: !

/*
Para este ejemplo la condición lógica
la escribimos en paréntesis con esto negamos
todo el conjunto de la condición lógica
*/

x = 10

si !(x > 100)
  escribir ("La condición se cumplió")
fin

Elegir conditional (Switch)¶

The Elegir condiditional is an alternative to si conditional that we saw in the previous chapter.

This conditional is used to perform different actions based on different logical conditions. In other words, this conditional evaluates an option in multiple possible cases and selects one of several code blocks to be executed.

The choose conditional contains the following statements:

Syntax of the “elegir” conditional¶

Syntax example

elegir(expression)
  caso 1:
    #Code block
    romper
  caso 2:
    #Code block
    romper
  defecto:
    #Code block
fin

Code example

/*
Depending on which condition is fulfilled, it will execute the code in its corresponding case.

In this example the program will write on the screen

Well done!.
*/
score = 'B'

elegir(score)
  caso 'A':
    escribir("¡Excellent!.")
  caso 'B':
    escribir("¡Well done!.")
  caso 'C':
    escribir("¡Well done!.")
  caso 'D':
    escribir("You need to improve")
  caso 'F':
    escribir("You failed.")
  otro:
    escribir("Invalid score")
fin

Note

Note that the case has to be repeated for B and C at the moment, multiple cases are not allowed as a single option.

Desde loop(For Loop)¶

Desde repeats the same code over and over again until its expression is fulfilled (is true).

Typically, the desde loop is used to navigate between items in an array or dictionary, but also to execute code that will be repetitive.

“Desde” loop syntax¶

Syntax example

desde (declaration; expresion; statement)
  #Code block
fin

Declarations	Description
Declaration	This is executed (only once) before the execution of the code
Expresion	Define the conditions for the code block to be executed
Statement	This is executed (every time) after executing the code block

Sample code

/*
In the following code
  as long as the variable i is less than or equal to 10
  the conditional from will continue to run.

 The program will print on the screen:
 0 1 2 3 4 5 6 7 8 9 10
 */

 desde (i = 0; i <= 10; i++)
   escribir(i)
 fin

/*
In this other example
the program will print on the screen:
10 9 8 7 6 5 4 3 2 1 0
*/

desde (i = 10; i >= 0; i--)
  escribir(i)
fin
#output: 10 9 8 7 6 5 4 3 2 1 0

A different way can be specified by changing the increment expression.

desde(i = 0; i < 50; i = i+10)
  imprimir(i)
fin
#output: 0 10 20 30 40

Use of libraries¶

Expresiones of the desde loop can implement the use of libraries, like this:

/*
This operation compare the amount
of items in the fruit array and
will write them on screen, like this:

> apple
> grape
> cherry
*/

fruit = ["apple", "grape", "cherry"]

desde(i=0; i < lista.longitud(fruit); i++)
  imprimir(fruit[i])
fin

Nesting “desde” loop¶

When a desde loop contains another desde loop within it, it’s called nested loop.

When the desde loop ( parent ) executes and reaches a nested loop ( child ), the parent loop does not continue until the child loop completes all of its cycles (until it is true). This whole cycle will repeat itself until the parent loop is true.

/*
This operation compares the quantity
of elements in the fruit array and adjectives
will write them on screen, like this:

> green apple
> green grape
> green cherry
> big apple
> big grape
> big cherry
> delicious apple
> delicious grape
> delicious cherry
*/

fruit    = ["apple", "grape", "cherry"]
adjectives = ["green", "big", "delicious"]

desde(i=0; i < lista.longitud(adjectives); i++)
  desde (e=0; e < lista.longitud(fruit); e++)
    escribir (adjectives[i].." "..fruit[e])
  fin
fin

Mientras loop (While Loop)¶

The mientras loop executing a block of code repeatedly as long as its condition is still met (is true).

This loop first verifies that its condition is met before executing the code.¶

Syntax of the loop “mientras”¶

Syntax example

mientras (condition)
  #Code block
fin

Code example

/*
As long as the operation is true
this code will write on screen
the following numbers:
0 1 2 3 4 5 6 7 8 9
*/

i=0

mientras i < 10
  escribir(i)
  i++            //Increases the value of i
fin

Note

In this example, if the value of the variable i is not increased, this loop would repeat infinitely without stopping, producing an error in memory.

Difference between “mientras” and “desde”¶

As you may have noticed, the mientras command and the desde command are very similar to each other, with the difference that the mientras command does not require a declaration or statement as in the desde command .

Example #1: “desde”

This example uses the command desde to acquire the car brands in a variable.

/*
In this example, print on screen:
BMW
Volvo
Ford
Nissan
*/

cars = ["BMW", "Volvo", "Ford", "Nissan"]
text = ""

desde (i=0; i < lista.longitud(cars); i++)
  text = text..cars[i].."\n"     # \n means new line
fin

escribir(text)

Example #2: “mientras”

This example is similar to the previous one with the difference that the mientras command will be used .

/*
In this example, print on screen:
BMW
Volvo
Ford
Nissan
*/

cars = ["BMW", "Volvo", "Ford", "Nissan"]
i = 0
text = ""

mientras(i < lista.longitud(cars))
  text = text..cars[i].."\n"     # \n means new line
i++
fin

escribir(text)

Condición Repetir (Do While)¶

La condicional repetir es una variante de la condicional mientras.

Esta condicional ejecuta su bloque de código al menos una vez antes de verificar si su condición es cumplida (es verdadera).

Mientras su condición sea verdadera, este bucle se volverá a repetir.

Sintaxis de la condicional “repetir”¶

Ejemplo de sintaxis

repetir
  #Bloque de código
hasta (condición)

/*
Hasta que la operación deje de ser cumplida
este código escribira en pantalla
los siguientes números:
0 1 2 3 4 5 6 7 8 9
*/

i=0

repetir
  escribir(i)
  i++            //incrementamos el valor de i
hasta i == 10

Note

En este ejemplo, si no se incrementa el valor de la variable i este bucle se repetiría infinitamente sin parar, produciendo un error en la memoria.

Módulos¶

Un módulo es cualquier archivo o directorio en donde se divide el programa en muchos componentes o bloques de códigos autónomos que pueden ser utilizados en diferentes partes del programa.

Creación de módulos¶

Un módulo no es más que otro archivo en Latino, el cual puede contener desde variables, funciones, listas, diccionarios, etc.

Para crear un módulo en Latino necesitamos guardar el código deseado en un archivo con extensión .lat.

Además es necesario definir en un diccionario las variables y funciones que serán exportadas desde el módulo con el comando retornar.

sintaxis de un modulo

variableMensaje = "Hola mundo"

retornar {"comandoAExportar":variableMensaje}

Uso de módulos¶

Para usar un módulo necesitamos utilizar el comando incluir( ).

Cuando se importan un módulo en Latino es necesario asignarlo a una variable, de esta manera el programa sabrá en cuál módulo buscar la función deseada.

Ejemplo con módulo¶

Para este ejemplo usaremos dos archivos los cuales deben de estar en la misma ubicación de carpeta.

El primer archivo será nuestro código principal en el cual utilizaremos el comando incluir( ) y después usaremos las funciones importadas del módulo.

/*
En este ejemplo escribiremos en pantalla
el resultado de nuestra función en nuestro módulo.
*/

m = incluir("moduloPersona")

escribir(m.hola)                   //Devolverá Hola mundo, Latino

escribir(m.persona_completo)       //Devolverá Melvin Guerrero

n = m.persona.edad
escribir("edad: "..n)              //Devolverá edad: 50

escribir(m.suma(2,3))              //Devolverá 5

El segundo archivo será el código de nuestro módulo, el cual guardaremos con el nombre de moduloPersona.lat.

Important

Es necesario especificar en el comando retornar las funciones y variables que deseamos que se exporten de este módulo, de lo contrario el módulo no funcionara.

/*
Como se puede ver,
un módulo no es más que un archivo en el cual este
será importado en otro archivo para ser usado.
*/

hola = "Hola mundo, Latino"

persona = {
  "nombre"   : "Melvin",
  "apellido" : "Guerrero",
  "edad"     : 50,
  "completo" : funcion()
      retornar persona.nombre.." "..persona.apellido
   fin
}

funcion suma(m,n)
  retornar m + n
fin

/*
**Importante**
Se deben de regresar las funciones y variables
que se quieran exponer del modulo.
*/
retornar {
  "hola"             : hola,
  "persona"          : persona,
  "persona_completo" : persona.completo(),
  "suma"             : suma
}

Subdirectorio¶

Con el comando incluir( ), para especificar archivos en subdirectorios varia dependiendo del sistema operativo.

En MS-Windows, para especificar un archivo en un subdirectorio usamos \.

En Linux y Mac, para especificar un archivo en un subdirectorio usamos /.

Ejemplo

Para añadir un archivo del siguiente subdirectorio carpeta/modulo lo especificamos de la siguiente manera:

incluir("carpeta\modulo")     //MS-Windows
incluir("carpeta/modulo")     //Unix

RegEx¶

Una expresión regular (regular expression ó RegEx, por su nombre en Ingles) es una secuencia de caracteres que forman un patrón de búsqueda.

Una RegEx puede ser utilizada para comprobar si una cadena(string) contiene un patrón de carácter específico.

Para hacer uso de las expresiones regulares se pueden utilizar los siguientes comandos:

~= de este operador relacional también se hace mención en este artículo.
cadena.regexl( ) el cual devuelve un valor buleano.
cadena.regex( ) el cual devuelve una lista de todas las coincidencias.

Operador ~=¶

Ejemplo de sintaxis

~= (expresión)

/*
El operador ~= utiliza las expresiones regulares
en cadenas para hacer patrones de búsqueda.

La condicional SI, devolverá:
"x inicia con hola"
*/

x = "hola mundo"

si x ~= "^hola"
  escribir("x inicia con hola")
sino
  escribir("x NO inicia con hola")
fin

cadena.regexl( )¶

Ejemplo de sintaxis

cadena.regexl(texto, expresión)

/*
En este ejemplo la expresión
buscará la letra U en la cadena.

Devolverá:
falso
*/

txt = "Las manzanas son verdes"
x = cadena.regexl(txt, "u")
escribir(x)

cadena.regex( )¶

Ejemplo de sintaxis

cadena.regex(texto, expresión)

Ejemplo 1

/*
En este ejemplo la variable TXT contendrá el texto principal
la variable X contendrá el resultado de cadena.regex
y su resultado se escribirá en pantalla.

Devolverá una lista de cada coincidencia encontrada:
[["a"], ["a"], ["a"]]
*/

txt = "El agua es vida"
x = cadena.regex(txt, "a")
escribir(x)

Ejemplo 2

/*
Devolverá una lista de cada coincidencia encontrada:
[["El agua es vida"]]
*/

txt = "El agua es vida"
x = cadena.regex(txt, "^El.*vida$")
escribir(x)

Ejemplo 3

/*
Este comando también se puede
utilizar en expresiones lógicas.

Devolverá:
"Eureka! la expresión ha sido encontrada"
*/

txt = "El agua es vida"
x = cadena.regex(txt, "^El.*vida$")

si x
  escribir ("Eureka! la expresión ha sido encontrada")
sino
  escribir ("No se ha encontrado la expresión")
fin

Metacaracteres¶

Los metacaracteres son caracteres con un significado especial.

Carácter	Descripción	Ejemplo
[ ]	Conjunto de caracteres	‘[a-m]’
\	Señaliza una secuencia especial	‘\d’
.	Cualquier carácter(excepto nuevas líneas)	‘Bien..dos’
^	Comienza con…	‘^hola’
$	Termina con…	‘mundo$’
*	Cero o más caracteres	‘Bienve*’
+	Uno o más caracteres	‘Hol+’
{ }	Número especifico de caracteres	‘Bien{7}’
\|	Cualquiera de las opciones	‘x\|y’
( )	Grupo

Conjuntos¶

Los conjuntos son caracteres dentro de corchetes [ ] los cuales tiene un significado especial.

Conjunto	Descripción
[arn]	Devuelve los conjuntos donde estén presentes cualquiera de los caracteres especificados (a, r ó n)
[a-n]	Devuelve los conjuntos de cualquier letra minúscula que estén alfabeticamente entre a y n
[^arn]	Devuelve cualquier conjunto de caracteres EXCEPTO a, r y n
[0123]	Devuelve los conjuntos donde estén presentes cualquiera de los digitos especificados (0, 1, 2 ó 3)
[0-9]	Devuelve cualquier conjuntos de digitos entre 0 y 9
[0-5][0-9]	Devuelve los conjuntos de cualquiera de los dos digitos entre 00 y 59
[a-zA-Z]	Devuelve cualquier conjunto de caracteres desde la a hasta la z sean minúsculas o mayusculas
[+]	Los conjuntos +, , ., \|, ( ), $, { }* no tienen un significado especial. [+] significa que devolverá una coincidencia para cualquier carácter + en la cadena.

secuencias especiales¶

Una secuencia especial inicia con una barra invertida \ seguido de uno carácter de la siguiente lista, los cuales tienen un significado especial.

Carácter	Descripción
\A	Devuelve un conjunto si el carácter especificado está al inicio del texto
\b	Devuelve un conjunto cuando un carácter especificado está al inicio o al final de una palabra
\B	Devuelve un conjunto cuando los caracteres especificados están presentes pero NO al inicio o al final de la palabra
\d	Devuelve un conjunto cuando la cadena(string) contiene números
\D	Devuelve un conjunto cuando la cadena(string) NO contiene números
\s	Devuelve un conjunto cuando la cadena(string) contiene almenos un espacio en blanco
\S	Devuelve un conjunto cuando la cadena(string) NO contiene espacios blanco
\w	Devuelve un conjunto cuando la cadena(string) cualquier carácter( a_Z, 0-9 ó _ )
\W	Devuelve un conjunto cuando la cadena(string) NO contiene ningún carácter
\Z	Devuelve un conjunto si el carácter especificado está al final de la cadena(string)

Patrones de expresiones regulares¶

Carácter [ ]¶

Los brackets son utilizados para buscar caracteres en un rango asignado.

Expresión	Descripción
[abc]	Busca cualquier carácter asignado en los brackets
[0-9]	Busca cualquier número asignado en los brackets
(x\|y)	Busca cualquiera de las alternativas separados por ‘\|’

/*
Busca entre todas las letras minúsculas
en orden alfabético desde la "a" hasta la "m"
*/

txt = "El agua es vida"
x = cadena.regex(txt, "[a-m]")
escribir (x)

acadena( )¶

The function acadena( ) converts numbers to strings(text).

This function can be used in any type of numbers, decimals, variables, or expressions.

acadena(x)            //Returns as text the numeric value of the variable X
acadena(123)          //Returns as text the numeric value 123
acadena(100 + 23)     //Returns as text the result of the expression

Example

x = 123
y = acadena(x)

escribir(x)           //Returns 123
escribir(y)           //Returns 123

/*Although visually it seems that nothing has changed if you use the tipo() function, you will see the difference*/

escribir(tipo(x))     //Returns float
escribir(tipo(y))     //Returns string

Convert booleans to srings(textos)¶

The acadena( ) function can be used to convert boolean (logical) values to strings (texts).

acadena(verdadero)     //Returns "verdadero"
acadena(falso)         //Returns "falso"

alogico( )¶

The alogico( ) function converts the numbers and texts to a logical value (verdadero o falso).

Any number other than 0, whether it is a positive, negative, or decimal number, will return verdadero .

In the same way any text even if this is a blank space will return verdadero.

The alogico( ) function will return falso only if the number is 0, if there is nothing in the quotes, or if we assign a nulo value.

Example

escribir(alogico(1))             //Returns "verdadero"
escribir(alogico(-1))            //Returns "verdadero"
escribir(alogico(3.14))          //Returns "verdadero"
escribir(alogico("Hola"))        //Returns "verdadero"
escribir(alogico(" "))           //Returns "verdadero" (having a blank space makes it "verdadero")
escribir(alogico("0"))           //Returns "falso"
escribir(alogico(nulo))          //Returns "falso"
escribir(alogico(""))            //Returns "falso"

anumero( )¶

The anumero( ) function convers strings (text) to numbers.

Quotation marks without characters, such as ‘’ will return Nulo the same as the number 0.

Blanks ‘ ‘ or whatever number that has a blank, such as ‘7 ‘ will be converted to ALT Code.

Example

escribir(anumero("3.14"))     //Returns 3.14
escribir(anumero(""))         //Returns nulo
escribir(anumero("0"))        //Returns nulo
escribir(anumero(" "))        //Returns 32 (This is the same in ALT Code)
escribir(anumero("9"))        //Returns 9
escribir(anumero("9 "))       //Returns 57(Since it has a blankm it returns its ALT Code)

Convert booleans to numbers¶

The anumero( ) function can be used to convert boolean (logical) values to a numeric value.

anumero(verdadero)     //Returns 1
anumero(falso)         //Returns "nulo" (It doesn't return 0, because its value is represented by a null)

imprimir, escribir, poner( )¶

The imprimir( ), escribir( ), y poner( ) functions write to the screen the string, number, or expression assigned to them.

These imprimir( ), escribir( ), and poner( ) functions are literally the same function, but with different names.

The reason for the wide variety of names that this function receives is because of the different ways that exist in other programming languages to perform the same function. Example: some languages use print and others put.

Example

imprimir("Hello World")                        //Returns "Hello World"
escribir("Latino is cool")               //Returns "Latino is cool"
poner("A psychological hug, bye bye")     //Returns "A psychological hug, bye bye"

imprimirf( )¶

The imprimirf( ) function is inspired by the command printf( ) in C, but the command is more limited in Latino.

This command is essentially similar to imprimir( ), escribir( ) and poner( ) but with some differences.

The command imprimirf( ) requires \n at the end of each string to escribir on the screen, which is NOT the case with the other commands.

This command allows you to format an ASCII character or value.

The command imprimirf( ) operates with the following format:

%c, Converts to a character an ASCII value.

%i, Converts to an integer.

%f, Converts to a float.

%d, Converts to a number.

%o, Converts to an octal number

%x, Converts to a hexadecimal.

%e, Converts to a scientific expression.

%s, Converts to a character or a string.

%%, Returns the porcentage (%) sign.

x = "hello"
escribir(cadena.formato("%c",x))                //Returns h
escribir(cadena.formato("%i",x))                //Returns 104
escribir(cadena.formato("%f",x))                //Returns 104.000000
escribir(cadena.formato("%d",x))                //Returns 104
escribir(cadena.formato("%o",x))                //Returns 150
escribir(cadena.formato("%x",x))                //Returns 68
escribir(cadena.formato("%e",x))                //Returns 5.556763e-307
escribir(cadena.formato("%s",x))                //Returns hello
escribir(cadena.formato("%%",x))                //Returns %
escribir(cadena.formato("%c",75))               //Returns K
escribir(cadena.formato("%c%c%c",75,76,77))     //Returns KLM

incluir( )¶

The incluir( ) function allows you to import modules and libraries in your project.

When we write the module or library, it must be written in quotes and it is not necessary to write its file extension.

Syntax

incluir("librería")              //It doesn't require a variable

variable = incluir("módulo")     //Require to be assigned to a variable

Note

This function can only include files with a .lat extension or library files that have been written for Latino and that use its API.

Subdirectory¶

With incluir( ), specifying files in subdirectories varies depending on the operating system.

on MS-Windows, to specify a file in a subdirectory use \.

On Linux and Mac, to specify a file in a subdirectory use /.

Example

To add a file from the following folder / module subdirectory, specify it as follows:

incluir("folder\module")     //MS-Windows
incluir("folder/module")     //Unix

leer( )¶

The leer( ) function scans the numeric and alphanumeric keys entered by the user, until they press the Enter key .

It is recommended to assign this command to a variable, since any data entered by the user can be manipulated more easily.

leer()

escribir("What's your name?")
x = leer()
escribir("Hi "..x)     //Returns "Hi (User name)"

limpiar( )¶

The limpiar( ) function clears the console screen.

This function is exactly the same as if you use cls on MS-Windows CMD or clear in UNIX-based systems.

limpiar()

escribir("Hello World")
limpiar()
escribir("The previous text was deleted")

tipo( )¶

The tipo( ) function returns the type of value stored in a variable or memory.

The values that this function can return can be found in data types.

x = 123
escribir(tipo(x))     //Returns decimal

x = "Hello world"
escribir(tipo(x))     //Returns cadena

x = ["Hello", "world"]
escribir(tipo(x))     //Returns lista

x = {"Message":"Hello", "Planet":"world"}
escribir(tipo(x))     //Returns diccionario

x = verdadero
escribir(tipo(x))     //Returns logico

x = nulo
escribir(tipo(x))     //Returns nulo

Lib “archivo”¶

La librería archivo contiene las funciones principales para el manejo de archivos en Latino.

Cada uno de estos comandos puede recibir el nombre como también la ruta del archivo.

El nombre de archivo o ruta del archivo deben ser escritas entre comillas.

Important

Al marcar las rutas es importante utilizar doble slash \ \ en MS-Windows

Y en macOS o Linux utilizar slash invertido /

Lista de comando

Comando	Parámetros	Descripción
anexar( )	2	Agrega un texto o dato al final del archivo
borrar( )	1	Elimina el archivo especificado
eliminar( )	1	Elimina el archivo especificado
crear( )	1	Crea un archivo con el nombre especificado
duplicar( )	2	Hace un duplicado del archivo especificado
ejecutar( )	1	Ejecuta el archivo especificado
escribir( )	2	Escribe y/o Sobrescribe en el archivo
leer( )	1	Lee el contenido de un archivo y lo convierte en cadena
lineas( )	1	Almacena en una lista cada línea del archivo
renombrar( )	2	Renombra un archivo por un nuevo nombre asignado

archivo.anexar( )¶

Este comando nos permite agregar texto al final del documento especificado.

A diferencia del comando archivo.escribir( ) que sobrescribe los datos existentes en el documento, el comando archivo.anexar( ) añade el texto al final del documento.

/*
Para este ejemplo supondremos que tenemos
un archivo llamado "prueba.lat" el cual
ya contiene un texto adentro "Hola mundo"
*/

/*
Devolverá:
Hola mundo, Latino

Hoy será un hermoso día.
*/

archivo.anexar("c:\\user\\prueba.lat", ", Latino\n\nHoy será un hermoso día.")

archivo.duplicar( )¶

Este comando crea un duplicado de un archivo especificado.

Ejemplo de sintaxis

archivo.duplicar("archivo_Original", "archivo_Copia")

/*
En este ejemplo se creará un duplicado del archivo
en la carpeta Desktop y se cambiará el nombre del archivo
por "hola.lat"
*/

archivo.duplicar("c:\\user\\prueba.lat", "c:\\user\\desktop\\hola.lat")

archivo.crear( )¶

Este comando nos permite crear un archivo con un nombre especificado en cualquier ruta de nuestro sistema.

/*
Este comando creará un archivo
con el nombre de "prueba"
en la ruta "C:\Users\"
*/

archivo.crear("C:\\Users\\prueba.lat")

Note

Si al especificar la ruta del archivo a crear escribimos un nombre de alguna carpeta que no existe, este no hará nada, ya que este comando solo puede crear archivos y no carpetas.

archivo.ejecutar( )¶

Este comando nos permite la ejecución de un archivo que contenga código de Latino.

archivo.ejecutar("c:\\user\\prueba.lat")

archivo.eliminar( )¶

Este comando nos ayuda a eliminar un archivo especificado.

archivo.eliminar("c:\\user\\prueba.lat")

archivo.escribir( )¶

Este comando nos permite escribir y sobrescribe un archivo especificado.

Important

Si deseamos añadir más información al archivo usar el comando archivo.anexar( )

Si se usa este comando en un archivo NO vacío este será completamente sobrescribe con la nueva información.

archivo.escribir("c:\\user\\prueba.lat", "Hola mundo")

archivo.leer( )¶

Para este comando se requiere almacenar en una variable el contenido del archivo que deseamos leer.

x = archivo.leer("C:\\Users\\prueba.lat")
escribir(x)

archivo.lineas( )¶

Este comando almacena en una lista cada línea de código de un archivo especificado.

Para este comando es requerido asignarlo a una variable para almacenar el contenido del archivo.

x = archivo.lineas("C:\\Users\\prueba.lat")
escribir(x)

archivo.renombrar( )¶

Este comando nos permite renombrar el nombre de un archivo.

Este comando también adminte rutas.

Ejecuta de sintaxis

archivo.renombrar(Nombre_viejo, Nombre_nuevo)

archivo.renombrar("hola.lat", "queTal.lat")     //Renombrará el archivo por queTal.lat

Lib “cadena”¶

La librería cadena nos permite trabajar y manipular las cadenas (string) en Latino.

Lista de comando

Comando	Parámetros	Descripción
bytes( )	1	Devuelve el valor ASCII de cada carácter en una lista
char( )	1	Combierte el valor o lista ASCII a un carácter o una lista de caracteres
comparar( )	2	Compara dos cadenas de textos y devuelve un valor númerico
concatenar( )	2	Combina dos cadenas de textos en una sola cadena
contiene( )	2	Devuelve un valor buleano si encuentra la palabra o cadena especificada
ejecutar( )	1	Ejecuta una cadena que tenga código de latino
eliminar( )	2	Elimina la primera considencia en una cadena
encontrar( )	2	Regresa la posición de la primera considencia encuentra
indice( )	2	Regresa la posición de la primera considencia encuentra
es_alfa( )	1	Comprueba si la cadena solo contiene texto y/o números
es_igual( )	2	Regresa verdadero si las dos cadenas son iguales
es_numerico( ) es_numero( )	1	Comprueba si la cadena solo contiene números
esta_vacia( )	1	Regresa verdadero si la cadena está vacia
formato( )	1	Asigna un formato a un carácter
inicia_con( )	2	Comprueba si la cadena inicia con un texto o cadena especificado
insertar( )	3	Agrega una cadena en la posición indicada
invertir( )	1	Invierte el contenido de la cadena
longitud( )	1	Regresa el tamaño de la cadena
mayusculas( )	1	Combierte toda la cadena en mayúsculas
minusculas( )	1	Combierte toda la cadena en minúsculas
recortar( )	1	Elimina los espacios al inicio y al final de la cadena
reemplazar( )	4	Cambiar una palabra por otra en una cadena
regex( )	2	Utiliza RegEx y regresa una lista de las coincidencias
regexl( )	2	Regresa un valor buelano si encuentra la coincidencia
rellenar_derecha( )	3	Agrega n caracteres al final de la cadena especificada
rellenar_izquierda( )	3	Agrega n caracteres al inicio de la cadena especificada
separar( )	2	Separa la cadena en una lista en base a un separador
subcadena( )	3	Devuelve una sub-cadena en base a la posición y su longitud
termina_con( )	2	Devuelve un valor buleano si hay una coincidencia
ultimo_indice( )	2	Devuelve la posición final de un caracter o palabra especificada

cadena.bytes( )¶

Este comando nos permite convertir nuestra cadena de texto a valor ASCII y la devuelve en una lista.

El comando cadena.char( ) es su contraparte, ya que convierte los valores ASCII a textos.

x = "Hola mundo"
escribir(cadena.bytes(x))     //Devolverá [72,111,108,97,32,109,117,110,100,111]

cadena.char( )¶

Este comando nos permite convertir un número o lista de valores ASCII a una cadena de texto.

El comando cadena.bytes( ) es su contraparte, ya que convierte los textos a valores ASCII.

x = [72,111,108,97,32,109,117,110,100,111]
escribir(cadena.char(x))     //Devolverá Hola mundo

cadena.comparar( )¶

Este comando comparar dos cadenas de textos carácter por carácter hasta encontrar la primera diferencia.

Este comando es similar al comando strcmp() en C.

El comando cadena.comparar( ) devuelve los siguientes valores:

-1, si la primera cadena es menor que la segunda.

0, si ambas cadenas son iguales.

1, si la primera cadena es mayor que la segunda.

Note

menor, igual o mayor hacen referencia al orden o posición de las letra en el alfabeto.

escribir(cadena.comparar("a","b"))               //Devolverá -1
escribir(cadena.comparar("a","a"))               //Devolverá 0
escribir(cadena.comparar("b","a"))               //Devolverá 1
escribir(cadena.comparar("abeja","avestruz")     //Devolverá -1

cadena.concatenar( )¶

Este comando nos permite unir dos cadenas de textos en una sola.

El comando cadena.concatenar( ) es una alternativa al comando doble punto (..).

x = "Hola"
y = " mundo"
z = cadena.concatenar(x,y)
escribir(z)     //Devolverá Hola mundo

cadena.contiene( )¶

Este comando nos permite verificar si existe una coincidencia del texto o cadena a buscar en otra y devolverá un valor buleano.

x = "LenguajeLatino"
y = "Latino"
escribir(cadena.contiene(x, y))     //Devolverá verdadero

cadena.ejecutar( )¶

Este comando nos permite ejecutar una cadeta de texto de tenga código de Latino.

x = 'escribir("Hola mundo")'     //Almacenamos en una variable el código en Latino como una cadena
cadena.ejecutar(x)               //Devolverá Hola mundo

cadena.eliminar( )¶

Este comando solo elimina la primera coincidencia encontrada en una cadena de texto.

x = "Hola mundo, holahola otra vez"
escribir(cadena.eliminar(x, "hola"))     //Devolverá Hola mundo, hola otra vez

cadena.encontrar( )¶

Este comando busca la posición de la primera coincidencia de caracteres o textos.

Este comando también dispone de un alias cadena.indice( ).

El comando cadena.encontrar( ) cuenta cada carácter de una cadena de texto hasta encontrar la primera coincidencia.

El comando comienza a contar desde el número cero (0) como primer número en adelante.

Si el texto o cadena no fue encontrado, entonces devolverá -1.

x = "Hola mundo latino, como estan?"
escribir(cadena.encontrar(x, "como"))     //Devolverá 19

cadena.es_alfa( )¶

Este comando comprueba si la cadena solo contiene valores alfanuméricos y NO símbolos.

El comando cadena.es_alfa( ) devolverá un valor buleano:

verdadero si la cadena es letras y/o números.

falso si la cadena contiene o es un símbolo.

escribir(cadena.es_alfa("1"))          //Devolverá verdadero
escribir(cadena.es_alfa("a"))          //Devolverá verdadero
escribir(cadena.es_alfa("&"))          //Devolverá falso
escribir(cadena.es_alfa("#"))          //Devolverá falso
escribir(cadena.es_alfa("Hola"))       //Devolverá verdadero
escribir(cadena.es_alfa("Hola++"))     //Devolverá falso

cadena.es_igual( )¶

Este comando comprueba si ambas cadenas coinciden entre sí y regresa un valor buleano.

escribir(cadena.es_igual("hola", "HOLA"))     //Devolverá falso
escribir(cadena.es_igual("hola", "hola"))     //Devolverá verdadero

cadena.es_numero( )¶

Este comando comprueba si la cadena solo contiene números y devolverá un valor buleano.

Este comando también dispone de un alias cadena.es_numerico( ).

escribir(cadena.es_numerico("123456"))     //Devolverá verdadero
escribir(cadena.es_numerico("1234f"))      //Devolverá falso
escribir(cadena.es_numerico("hola24"))     //Devolverá falso
escribir(cadena.es_numerico("123$%"))      //Devolverá falso

cadena.esta_vacia( )¶

Este comando verificar que la cadena está vacía.

El comando cadena.esta_vacia( ) devolverá un valor buleano:

verdadero si la cadena esta vacía.

falso si la cadena NO esta vacía.

escribir(cadena.esta_vacia(""))      //Devolverá verdadero
escribir(cadena.esta_vacia("a"))     //Devolverá falso

cadena.formato( )¶

Este comando permite dar formato a un carácter o valor ASCII.

Este comando es similar al comando imprimirf( ), aunque este ultimo requiere del carácter \n para poder escribir en pantalla.

El comando cadena.formato( ) opera con los siguientes formatos:

%c, convierte a un carácter el valor ASCII.

%i, convierte a un número enteros.

%f, convierte a un número decimal.

%d, convierte a un número.

%o, convierte a un valor octal.

%x, convierte a un hexadecimal.

%e, convierte a una expresión científica.

%s, convierte a carácter o ha una cadena de texto.

%%, Devuelve el simbolo de porcentage (%).

x = "hola"
escribir(cadena.formato("%c",x))                //Devolverá h
escribir(cadena.formato("%i",x))                //Devolverá 104
escribir(cadena.formato("%f",x))                //Devolverá 104.000000
escribir(cadena.formato("%d",x))                //Devolverá 104
escribir(cadena.formato("%o",x))                //Devolverá 150
escribir(cadena.formato("%x",x))                //Devolverá 68
escribir(cadena.formato("%e",x))                //Devolverá 5.556763e-307
escribir(cadena.formato("%s",x))                //Devolverá hola
escribir(cadena.formato("%%",x))                //Devolverá %
escribir(cadena.formato("%c",75))               //Devolverá K
escribir(cadena.formato("%c%c%c",75,76,77))     //Devolverá KLM

cadena.inicia_con( )¶

A diferencia del comando cadena.termina_con( ), este comando comprueba si la cadena de texto inicia con un carácter especificado, y este devolverá un valor buleano.

Este comando distingue entre mayúsculas y minúsculas.

x = "Hola mundo"
escribir(cadena.inicia_con(x, "H"))     //Devolverá verdadero
escribir(cadena.inicia_con(x, "h"))     //Devolverá falso

cadena.insertar( )¶

Este comando nos permite añadir una cadena a otra cadena de texto en cualquier posición especificada.

La posición se maneja contando cada carácter de la cadena original. Este conteo inicia desde el número cero (0) como primer número en adelante.

Ejemplo de sintaxis

cadena.insertar(cadena_original, cadena_a_agregar, la_posición)

x = "Hola mundo, como estan?"
y = " Latino"
escribir(cadena.insertar(x, y, 10))     //Devolverá Hola mundo Latino, como estan?

cadena.invertir( )¶

Este comando nos permite invertir el orden de la cadena.

x = "Hola mundo, como estan?"
escribir(cadena.invertir(x))     //Devolverá ?natse omoc ,odnum aloH

cadena.longitud( )¶

Este comando retorna la longitud de la cadena en dígitos.

El comando comienza a contar desde el número uno (1) como primer número en adelante.

x = "Hola mundo, como estan?"
escribir(cadena.longitud(x))     //Devolverá 23

cadena.mayusculas( )¶

Este comando nos permite transformar toda nuestra cadena a letras mayúsculas.

x = "hola mundo"
escribir(cadena.mayusculas(x))     //Devolverá HOLA MUNDO

cadena.minusculas( )¶

Este comando nos permite transformar toda nuestra cadena a letras minúsculas.

x = "HOLA MUNDO"
escribir(cadena.minusculas(x))     //Devolverá hola mundo

cadena.recortar( )¶

Este comando elimina cualquier carácter de espacio al inicio y al final de la cadena, ya sea espacio en blanco o tabulación.

x = "     Hola mundo"
escribir(cadena.recortar(x))     //Devolverá Hola mundo

cadena.reemplazar( )¶

Este comanod nos permite cambiar una palabra por otra en una cadena

Ejemplo de sintaxis

(cadena_original, texto_a_reemplazar, texto_nuevo, posición)

Note

Este comando cambia el texto seleccionado por el nuevo texto asignado, mas no lo guarda.

Para guardar el cambio es recomendable asignarlo a una variable.

x = "Hola mundo HTML"
y = cadena.reemplazar(x, "HTML", "Latino", 12)     //Asignamos en una variable el nuevo texto
escribir(x)                                        //Devolverá Hola mundo HTML
escribir(y)                                        //Devolverá Hola mundo Latino

cadena.regex( )¶

Este comando hace uso de las Expresiones Regulares o RegEx para hacer una búsqueda avanzada y retorna una lista con cada una de las coincidencias.

Para aprender más sobre este comando y las expresiones regulares, mire el artículo de RegEx, aquí.

x = "Hola mundo, Latino"
escribir(cadena.regex(x, "o"))     //Devolverá [["o"], ["o"], ["o"]]

cadena.regexl( )¶

Este comando es conocido como regex lógico.

Este comando hace use de las Expresiones Regulares o RegEx para hacer una búsqueda avanzada y retorna verdadero si encuentra la coincidencia y falso si no la encontró.

Para aprender más sobre este comando y las expresiones regulares, mire el artículo de RegEx, aquí.

//Busca si la cadena termina con "Latino"

x = "Hola mundo, Latino"
escribir(cadena.regexl(x, "Latino$"))     //Devolverá verdadero

cadena.rellenar_derecha( )¶

Este comando nos permite añadir al final de la cadena especificada un texto o cadena.

El comando cadena.rellenar_derecha( ) nos permite indicar la cantidad de veces que deseamos se repita el nuevo texto a añadir.

Ejemplo de sintaxis

cadena.rellenar_derecha(cadena_original, cadena_a_agregar, long_cadena_original + cantidad_de_repeticiones(Valor númerico))

/*
El no.19 es la longitud de la cadena_original
más la cantidad de repeticiones que deseamos,
en este caso indicamos que sean dos veces
*/

x = "Hola mundo, Latino"
y = " que tal?"
escribir(cadena.rellenar_derecha(x,y,19))     //Devolverá Hola mundo, Latino que tal? que tal?

cadena.rellenar_izquierda( )¶

Este comando nos permite añadir al inicio de la cadena especificada un texto o cadena.

El comando cadena.rellenar_izquierda( ) nos permite indicar la cantidad de veces que deseamos se repita el nuevo texto a añadir.

Ejemplo de sintaxis

cadena.rellenar_izquierda(cadena_original, cadena_a_agregar, long_cadena_original + cantidad_de_repeticiones(Valor númerico))

/*
El no.14 es la longitud de la cadena_original
más la cantidad de repeticiones que deseamos,
en este caso indicamos que sean dos veces
*/

x = "mundo, Latino"
y = "hola "
escribir(cadena.rellenar_izquierda(x,y,14))     //Devolverá hola hola mundo, Latino

cadena.separar( )¶

Este comando nos permite segmentar una cadena de texto al especificar un separador y el resultado lo devuelve en una lista.

El separador debe ser especificado dentro de comillas.

Si no se le asigna un separador, por defecto buscara los espacios en blanco.

Ejemplo de sintaxis

cadena.separar(cadena_original, separador)

x = "Hola-mundo-Latino-que tal-estan-todos?"
escribir(cadena.separar(x,"-"))     //Devolverá ["Hola","mundo","Latino","que tal","estan","todos?"]

cadena.subcadena( )¶

Este comando copia de una cadena el texto deseado el cual se define indicando en donde inicia y la longitud que deseamos que tenga el texto a copiar.

La posición_inicial comienza a contar desde el número cero (0) en adelante.

La longitud comienza a contar desde el número uno (1) en adelante.

Ejemplo de sintaxis

cadena.subcadena(cadena_original, posición_inicial(número), longitud(número))

x = "Hola mundo Latino que tal estan todos?"
escribir(cadena.subcadena(x,5,12))     //Devolverá mundo Latino

cadena.termina_con( )¶

A diferencia del comando cadena.inicia_con, este comando nos permite buscar en una cadena de texto si esta termina con un carácter especificado y devuelve un valor buelano.

Este comando distingue entre mayúsculas y minúsculas.

x = "Hola mundo"
escribir(cadena.termina_con(x, "O"))     //Devolverá falso
escribir(cadena.termina_con(x, "o"))     //Devolverá verdadero

cadena.ultimo_indice( )¶

Este comando devuelve la última posición encontrada del carácter especificado.

Este comando comienza a contar desde el número cero (0) en adelante.

x = "Hola mundo"
escribir(cadena.ultimo_indice(x, "u"))     //Devolverá 6

Lib “dic”¶

La librería dic nos permite trabajar y manipular los diccionarios en Latino.

Lista de comando

Comando	Parámetros	Descripción
contiene( )	2	Devuelve verdadero si el elemento existe
eliminar( )	2	Elimina la llave asignada y su valor
llaves( )	1	Devuelve el nombre de la propiedad (llave)
longitud( )	1	Devuelve la longitud de texto
valores( )	1	Devuelve el valor de la propiedad
vals( )	1	Devuelve el valor de la propiedad

dic.contiene( )¶

Este comando nos permite comprobar si una llave o propiedad existe en un diccionario.

Este comando es sensible a las mayúsculas y minúsculas.

persona = {"nombre":"Melvin", "apellido":"Guerrero", "edad":50, "etimología":"Latino"}
escribir(dic.contiene(persona, "edad"))     //Devolverá verdadero

dic.eliminar( )¶

Este comando nos permite eliminar una llave o propiedad existente de un diccionario.

Este comando es sensible a las mayúsculas y minúsculas.

persona = {"nombre":"Melvin", "apellido":"Guerrero", "edad":50, "etimología":"Latino"}
dic.eliminar(persona, "edad")     //Eliminamos la propiedad llamada edad
escribir(persona)                 //Devolverá {"nombre": "Melvin", "apellido": "Guerrero", "etimologa": "Latino"}

dic.llaves( )¶

Para obtener las llaves (propiedades) que almacena un diccionario usaremos el siguiente comando dic.llaves( ).

persona = {"nombre":"Melvin", "apellido":"Guerrero", "edad":50, "etimología":"Latino"}
escribir(dic.llaves(persona))     //Devolverá ["nombre", "apellido", "edad", "etimología"]

dic.longitud( )¶

Para obtener la Longitud de un diccionario usaremos el siguiente comando dic.longitud( ).

persona = {"nombre":"Melvin", "apellido":"Guerrero", "edad":50, "etimología":"Latino"}
escribir(dic.longitud(persona))     //Devolverá un valor de 4

dic.valores( )¶

Para obtener los valores almacenados en las propiedades de un diccionario usaremos el siguiente comando dic.valores( ), también podemos usar este otro comando que de igual manera hace lo mismo dic.vals( ).

persona = {"nombre":"Melvin", "apellido":"Guerrero", "edad":50, "etimología":"Latino"}
escribir(dic.vals(persona))     //Devolverá ["Melvin", "Guerrero", 50, "Latino"]

Lib “lista”¶

La librería lista contiene las funciones para el manejo de lista en Latino.

Lista de comando

Comando	Parámetros	Descripción
agregar( )	2	Agrega un elemento al final de la lista
comparar( )	2	Comprueba el orden y tamaño de letras de los elementos
concatenar( )	2	Uné todos los elementos de dos listas en una sola
contiene( )	2	Devuelve verdadero si el elemento existe en la lista
crear( )	1	Crea una lista con el nombre especificado
eliminar( )	2	Elimina solo la primera coincidencia de la lista
eliminar_indice( )	2	Elimina un elemento de la lista por posición
encontrar( )	2	Devuelve el índice del elemento buscado
indice( )	2	Devuelve el índice del elemento buscado
extender( )	2	Agrega los elementos de una lista en otra lista
insertar( )	3	Inserta un nuevo elemento a una lista
invertir( )	1	Invierte el orden de la lista
longitud( )	1	Devuelve la cantidad de elementos de una lista
separador( )	2	Separa los elementos de una lista

lista.agregar( )¶

Para agregar un nuevo elemento a la lista usamos el comando lista.agregar().

Este comando agrega un nuevo elemento al final de la lista.

carros = ["Toyota", "Ford", "Peugeot"]
lista.agregar(carros, "Honda")           //Agregará "Honda" al final de la lista
escribir(carros)                         //Imprimirá ["Toyota", "Ford", "Peugeot", "Honda"]

lista.comparar( )¶

Con este comando podremos comparar la longitud de dos listas.

Este comando devolverá los siguientes valor según el resultado:

-1 si la lista original es menor.
1 si la lista original es mayor.
0 si ambas listas son iguales.

Ejemplo de sintaxis

lista.comparar(listaOriginal, listaAComparar)

lista1 = ["Hola", "mundo"]
lista2 = ["Mundo", "Latino"]
escribir(lista.comparar(lista1, lista2))
escribir(lista.comparar(lista2, lista1))
escribir(lista.comparar(lista2, lista2))     //Devolverá cero"0", ya que la lista son idénticas

lista.concatenar( )¶

Con este comando podremos unir dos listas en una nueva lista.

lista1 = ["Hola", "mundo"]
lista2 = ["como", "estan?"]
lista3 = lista.concatenar(lista1, lista2)
escribir(lista3)     //Devolverá ["Hola", "mundo", "como", "estan?"]

lista.contiene( )¶

Este comando nos permite comprobar si un elemento existe en la lista.

Este comando es sensible a las mayúsculas y minúsculas.

mensaje = ["Hola", "mundo"]
escribir(lista.contiene(mensaje, "Latino"))     //Devolverá Falso

lista.crear( )¶

Este comando nos permite crear una lista asignando la cantidad de elementos que esta tendrá.

Al crear una lista con este comando, cada elemento tendrá un valor nulo los cuales podrán ser modificados después.

Este comando admite un valor número positivo, de ser asignado cualquier número negativo, esta creará una lista vacía.

/*
Al crear una lista con este comando,
sus elementos serán nulos
*/

x = lista.crear(3)     //Creará una lista con 3 elementos nulos
escribir(x)            //Devolverá [nulo, nulo, nulo]

y = lista.crear(-1)    //Creará una lista con cero elementos
escribir(y)            //Devolverá [ ]

lista.eliminar( )¶

A diferencia de lista.eliminar_indice( ) el comando lista.eliminar( ) elimina la primera coincidencia de la lista.

/*
Elimina solo la primera coincidencia.
Para eliminar las demás coincidencias
se tendrá que repetir el código.
*/

mensaje = ["hola", "Hola", "Hola", "xHola"]

lista.eliminar(mensaje, "Hola")     //Eliminará la primera coincidencia
escribir(mensaje)                   //Devolverá ["hola", "Hola", "xHola"]

lista.eliminar(mensaje, "Hola")     //Eliminará el segundo "Hola"
escribir(mensaje)                   //Devolverá ["hola", "xHola"]

lista.eliminar_indice( )¶

Este comando nos permite eliminar un elemento de la lista asignada por medio de su número de índice.

En una lista los elementos de esta están organizados por índices y estos índices inicial desde el número cero ( 0 ) en adelante.

Este comando NO admite números negativos.

mensaje = ["Hola", "mundo", "Latino", "es lo máximo"]
lista.eliminar_indice(mensaje, 3)     //Aquí asignamos la librería y el índice del elemento a eliminar
escribir(mensaje)                     //Devolverá ["Hola", "mundo", "Latino"]

lista.indice( )¶

El comando lista.indice( ) también dispone de un alias el cual es lista.encontrar( ). Este comando nos permite buscar un elemento por su nombre en una lista y nos devolverá su número de índice.

Este comando es sensible a las mayúsculas y minúsculas.

Si NO encuentra el nombre del elemento a buscar, entonces regresara -1.

mensaje = ["Hola", "mundo", "Latino"]
escribir(lista.indice(mensaje, "latino"))        //Devolverá -1, ya que latino esta en mayúsculas
escribir(lista.encontrar(mensaje, "Latino"))     //Devolverá 2, ya que el índice comienza a contar desde el número cero

lista.extender( )¶

El comando lista.extender( ) copiará los elementos de una lista para ser insertados al final de otra lista deseada.

Ejemplo de sintaxis

lista.extender("ListaAExtender", "ListaACopiar")

mensaje = ["Hola", "mundo"]
copiar = ["Latino", "es lo máximo!"]
lista.extender(mensaje, copiar)
escribir(mensaje)                      //Devolverá ["Hola", "mundo", "Latino", "es lo maximo!"

lista.insertar( )¶

Con este comando podemos insertar un elementos en cualquier indice deseado de una lista.

Ejemplo de sintaxis

lista.insertar(listaOriginal, elementoNuevo, indice)

mensaje = ["Hola", "mundo", "Latino"]
lista.insertar(mensaje, "Lenguaje", 2)
escribir(mensaje)                          //Devolverá ["Hola", "mundo", "Lenguaje", "Latino"]

lista.invertir( )¶

Para invertir el orden de una lista, utilizamos el comando lista.invertir( ).

carros = ["Toyota", "Ford", "Peugeot", "Nissan", "Subaru", "Chevrolet"]
escribir(lista.invertir(carros))     //Devolverá la lista en orden invertido

lista.longitud( )¶

Este comando devuelve la cantidad de elementos de una lista.

mensaje = ["Hola", "mundo", "Latino"]
escribir(lista.longitud(mensaje))     //Devolverá "3"

lista.separar( )¶

El comando lista.separar( ) nos permite separar cada elemento de la lista con un separador asignado.

El separador debe ser declarado dentro de comillas.

Por defecto si no se indica un separador este será sustituido por un espacio en blanco.

Ejemplo de sintaxis

lista.insertar(lista, separador)

mensaje = ["Hola", "mundo", "Latino"]
escribir(lista.separar(mensaje, "-"))                          //Devolverá Hola-mundo-Latino
escribir(lista.separar(mensaje, ".."))                         //Devolverá Hola..mundo..Latino
escribir(lista.separar(mensaje, "_"))                          //Devolverá Hola_mundo_Latino
escribir(lista.separar(mensaje, ""))                           //Devolverá HolamundoLatino
escribir(lista.separar(mensaje))                               //Devolverá Hola mundo Latino]

Lib “mate”¶

La librería mate contiene las funciones de matemáticas en Latino.

Lista de comando

Comando	Parámetros	Descripción
abs( )	1	Devuelve el valor absoluto
acos( )	1	Devuelve el arcocoseno en radianes
acosh( )	1	Devuelve el coseno hiperbólico inverso de un número
aleatorio( )	0, 1 ó 2	Devuelve un número aleatorio
alt( )	0, 1 ó 2	Devuelve un número aleatorio
asen( )	1	Devuelve el arcoseno en radianes
asenh( )	1	Devuelve el arcoseno hiperbólico inverso de un número
atan( )	1	Devuelve el arcotangente como un valor numérico entrew -PI/2 y PI/2 radianes
atanh( )	1	Devuelve el arcotangente hiperbólico inverso de un número
atan2( )	2	Devuelve el arcotangente del cociente de sus argumentos
base( )	2	Devuelve la base de la operación
cos( )	1	Devuelve el coseno
cosh( )	1	Devuelve el coseno hiperbólico
e( )	0	Devuelve el valor del número de Eular (Eular’s number)
exp( )	1	Devuelve el valor de $E^x$, donde E es un número de Euler
frexp( )	2	Devuelve el número descompuesto y a una potencia integral de dos.
ldexp( )	2	Devuelve el número multiplicado por 2 elevado a una potencia
log( )	1	Devuelve el logaritmo natural
log10( )	1	Devuelve el logaritmo natural en base diez
parte( )	2	Devuelve la parte de la operación
pi( )	0	Devuelve el valor de PI
piso( )	1	Devuelve el número redondeado hacia abajo al número entero más cercano
porc( )	2	Devuelve el porcentaje de la operación
porciento( )
porcentaje( )
pot( )	2	Devuelve el valor de un número elevado a la potencia
max( )	1,2,3…	Devuelve el más alto valor de una lista
min( )	1,2,3…	Devuelve el más bajo valor de una lista
raiz( )	1	Devuelve la raíz cuadrada
raizc( )	1	Devuelve la raíz cúbica de un número
redondear( )	1	Devuelve el número redondeado
rnd( )	1	Devuelve el número redondeado
sen( )	1	Devuelve el seno
senh( )	1	Devuelve el seno hiperbólico
tan( )	1	Devuelve la tangente de un ángulo
tanh( )	1	Devuelve la tangente hiperbólico de un número
tau( )	0	Devuelve el valor de TAU
techo( )	1	Devuelve el número redondeado hacia arriba al número entero más cercano
trunc( )	1	Devuelve las partes enteras truncadas de diferentes números

mate.abs( )¶

El comando mate.abs( ) devuelve el valor absoluto (positivo) del número especificado.

escribir(mate.abs(-7.25))     //Devolverá 7.25

mate.acos( )¶

Este comando devuelve el arcocoseno de un número como un valor entre el cero (0) y PI radianes.

Si el número asignado está fuera del rango de -1 a 1, el comando devolverá NaN.

El valor de -1 devolverá el valor de PI, y el valor de 1 devolverá el valor de cero (0).

escribir(mate.acos(0.5))     //Devolverá 1.04719...

mate.acosh( )¶

Este comando devuelve el coseno hiperbólico inverso de un número.

Este comando admite números igual o mayor que 1 (x >= 1).

Si el número asignado está fuera es menor que 1, el comando devolverá NaN.

escribir(mate.acosh(7))        //Devolverá 2.633915793849634
escribir(mate.acosh(56))       //Devolverá 4.71841914237288
escribir(mate.acosh(2.45))     //Devolverá 1.544713117870739
escribir(mate.acosh(1))        //Devolverá 0

mate.aleatorio( )¶

El comando mate.aleatorio( ) devuelve un número.

Este comando también dispone de un alias mate.alt().

Este comando puede admitir desde cero (0) parámetros, hasta un máximo de dos (2) parámetros.

En este comando se puede asignar números positivos como negativos.

Note

Los parámetros se definen de la siguiente manera:

Cero o ningún parámetro:

Devolverá un valor aleatorio entre cero (0) y uno (1).
Un parámetro:

Se tomará como el número máximo, y devolverá entre cero (0) hasta el número asignado.
Dos parámetros:

Devolverá un número aleatorio dentro del rango numérico asignado.

escribir(mate.alt())                //Devolverá un número aleatorio entre 0 y 1
escribir(mate.aleatorio(25))        //Devolverá un número aleatorio entre 0 y 25
escribir(mate.aleatorio(-25,5))     //Devolverá un número aleatorio entre -25 a 5

mate.asen( )¶

El comando mate.asen( ) devuelve el arcoseno de un número como un valor entre -PI/2 y PI/2 radianes.

Si el número asignado está fuera del rango de -1 a 1, el comando devolverá NaN.

El valor de 1 devolverá el valor de PI/2 y el valor de -1 devolverá el valor de -PI/2.

escribir(mate.asen(0.5))     //Devolverá 0.52359...

mate.asenh( )¶

Este comando devuelve el arcoseno hiperbólico inverso de un número.

escribir(mate.asenh(7))        //Devolverá 2.644120761058629
escribir(mate.asenh(56))       //Devolverá 4.718578581151767
escribir(mate.asenh(2.45))     //Devolverá 1.6284998192841909
escribir(mate.asenh(1))        //Devolverá 0.881373587019543
escribir(mate.asenh(0.5))      //Devolverá 0.48121182505960347
escribir(mate.asenh(-10))      //Devolverá -2.99822295029797

mate.atan( )¶

Este comando devuelve el arcotangente de un número como un valor entre -PI/2 y PI/2 radianes.

escribir(mate.atan(2))     //Devolverá 1.10714...

mate.atanh( )¶

Este comando devuelve el arcotangente hiperbólico inverso de un número.

El parámetro admitido por este comando debe estar entre -0.99 y 0.99.

escribir(mate.atanh(0.59))      //Devolverá 0.6776660677579618
escribir(mate.atanh(-0.12))     //Devolverá -0.120581028408444
escribir(mate.atanh(0.99))      //Devolverá 2.646652412362246

mate.atan2( )¶

Este comando devuelve el arcotangente del cociente de sus argumentos, como un valor numérico entre PI y -PI radianes.

El número devuelto representa el ángulo en el sentido contrario de las agujas del reloj en radianes (pero NO en grados) entre los dos valores asignados a la operación.

/*
En este ejemplo usaremos las coordenadas de (4,8).

**Importante**
Con este comando la segunda coordenada se pasa como primer argumento
y la primera coordenada se pasa como segundo argumento
*/

escribir(mate.atan2(8,4))     //Devolverá 1.10714...

mate.base( )¶

Este comando devuelve la base de un porciento.

Para el porcentaje NO es necesario digitarlo en número decimal sino en porcentaje.

Este comando está relacionado con los comandos mate.parte( ) y mate.porc( )

Ejemplo de sintaxis

base = parte / porciento

/*
En este ejemplo buscaremos la base.
Ejemplo: ¿30 es una parte que representa el 40% de cuál número?
*/

escribir(mate.base(30,40))     //Devolverá 75

mate.cos( )¶

Este comando devuelve el coseno de un número.

El comando mate.cos( ) devuelve un valor numérico entre -1 y 1, que representa el coseno del ángulo.

escribir(mate.cos(3))     //Devolverá -0.98999...

mate.cosh( )¶

Este comando devuelve el coseno hiperbólico de un número.

escribir(mate.cosh(3))     //Devolverá 10.06766...

mate.e( )¶

Este comando devuelve el valor del número de Eular (eular’s number).

escribir(mate.e())     //Devolverá 2.718281828459045

mate.exp( )¶

Este comando devuelve el valor $E^x$, donde E es un número de Euler (aproximadamente 2,7183) y equis(x) es el número que se le pasa.

escribir(mate.exp(1))      //Devolverá 2.71828...
escribir(mate.exp(-1))     //Devolverá 0.36787...
escribir(mate.exp(5))      //Devolverá 148.41315...
escribir(mate.exp(10))     //Devolverá 22026.46579...

mate.frexp( )¶

Este comando descompone un número en significativo y a una potencia integral de 2.

escribir(mate.frexp(123.45,0.45))     //Devolverá 0.96445...

mate.ldexp( )¶

Este comando multiplica un número por 2, elevado a una potencia.

escribir(mate.ldexp(7,-4))        //Devolverá 0.4375
escribir(mate.ldexp(1,-1074))     //Devolverá 4.94065...
escribir(mate.ldexp(-0,10))       //Devolverá -0
escribir(mate.ldexp(1,1024))      //Devolverá inf

mate.log( )¶

Este comando devuelve el logaritmo natural de un número.

Si el parámetro es negativo, devolverá NaN.

Si el parámetro es cero (0), devolverá infinito.

escribir(mate.log(2))          //Devolverá 0.69314...
escribir(mate.log(2.7183))     //Devolverá 1.0000066849...
escribir(mate.log(1))          //Devolverá 0
escribir(mate.log(0))          //Devolverá -inf
escribir(mate.log(-1))         //Devolverá NaN

mate.log10( )¶

Este comando devuelve el logaritmo común de un número (en base a 10).

Si el parámetro es negativo, devolverá NaN.

Si el parámetro es cero (0), devolverá infinito.

escribir(mate.log10(1))         //Devolverá 0
escribir(mate.log10(5))         //Devolverá 0.69897...
escribir(mate.log10(10))        //Devolverá 1
escribir(mate.log10(20))        //Devolverá 1.30102...
escribir(mate.log10(100))       //Devolverá 2
escribir(mate.log10(1000))      //Devolverá 3
escribir(mate.log10(0.001))     //Devolverá -3
escribir(mate.log10(0))         //Devolverá -inf
escribir(mate.log10(-1))        //Devolverá NaN

mate.parte( )¶

Este comando devuelve la parte de un porciento.

Para el porcentaje NO es necesario digitarlo en número decimal sino en porcentaje.

Este comando está relacionado con los comandos mate.base( ) y mate.porc( )

Ejemplo de sintaxis

parte = base * porciento

/*
En este ejemplo buscaremos la parte.
Ejemplo: ¿cuanto es el 35% de 200?
*/

escribir(mate.parte(35,200))     //Devolverá 70

mate.pi( )¶

Este comando devuelve el valor de PI.

escribir(mate.pi())     //Devolverá 3.141592653589793

mate.piso( )¶

A diferencia del comando mate.techo( ), el comando mate.piso( ) redondea un número hacia abajo al entero más cercano.

Si el argumento pasado es un número entero, el valor NO se redondeará.

escribir(mate.piso(1.6))      //Devolverá 1
escribir(mate.piso(0.60))     //Devolverá 0
escribir(mate.piso(5))        //Devolverá 5
escribir(mate.piso(5.1))      //Devolverá 5
escribir(mate.piso(-5.1))     //Devolverá -6
escribir(mate.piso(-5.9))     //Devolverá -6

mate.porc( )¶

Este comando devuelve la porcentaje de un porciento.

Este comando también dispone de alias como mate.porciento( ) y mate.porcentaje( ).

Para el porcentaje NO es necesario digitarlo en número decimal sino en porcentaje.

Este comando está relacionado con los comandos mate.base( ) y mate.parte( )

Ejemplo de sintaxis

porcentaje = parte / base

/*
En este ejemplo buscaremos el porcentaje.
Ejemplo: ¿45 es cual porcentaje de 70?
*/

escribir(mate.porc(45,70))     //Devolverá 0.6428571428571429

mate.pot( )¶

Este comando devuelve el valor(primer dígito) elevado a la potencia (segundo dígito).

escribir(mate.pot(4,3))      //Devolverá 64
escribir(mate.pot(0,1))      //Devolverá 0
escribir(mate.pot(1,1))      //Devolverá 1
escribir(mate.pot(1,10))     //Devolverá 1
escribir(mate.pot(3,3))      //Devolverá 27
escribir(mate.pot(-3,3))     //Devolverá -27
escribir(mate.pot(2,4))      //Devolverá 16

mate.max( )¶

Este comando devuelve el más alto valor de una lista.

Este comando también trabaja con números negativos.

Este comando NO tiene cantidad máxima de parámetros, lo que significa que se puede hacer una comparación entre 2 a 1000 números si se desea.

escribir(mate.max(-4,-15,1,5,10,2))      //Devolverá 10

mate.min( )¶

Este comando devuelve el más bajo valor de una lista.

Este comando también trabaja con números negativos.

Este comando NO tiene cantidad máxima de parámetros, lo que significa que se puede hacer una comparación entre 2 a 1000 números si se desea.

escribir(mate.min(-20,1,5,-15,10,2))      //Devolverá -20

mate.raiz( )¶

Este comando devuelve la raíz cuadrada de un número.

escribir(mate.raiz(9))      //Devolverá 3
escribir(mate.raiz(0))      //Devolverá 0
escribir(mate.raiz(1))      //Devolverá 1
escribir(mate.raiz(64))     //Devolverá 8
escribir(mate.raiz(-9))     //Devolverá NaN

mate.raizc( )¶

Este comando devuelve la raíz cúbica de un número.

escribir(mate.raizc(6))      //Devolverá 1.817120592832139

mate.redondear( )¶

Este comando redondea el número a su mas cercano entero.

Este comando también dispone de un alias mate.rnd( ).

escribir(mate.redondear(5.4))     //Devolverá 5
escribir(mate.rnd(5.6)            //Devolverá 6

mate.sen( )¶

Este comando devuelve el seno de un número.

El comando mate.sen( ) devuelve un valor entre -1 y 1, que representa el seno del parámetro asignado.

escribir(mate.sen(3))      //Devolverá 0.14112...
escribir(mate.sen(-3))     //Devolverá -0.14112...
escribir(mate.sen(0))      //Devolverá 0

mate.senh( )¶

Este comando devuelve el seno hiperbólico de un número.

escribir(mate.senh(1))     //Devolverá 1.17520...

mate.tan( )¶

Este comando devuelve la tangente de un número.

escribir(mate.tan(1))     //Devolverá 1.55740...

mate.tanh( )¶

Este comando devuelve la tangente hiperbólica de un número.

escribir(mate.tanh(1))     //Devolverá 0.76159...

mate.tau( )¶

Este comando devuelve el valor de TAU.

escribir(mate.tau())     //Devolverá 6.283185307179586

mate.techo( )¶

A diferencia del comando mate.piso( ), el comando mate.techo( ) redondea un número hacia arriba al entero más cercano.

Si el argumento pasado es un número entero, el valor NO se redondeará.

escribir(mate.techo(1.4))      //Devolverá 2
escribir(mate.techo(0.60))     //Devolverá 1
escribir(mate.techo(5))        //Devolverá 5
escribir(mate.techo(5.1))      //Devolverá 6
escribir(mate.techo(-5.1))     //Devolverá -5
escribir(mate.techo(-5.9))     //Devolverá -5

mate.trunc( )¶

Este comando devuelve la parte entera truncada de un número.

Este comando NO redondea el número al más cercado entero, sino remueve su punto decimal.

escribir(mate.trunc(2.77))       //Devolverá 2
escribir(mate.trunc(8.32))       //Devolverá 8
escribir(mate.trunc(-99.29))     //Devolverá -99

Lib “sis”¶

La librería sis contiene funciones que nos permitirán operar con nuestro sistema desde Latino.

Lista de comando

Comando	Parámetros	Descripción
dormir( )	1	Detiene el sistema por segundos
ejecutar( )	1	Ejecuta un comando de la consola desde latino
fecha( )	1	Imprime la fecha y hora del sistema (cadena)
salir( )	0	Termina la ejecución de latino
cwd( )	0	Imprime la ruta de donde se está ejecutando Latino
iraxy( )	2	Mueve el cursor de la consola a una nueva posición
tiempo( )	2	Muestra el año, mes, hora, min, y seg de la máquina local
usuario( )	0	Devuelve el nombre del usuario activo del sistema
operativo( )	1	Devuleve el sistema operativo en el que se ejecuta
op( )	1	Devuleve el sistema operativo en el que se ejecuta

sis.dormir( )¶

Este comando detiene la ejecución del código por la cantidad de segundos signados.

Es importante recalcar que este comando admite segundos y NO milisegundos.

sis.dormir(5)             //Detendar la ejecución del código por 5 segundos
escribir("Hola mundo)     //Escribirá el mensaje después de pasar el tiempo asignado

sis.ejecutar( )¶

Con este comando podemos efectuar comandos nativos de la consola en el que estamos.

/*
Este comando escribirá
"Hola mundo" en la consola
*/

sis.ejecutar("echo Hola mundo")

sis.fecha( )¶

Este comando nos permite obtener la fecha del equipo o máquina local en donde Latino se está ejecutado.

Los comando a utilizar son los siguientes:

Comandos	Descripción
seg	Devuelve los segundos
min	Devuelve los minutos
hora	Devuelve las horas (hora militar)
mes	Devuelve el mes
año	Devuelve el año
d_sem	Devuelve el día de la semana
d_mes	Devuelve el día del mes
d_año	Devuelve el día del año
estacion	Devuelve la estación del año

escribir(sis.fecha("hora"))     //Devolverá las horas EJ. 17 horas

sis.salir( )¶

Con este comando podemos cerrar o terminar la ejecución de Latino.

Este comando es similar al atajo de teclado de consola explicado aquí.

sis.salir()

sis.cwd( )¶

Imprime la ruta en donde Latino esta siendo ejecutado.

escribir(sis.cwd())

sis.iraxy( )¶

Con este comando podemos mover el cursor de texto a cualquier parte de la ventana.

Este comando es similar al comando gotoxy( ) en C.

Ejemplo de sintaxis

sis.iraxy(valorHorizontal, valorVertical)

/*
Este código dibujara una caja
para luego mover el cursor dentro de ella
*/

escribir("Ente su número en la caja
+----------+
|          |
+----------+")
sis.iraxy(2,3)     //Moverá el cursor al sitio deseado
x = leer()

sis.tiempo( )¶

A diferencia del comando sis.fecha( ), el comando sis.tiempo( ) nos permite tener un mayor control de las fechas y horas.

Este comando es similar a la librería datetime en Python.

Comando	Descripción
%a	Nombre del día de la semana abreviado
%A	Nombre del día de la semana completo
%w	Día de la semana en números del 0-6 (0 es domingo)
%d	Día del mes
%b	Nombre del mes abreviado
%B	Nombre del mes completo
%m	Mes en números
%y	Año abreviado
%Y	Año completo
%H	Horas (00-23)
%I	Horas (00-12)
%p	AM/PM
%M	Minutos (00-59)
%S	Segundos (00-59)
%z	UTC offset
%Z	Zona horaria (timezone)
%j	Número del día del año (001-366)
%U	Números de la semana del año (00-53, Domingo como el primer día de la semana)
%W	Números de la semana del año (00-53, Lunes como el primer día de la semana)
%c	Fecha y el hora de la máquina local
%x	Fecha de la máquina local
%X	Hora de la máquina local
%%	Devuelve el carácter de %

escribir(sis.tiempo("%c"))     //Devolverá la fecha y hora actual

sis.usuario( )¶

Este comando obtener el nombre del usuario activo en el sistema.

escribir(sis.usuario())

sis.operativo( )¶

El comando sis.operativo( ) también dispone de una abreviación op.

Ambos comandos retornar el nombre del sistema operativo es en el que Latino esta siendo ejecutado.

Estés comando solo admite los siguientes comandos (en mayúsculas):

WIN32 : para MS-Windows
APPLE : para macOS-X
LINUX : para Linux

/*
Esta operación escribirá un mensaje personalizado
dependiendo del sistema operativo en donde sea ejecutado
*/

si sis.op("WIN32")
    escribir("Windows-XP 4ever")
osi sis.operativo("APPLE")
    escribir("Think Different")
osi sis.op("LINUX")
    escribir("Linux for Humand")
sino
    escribir("El sistema no es reconosido por Latino")
fin

Console commands¶

The console commands are some functions that we can carry out with Latino before executing it in our console or terminal.

Below is a table with the console commands available in Latino.

Commands¶

Run a command¶

To run a command with Latino in the console, you can use the following:

latino -e *Latino code*

Show Latino version¶

To show the version of Latino that is installed on our system, you can use the following command:

latino -v
latino --version

Close Latino in the console¶

If after starting Latino on your console, you want to close the program, you can press the following keyboard combination:

Ctrl + C

You can also exit Latino by running the command explained here.

Glossary¶

Temporary glossary

The content of this will be updated periodically.

Reserved keywords¶

caso
cierto | verdadero
continuar
defecto | otro
desde
elegir
error
escribir | imprimir | poner
falso
fin
funcion | fun
global
hasta
imprimirf
incluir
mientras
nulo
osi
repetir
retorno | retornar | ret
romper
si
sino
tipo

Libraries¶

archivo
cadena
dic
gc
lista
mate
paquete
sis

Manual Latino 1.3.0 (English version)¶

Getting Started¶

Categories¶

Other Documentations¶

External links¶

Get Involved¶

Introduction¶

Who is this intended for?¶

Learn with examples¶

Learn at your pace¶

About Latino¶

What is Latino?¶

Why another programming language?¶

I code in English, why learning Latino?¶

Advantages of this programming language¶

Who develops Latino?¶

What are the plans for the future?¶

MS-Windows¶

Debian - Ubuntu¶

Fedora - CentOS¶

macOS-X¶

Atom¶

Notepad++¶

Sublime Text¶

TextMate¶

Vim¶

VS Code¶

My First Program¶

Comments¶

Single line comments¶

Multi-line comments¶

Using comments to prevent code execution:¶

Variables¶

Declaración (creación) de variables¶

Las variables SI pueden:¶

Las variables NO pueden:¶

Declaraciones de múltiples variables¶

Tipos de variables¶

Variables numéricas¶

Concatenar variables¶

Constantes¶

Operadores¶

Operadores aritméticos¶

Operadores de incremento y decremento¶

Operadores de asignación¶

Operadores relacionales¶

Operadores lógicos¶

Operadores condicionales¶

Otros operadores¶

Operador de concatenación¶

Operador de acceso a miembro¶

Arithmetic¶

Arithmetic operators¶

Addition¶

Substraction¶

Multiplication¶

Division¶

Modulo (Remainder)¶

Power¶

Increment and decrement operators¶

Increment¶

Decrement¶

Precedence in Operators¶

Assignment¶

Operator =¶

Operator +=¶

Operator -=¶

Operator *=¶

Operator /=¶

Operator %=¶

Relacionales¶

Lógicos¶

Tipos de Datos¶

Tipos de datos: Lógico¶

Tipos de datos: Numérico¶

Tipos de datos: Cadena¶

Tipos de datos: Lista¶

Tipos de datos: Diccionario¶

Nulo¶

Diferencia entre un valor vacío y un nulo¶