JavaScript

• Deno
  • Instalar Deno Engine
  • Ejecutar un archivo
  • Vendor - Dependencias en local
  • Archivos de proyecto
• TypeScript - JavaScript
  • Comentarios
  • Importar
    • Importar desde JSR
    • Importar desde NPM
  • Variables y constantes
  • Structuras
    • Tipos
  • Funciones
  • Condicionales
    • If - else if - else
    • Switch
    • While
    • For
  • Arrays
  • Tests - Pruebas
  • Funciones comunes

Es un estándar (ECMAScript), por lo que cada engine puede expandirlo.

• TypeScript

  Creado por Microsoft añade que se tengan que especificar el tipo de dato.

  TypeScript usa la extensión ".ts"

Al estar pensado para scripting, sigue el mismo esquema que BASH; solo ejecuta funciones si son llamadas directamente, el resto lo procesa todo en tiempo de ejecución.

Deno

Instalar Deno Engine

curl -fsSL https://deno.land/install.sh | sh

Ejecutar un archivo

deno run [archivo].ts

• "--allow-net" para permitir que el archivo use red
• "--config" para especificar otro archivo de configuración deno.json ó deno.jsonc

Vendor - Dependencias en local

deno cache [archivo].ts

Archivos de proyecto

• deno.json ó deno.jsonc

  Contiene las dependencias y configuración del proyecto para el compilador, formateador y enlazador.

  Si contiene "tasks" permite acortar comandos largos en una simple tarea. Las tareas se corren con; "deno task [name]"

  Si contiene "fmt" permite personalizar como va a formatear si se corre un "deno fmt".

  Si contiene el tuple "exclude" se puede indicar que directorios no se quiere incluir por parte de la ejecución de Deno.

{
  "compilerOptions": {
    "allowJs": true,
    "lib": ["deno.window"],
    "strict": true
  },
  "lint": {
    "include": ["src/"],
    "exclude": ["src/testdata/", "src/fixtures/**/*.ts"],
    "rules": {
      "tags": ["recommended"],
      "include": ["ban-untagged-todo"],
      "exclude": ["no-unused-vars"]
    }
  },
  "fmt": {
    "useTabs": true,
    "lineWidth": 80,
    "indentWidth": 4,
    "semiColons": false,
    "singleQuote": true,
    "proseWrap": "preserve",
    "include": ["src/"],
    "exclude": ["src/testdata/", "src/fixtures/**/*.ts"]
  },
  "lock": false,
  "nodeModulesDir": true,
  "unstable": ["webgpu"],
  "npmRegistry": "https://mycompany.net/artifactory/api/npm/virtual-npm",
  "test": {
    "include": ["src/"],
    "exclude": ["src/testdata/", "src/fixtures/**/*.ts"]
  },
  "tasks": {
    "start": "deno run --allow-read main.ts"
  },
  "imports": {
    "oak": "jsr:@oak/oak"
  },
  "exclude": [
    "dist/"
  ]
}

TypeScript - JavaScript

Comentarios

// Esto es un comentario

Importar

Deno soporta tanto NPM como JSR.

Consideración; la función debe estar dentro de "{}" cuando el módulo no tiene un "export default function ....."

Las funciones que no necesitar las "{}" en el import son las que tienen en su módulo un el default.

• De otros archivos

import [Struct],[function_N] from "./[archivo].ts";

• De la stdlib

Deno stdlib

import [Function] from "[package_registry]:@std/[module]"

Importar desde JSR

import [Function] as mod from "jsr:@[user_or_organization]/[module]"

Importar desde NPM

import [Function] from "npm:[module]@[version]"

Variables y constantes

• Variable

  Alcance local en una función

var [var_name]: [var_type_if_is_Typescript] = [value]

• Constante

  Alcance global cuando son variables declaradas fuera de una función pero con alcance de bloque. Funciones incluidas.

  Solo pueden ser declaradas una vez dentro de su alcance.

{
    const [var_name]: [var_type_if_is_Typescript] = [value]
}

Las constantes no pueden actualizarse a futuro (por que hace un shadowing en realidad, que es una redeclaración a bajo nivel).

• let

  Al igual que en Rust, sirven para declarar variables. Y al igual que en "const" tiene alcance de bloque pero pueden actualizarse a posteriori.

{
    let [var_name]: [var_type_if_is_Typescript] = [value]
}

Structuras

interface [struct_name] {
    [var_name1]: [type];
    [var_name2]: [type];
}

const [instance_name]: [struct_name] = {
    [var_name1]: [value],
    [var_name2]: [value],
}

Tipos

let var1 = 5;
let var2 = 12.1;
let var3 = 'string1';
let var4 = "string2";
let var5 = true;
let var6 = false;
let var7 = 'c';

Se puede formatear un retorno de string sin guardar previamente en una variable;

return 'Hello, ${[var_or_struct]}'; 

Funciones

function [func_name]([var_name]: [type]): [return_type]{
    [operations];
    return [return_value];
} 

Si a la función se le añade "export function ...." entonces se vuelve pública y puede ser llamada desde otros archivos.

Equivalente al "pub" en Rust.

Si a la función le añadis "async" la volves eso; asíncrona, luego la variable que va a contener el retorno debe tener un "await" antes de su llamado.

Condicionales

• Para booleanos es un triple = para verificar valores
• Para el resto de tipos de datos son dobles = solamente

If - else if - else

if (var1 > var2) {
    console.log("el valor de var2 es mayor que var1." + '\n' + "Var2;" + var2 + '\n' + "Var1;" + var1);
} else if (var1 > var2) {
    console.log("el valor de var2 es menor que var1." + '\n' + "Var2;" + var2 + '\n' + "Var1;" + var1);
} else if (var1 == 0 || var2 >=12) {
    console.log("var1 es cero ó var2 es mayor o igual a 12" + '\n' + "Var2;" + var2 + '\n' + "Var1;" + var1);
} else if ( var1 != var2 ) {
    console.log("var1 no es igual a var2");
} else {
    console.log("sin valores de coincidencia");
}

Switch

switch (var1) {
    case 0:
    case 1:
        console.log("el valor de var1 es 0 ó 1");
        break;
    case 5:
        console.log("el valor de var1 es 5");
        break;
    default:
        console.log("sin valores de coincidencia");
        break;
}

While

while (var5 === true) {
    console.log("var 5 es verdadero");
}

/// Loop infinito

while (true){
    console.log("loop infinito");
}

/// Loop combinado
let temporal1 = 0;
while (var5 === true && temporal1 <= 5){
    console.log("loop finito");
    temporal1 += 1;
}

For

Es igual que en C: inicio; condicion; modificacion final Al igual que con los if/else, pueden combinarse unos dentro de otros

for (let i = 0; i <= 15; i++){
    console.log("i = " + i + ".");
}

/// Breaks combinados
/// Cuando en un bucle se usa el break se asegura que el resto no se procesa y que se
/// termina el ciclo

for (let j = 0; j <= 15; j++){
    // Acá el if hace que no se impriman los mayores a 10
    if ( j > 10) {
        break;
    } 
    console.log("j = " + j + ".");
}

/// El continue en cambio, hace que el ciclo se termine y se inicie el nuevo

for (let e = 0; e <= 15; e++){
    // Acá el if hace que solamente se impriman los mayores a 10
    if ( e < 10) {
        continue;
    } 
    console.log("e = " + e + ".");
}

Arrays

El estándar de javascript lo toma como una sucesion finita de chars con eso se puede hacer uso de cada uno de sus componentes/chars.

Se cuenta desde cero, por que va por posiciones

let string1 = "Cadena de texto 1";

/// imprimirá "C"
console.log("caracter cero; " + string1[0]);
/// también se puede contar desde atrás
/// imprimirá "!"
/// el método "length" devuelve el largo de la cadena
console.log("ultimo caracter; " + string1[ string1.length -1 ]);

/// Si se utiliza un array que está en una posición inválida se obtiene un error de tipo
/// "undefined"

console.log("caracter fuera de rango; " + string1[99999]);

/// Así mismo los valores pueden ser asignados a otras variables
/// La primera toma el primer caracter
/// La segunda toma el rango desde cero hasta la posicion numero 5
let varbuffer = string1[0];
let varbuffer2 = string1[0,5];

console.log("Buffer1 es;" + varbuffer + '\n' + "Buffer2 es;" + varbuffer2);

Tests - Pruebas

Esto lo ofrece el motor Deno

import { assertEquals } from "jsr:@std/assert";
import Person, { sayHello } from "./person.ts";

Deno.test("sayHello function", () => {
  const grace: Person = {
    lastName: "Hopper",
    firstName: "Grace",
  };

  assertEquals("Hello, Grace!", sayHello(grace));
});

Luego se ejecuta ese testeo con;

deno test [archivo].ts

Funciones comunes

• Imprimir en pantalla

console.log([function_or_variable])

// show variable type
console.log("constante1 es del tipo; " + typeof constante1);

• Llamado asíncrono

await [function][func_parameters];

Al ser guardado en una variable, si se imprime en pantalla también necesita un "await").

• Request web (asíncrono)

fetch("[URL]");

• Tipo de dato

typeof [var]

• Obtener el largo de una cadena

[string_variable].length

• Ejecutar proceso hijo

new Deno.command("[path]/[binario]", [args], [opciones])

Algunas de las opciones son; - stdin: "piped", - stdout: "piped",