Update article.md

Author: joaquinelio

1-js/09-classes/06-instanceof/article.md

@@ -10,7 +10,7 @@ La sintaxis es:
 ```js
 obj instanceof Class
 ```
-Devuelve `true` si `obj` pertenece a la `Class` o una clase que hereda de ella.
+Devuelve `true` si `obj` pertenece a `Class` o una clase que hereda de ella.
 
 Por ejemplo:
 
@@ -20,7 +20,7 @@ let rabbit = new Rabbit();
 
 // ¿Es un objeto de la clase Rabbit?
 *!*
-alert( rabbit instanceof Rabbit ); // verdadero
+alert( rabbit instanceof Rabbit ); // true
 */!*
 ```
 
@@ -32,15 +32,15 @@ También funciona con funciones de constructor:
 function Rabbit() {}
 */!*
 
-alert( new Rabbit() instanceof Rabbit ); // verdadero
+alert( new Rabbit() instanceof Rabbit ); // true
 ```
 
-...Y con clases integradas como `Array`:
+...Y con clases nativas como `Array`:
 
 ```js run
 let arr = [1, 2, 3];
-alert( arr instanceof Array ); // verdadero
-alert( arr instanceof Object ); // verdadero
+alert( arr instanceof Array ); // true
+alert( arr instanceof Object ); // true
 ```
 
 Tenga en cuenta que `arr` también pertenece a la clase `Object`. Esto se debe a que `Array` hereda prototípicamente de `Object`.
@@ -54,14 +54,10 @@ El algoritmo de `obj instanceof Class` funciona más o menos de la siguiente man
     Por ejemplo:
 
     ```js run
-<<<<<<< HEAD
-    // Instalar instancia de verificación que asume que
-    // cualquier cosa con propiedad canEat es un animal
-
-=======
-    // set up instanceof check that assumes that
-    // anything with canEat property is an animal
->>>>>>> 51bc6d3cdc16b6eb79cb88820a58c4f037f3bf19
+
+    // verificacion con instanceof que determina que 
+    // cualquier cosa que tenga la propiedad canEat es un animal
+
     class Animal {
       static [Symbol.hasInstance](obj) {
         if (obj.canEat) return true;
@@ -70,16 +66,12 @@ El algoritmo de `obj instanceof Class` funciona más o menos de la siguiente man
 
     let obj = { canEat: true };
 
-    alert(obj instanceof Animal); // verdadero: Animal[Symbol.hasInstance](obj) es llamada
+    alert(obj instanceof Animal); // true: Animal[Symbol.hasInstance](obj) es llamada
     ```
 
-<<<<<<< HEAD
-2. La mayoría de las clases no tienen `Symbol.hasInstance`. En ese caso, se utiliza la lógica estándar: `obj instanceOf Class` comprueba si `Class.prototype` es igual a uno de los prototipos en la cadena de prototipos `obj`.
+2. La mayoría de las clases no tienen `Symbol.hasInstance`. En ese caso, se utiliza la lógica estándar: `obj instanceof Class` comprueba si `Class.prototype` es igual a uno de los prototipos en la cadena de prototipos `obj`.
 
     En otras palabras, compara uno tras otro:
-=======
-2. Most classes do not have `Symbol.hasInstance`. In that case, the standard logic is used: `obj instanceof Class` checks whether `Class.prototype` is equal to one of the prototypes in the `obj` prototype chain.
->>>>>>> 51bc6d3cdc16b6eb79cb88820a58c4f037f3bf19
 
     ```js
     obj.__proto__ === Class.prototype?
@@ -100,7 +92,7 @@ El algoritmo de `obj instanceof Class` funciona más o menos de la siguiente man
 
     let rabbit = new Rabbit();
     *!*
-    alert(rabbit instanceof Animal); // verdadero
+    alert(rabbit instanceof Animal); // true
     */!*
 
     // rabbit.__proto__ === Animal.prototype (no match)
@@ -115,7 +107,7 @@ Aquí está la ilustración de lo que `rabbit instanceof Animal` compara con `An
 
 Por cierto, también hay un método [objA.isPrototypeOf(objB)](https://developer.mozilla.org/es/docs/Web/JavaScript/Referencia/Objetos_globales/object/isPrototypeOf), que devuelve `true` si `objA` está en algún lugar de la cadena de prototipos para `objB`. Por lo tanto, la prueba de `obj instanceof Class` se puede reformular como `Class.prototype.isPrototypeOf(obj)`.
 
-Es divertido, ¡pero el constructor `Class` en sí mismo no participa en el chequeo! Solo importa la cadena de prototipos y `Class.prototype`.
+Es extraño, ¡pero el constructor `Class` en sí mismo no participa en el chequeo! Solo importa la cadena de prototipos y `Class.prototype`.
 
 Eso puede llevar a consecuencias interesantes cuando se cambia una propiedad `prototype` después de crear el objeto.
 
@@ -130,7 +122,7 @@ Rabbit.prototype = {};
 
 // ...ya no es un conejo!
 *!*
-alert( rabbit instanceof Rabbit ); // falso
+alert( rabbit instanceof Rabbit ); // false
 */!*
 ```
 
@@ -210,7 +202,7 @@ Como puedes ver, el resultado es exactamente `Symbol.toStringTag` (si existe), e
 
 Al final tenemos "typeof con esteroides" que no solo funciona para tipos de datos primitivos, sino también para objetos incorporados e incluso puede personalizarse.
 
-Podemos usar `{}.toString.call` en lugar de `instanceof` para los objetos incorporados cuando deseamos obtener el tipo como una cadena en lugar de solo verificar.
+Podemos usar `{}.toString.call` en lugar de `instanceof` para los objetos nativos cuando deseamos obtener el tipo como una cadena en lugar de solo verificar.
 
 ## Resumen