fix(guide): simplify directory structure

guide/spanish/certifications/javascript-algorithms-and-data-structures/object-oriented-programming/add-methods-after-inheritance/index.md

@@ -0,0 +1,40 @@
+---
+title: Add Methods After Inheritance
+localeTitle: Añadir métodos después de la herencia
+---
+## Añadir métodos después de la herencia
+
+### Método
+
+Al igual que en el ejemplo siguiente, se debe crear una nueva instancia de un objeto, `Dog` , y se debe configurar el `prototype` .
+
+```javascript
+function Bird() { } 
+ Bird.prototype = Object.create(Animal.prototype); 
+ Bird.prototype.constructor = Bird; 
+```
+
+Luego se debe agregar una nueva función - `bark()` - al prototipo Dog.
+
+### Solución
+
+```javascript
+function Animal() { } 
+ Animal.prototype.eat = function() { console.log("nom nom nom"); }; 
+ 
+ function Dog() { } 
+ 
+ // Add your code below this line 
+ Dog.prototype = Object.create(Animal.prototype); 
+ Dog.prototype.constructor = Dog; 
+ Dog.prototype.bark = function() { 
+    console.log("Woof woof!"); 
+ }; 
+ // Add your code above this line 
+ 
+ let beagle = new Dog(); 
+ 
+ beagle.eat(); // Should print "nom nom nom" 
+ beagle.bark(); // Should print "Woof!" 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/object-oriented-programming/change-the-prototype-to-a-new-object/index.md

@@ -0,0 +1,79 @@
+---
+title: Change the Prototype to a New Object
+localeTitle: Cambia el prototipo a un nuevo objeto
+---
+## Cambia el prototipo a un nuevo objeto
+
+En lugar de agregar cada propiedad prototipo una a una con `object.prototype.property` . Podemos hacer esto mucho más fácil configurando el prototipo a un nuevo objeto. De esa manera, todas las propiedades del prototipo se agregan a la vez.
+
+  
+
+## Insinuación:
+
+```javascript
+Dog.prototype = { 
+  property: value, 
+  functionName: function(){ 
+ 
+  }, 
+ } 
+```
+
+¡Ahora trata de resolver el desafío!
+
+  
+
+## ¡Solución Spoiler-Alert por delante!
+
+  
+
+## Solución 1:
+
+```javascript
+function Dog(name) { 
+  this.name = name; 
+ } 
+ Dog.prototype = { 
+  // Add your code below this line 
+  numLegs: 2, 
+  eat: function(){ 
+    console.log('nom nom nom'); 
+  }, 
+  describe: function(){ 
+    console.log("My name is " + this.name); 
+  } 
+ } 
+```
+
+## Explicación del código:
+
+Asignamos la variable prototipo a un nuevo objeto. Luego declaramos la propiedad numLegs y le damos un valor de 2.
+
+A continuación creamos las dos funciones "comer" y "describir". Ahora recuerde que las funciones en los objetos son métodos con la misma sintaxis que las propiedades. Tienes el nombre seguido de un valor. Ese valor es la función y el nombre es el nombre de su función.  
+
+## Solución 2:
+
+```javascript
+function Dog(name) { 
+  this.name = name; 
+ } 
+ 
+ Dog.prototype = { 
+  // Add your code below this line 
+  numLegs: 2, 
+  eat(){ 
+    console.log('nom nom nom'); 
+  }, 
+  describe(){ 
+    console.log("My name is " + this.name); 
+  } 
+ }; 
+```
+
+## Explicación del código:
+
+La única diferencia entre esta solución y la última es que acortamos la sintaxis de las funciones "comer" y "describir". Lo hicimos eliminando la función ":" y la palabra "función".
+
+Con ES6 podemos hacer esto.
+
+Puedes leer sobre esto aquí: [Referencia](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Method_definitions)

guide/spanish/certifications/javascript-algorithms-and-data-structures/object-oriented-programming/create-a-basic-javascript-object/index.md

@@ -0,0 +1,19 @@
+---
+title: Create a Basic JavaScript Object
+localeTitle: Crear un objeto JavaScript básico
+---
+## Crear un objeto JavaScript básico
+
+### Método:
+
+La idea de este problema es más o menos idéntica al ejemplo dado. Déle al objeto `dog` dos nuevas propiedades ( `name` y `numLegs` y `numLegs` en una cadena y un número, respectivamente.
+
+### Solución:
+
+```javascript
+let dog = { 
+  name: "George", 
+  numLegs: 4 
+ }; 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/object-oriented-programming/create-a-method-on-an-object/index.md

@@ -0,0 +1,34 @@
+---
+title: Create a Method on an Object
+localeTitle: Crear un método en un objeto
+---
+## Crear un método en un objeto
+
+### Método:
+
+Una función de objetos debe inicializarse dentro del propio objeto. Esto se demuestra en el siguiente código.
+
+```javascript
+let obj = { 
+  property1 = 1, 
+ 
+  function1: function() { 
+    //Code to be exectued 
+  } 
+ }; 
+```
+
+### Solución:
+
+```javascript
+let dog = { 
+  name: "Spot", 
+  numLegs: 4, 
+  sayLegs: function() { 
+    return "This dog has " + dog.numLegs + " legs."; 
+  } 
+ }; 
+ 
+ dog.sayLegs(); 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/object-oriented-programming/define-a-constructor-function/index.md

@@ -0,0 +1,20 @@
+---
+title: Define a Constructor Function
+localeTitle: Definir una función de constructor
+---
+## Definir una función de constructor
+
+### Método:
+
+La función `Dog()` debe escribirse exactamente en el mismo formato que la función `Bird()` dada en el ejemplo. Simplemente reemplace `Bird` con `Dog` para pasar todos los casos de prueba.
+
+### Solución:
+
+```javascript
+function Dog() { 
+  this.name = "Geogre", 
+  this.color = "White", 
+  this.numLegs = 4; 
+ } 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/object-oriented-programming/extend-constructors-to-receive-arguments/index.md

@@ -0,0 +1,21 @@
+---
+title: Extend Constructors to Receive Arguments
+localeTitle: Extender constructores para recibir argumentos
+---
+## Extender constructores para recibir argumentos
+
+### Método:
+
+Al igual que en el ejemplo de `Bird()` , la función `Dog()` debe tomar dos parámetros: `name` y `color` . El nombre y el color deben inicializarse dentro de la función usando la palabra clave `this` . La propiedad final - `numLegs` se establece en 4 ya que la función no toma un parámetro numLegs.
+
+### Solución:
+
+```javascript
+function Dog(name, color) { 
+  this.name = name; 
+  this.color = color; 
+  this.numLegs = 4; 
+ } 
+ let terrier = new Dog("George","White"); 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/object-oriented-programming/index.md

@@ -0,0 +1,11 @@
+---
+title: Object Oriented Programming
+localeTitle: Programación orientada a objetos
+---
+## Programación orientada a objetos
+
+Esto es un talón. [Ayuda a nuestra comunidad a expandirla](https://github.com/freecodecamp/guides/tree/master/src/pages/mathematics/quadratic-equations/index.md) .
+
+[Esta guía rápida de estilo ayudará a asegurar que su solicitud de extracción sea aceptada](https://github.com/freecodecamp/guides/blob/master/README.md) .
+
+#### Más información:

guide/spanish/certifications/javascript-algorithms-and-data-structures/object-oriented-programming/inherit-behaviors-from-a-supertype/index.md

@@ -0,0 +1,30 @@
+---
+title: Inherit Behaviors from a Supertype
+localeTitle: Heredar los comportamientos de un supertipo
+---
+## Heredar los comportamientos de un supertipo
+
+### Método
+
+Para superar este desafío, simplemente cree los nuevos objetos `duck` y `beagle` usando el método `Object.create()` que se ve en el siguiente ejemplo.
+
+\`\` \`javascript
+
+dejar animal = Object.create (Animal.prototype);
+```
+### Solution 
+```
+
+javascript
+
+función animal () {}
+
+Animal.prototype = { constructor: animal, comer: función () { console.log ("nom nom nom"); } };
+
+// Añade tu código debajo de esta línea
+
+let duck = Object.create (Animal.prototype); // cambiar esta linea let beagle = Object.create (Animal.prototype) ;; // cambiar esta linea
+
+duck.eat (); // Debería imprimir "nom nom nom" beagle.eat (); // Debería imprimir "nom nom nom"
+
+\`\` \`

guide/spanish/certifications/javascript-algorithms-and-data-structures/object-oriented-programming/iterate-over-all-properties/index.md

@@ -0,0 +1,35 @@
+---
+title: Iterate Over All Properties
+localeTitle: Iterar sobre todas las propiedades
+---
+## Iterar sobre todas las propiedades
+
+### Método
+
+El método consiste en utilizar un `for-in-loop` para recorrer cada propiedad en el objeto. Dentro del bucle, verifica si la propiedad es de propiedad `own-property` o de `prototype` y la coloca en la matriz `ownProps[]` o en la matriz `prototypeProps[]` . Recuerde `push` propiedades al objeto `beagle` y no al objeto `Dog` para pasar todos los casos de prueba.
+
+### Solución
+
+```javascript
+function Dog(name) { 
+  this.name = name; 
+ } 
+ 
+ Dog.prototype.numLegs = 4; 
+ 
+ let beagle = new Dog("Snoopy"); 
+ 
+ let ownProps = []; 
+ let prototypeProps = []; 
+ 
+ // Add your code below this line 
+ for (let property in beagle) { 
+  if(Dog.hasOwnProperty(property)) { 
+    ownProps.push(property) 
+  } 
+  else { 
+    prototypeProps.push(property) 
+  } 
+ } 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/object-oriented-programming/make-code-more-reusable-with-the-this-keyword/index.md

@@ -0,0 +1,22 @@
+---
+title: Make Code More Reusable with the this Keyword
+localeTitle: Hacer el código más reutilizable con la palabra clave
+---
+## Hacer el código más reutilizable con la palabra clave
+
+### Método:
+
+Este desafío es simplemente demostrar el poder de `this` palabra clave. Reemplazar `dog.numLegs` con `this.numLegs` fortalece nuestro código haciendo referencia directamente a este objeto. [developer.mozilla.org](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/this) tiene muchos ejemplos para determinar los efectos de `this` palabra clave.
+
+### Solución:
+
+```javascript
+let dog = { 
+  name: "Spot", 
+  numLegs: 4, 
+  sayLegs: function() {return "This dog has " + this.numLegs + " legs.";} 
+ }; 
+ 
+ dog.sayLegs(); 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/object-oriented-programming/override-inherited-methods/index.md

@@ -0,0 +1,14 @@
+---
+title: Override Inherited Methods
+localeTitle: Anular métodos heredados
+---
+## Anular métodos heredados
+
+# Solución
+
+```javascript
+Penguin.prototype.fly = function() { 
+    return  "Alas, this is a flightless bird."; 
+ }; 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/object-oriented-programming/remember-to-set-the-constructor-property-when-changing-the-prototype/index.md

@@ -0,0 +1,25 @@
+---
+title: Remember to Set the Constructor Property when Changing the Prototype
+localeTitle: Recuerde establecer la propiedad del constructor al cambiar el prototipo
+---
+## Recuerde establecer la propiedad del constructor al cambiar el prototipo
+
+*   Recuerde definir la propiedad del constructor cuando configure un prototipo en un nuevo objeto.
+
+# Solución
+
+```javascript
+Dog.prototype = { 
+ 
+  constructor: Dog, // Solution 
+ 
+  numLegs: 2, 
+  eat: function() { 
+    console.log("nom nom nom"); 
+  }, 
+  describe: function() { 
+    console.log("My name is " + this.name); 
+  } 
+ }; 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/object-oriented-programming/reset-an-inherited-constructor-property/index.md

@@ -0,0 +1,32 @@
+---
+title: Reset an Inherited Constructor Property
+localeTitle: Restablecer una propiedad de constructor heredada
+---
+## Restablecer una propiedad de constructor heredada
+
+### Método
+
+Los objetos `duck` y `beagle` han sido programados para heredar las propiedades del constructor de `supertypes` . Para sobrescribir estas dos líneas de código, tendrá que escribirse para establecer los constructores en los constructores deseados `Bird` y `Dog` . El siguiente código demuestra cómo se puede lograr esto.
+
+```javascript
+Bird.prototype.constructor = Bird; 
+```
+
+### Solución
+
+```javascript
+function Animal() { } 
+ function Bird() { } 
+ function Dog() { } 
+ 
+ Bird.prototype = Object.create(Animal.prototype); 
+ Dog.prototype = Object.create(Animal.prototype); 
+ 
+ // Add your code below this line 
+ Bird.prototype.constructor = Bird; 
+ Dog.prototype.constructor = Dog; 
+ 
+ let duck = new Bird(); 
+ let beagle = new Dog(); 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/object-oriented-programming/set-the-childs-prototype-to-an-instance-of-the-parent/index.md

@@ -0,0 +1,35 @@
+---
+title: Set the Child's Prototype to an Instance of the Parent
+localeTitle: Establecer el prototipo del niño en una instancia del padre
+---
+## Establecer el prototipo del niño en una instancia del padre
+
+### Método
+
+Este desafío no es diferente del último desafío, en el hecho de que debe crear un objeto que herede del `supertype` . Solo que esta vez el subtipo `Dog` heredará el supertipo `Animal` . Simplemente cree una nueva instancia de `Dog.prototype` como el siguiente ejemplo.
+
+```javascript
+Bird.prototype = Object.create(Animal.prototype); 
+```
+
+### Solución
+
+```javascript
+function Animal() { } 
+ 
+ Animal.prototype = { 
+  constructor: Animal, 
+  eat: function() { 
+    console.log("nom nom nom"); 
+  } 
+ }; 
+ 
+ function Dog() { } 
+ 
+ // Add your code below this line 
+ Dog.prototype = Object.create(Animal.prototype); 
+ 
+ let beagle = new Dog(); 
+ beagle.eat();  // Should print "nom nom nom" 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/object-oriented-programming/understand-own-properties/index.md

@@ -0,0 +1,25 @@
+---
+title: Understand Own Properties
+localeTitle: Entender propiedades propias
+---
+## Entender propiedades propias
+
+### Método:
+
+En el código de ejemplo dado, verá una nueva matriz `ownProps[]` intializada seguida de una declaración `for...in` para recorrer las propiedades de `duck` y luego usar una declaración `push()` para completar la nueva matriz. Se debe seguir el mismo método para el objeto `canary` .
+
+Simplemente reemplace el objeto `duck` en la declaración 'para ... en' con el objeto `canary` para pasar todos los casos de prueba.
+
+### Solución:
+
+```javascript
+let canary = new Bird("Tweety"); 
+ let ownProps = []; 
+ // Add your code below this line 
+ for(let property in canary) { 
+  if(canary.hasOwnProperty(property)) { 
+    ownProps.push(property); 
+  } 
+ } 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/object-oriented-programming/understand-the-constructor-property/index.md

@@ -0,0 +1,28 @@
+---
+title: Understand the Constructor Property
+localeTitle: Entender la propiedad del constructor
+---
+## Entender la propiedad del constructor
+
+### Método
+
+Simplemente termina la función como la del ejemplo dado. Use una `if-statement` para probar si el `candidate` es un `Dog` o no.
+
+### Solución
+
+```javascript
+function Dog(name) { 
+  this.name = name; 
+ } 
+ 
+ // Add your code below this line 
+ function joinDogFraternity(candidate) { 
+  if(candidate.constructor === Dog) { 
+    return true; 
+  } 
+  else { 
+    return false; 
+  } 
+ } 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/object-oriented-programming/understand-the-immediately-invoked-function-expression-iife/index.md

@@ -0,0 +1,18 @@
+---
+title: Understand the Immediately Invoked Function Expression (IIFE)
+localeTitle: Comprender la expresión de función invocada inmediatamente (IIFE)
+---
+## Comprender la expresión de función invocada inmediatamente (IIFE)
+
+### Método
+
+El primer caso de prueba le pide que haga la función anónima. Para hacer esto, simplemente elimine el nombre de la función como se ve en el ejemplo. La función debe estar envuelta entre paréntesis con otro juego de corchetes al final para llamar inmediatamente a la función.
+
+### Solución
+
+```javascript
+(function() { 
+  console.log("A cozy nest is ready"); 
+ })(); 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/object-oriented-programming/understand-the-prototype-chain/index.md

@@ -0,0 +1,17 @@
+---
+title: Understand the Prototype Chain
+localeTitle: Entender la cadena de prototipos
+---
+## Entender la cadena de prototipos
+
+### Solución
+
+Su código debe mostrar que Object.prototype es el prototipo de Dog.prototype
+
+\`\` \`javascript función perro (nombre) { this.name = nombre; }
+
+let beagle = new Dog ("Snoopy");
+
+Dog.prototype.isPrototypeOf (beagle); // => verdadero
+
+// Arregla el siguiente código para que se evalúe como verdadero Object.prototype.isPrototypeOf (Dog.prototype); \`\` \`

guide/spanish/certifications/javascript-algorithms-and-data-structures/object-oriented-programming/understand-where-an-objects-prototype-comes-from/index.md

@@ -0,0 +1,9 @@
+---
+title: Understand Where an Object’s Prototype Comes From
+localeTitle: Entender de dónde viene el prototipo de un objeto
+---
+## Entender de dónde viene el prototipo de un objeto
+
+Esto es un talón. [Ayuda a nuestra comunidad a expandirla](https://github.com/freecodecamp/guides/tree/master/src/pages/certifications/javascript-algorithms-and-data-structures/object-oriented-programming/understand-where-an-objects-prototype-comes-from/index.md) .
+
+[Esta guía rápida de estilo ayudará a asegurar que su solicitud de extracción sea aceptada](https://github.com/freecodecamp/guides/blob/master/README.md) .

guide/spanish/certifications/javascript-algorithms-and-data-structures/object-oriented-programming/use-a-constructor-to-create-objects/index.md

@@ -0,0 +1,22 @@
+---
+title: Use a Constructor to Create Objects
+localeTitle: Usa un constructor para crear objetos
+---
+## Usa un constructor para crear objetos
+
+### Método:
+
+Vimos en el último desafío cómo crear una función constructora. Ahora podemos simplemente llamar a esta función para crear un nuevo objeto con las propiedades ya definidas en el constructor. Simplemente inicialice una nueva variable `hound` llamando al constructor `Dog()` .
+
+### Solución:
+
+```javascript
+function Dog() { 
+  this.name = "Rupert"; 
+  this.color = "brown"; 
+  this.numLegs = 4; 
+ } 
+ // Add your code below this line 
+ let hound = new Dog(); 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/object-oriented-programming/use-a-mixin-to-add-common-behavior-between-unrelated-objects/index.md

@@ -0,0 +1,33 @@
+---
+title: Use a Mixin to Add Common Behavior Between Unrelated Objects
+localeTitle: Use un Mixin para agregar un comportamiento común entre objetos no relacionados
+---
+## Use un Mixin para agregar un comportamiento común entre objetos no relacionados
+
+### Método
+
+Al igual que la función `flyMixin` , se debe crear una nueva función `glideMixin` para aceptar objetos de `bird` y `boat` como parámetro. Cree esta nueva función utilizando la misma sintaxis que la función `flyMixin` y luego llame a la función en ambos objetos.
+
+### Solución
+
+```javascript
+let bird = { 
+  name: "Donald", 
+  numLegs: 2 
+ }; 
+ 
+ let boat = { 
+  name: "Warrior", 
+  type: "race-boat" 
+ }; 
+ 
+ // Add your code below this line 
+ let glideMixin = function(obj) { 
+    obj.glide = function() { 
+        console.log("Gliding!"); 
+    } 
+ }; 
+ glideMixin(bird); 
+ glideMixin(boat); 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/object-oriented-programming/use-an-iife-to-create-a-module/index.md

@@ -0,0 +1,45 @@
+---
+title: Use an IIFE to Create a Module
+localeTitle: Utilice un IIFE para crear un módulo
+---
+## Utilice un IIFE para crear un módulo
+
+### Método
+
+Ambos `Mixin` deben estar envueltos en un nuevo `funModule` por lo que un buen punto de partida es comentar todo el código hasta el momento.
+
+```javascript
+/*let isCuteMixin = function(obj) { 
+  obj.isCute = function() { 
+    return true; 
+  }; 
+ }; 
+ let singMixin = function(obj) { 
+  obj.sing = function() { 
+    console.log("Singing to an awesome tune"); 
+  }; 
+ }; 
+ */ 
+```
+
+Luego, a continuación, comience a escribir su nuevo código `funModule` . Dentro del nuevo módulo, debe escribir una declaración de retorno para devolver ambos bloques de código `Mixin` . Simplemente copia ambos originales `Mixin` bloques de código en el nuevo código de módulo, pero recuerde que debe separar las dos mixins con una `,`
+
+### Solución
+
+```javascript
+let funModule = (function() { 
+  return { 
+    isCuteMixin: function(obj) { 
+      obj.isCute = function() { 
+        return true; 
+      }; 
+    }, 
+    singMixin: function(obj) { 
+      obj.sing = function() { 
+         console.log("Singing to an awesome tune"); 
+      }; 
+    } 
+  } 
+ })(); 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/object-oriented-programming/use-closure-to-protect-properties-within-an-object-from-being-modified-externally/index.md

@@ -0,0 +1,23 @@
+---
+title: Use Closure to Protect Properties Within an Object from Being Modified Externally
+localeTitle: Utilice el cierre para proteger las propiedades dentro de un objeto de ser modificado externamente
+---
+## Utilice el cierre para proteger las propiedades dentro de un objeto de ser modificado externamente
+
+### Método
+
+Al igual que en el ejemplo dado, en lugar de declarar la variable de `weight` con la palabra clave `this` , la palabra clave `let` debe utilizarse para declararla como una variable privada. De esta manera solo se puede acceder dentro de la función `Bird` . El método `getWeight` se debe agregar dentro de la función `Bird` para acceder a la variable de `weight` .
+
+### Solución
+
+```javascript
+function Bird() { 
+  let weight = 15; 
+ 
+  this.getWeight = function() { 
+    return weight; 
+  }; 
+ 
+ } 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/object-oriented-programming/use-dot-notation-to-access-the-properties-of-an-object/index.md

@@ -0,0 +1,33 @@
+---
+title: Use Dot Notation to Access the Properties of an Object
+localeTitle: Usar la notación de puntos para acceder a las propiedades de un objeto
+---
+## Usar la notación de puntos para acceder a las propiedades de un objeto
+
+### Método:
+
+El siguiente código simplemente imprimirá `property1` del objeto `obj` .
+
+```javascript
+let obj = { 
+  property1 = 1, 
+  property2 = 2 
+ }; 
+ 
+ console.log(obj.property1); 
+```
+
+Siguiendo esta lógica, use la operación `console.log` para imprimir tanto la `property1` como la `property2` en la pantalla.
+
+### Solución:
+
+```javascript
+let dog = { 
+  name: "Spot", 
+  numLegs: 4 
+ }; 
+ // Add your code below this line 
+ console.log(dog.name); 
+ console.log(dog.numLegs); 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/object-oriented-programming/use-inheritance-so-you-dont-repeat-yourself/index.md

@@ -0,0 +1,37 @@
+---
+title: Use Inheritance So You Don't Repeat Yourself
+localeTitle: Usa la herencia para que no te repitas
+---
+## Usa la herencia para que no te repitas
+
+### Solución
+
+Elimine el método "comer" de Cat.prototype y Bear.prototype y agréguelo al Animal.prototype.
+
+```javascript
+function Cat(name) { 
+  this.name = name; 
+ }; 
+ 
+ Cat.prototype = { 
+  constructor: Cat 
+ }; 
+ 
+ function Bear(name) { 
+  this.name = name; 
+ }; 
+ 
+ Bear.prototype = { 
+  constructor: Bear 
+ }; 
+ 
+ function Animal() { }; 
+ 
+ Animal.prototype = { 
+  constructor: Animal, 
+  eat: function() { 
+    console.log("nom nom nom"); 
+  } 
+ }; 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/object-oriented-programming/use-prototype-properties-to-reduce-duplicate-code/index.md

@@ -0,0 +1,31 @@
+---
+title: Use Prototype Properties to Reduce Duplicate Code
+localeTitle: Use las propiedades de prototipo para reducir el código duplicado
+---
+## Use las propiedades de prototipo para reducir el código duplicado
+
+### Método:
+
+La propiedad `prototype` nos permite agregar nuevas propiedades a un constructor de objetos desde fuera del bloque de código original. La propiedad prototipo también le permite agregar nuevas funciones al constructor de objetos. El siguiente código muestra cómo usar `.prototype` en un objeto para crear una nueva propiedad en el constructor.
+
+#### Ejemplo:
+
+```javascript
+Obj.prototype.newProperty = "New Property!"; 
+```
+
+Usando esta lógica, simplemente cree una nueva propiedad `prototype` para `numLegs` . Los casos de prueba se pueden pasar al reemplazar el objeto `Bird` con el objeto `Dog` en el ejemplo dado: `Bird.prototype.numLegs = 2;`
+
+### Solución:
+
+```javascript
+function Dog(name) { 
+  this.name = name; 
+ } 
+ 
+ Dog.prototype.numLegs = 4; 
+ 
+ // Add your code above this line 
+ let beagle = new Dog("Snoopy"); 
+
+```

guide/spanish/certifications/javascript-algorithms-and-data-structures/object-oriented-programming/verify-an-objects-constructor-with-instanceof/index.md

@@ -0,0 +1,32 @@
+---
+title: Verify an Object's Constructor with instanceof
+localeTitle: Verifique el constructor de un objeto con instanceof
+---
+## Verifique el constructor de un objeto con instanceof
+
+### Método:
+
+Al igual que en el último desafío, crea un nuevo objeto, `myHouse` , usando el constructor dado.
+
+#### Ejemplo:
+
+```javascript
+let hound = new Dog(); 
+```
+
+Recuerde darle a la función `House` un parámetro para inicializar el número de habitaciones. Luego simplemente llame al operador de `instanceof` para devolver verdadero en su nueva casa.
+
+### Solución:
+
+```javascript
+/* jshint expr: true */ 
+ 
+ function House(numBedrooms) { 
+  this.numBedrooms = numBedrooms; 
+ } 
+ 
+ // Add your code below this line 
+ let myHouse = new House(5); 
+ myHouse instanceof House; 
+
+```