Un objeto es uno de los tipos de dato más usados en programación. Un objeto es una colección de datos relacionados, almacenados como pares de clave-valor. Por ejemplo:

let userDetails = {
  name: "John Doe",
  username: "jonnydoe",
  age: 14,
}

Cuando trabajes con objetos, puede ser que necesites verificar si un objeto está vacío antes de ejecutar una función.

En JavaScript, hay distintas maneras de verificar si un objeto está vacío. En este artículo, aprenderás distintas maneras para hacerlo, las opciones que se pueden unir y por qué

Nota: Un objeto es considerado vacío cuando este no tiene par de clave-valor.

En caso de que tengas prisa, aquí tienes un ejemplo básico:

const myEmptyObj = {};

// Works best with new browsers
Object.keys(myEmptyObj).length === 0 && myEmptyObj.constructor === Object

// Works with all browsers
_.isEmpty(myEmptyObj)

Ambos métodos devolverán true. Ahora comprendamos estas y más opciones que se pueden usar para verificar si un objeto está vacío en JavaScript.

Como verificar si un objeto está vacío con Object.keys()

El método Object.keys() es un método de objeto estático introducido en ECMAScript6 (ES6) y es compatible con todos los navegadores modernos. Este método devuelve un arreglo con las claves de un objeto. Por ejemplo:

let userDetails = {
  name: "John Doe",
  username: "jonnydoe",
  age: 14
};

console.log(Object.keys(userDetails)); // ["name","username","age"]

Con esto puedes aplicar la propiedad .length. Si devulve cero (0) el objeto está vacío.

let userDetails = {
  name: "John Doe",
  username: "jonnydoe",
  age: 14
};

let myEmptyObj = {};

console.log(Object.keys(userDetails).length); // 3
console.log(Object.keys(myEmptyObj).length); // 0

Puedes usar este método para verificar si un objeto está vacío con una sentencia if o crear una función que lo compruebe.

const isObjectEmpty = (objectName) => {
  return Object.keys(objectName).length === 0
}

Esto devolverá true o false. Si el objeto está vacío, devolverá true caso contrario devolverá false.

let userDetails = {
  name: "John Doe",
  username: "jonnydoe",
  age: 14
};

let myEmptyObj = {};

const isObjectEmpty = (objectName) => {
  return Object.keys(objectName).length === 0
}

console.log(isObjectEmpty(userDetails)); // false
console.log(isObjectEmpty(myEmptyObj)); // true

Nota: Verificar solamente la longitud no es la mejor opción cuando se verifica si un objeto está vacío o para cualquier tipo de dato. Siempre es mejor confirmar si el tipo de dato es correcto.

Para hacerlo, puedes usar el verificador de constructor:

const isObjectEmpty = (objectName) => {
  return Object.keys(objectName).length === 0 && objectName.constructor === Object;
}

De esta manera, es probable que obtengas un control más completo.

Hasta ahora todo ha funcionado bien. Pero también es posible que desees evitar que se genere un TypeError cuando una variable es undefined o se pasa un valor null en vez de {}. Para arreglarlo, podemos añadir una verificación adicional:

const isObjectEmpty = (objectName) => {
  return (
    objectName &&
    Object.keys(objectName).length === 0 &&
    objectName.constructor === Object
  );
};

En el código anterior se añade una verificación. Esto significa que devolverá null o undefined si no es un objeto vacío, como se muestra en el siguiente ejemplo:

let userDetails = {
  name: "John Doe",
  username: "jonnydoe",
  age: 14
};

let myEmptyObj = {};
let nullObj = null;
let undefinedObj;

const isObjectEmpty = (objectName) => {
  return (
    objectName &&
    Object.keys(objectName).length === 0 &&
    objectName.constructor === Object
  );
};

console.log(isObjectEmpty(userDetails)); // false
console.log(isObjectEmpty(myEmptyObj)); // true
console.log(isObjectEmpty(undefinedObj)); // undefined
console.log(isObjectEmpty(nullObj)); // null

Nota: Esto aplica a otros métodos estáticos de objeto, lo que significa que puedes usar Object.entries() o Object.values() en vez de Object.keys().

Cómo verificar si un objeto está vacío con un bucle for...in

Otro método que puedes usar en ES6 es el bucle for...in. Puedes usar este loop junto al método hasOwnProperty().

const isObjectEmpty = (objectName) => {
  for (let prop in objectName) {
    if (objectName.hasOwnProperty(prop)) {
      return false;
    }
  }
  return true;
};

El método anterior recorrerá cada propiedad del objeto. Si encuentra una sola iteración, el objeto no está vacío. Además, hasOwnProperty() devolverá un valor booleano que indica si el objeto tiene la propiedad especificada como propiedad.

let userDetails = {
  name: "John Doe",
  username: "jonnydoe",
  age: 14
};

let myEmptyObj = {};

const isObjectEmpty = (objectName) => {
  for (let prop in objectName) {
    if (objectName.hasOwnProperty(prop)) {
      return false;
    }
  }
  return true;
};

console.log(isObjectEmpty(userDetails)); // false
console.log(isObjectEmpty(myEmptyObj)); // true

Cómo verificar si un objeto está vacío con JSON.stringify()

También puedes usar el método JSON.stringify(), el cual es usado para convertir un valor JavaScript a una cadena JSON. Esto significa que convertirá los valores de su objeto a una cadena del objeto. Por ejemplo:

let userDetails = {
  name: "John Doe",
  username: "jonnydoe",
  age: 14
};

console.log(JSON.stringify(userDetails)); 

Output:
"{'name':'John Doe','username':'jonnydoe','age':14}"

Esto significa que cuando es un objeto vacío, este devolverá "{}". Puedes haces uso de esto para verificar si hay un objeto vacío.

const isObjectEmpty = (objectName) => {
  return JSON.stringify(objectName) === "{}";
};

Este devolverá true si el objeto está vacío, de otra manera false:

let userDetails = {
  name: "John Doe",
  username: "jonnydoe",
  age: 14
};

let myEmptyObj = {};

const isObjectEmpty = (objectName) => {
  return JSON.stringify(objectName) === "{}";
};

console.log(isObjectEmpty(userDetails)); // false
console.log(isObjectEmpty(myEmptyObj)); // true

Cómo verificar si un objeto está vacío con Lodash

Finalmente, algunos de los métodos explicados pueden funcionar para versiones antiguas de navegador, mientras que en otras puede que no funcionen. Si te preocupa tener una solución que funcione tanto para las versiones antiguas de navegador como para las modernas, puedes usar Lodash.

Lodash es una biblioteca moderna de utilidades de JavaScript que puede realizar muchas funcionalidades de JavaScript con una sintaxis muy básica.

Por ejemplo, si quieres verificar si un objeto está vacío, solo necesitas usar el metodo "isEmpty".

_.isEmpty(objectName);

Instalar Lodash en tu proyecto es bastante fácil. Todo lo que tienes que hacer es usar este comando:

$ npm install lodash

Puedes inicializar el método de guion bajo y usarlo:

const _ = require('lodash');

let userDetails = {
  name: "John Doe",
  username: "jonnydoe",
  age: 14
};

let myEmptyObj = {};

const isObjectEmpty = (objectName) => {
  return _.isEmpty(objectName);
};

console.log(isObjectEmpty(userDetails)); // false
console.log(isObjectEmpty(myEmptyObj)); // true

¡Eso es todo! ?

Disfruté explorando las diversas maneras en que se puede verificar si un objeto está vacío. Siéntete libre de usar el mejor método que se adapte a tu proyecto o tarea.

¡Diviértete programando!

Si usas Github sin configurar una clave SSH, te lo estas perdiendo. Sólo piensa en todo el tiempo que gastas en introducir tu correo electrónico y contraseña en la consola cada vez que haces push de un commit, que podría ser dedicado a programar.

Bueno, no mas. Aquí hay una guía rápida para generar y configurar una clave SSH con GitHub, para que nunca mas tengas que autenticarte de la manera antigua.

Verifica si ya existe una clave SSH

Primero, revisa si ya tienes generadas claves SSH para tu maquina. Abre la terminal e ingresa el siguiente comando.

ls -al ~/.ssh

Si ya generaste claves SSH, deberías ver una respuesta similar a esta:

-rw-------  1 user_name user_name  1766 Jul  7  2018 id_rsa
-rw-r--r--  1 user_name user_name   414 Jul  7  2018 id_rsa.pub
-rw-------  1 user_name user_name 12892 Feb  5 18:39 known_hosts

Si tus claves ya existen, avanza a la sección copiar tu clave SSH pública mas debajo.

Si no ves ninguna respuesta o recibes un mensaje de que el archivo o directorio no existe (No such file or directory), entonces ejecuta en la terminal:

mkdir $HOME/.ssh

Luego genera un nuevo conjunto de claves con:

ssh-keygen -t rsa -b 4096 -C your@email.com

Ahora revisa que tus claves existan con el comando ls -al ~/.ssh y asegurate de que la salida de la terminal es similar a la mostrada mas arriba.

Aviso: Las claves SSH siempre son generadas como un par de claves públicas (id_rsa.pub)  y privadas (id_rsa). Es extremadamente importante que nunca reveles tu clave privada, y solo uses tu clave pública para cosas como la autenticación en GitHub. Puedes leer mas sobre como funcionan los pares de claves SSH / RSA aquí.

Agregua tu clave SSH al ssh-agent

ssh-agent es un programa que se inicia cuando inicias sesión y almacena tus claves privadas. Para que funcione correctamente, necesita estar ejecutandose y tener una copia de tu clave privada.

Primero, asegúrate de que ssh-agent esta ejecutándose con:

eval "$(ssh-agent -s)" # for Mac and Linux

o:

eval `ssh-agent -s`
ssh-agent -s # for Windows

Luego, añade tu clave privada al ssh-agent con:

ssh-add ~/.ssh/id_rsa

Copia tu clave SSH publica

A continuación, debes copiar tu clave SSH pública en el portapapeles

Para Linux o Mac, imprime el contenido de tu clave pública a la consola con:

cat ~/.ssh/id_rsa.pub # Linux

Luego selecciona y copia la respuesta.

O para Windows simplemente ejecuta:

clip < ~/.ssh/id_rsa.pub # Windows

Añade tu clave pública SSH a GitHub

Ve a la página de ajustes de GitHub, click en SSH and GPG keys y en dar al botón "New SSH key":

Luego ingresa un nombre reconocible y pega tu clave pública  (id_rsa.pub) :

Finalmente, comprueba la autenticación en la terminal con:

ssh -T git@github.com

Si seguiste correctamente todos los pasos, deberías ver este mensaje:

Hi your_user_name! You've successfully authenticated, but GitHub does not provide shell access.

A veces necesitarás conocer la dirección IP de tu router. Esto te dará acceso a la página de configuración para hacer modificaciones en el router, como cambiar contraseñas, expulsar usuarios no deseados, limitar usuarios, etc.

En este artículo te mostraré como averiguar cuál es la dirección IP de tu router en una máquina Windows y smartphone Android.

¿Qué es una dirección IP?

Antes de empezar aclaremos que es una dirección IP

La abreviatura IP significa protocolo de internet (internet protocol). El protocolo de internet es un conjunto de reglas que se cumplen para que computadoras, celulares y otros dispositivos compartan datos en internet o redes locales.

Una dirección IP es un identificador numérico especial que permite enviar información entre varios dispositivos en una red.

Como hallar la dirección Wifi en una computadora con Windows.

Para averiguar cuál es la dirección IP de tu router (o de cualquier otro dispositivo que tenga acceso a tu Wifi), puedes usar el símbolo del sistema o el panel de control.

Como encontrar la dirección Wifi en Windows mediante el símbolo del sistema.

Paso 1: Clic en Inicio (logo de Windows) o presionar botón de Windows en el teclado.
Paso 2: Introducir el texto "cmd" y presionar ENTER para lanzar el símbolo del sistema.

Paso 3: Dentro del símbolo del sistema, escribe "ipconfig" y presiona Enter. El número asignado a "puerta de enlace predeterminada" es la dirección IP de tu router.

Cómo halla la dirección Wifi en Windows a través del panel de control

Paso 1: Clic en inicio (logo de Windows), introducir el texto "panel de control", hacer clic en el primer resultado de la búsqueda o presionar Enter para iniciar el panel de control.

Paso 2: En "Redes e Internet", hacer click en "Ver el estado y tareas de red".

Pase 3: Verás el nombre de tu router a la derecha. Haz clic en él y una pequeña ventana aparecerá.

Paso 4: En la ventana emergente haz clic en "Detalles".

Después de hacer clic en el botón "Detalles", aparecerá otra pequeña ventana que muestra diversa información sobre tu router. El valor asignado a IPv4 es la dirección IP de tu router.

Como hallar la dirección Wifi en un smartphone Android.

Algunos dispositivos Android no suelen tener una opción nativa para revisar la dirección del router. Pero puedes usar una aplicación como analizador de Wi-Fi (Wifi analyzer).

Una vez instalada la aplicación, ábrela.

Inmediatamente verás la pestaña de gráfico de canal.

Cambia a la pestaña de puntos de acceso y podrás ver la dirección IP de tu router.

Conclusión

En este artículo, aprendiste como hallar la dirección IP de tu router en una computadora Windows y celular Android.

Puedes usar el router sin conocer cuál es su dirección IP, pero conocerla te dará más control sobre este y te permitirá personalizarlo.

Gracias por leer. Si encuentras este artículo útil, por favor compártelo con tus amigos y familia.