Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

Creando métodos estáticos en JavaScript

18/19
Recursos

Aportes 17

Preguntas 4

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

Mi solución para que no tome los arrays como objetos :

SuperObject.isObject = function (subject) {
	if(Array.isArray(subject)){
		return false
	}
  return typeof subject == "object";
}

Llevo 3 clases perdida literal, la borradera de codigo hace que todo sea confuso. Soy participe de trabajar en archivos diferentes por clase

Saludos. 👋
Esta es mi solución al reto. Ademas de la comprobación del Array, agregué una comprobación para null, ya que existe un bug en ECMAScript que indica que null es un tipo objeto.

typeof null // object

Y para evitar errores a futuro hice esto.

SuperObject.isObject = function (subject) {
  if (subject === null || Array.isArray(subject)) return false;
  return typeof subject === "object";
}

La forma mas corta que encontré es la siguiente:

  function isObject(source) {
  return source.constructor.name == 'Object'
}

Lo que dice el profesor: Los arrays son instancias del prototipo Array, que es a su vez una instancia del super prototipo Object; lo vemos en la consola:

Nos damos cuenta de que podemos comprobar los array de la misma manera que los objetos:

  function isArray(source) {
  return source.constructor.name == 'Array'
}

// Resultados
isObject({}) //true
isArray({}) //false
isObject([]) //false
isArray([]) //true

Sinceramente aun no llego a entender como funciona typeof, para mí, por ahora más se trata de memorizar que retorna en cada situación que lo usemos.

Un poco de documentación:

me perdí, no entendí el punto de la clase, se que esta en el titulo pero lo que vi es que en vez de usar “deepcopy()” o, "isObject"
lo escribe mas largo con “superObject.deepcopy()” cual es la utilidad de eso?

les dejo , el link de este canal , en donde dejo muchos ejercicios , que están buenos para hacer https://www.youtube.com/watch?v=LqXh7jOfLlM&list=PLvq-jIkSeTUZ6QgYYO3MwG9EMqC-KoLXA&index=44

SuperObject.isObject = (subject) => typeof subject == "object" && !Array.isArray(subject);

Mi solución para el problema es el siguiente:

SuperObject.isObject = function (subject) {
  if (!isArray(subject)) {
    return typeof subject == "object";
  } else {
    return false;
  }
}

Mi solución para el reto:

SuperObject.isObject = function (subject) {
  if (!isArray(subject) && subject !== null) {
    return typeof subject == "object";
  } else {
    return false;
  }
}

Agregue una validación de subject !== null, ya que el typeof null es object, si le pasaramos null nos devolveria true. De esta forma lo evitamos.

Limpio y al hueso

let isObject = (subject) => subject.__proto__.constructor.name === 'Object'

Reto:

static isObject(subject) {
    if (Array.isArray(subject)) {
      return false;
    }
    return typeof subject === "object";
  }

todavia no entiendo la convencion que usa el profe es camellcase pero iniciando con mayuscula?

el copy y paste para mover código de un lado a otro, es demasiado confuso!!!

SuperObject.isObject = function (subject) {

    if (Array.isArray(subject)) {
        return console.log(`El elemento es un array`);
    }
    if (subject === null || subject === undefined) {
        return false;
    }
    return typeof subject == "object";
}

Esta es mi solución al problema que toma los Arrays como objetos

SuperObject.isObject = function (subject){
    return Object.prototype.toString.call(subject) == "[object Object]";
}  

Esta es mi solución del reto !!

SuperObjet.esUnObjeto = function (subjet) {
    if (Array.isArray(subjet)){
        return Array.isArray(subjet)
    }else {
        return typeof subjet === "object";
    }
}

Acepto cualquier tipo de feedback 😃

Hola me gusto mucho el curso, pero si me costo trabajo seguir el ritmo, Me pregunto si podrían hacer esto mismo pero con ejemplos más pequeños para no perdernos de pronto con tanto código. Mi solución basando me a lo que se vio desde en clases pasadas podemos hacer lo siguiente:

<SuperObject.isObject = function (subject){
    if (subject.constructor.name == "Array"){  // con esta modificacion podemos saber si subject es un array[] o un object{}
        return typeof subject == "Array";
    }else {
        return typeof subject == "object";
    }
}>