tarjetaCredito-Jessica Meza

.eslintrc

@@ -0,0 +1,29 @@
+{
+  "parserOptions": {
+    "ecmaVersion": 6
+  },
+  "rules": {
+    "keyword-spacing": 1,
+    "space-before-function-paren": [1, "never"],
+    "eqeqeq": 1,
+    "space-infix-ops": 1,
+    "comma-spacing": 1,
+    "brace-style": 1,
+    "no-multiple-empty-lines": 1,
+    "camelcase": 1,
+    "func-call-spacing": 1,
+    "key-spacing": 1,
+    "semi": 1,
+    "no-floating-decimal": 1,
+    "no-multi-spaces": 1,
+    "object-property-newline": 1,
+    "padded-blocks": [1, "never"],
+    "space-before-blocks": 1,
+    "space-in-parens": 1,
+    "spaced-comment": 1,
+    "quotes": [1, "single"],
+    "id-length": [1, { "exceptions": ["i", "j", "x"] }],
+    "indent": [1, 2],
+    "no-array-constructor": 1
+  }
+}

README.md

@@ -1,38 +1,132 @@
-# Tarjeta de crédito válida
+# VALID CREDIT CARD
+#### Contenido:
+1. Diagrama de flujo validCard.
+2. Pseudocódigo validCard.
+3. Explicación del código.
 
-Crea una web que pida, por medio de un `prompt()`, el número de una tarjeta de
-crédito y confirme su validez según el [algoritmo de Luhn](https://es.wikipedia.org/wiki/Algoritmo_de_Luhn). 
-Lee este blog que explica [cómo funciona el algoritmo de Luhn](http://www.quobit.mx/asi-funciona-el-algoritmo-de-luhn-para-generar-numeros-de-tarjetas-de-credito.html).
+
+--------------------------
+
+### 1. DIAGRAMA DE FLUJO
+
+![validcard](assets/docs/diagramaFlujoValidCard.jpeg)
+[diagramaflujo](https://ibb.co/crgeFb)
+
+### 2. PSEUDOCÓDIGO
+
+    inicioProceso
+      escribir cardNumber
+
+      función isValidCard <--- (cardNumber)
+
+        Crear variables
+        var arrayNumbers, arrayInverse, sum
+
+        Almaceno en la variable cada ejecución
+        arrayNumbers <-- cardNumber.split('')
+        arrayInverse <-- arrayNumbers.reverse()
+        sum <-- 0
+
+        Bucle : Para i == 0  Hasta i < longitudArrayNumbers Con Paso i++ Hacer
+        arrayInverse[i] <-- parseInt(arrayInverse[i])
+
+          Si (i % 2 == 1) Entonces
+            arrayInverse[i] <--suma de digitos(multiplicar*2 (indices impares))
+
+          Fin Si
+         sum <-- suma de digitos d ela tarjeta
+
+        Fin Bucle
+
+        retornar sum % 10 == 0 ? true : false
+        Fin función
+
+    Fin Proceso
+
+--------------------------------------------
+
+### 3. EXPLICACIÓN DEL CÓDIGO
+
+Se nos pide hacer la validación de un número de tarjeta de crédito utilizando el algoritmo de Luhn.
+
+**Ingreso de datos**
+
+Aquí solicitamos el número de tarjeta, mediante un `prompt`, y lo guardamos en la variable cardNumber.
+
+`var cardNumber = prompt ("Ingrese su número de tarjeta: ");`
+
+Ejemplo: cardNumber = '4975226157921705'
+
+>NOTA: Al ingresar un dato mediante prompt, este siempre es de tipo string, así que el número de tarjeta ingresado, será de tipo string.
+
+**Creación de la función isValidCard**
+
+`function isValidCard(cardNumber){}`
+
+**Proceso para validar el número**
 
-## Entregables
+* Convertimos el string en un array con separacion de (''), con el método split: 
+
+  `var arrayNumbers = cardNumber.split('');`
+
+  Obteniendo: ['4', '9', '7', '5', '2', '2', '6', '1', '5', '7', '9', '2', '1', '7', '0', '5' ]
+
+* Para seguir con el algoritmo de Luhn, invertimos el array, con `reverse()`:
+
+  `var arrayInverse = arrayNumbers.reverse();`
+
+  Obteniendo: ['5', '0', '7', '1', '2', '9', '7', '5', '1', '6', '2', '2', '5', '7', '9', '4' ]
+
+* Creamos el acumulador suma para almacenar más adelante, la suma de dígitos.
+
+  `var sum = 0;`
+
+* Ahora, vamos a convertir los elementos del array tipo string a tipo number.
+
+
+       for(var i = 0; i < arrayInverse.length; i++{
+        arrayInverse[i] = parseInt(arrayInverse[i]);
+       }
+
+  Se obtendrá: [5, 0, 7, 1, 2, 9, 7, 5, 1, 6, 2, 2, 5, 7, 9, 4 ]
+
+* Debemos multiplicar x2 a las posiciones impares de nuestro array, teniendo encuenta que inicializamos con i = 0, para ello hacemos un if.
+
+* Despues debemos sumar los dígitos de los resultados, es decir, si en mi posición i = 5, obtengo un dígito de dos cifras, por ejemplo, 18, debo sumar 1 + 8:
+
+* Aplicando parseInt obtenemos la parte entera: 
+
+  `18 / 10 = 1.8` &rarr;  `parseInt(18 / 10) = 1`
+
+* Aplicando MOD obtenemos el segundo dígito 
+
+  `18 % 10 = 8`
+
+* En código será asi:
+
+      if(i % 2 == 1){
+      arrayInverse[i] = (parseInt((arrayInverse[i] * 2 )/ 10 )) + ((arrayInverse[i] * 2 ) % 10 );
+      }
+
+>NOTA: Lo que ejecuta el IF será la suma de los digitos, almacenado en el mismo array.
+
 
-Para cada producto debes entregar **un repositorio de GitHub** que
-contenga:
-1. Archivo `README.md` que explique el **pseudocódigo** de tu solución y su
-**diagrama de flujo**
-2. Archivo `app.js` con el **código** de tu solución
-3. Archivo `index.html` vinculado con tu `app.js`
+* Debemos obtener la suma de elementos, para ellos utilizaremos nuestro acumulador sum, creado anteriormente.
 
-## Tips
+      sum += arrayInverse[i];
 
-A continuación un video de Michelle que te lleva a través del algoritmo de
-Luhn y te da tips para completar este proyecto:
+    Dando como resultado, según nuestro ejemplo, 70.
 
-[![tips credit card](https://img.youtube.com/vi/f0zL6Ot9y_w/0.jpg)](https://www.youtube.com/watch?v=f0zL6Ot9y_w)
+* Para comprobar si este número de tarjeta es válido, y no una serie de número al azar, nuestra suma MOD 10 debe resultar 0.
 
-## Consideraciones específicas
+      sum % 10 == 0
+
+  Para este ejemplo `70 % 10 = 0`, es decir, nuestra tarjeta es válida.
 
-1. Tu código debe estar compuesto por 1 función: `isValidCard`
-2. El usuario no debe poder ingresar un campo vacío
+* Por último mostrar un document.write que indique el resultado de la validación.
 
-## Criterios de evaluación
+      return sum % 10 == 0 ? document.write('Su número de tarjeta es válido')  : document.write('Su número de tarjeta NO es válido') ;
 
-Se tomarán en cuenta las siguientes consideraciones a la hora de evaluar tu solución:
+* Finalmente, no olvidar invocar la función.
 
-1. Nombramiento de variables
-2. Indentación
-3. Validación de input: el usuario no debe poder ingresar un campo vacío o de tipo que no corresponda
-4. Estructura de tus archivos
-5. Archivo `README.md` correctamente redactado
-6. Uso de comentarios para hacer tu código más legible
-7. Que el programa cumpla con el propósito requerido
+      isValidCard (cardNumber);

index.html

@@ -0,0 +1,16 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <title>VALIDAR TARJETA</title>
+  </head>
+  <body>
+    <h2 align = 'center'>VALIDAR TARJETA</h2>
+    <P><h3>Su resultado es: </h3> </P>
+
+      <script type="text/javascript" src="js/app.js">
+
+      </script>
+
+  </body>
+</html>

js/app.js

@@ -0,0 +1,44 @@
+function isValidCard(cardNumber) {
+  // cada digito del string es colocado en un array con split y espacio ''
+  var arrayNumbers = cardNumber.split('');
+  // el arrayNumbers es invertido
+  var arrayInverse = arrayNumbers.reverse();
+  // creo un acumulador suma, donde se almacenara las sumas de los digitos de la tarjeta
+  var sum = 0;
+
+  // creo un bucle for, que recorre todo los indices del arrayInverse
+  for (var i = 0; i < arrayInverse.length; i++) {
+    // el array de los numeros tipo string lo convierto en tipo numbers y lo almaceno en el mismo array
+    arrayInverse[i] = parseInt(arrayInverse[i]);
+    // condiciono un mod == 1, para que solo tomen los indices impares
+    if (i % 2 === 1) {
+      /* segun la validacón de tarjeta los indices impares (en mi caso porque tomo como inicializacion 
+      i = 0) debo multiplicarlo por dos, si el resultado de esa multiplicación me da un número de dos 
+      digitos, entonces debo sumar dichos digitos. Para obtener el PRIMER DIGITO, debo 
+      dividir el número entre 10 y mostrarlo con un parseInt y obtener solo solo la parte entera del 
+      resultado. Luego, para el SEGUNDO DIGITO, debo sacar MOD 10 del valor para obtener las unidades. 
+      Después, sumo dicho valores y el resultaado es alamacenado en el arrayInverse */
+      arrayInverse[i] = (parseInt((arrayInverse[i] * 2) / 10)) + ((arrayInverse[i] * 2) % 10);
+    }
+    // Ahora sumare los elementos del array al acumulador sum para obtener un solo resultado.
+    sum += arrayInverse[i];
+  }
+  // Para validar el numero de tarjetas, la suma de digitos MOD 10 debe resultar cero. Si es asi, me muestra true; de lo contrario, false.
+  return sum % 10 === 0 ? document.write('Su número de tarjeta es válido.') : document.write('Su número de tarjeta NO es válido');
+}
+
+do {
+  var centinel = false;
+  // Los datos ingresados en un prompt son siempre de tipo string
+  var cardNumber = prompt('Ingrese su número de tarjeta: ');
+
+  // Condiciono que el ingreso es de 16 digitos, además no sea un ingreso de 16 veces cero.
+  if (cardNumber.length === 16 & cardNumber !== 0000000000000000) {
+    centinel = true;
+    // Llamo a la funcion isValidCard tomando como argumento cardNumber
+    isValidCard(cardNumber);
+    break;
+    // Si no se cumple la función. manda una alerta de que el ingreso no es válido y vuelve a pedir el número
+  } else
+    alert('Error. Ingreso no válido.');
+} while (centinel === false);