Me apetecía programar una IA en javascript y necesitaba alguna forma de pasarle input, asique decidí hacer un bot de telegram.
Como ya van varios bots que hago, alguno salió algo buggeado y posiblemente en el futuro haga otros parecidos, decidí hacer un bot/nucleo a partir del cual pueda escribir cualquier bot.

Asique este bot tiene lo básico y mínimo indispensable que se puede necesitar para un bot. Le metí varios argumentos cli básicos para configurar el bot, meterle el token y ver su uso.
También le metí que responda al telegram a unos pocos comandos de ejemplo.

De momento no encontré ningún bug. Si encuentro alguno o meto algún cambio interesante o importante, lo añadiré aquí.

import * as std from "std";
import * as os from "os";
 
let run = command => {
  let p = std.popen(command, "r"),
  msg = "",
  r = "";
 
  while(( r = p.getline() ) != null) {
    msg += r + "\n";
  }
  return msg;
}
 
let cli = {};
cli.COLORS = {
  RED: "\x1b[31m",
  RESET: "\x1b[0m",
  YELLOW:"\x1b[33m",
  BLUE: "\x1b[34m",
  GREEN: "\x1b[32m"
};
 
for (let i in scriptArgs) {
  switch(scriptArgs[i]) {
    case "-t":
    case "--token":
      cli.token = scriptArgs[+i + +1];
    break;
 
    case "-s":
    case "--save":
      let fd = std.open(".token", "w");
      fd.puts(cli.token);
      fd.close();
    break;
 
    case "-l":
    case "--load":
      cli.token = std.loadFile(".token");
    break;
 
    case "-h":
    case "--help":
      throw `
 
usage: qjs tgbot.js [options]
  -t  --token            Telegram Bot Api Token. https://t.me/BotFather
  -s  --save             Save the token internally to start the bot in the future without manually provide the token each time.
  -l  --load             Use the saved token to start the bot.
  -h  --help             This message.
  -v  --verbose          Show basic feedback to the command line interface.
  -w  --wait             Bot delay in seconds. (Can process multiple messages at once, so you don't need a really low number to don't fallback).
 
Examples:
qjs tgbot.js -t 192829292:iqidkwiexampleunvalidtokeniwjwusjwis -s -v
 
qjs tgbot.js -l -v
 
qjsc -o ctgbot tgbot.js && cp tgbot ~/../usr/bin/
tgbot -l -w 2 -v
 
`;
 
    case "-v":
    case "--verbose":
      cli.v = true;;
    break;
 
    case "-w":
    case "--wait":
      cli.wait = scriptArgs[+i + +1];
    break;
  }
}
 
 
if (!cli.token) {
  throw `${cli.COLORS.RED}No has introducido tu token de telegram.${cli.COLORS.RESET}
 
Si aún no pusiste tu token.
Inicia con: qjs tgbot.js -t 183828181:kqnsiwnskwkziqnsoqnsiqn -s
 
Si ya introduciste tu token.
Inicia con: qjs tgbot.js -l
 
Si aún no tienes un token.
Visita ${cli.COLORS.BLUE}https://t.me/BotFather${cli.COLORS.RESET} y escríbele /newBot
 
 
ESCRIBE ${cli.COLORS.YELLOW}qjs tgbot.js -h${cli.COLORS.RESET} PARA OBTENER LISTA DE COMANDOS.`;
}
 
let bot = () => {
let api = run(`curl https://api.telegram.org/bot${cli.token}/getUpdates --silent`);
 
let apiJson = JSON.parse(api);
 
if (apiJson.ok !== true) {
  throw `Telegram Api Returning An Error:
${api}`;
}
 
if (!apiJson.result) {
  throw `No results to parse:
${api}`;
}
 
let process = (text, username, chatId) => {
  let response = "";
 
 
  if (text.substr(0,1) == "/") {
    let recv = text.substring(1).toLowerCase();
    switch(recv) {
      case "start":
        response = "Comandos Disponibles:\n/Placeholder1 Haz esto\n/Placeholder2 Haz Aquello\n";
      break;
 
      case "hola":
        response = `Hola ${username} soy un bot escrito en javascript por @StringManolo.`;
      break;
 
      case "adios":
      case "chao":
        response = `Un placer ${username}! Qué vaya bien.`;
      break;
 
      default:
        response = `No se que significa ${recv}...`;
    }
 
  }
 
  if (response) {
    cli.v && console.log(`Respuesta: ${response}\n`);
    let aux = `https://api.telegram.org/bot${cli.token}/sendMessage?chat_id=${chatId}&text=${encodeURIComponent(response)}`;
    run(`curl "${aux}" --silent`);
  }
}
 
 
let lastId = 0;
for (let i in apiJson.result) {
  if (apiJson.result[i].message &&
  apiJson.result[i].message.text &&
  apiJson.result[i].update_id &&
  apiJson.result[i].message.from.username &&
  apiJson.result[i].message.chat.id) {
    let text = apiJson.result[i].message.text;
    let updateId = apiJson.result[i].update_id;
    let username = apiJson.result[i].message.from.username;
    let chatId = apiJson.result[i].message.chat.id;
    lastId = updateId;
    process(text, username, chatId);
  }
}
 
let borrarMensajesApi = () => {
  run(`curl https://api.telegram.org/bot${cli.token}/getUpdates?offset=${+lastId + 1} --silent`);
}
 
borrarMensajesApi();
cli.v && console.log("Bot process end");
}
 
let i = 0;
for (;;) {
  cli.v && console.log(`Running bot for the ${++i}° time.`);
  bot();
  cli.v && console.log(`Waiting ${(cli.wait || 20)} seconds to save resources.`);
  os.sleep( (cli.wait || 20) * 1000);
}

El % hace referencia al documento.

100% es el 100% del documento.

En tu caso el documento son el primer div con 1000px de alto, y los otros divs con 100px cada uno.

Sin contar el div que quieres centrar tienes el primer div con 1000px, el segundo div con 100px y el cuarto div con 100px.

Ponte en el caso de que no sabes el tamaño del primer div. Puedes usar calc para hacer cálculos a partir del tamaño del documento:

<div style="background-color: #FFEB3B; width: 100%; height: calc(100% - 100px - 100px - 10px)">   </div>

Esos últimos 10px te los puse para que veas un trozito negro para confirmas que está ocupando justo el espacio que quieres.

En tu caso al poner 1000px, estás limitando la resolución. Si por ejemplo tengo una pantalla de 4000 px, tu div solo me ocupará 1/4 de la pantalla de alto. Como en el width si que usas el 100%, en todas las pantallas se verás algo distinto. Por eso te recomiendo que uses el height también como %.
Por ejemplo le pones al body el 100%, al primer div el 50% al secundo el 5%, etc

Al servidor le da igual desde donde se le mande la petición. Asique tiene que ser problema del código de tu cliente.

Busca algún ejemplo de cliente por la web que te funcione. Yo suelo usar ncat para debuggear este tipo de aplicaciones.

Si no quieres gastarte un duro tira por la descarga de libros gratuitos y videos de youtube. Practica en páginas de hacking como hackthissite.org y root-me.org, aprende programación, haz ctfs, lee blogs y sigue a los más reconocidos por twitter ya que publican contenido interesante así como sus propios blogs de seguridad. En este punto ya puedes encontrar fallos de seguridad en empresas con millones de visitas y obtener remuneración. Lo más importante es la constancia. Aprende de forma moderada para no quemarte. Estimo que lo idoneo son de 2 a 4 horas diarias con 5 minutos de descanso cada 40 mins. Puedes forzar muchísimo más la máquina pero a la larga no compensa. Hay que vivir la vida también, hacer deporte, relajarse, reflexionar...

Tutorial básico de quickjs.

Qué es:
Quickjs es un entorno de ejecución (motor) de javascript que cumple en gran medida con el estandar de javascript.

Sirve para interpretar, ejecutar o compilar codigo javascript.


Cómo se compara a Node.js y a Chrome:
Quickjs es mucho más pequeño que node o v8. Se ejecuta de forma rápida sin esperar al cargar scripts y ocupa poco espacio, lo que lo hace ideal para crear pequeños scripts y utilidades para la consola de comandos de Linux, Windows o Termux.
                                                     
Como se instala:
Puedes descargarlo de su página oficial, de github y compilarlo o utilizando apt-get install quickjs


A parte del javascript estandar que más trae:
Trae 2 librerías preinstaladas que podemos importar. std y os.
La librería std trae varias funciones del lenguaje de C y la librería os trae hilos, funciones para abrir procesos, y varias utilidades.


Al lio:
holaMundo.js

console.log("Hola mundo");

Puedes ejecutarlo con el comando qjs holaMundo.js
También puedes compilarlo con qjsc -o holaMundo holaMundo.js


correrCualquierComando.js

import * as std from "std";
let run = comando => {
  let prog = std.popen(comando, "r");
  let r, msg = "";
  while ((r = prog.getline()) != null) {
    msg += r + "\n";
  }
  return msg;
}
 
console.log( run("ls") );
console.log( run("ls && pwd") );

generadorDeArchivos.js

import * as std from "std";
console.log(`Generador de archivos 2021
 
Genera el esqueleto de archivos para no tener que escribir a mano partes recurrentes de archivos comunes.
 
 
 1. Proyecto HTML
 2. Reporte de Seguridad
 
Selecciona el número correspondiente a la opción que deseas.`);
 
let opcionUsuario = +std.in.getline();
 
if (opcionUsuario === 1) {
  let fd = std.open("index.html", "w");
  fd.puts(`<!DOCTYPE html>
<html lang="en">
  <head prefix="og:http://ogp.me/ns#">
    <meta charset="utf-8">
    <link rel="icon" href="data:;base64,iVBORw0KGgo=">
    <title>Index.html</title>
    <!--
      <meta property="og:type" content="website">
    -->
    <link rel="stylesheet" href="./code.css">
    <meta name="theme-color" content="#ffffff">
  </head>
 
  <body>
 
 
    <script src="./main.js"></script>
  </body>
</html>`);
  fd.close();
 
  fd = std.open("main.js", "w");
  fd.close();
 
  fd = std.open("code.css", "w");
  fd.puts(`body {
  margin: 0 0 0 0; /* Remove ugly left side border */
  text-size-adjust: none; /* Fix Android Big Text */
  text-rendering: optimizeLegibility; /* Improve text */
}
 
  /* Media query */
  @media (min-width: 0px) and (orientation:landscape) {
  body {
    font-size: 1.1vw;
  }
}`);
  fd.close();
} else if (opcionUsuario === 2) {
  console.log("Esta opción se programará en el futuro");
}

scraper.js

import * as std from "std";
 
let run = comando => {
  let prog = std.popen(comando, "r");
  let r, msg = "";
  while ((r = prog.getline()) != null) {
    msg += r + "\n";
  }
  return msg;
}
 
let getTargetAndSelector = () => {
  let returnValues = {};
  for(let i in scriptArgs) {
    if (scriptArgs[i] == "-t" || scriptArgs[i] == "--target") {
      returnValues.target = scriptArgs[+i+1];
    } else if (scriptArgs[i] == "-s" || scriptArgs[i] == "--selector") {
      returnValues.selector = scriptArgs[+i+1];
    }
  }
  if (returnValues.target && returnValues.selector) {
    return [returnValues.target, returnValues.selector];
  } else {
    throw `Usage:
-t  --target  Url to download
-s  --selector Selector to use
 
Example: qjs scraper.js -t https://example.com -s h1`;
  }
}
 
 
let result = run(`curl ${getTargetAndSelector()[0]} -A "Mozilla/5.0" --silent | pup ${getTargetAndSelector()[1]}`);
console.log(result);

Puedes compilarlos y meterlos en bin y darle permisos para usarlos como cualquier otro comando sin necesidad de estar en la misma carpeta que el código.
qjsc -o scraper scraper.js && cp scraper ~/../usr/bin/ && chmod +775 ~/../usr/bin/scraper
scraper -t https://example.com -s a



Documentación Official Quickjs: https://bellard.org/quickjs/quickjs.html


Documentación Herramienta Pup para usar selectores en la linea de comandos: https://github.com/ericchiang/pup

Qué recuerdos del colegio. Ahí va mi forma de hacerlo:

let proporcion = (...nums) => {
  let greater, less = 0, equal = 0;
 
  for(let i in nums) {
    nums[i] < 0 && ++less;
    nums[i] == 0 && ++equal;
  }
 
  greater = ( nums.length - (less + equal) ) / nums.length;
  less /= nums.length;
  equal /= nums.length;
 
  return [greater, less, equal];
}
 
alert(proporcion(-5, 5, 4, 3, 2, 1, 0, -1));

Yo solo tengo una contraseña. La del correo. La del resto de servicios las pongo random y las regenero cada vez que necesito hacer login.

Algunos servicios te dejan directamente acceder mediante link de correo sin necesidad de establecer contraseña. (Firebase te deja esta opción por ejemplo)

Que se supone que quieres saberbo hacer?

El titulo de tu pregunta es como declarar un array vacio y ya lo estás haciendo.

En tu código tienes un bucle de 0 al tamaño del array vacio, que también es 0. Asique tu bucle hace 0 iteraciones, o lo que es lo mismo, no hace nada.

Aunque iterases una vez el bucle, estás haciendo append de un elemento de una array que no tiene elementos. El array no tiene dentro []. No tiene nada dentro. [] Es para delimitar los elementos que pertenecen al array.
var myArray = [1, 3];

Pregunta algo concreto o muestra el problema que quieres resolver.

Si se lo quiere jugar todo, hasta sus órganos, es su vida.

Ha estado trabajando toda la vida para que pueda hacer con su dinero y sus propiedades lo que le de la gana.

Consulta a un abogado para que evalue la situación de tu aval a ver si tienes alguna clausula (que dudo mucho que tengas porque la mayoria firma palante y después llora) para dejar de ser aval.

En caso contrario la única salida legal es intentar negociar con la entidad bancaria, que no está obligada a absolutamente nada.

Se llama reverse shell. Puedes usar funciones como popen y system entre otras.

Simplemente mandas el texto desde el servidor al cliente, en el cliente lo ejecutas con popen y mandas la respuesta del comando al servidor.