Introducción al curso

1

¡Alto! Tenemos una nueva versión de este curso para ti

2

Bienvenidos al Curso de Fundamentos de JavaScript

3

Repositorio de este curso de fundamentos de JS

Primeros pasos en JavaScript

4

Variables

5

Variables: Strings

6

Variables: Números

7

Funciones

8

El alcance de las funciones

9

Objetos

10

Desestructurar objetos

11

Parámetros como referencia o como valor

12

Comparaciones en JavaScript

Estructuras de Control y Funciones

13

Condicionales

14

Funciones que retornan valores

15

Arrow functions

16

Estructuras repetitivas: for

17

Estructuras repetitivas: while

18

Estructuras repetitivas: do-while

19

Condicional múltiple: switch

Arrays

20

Introducción a arrays

21

Filtrar un array

22

Transformar un array

23

Reducir un array a un valor

Programación Orientada a Objetos en JavaScript

24

Cómo funcionan las clases en JavaScript

25

Modificando un prototipo

26

El contexto de las funciones: quién es this

27

La verdad oculta sobre las clases en JavaScript

28

Clases en JavaScript

Asincronismo

29

Funciones como parámetros

30

Cómo funciona el asincronismo en JavaScript

31

Cómo funciona el tiempo en JavaScript

32

¿Qué pasó con swapi.co?

33

Callbacks

34

Haciendo múltiples requests

35

Manejando el Orden y el Asincronismo en JavaScript

36

Manejo de errores con callbacks

37

Promesas

38

Promesas Encadenadas

39

Múltiples promesas en paralelo

40

Async-await: lo último en asincronismo

Juego de HTML

41

Comenzando el juego

42

Generando una secuencia de números

43

Iluminando la secuencia de colores

44

Obteniendo el input del usuario

45

Agregando la verificación del color elegido

46

Agregando los estados finales del juego

47

Conclusiones del curso

Complementos

48

Diferencias entre var, let y const

49

Memoización: ahorrando cómputo

50

¿Hace cuántos días naciste?

51

Funciones recursivas

52

Entiende los closures de JavaScript

53

Estructuras de datos inmutables

54

Cambiando de contexto al llamar a una función

55

¿Cuándo hace falta poner el punto y coma al final de la línea?

Crea una cuenta o inicia sesión

¡Continúa aprendiendo sin ningún costo! Únete y comienza a potenciar tu carrera

Variables: Strings

5/55
Recursos

Los strings son cadenas de texto. Para indicar que estamos usando una cadena de texto debemos de colocar las comillas simples.

En este curso utilizaremos los métodos:

  • toUpperCase, que sirve para transformar un String a mayúsculas.
  • toLowerCase, que sirve para transformar el string a minúsculas.

También usaremos el atributo:

  • length, que nos indica la cantidad de caractéres que tiene un string.

Para concatenar dos strings se utiliza el símbolo (+)
var nombreCompleto = nombre + ’ ’ + apellido

Desafío: Encuentra la última letra de su nombre

Aportes 1808

Preguntas 49

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Solución desafío:

var ultimaLetra = nombre.charAt(nombre.length-1)

Explicación:

  1. Creamos una variable llamada ultimaLetra
  2. Asignamos como valor a la variable el resultado de nombre.charAt
  3. Dentro de la función charAt pasamos como parámetro todo el largo de nuestro nombre y le restamos 1

¿Por qué restamos 1?
Porque charAt y length comienzan a contar de manera distinta, mientras charAt comienza de 0, length comienza de 1. Y lo que realmente pasa dentro de nombre.charAt(nombre.length-1) es que primero se ejecuta lo que está entre paréntesis, es decir devuelve un valor x, y luego se ejecuta el charAt, es decir mueve el cursor a la posición del valor de x.

Para tratar de ejemplificar más, en el siguiente ejemplo tenemos la palabra Platzi, tiene 6 caracteres en total, si queremos ir a la última letra en este caso la i, el valor de lenght es 6 y para charAt es 5, por eso restamos 1.

Resumen de la clase con el desafío inlcuido:

var nombre = 'Mirna', apellido = 'Veras'

//Transformar un string a mayúsculas
var nombreEnMayusculas = nombre.toUpperCase()

//Transformar un string a minúsculas
var apellidoEnMinusculas = apellido.toLowerCase()

//Extraer la primera letra de un string
var primeraLetraDelNombre = nombre.charAt(0)

//Para saber la cantidad de caracteres que tiene un string
var cantidadDeLetrasDelNombre = nombre.length

//Concatenar 2 strings:
var nombreCompleto = nombre + ' ' + apellido

//Otra forma de concatenar es la Interpolación de Textos
var nombreEntero = `${nombre} ${apellido}`

//Interpolación de textos incluyendo código JS
var nombreEnteroCodigo = `${nombre} ${apellido.toUpperCase()}`

//Substring - Extraer caracteres de un string
var str = nombre.substr(1, 2)

//Mostrar la última letra de un string
var ultimaLetraDelNombre = nombre.substr((cantidadDeLetrasDelNombre-1), 1)```

por si alguien quiere los apuntes de lo que llevamos.

Fundamentos Js.

Variables: las variables son aquellas propiedades que están sujetas a algún tipo de cambio, en otras palabras, permite identificar a un elemento no especificado dentro de un determinado grupo de elementos.

Variables en Js: puede comenzar a utilizarse por medio del código
“Var” y se aplica de la siguiente manera:
Ejemplo.
Var nombre = ‘Angel’
Var apellido = ‘Sulbaran
Allí se le está especificando al código que al escribir la palabra nombre, tomara el nombre angel.

“Console.log” sirve para mostrar un mensaje o alcun contenido en la consola, por lo que si usamos por ejemplo:

Console.log(‘hola ’ + nombre) como usamos la variable anteriormente creada que es “nombre” nos dira “hola angel”

Nota importante: en Javascript no es necesario usar punto y coma (😉, debido a que no lo pide, algunos lo usan solo por tradicionalismo.

También puedes usar 2 variables por ejemplo en la misma línea, por ejemplo:
Var nombre = ‘Angel’, apellido = ‘Sulbaran’.

Strings
Para hacer que el nombre vaya en mayúsculas, creamos una varible de la siguiente manera.
Var nombreEnMayusculas = nombre.toUppercase()
En minúsculas
Var NombreEnMinusculas = nombre.toLowerCase()

Si queremos que diga la primera letra del nombre.

Var primeraLetraDelNombre = nombre.charAt(0)
Var cantidadDeLetrasDelNombre = nombre.length  este no necesita el ______________________________________________paréntesis al final “()”.
Para concatenar se puede hacer de la siguiente manera

Var nombreCompleto = nombre + apellido
Sin embargo, al concatenarlo de esta manera, vamos a observar que el nombre y el apellido estarán pegados de la siguiente manera “AngelSulbaran”.
Por lo que debemos podemos agregar un espacio a la concatenación de la siguiente manera.
Var nombreCompleto = nombre + ‘ ’ + apellido

Al escribir nombreCompleto en la consola nos dira nuestro nombre completo separado de manera correcta (Angel Sulbaran).

Existe otra manera de concatenar strings, que es mas nueva y mejor, se llama interpolación de texto. se usa de la siguiente manera.

Var nombreCompleto = ${nombre} ${apellido}
Para interpolar variables debemos usar las comillas invertidas y colocar el signo “$” antes de las llaves “{}”, y dentro de las llaves vamos a colocar nuestro Javascript, por lo que podemos leer la variable anterior, entre el uso de las dos variables “nombre” y “apellido” existe un espacio que la consola tomara en cuenta a la hora de usar la variable “nombreCompleto”.

Otra cosa que podemos hacer con los strings es acceder a un sub-string dentro de un string, es decir a un string mas pequeño, eso se hace con la función “str”.
Ejemplo.

Var str = nombre.charAt(1) + nombre.charAt(2)
Aca si escribimos “str” en el console log nos dira ac pero estamos especificando 2 veces la misma varible con la misma función exceptuando el hecho de que les estamos diciendo que nos indiquen caracteres que tienen diferentes posiciones o diferentes numero de orden. Para simplificar esto pordemos usar esta fuincion.
Ejemplo.
Var str = nombre.substr(1, 2)

Y escribir str en el console log nos dira ac igualmente.

var nombre = prompt (`¿cual es tu nombre?`)
var UltimoCaracter = nombre.charAt(nombre.length -1)

alert(`la ultima letra de tu nombre es `+ nombre.charAt(nombre.length -1))

![](

Las comillas Invertidas se pueden escribir con ALT + 96 `

Alt + 96 para invocar las comillas simples ``

ASCII para comilla invertida. Tecla ALT+ 96

Resumen:

Convertir a Mayusculas:
Para convertir a mayusculas se usa la funcions
toUpperCase()

Convertir a Minusculas:
Para convertir a mayusculas se usa la funcions
toLoweerCase()

Para conocer que caracter se encuentra en determinada posicion:
Se usa la funcion charAt(a) donde a es la posicion que
queremos.

Para conocer la longitud de un string:
Se usa la funcio length

6:32 Se puede sacar las tildes invertidas con Alt + 96 en un teclado en español

METODOS DE STRINGS:

- toUpperCase() : Retorna los caracteres transformados en MAYUSCULA.

- toLowerCase() : Retorna los caracteres transformados en MINUSCULA.

- charAt() : Recibe 1 parametro “( Pocision del caracater)”,y retornara solo el caracter que tiene esa pocision.

- substr() : Recibe 2 parametros “(Posicion Inicial,Pocision final )”, y retornara el numero de caracteres que haigamos definido.

ATRIBUTOS
- length : Retorna el numero total de caracteres.

Esta es la historia de mi amigo Olonganopatricio. 😃

let nombre = 'Olonganopatricio';

let letrasDeNombre = nombre.length;
let nombreCorto = nombre.substr(8, 16);
let nombreMayusculas = nombre.toUpperCase();

console.log(`Tengo un amigo llamado ${nombre}`);
console.log(`Su nombre es demasiado largo. Tiene ${letrasDeNombre} letras. D:`);
console.log(`Aveces preferiria decirle solo ${nombreCorto}`);
console.log(`Pero el me reclama diciendome que su nombre es ${nombreMayusculas}`);
Metodos con strings

Pasar a mayuscula
    string.toUpperCase()

Pasar a minuscula
    string.toLowerCase()

Primera letra 
    string.charAt(0)

Letra en posicion n
    string.charAt(n)

Contar el numero de caracteres
    string.length

Concatenar strings
    stringConcatenado = string1 + string2

Interpolacion de texto
(tambien concatena) se usa comilla invertida

    stringConcatenado = `${string1} ${string2}`

Acceder a un substring
    string.substr(posicion_inicio,posicion_final)

charAt(0)= acceder a un carácter
Substr(1,2)=tomar desde una posición un carácter, y una cantidad.
length=Cantidad de caracteres que tiene una palabra
ToUpperCase= Mayúscula
ToLowerCase=Minúscula
´${variable1} ${variable2}´= concatena, debe ir entre comillas inversas

var nombre=Luisa;
var ultimaLetra=nombre.charAt(nombre.length-1)

var nombre;

nombre = prompt ("Inserte nombre: ");
var num = nombre.length;
var str = nombre.substr (num-1);
console.log (nombre);
console.log (str);

Por acá dejo el desarrollo de mi desafío.

var nombre = "Cesar";
var apellido = "Espitia";
var edad = 33;
var peso = 60;
var estatura = 1.76;

console.log(`Hola ${nombre} ${apellido} tienes ${edad} años, mides ${estatura} y pesas ${peso}`);

console.log(`La última letra del nombre ${nombre} es ${nombre.substr(-1)}`);

Utilice el parametro negativo en el metodo subtr(-1) para obtener la letra final del string.

Para más info ver la siguiente documentación.
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/substr

Esto es trampa ya que aun no vimos operaciones, output, ni input! tocó salir a investigar un poco…

//Desafio: Mostrar al usuario cual es la ultima letra de su nombre.

var nombre = prompt('Ingrese su nombre')
var largo, posicionUltimaLetra, ultimaLetra
largo = nombre.length
posicionUltimaLetra = largo - 1
ultimaLetra = nombre.charAt(posicionUltimaLetra)
alert("La ultima letra de su nombre es: " + ultimaLetra)
var nombre = prompt("Introduce tu nombre,por favor: ")

console.log(`Tu nombre es, ${nombre}`)
console.log(`La ultima letra de tu nombre es, ${nombre.charAt(nombre.length-1)}`)

En windows para la comilla investida es : alt + 96

Reto

var ultimaLetraDeTuNombre = nombre.charAt(nombre.length - 1)
/* muestra la ultima letra de un nombre */

En el teclado de Mac encuentran las comillas invertidas al lado derecho de la “p”

El comando prompt nos permite almacenar datos en una variable desde la ventana del navegador, quedando así mi reto:

var nombre = prompt('¿Cuál es tu nombre?')
alert('La última letra de tu nombre es ' + nombre.charAt(nombre.length - 1))

let nom = “Mario”;
for(let i = 0; i < nom.length; i++){

if( i === 4){
    console.log(nom.charAt(i))
}

}

He realizado la tarea y este programa te dice tu primera y ultima letra.
html

<!DOCTYPE html>
<html lang="es">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Nombre</title>
</head>
<body>
    <h1>Dime tu nombre y te dire tu última letra</h1>
    <script src="nombreletra.js"></script>
</body>
</html>

js

var nombre = prompt("Introduce tu nombre");
alert("la primera letra es "+ nombre.charAt(0) + " y la ultima letra es "+  nombre.charAt(nombre.length-1));

Reto Completado, Como dato curioso la funcion substr(), está en desuso. Puedes checar su documentación Aquí

var ultimaLetra = nombre.substr(cantidadDeLetrasDelNombre - 1);
ultimaLetra = nombre.slice(-1); //Una segunda forma de hacerlo```

https://jsconsole.com/ pueden user esta como consola para lo que queda del curso y escribir su codigo.

PD: Lo saque de otro curso de JS y es muy util

Comparto mi solución al desafió por si alguien le interesa


//Declarando las variables y solicitando el nombre al usuario
var nombre = prompt("Ingrese su nombre: ");
ultimaLetra(nombre);

//Creando una función para utilizar el código con cualquier nombre
function ultimaLetra(nombre){  
    //Contando la cantidad de letras
    numeroDeLetras = nombre.length
    console.log(`La su nombre tiene: ${numeroDeLetras} letras`)
    //Mostrando la ultima letra del nombre
    console.log(`La ultima letra de su nombre es: ${nombre.charAt(numeroDeLetras-1)}`)
}

Solución al desafío: Cuando pones números negativos en “substr”, podras obtener los caracteres desde el ultimo al primero respectivamente.

<code> var str = nombre.substr(-1); 

Propiedades de los string:


  • .length nos ayuda a saber cuantos caracteres tiene ese dato.

Una propiedad es una caracteristica que tiene ese dato o  valor.


Metodos de los string:

  • Sin parametros tenemos:
    • .trim( ) quita los espacios en blanco al inicio y al final.
    • .toUpperCase( ) convierte todo a mayusculas.
    • .toLowerCase( ) convierte todo a minusculas.

Un metodo es algo que ese dato puede hacer. (Una accion u operacion).


Metodos para encontrar caracteres en un string:

  • .indexOf(string, i) devuelve posicion (indice).
    • si no encuentra el string o caracter tira un -1.
  • .lastIndexOf(string, i) devuelve posicion.
    • si no encuentra el string o caracter tira un -1.

La “i” es el numero de posicion donde comienza a contar, por ejm si hay varias “p”, si queremos saber la segunda “p” i es igual a la posicion de la primera + 1. Asi encontrara la segunda ya que comenzo a contar despues de la posicion de la primera.

variable.indexOf(“p”, variable.indexOf(“p”) + 1)

  • .includes(string, i) pregunta si el texto incluye cierta cadena de texto, por lo tanto devuelve boolean.
  • .startsWidth(string, i) pregunta si comienza con determinado texto
  • .endsWidth(string, i) pregunta si termina con determinado texto

Estos ultimos 3 tambien devuelven true o false


Metodos para manipular texto

  • .replace(original, replacement)
  • .split(separator) devuelve un array. Si quiero posicion le especifico asi:

.split(separator)[position]

let nombre = "Lester Obed"

nombre.split(" ") /* devuelve un array ["Lester", "Obed"] */

nombre.split(" ")[1] /* devuelve "Obed" */

nombre.split("") /* devuelve cada letra de la cadena ["L", "e", "s", "t"..,] */

Si queremos saber la posicion de una letra no es necesario el split, solo le mandamos la posicion: nombre[3]     esto nos da “t”. Recuerda que una cadena de texto, en terminos tecnicos es un array.

  • substring(start, end)

No incluye end   quiere decir que si le damos end no lo va incluir en el texto final.

y si end es negativo extrae hacia atras, es decir desde end hacia el inicio.

  • substr(start, end) en este end ya no es posicion, es cantidad de caracteres.

Si start es negativo, empieza a extraer desde atras. Es decir, los ultimos caracteres.

  • slice(start, end)

se diferencia de substr con valores negativos.

end negativo, no toma los ultimos [end] valores.

start negativo, empieza a contar desde el final

  • (el end es opcional en estos ultimos tres metodos)

nombre.substring(4)

//“er Obed”

desde la posicion 4 en adelante, se trae todo el texto, incluyendo esa posicion.

substr(-2)

//“ed”

extrae los ultimos caracteres

slice(-4, -1)

//"Obe

extrae los ultimos caracteres y le quita el ultimo. dependiendo del end le quita los ultimos caracteres.

Challenge completed

var str = name.substr(-1,)

console.log(Ultima letra del nombre: ${nombre.charAt(nombre.length-1)})

RETO

var nombre = 'Christian'
var ultimaLetraDelNombre = nombre.substr(-1)

Reto Cumplido 😄

Yo encontré dos versiones para la solución.

  1. Con chartAt
var ultimaLetraDelNombre = nombre.charAt(cantidadDeLetrasDelNombre - 1);
  1. Con subStr
var ultimaLetraDelNombre = nombre.substr(cantidadDeLetrasDelNombre - 1);

Reto:

var nombreUsuario = prompt('Ingrese su nombre');
var tamanoDeCadena = nombreUsuario.length
var ultimaLetraDelNombre = nombreUsuario.substr(tamanoDeCadena - 1,1);
console.log(`La última letra del nombre ${nombreUsuario} es ${ultimaLetraDelNombre}`);

El método substr() devuelve los caracteres de una cadena que comienzan en una localización especificada y de acuerdo al número de caracteres que se especifiquen.

var  nombre = Imelda;
var ultimaLetra = nombre.substr(nombre.length - 1 , 1);
console.log(ultimaLetra);

asi solucione el desafio. Saludos.

var ultimaLetraNombre  = nombre.charAt(nombre.length-1)
    var nombre = prompt('Cual es tu nombre');
    var ultimaLetraDelNombre = nombre.substr(-1);
    alert(ultimaLetraDelNombre);

var name = ‘Andy’

console.log(name.charAt(name.length-1))

Reto:

var nombre = 'Nicolas’
var longitudNombre = nombre.length
var ultimaLetra = nombre.charAt(longitudNombre - 1)

console.log(‘Su nombre es Nicolas’)
console.log('La ultima letra de su nombre es ’ + ultimaLetra)

Obtener ultima letra del nombre

//Ultima letra del nombre
var ultima = nombre.charAt(nombre.length-1);
var str = nombre.charAt(nombre.length - 1)

var nombre = ‘Tomas’, apellido = ‘Herrou’;
var nombreEnMayus = nombre.toUpperCase();
var apellidoEnMayus = apellido.toUpperCase();
var ultimaLetra = nombre.charAt(nombre.lenght - 1);
console.log(ultimaLetra);

para los que quieran sacar las comillas invertidas `` sin necesidad de ir a buscarlas y coppiarla se puede con codigo ascii Alt+96=`
recuerde es bueno aprenderce algunos comando en ascii

//apuntes de la clase + desafio
var nombre = ‘samuel’, apellido = 'Figueroa’
var nombreEnMayusculas = nombre.toUpperCase();
var apellidoEnMinusculas = apellido.toLowerCase();
//acceder a un caracter por su posicion en la cadena
var primerLetraDelNombre = nombre.charAt(0);
var cantidadDeLetrasDelNombre = nombre.length;

//concatendado
var nombreCompleto = nombre + ’ ’ + apellido;

//nuevo concatenado interpolacion del texto con comilla invertida
var nomCompleto = ${nombre} ${apellido.toUpperCase()};

//acceder a uno o varios caracteres por su posicion en la cadena
//pasando por parametro las posiciones comprendidas, es decir:
//en el ejemplo se ve desde la posicion 1 hasta la 2
var str = nombre.substr(1, 2)

//desafio del la clase
//mostrar al usuario la ultima letra de su nombre

var nombreUsuario = ‘Juan’;
var cantidadLetras = nombreUsuario.length-1;
var ultimaLetra = nombreUsuario.charAt(cantidadLetras);

console.log(ultimaLetra);

ALT + 96 para comillas al revez ❤️

comparto reto:
var lastLetterName = nombre.substr(length-1, 1)

var nombre = prompt('Hola. Ingrese su nombre por favor:')
alert(`El último caracter de su nombre es: ${nombre.charAt(nombre.length - 1)}`)
var ultimaLetra = nombre.charAt(nombre.length-1)

Comilla invertida = ALT + 96

Algo que note, es que el atributo length cuenta también los espacios. Lo digo después de hacer la prueba con las siguientes lineas

var texto = 'Este texto se pondrá en minúsculas'
var cantidadDeLetrasDelTexto = texto.length

Reto Clase # 4 Variables: String

var nombre= 'Josadec';
var str = nombre.length;
var str1 = nombre.charAt(str -1);
console.log('Ultima Letra del String:'+str1)

Si se quiere incluir… Se debe incluir…
Una nueva línea \n
Un tabulador \t
Una comilla simple '
Una comilla doble "
Una barra inclinada \
fuente: https://uniwebsidad.com/libros/javascript/capitulo-3/tipos-de-variables

Las comillas invertidas tambien se le conoce como platilla literales o Template Literals, y son usadas para escribir Javascript dentro de cadenas, inicialmente esta función nacio por la problematica que hay veces daba concatenar variables y funciones dentro de las cadenas, y escribir html con javascript.

Sabia que JavaScript soportaba la interpolacion de strings

console.log(`Hello ${prompt("What is your name?")}`);


var nombre = "aNaCleTa";

console.log(`Recuerdas la contraseña: ${nombre.substr(0,3)} XXXXXXX`);
console.log(`La contraseña deve tener minimo 10 letras la tuya tiene ${nombre.length} letras`)
var ultimaLetraDelNombre = nombre.charAt(nombre.length - 1)
console.log(ultimaLetraDelNombre)

Acá la respuesta al desafío planteado:

let nombre = "Pedro", apellido = "Marcano";
console.log("Hola" + nombre.toUpperCase() + " " + apellido.toUpperCase() + ".");
console.log("Hola, " + nombre.toUpperCase() + " " + apellido.toUpperCase() + ".");
console.log("Cantidad de letras de mi nombre completo: "+(nombre.length + apellido.length));
console.log("Y la última letra es: " + nombre.charAt(nombre.length - 1));
console.log("Y la primera letra es: " + nombre.charAt(0));

Yo sí me salté la sección de guardar la operación de los strings en variables y fui directo al punto.

Variables:Strings
toUpperCase(): es un metodo que nos permite transformar las variables de caracteres en mayusculas. sintaxis var NombreVariable = nombre.toUpperCase()
toLowerCase(): nos permite pasar a minusculas nuestra variables de caracteres.
charAt(0): nos da la letra que le indiquemos cuando le damos como parametro una funcion.
.length: llamamos a este atributo para saber las cantidades de letras que tiene una variable.
substr(): es una funcion es parecidad al charAt. La diferencia es que nos permite
seleccionar un rango de caracteres.

<
var pregunta = prompt ('Escribe aqui cual es tu nombre...')

var cantidad = pregunta.length

var resultado = pregunta.charAt(cantidad-1)

console.log('La ultima letra que hay en tu nombre es:' + resultado)
>

var nombre = ‘Cristian’, apellido = ‘Beltran’

var usuario = ${nombre.toUpperCase().charAt(0)}${apellido.toUpperCase()}

//Se pueden concatenar dos funciones de la forma como se muestra en la variable usuario?

RETO COMPLETADO! 😄

/*MOSTRAS LA ULTIMA LETRA DEL NOMBRE*/

var nombre = "platzi";
var ultimaLetraNombre = nombre.charAt(nombre.length - 1);

console.log(ultimaLetraNombre);

muy bien explicado

reto resuelto

RETO DE LA CLASE

  • Codigo HTML
<html lang="en" dir="ltr">
  <head>
    <meta charset="utf-8">
    <title>Clase 2 - Strings</title>
  </head>
  <body>
    <h1>La ultima letra de mi nombre</h1>
    <p>Nombre: Fernando</p>
    <p id="ultimaletra"></p>
    <script src="clase2.js"></script>
  </body>
</html>

  • Codigo Java Script
var ultimaLetra = document.getElementById("ultimaletra")
var nombre = 'Fernando'
var longitud = nombre.length
var ultimaLetraTexto = nombre.charAt(longitud-1)
ultimaLetra.innerHTML = `${'Ultima Letra:'} ${ultimaLetraTexto}`
var ultimaLetra = nombre.substr(nombre.length-1,nombre.length-1)

Tres formas de hacer el desafio.

var name = 'FredBen';
name = name.charAt(name.length-1);
name = name.substr(name.length-1,1);
name = name.substr(-1,1);

Reto completado!

//desafio
//mostrar la ultima letra de un nombre
var nombreReto = prompt('Escribe tu nombre')

var posicionUltimaLetraNombreReto = nombreReto.length - 1

var ultimaLetraNombreReto = nombreReto.charAt(posicionUltimaLetraNombreReto)

alert('La ultima letra de tu nombre es: ' + ultimaLetraNombreReto)

Mis comentarios sobre esta clase

// Declaración e inicialización de variables
var nombre = 'Alejandro', apellidos = 'González Reyes'

// Metodos para transformar una cadena a mayúsculas y minúsculas
// No mutan la cadena
var nombreEnMayusculas = nombre.toUpperCase()
var apellidosEnMinusculas = apellidos.toLowerCase()

// Obtener un caracter por su posición especifica
// Obtneer la cantidad de caractes que conforman una cadena de texto
var primerLetraDelNombre = nombre.charAt(0)
var cantidadDeLetrasDelNombre = nombre.length

// Concatenación tradicional en JS e interpolación de variables en JS6
var nombreCompleto = nombre + ' ' + apellidos
var nombreDePila = `${nombre} ${apellidos}`
var nombreCompletoMayusculas = `${nombre.toUpperCase()} ${apellidos.toUpperCase()}`

// Obtener los primeros cuatro caracteres de una cadena de texto
var subcadenaNombre = nombre.substr(0, 4)
var subcadenaApellidos = apellidos.substr(3, 4)

// Recuperar el último caracter de una cadena de texto
var ultimaLetraNombre = nombre.charAt(nombre.length - 1)
var ultimaLetraApellido = apellidos.substr(-1, 1)

Extraer la última letra de tu nombre y mostrarlo en consola.

const c = console.log

let ingresaTuNombre = prompt('Ingresa tu nombre')

c(`La última letra de tu nombre es: ${ingresaTuNombre.substr(-1)}`)
var ultimaLetraDelNombre = nombre.charAt(nombre.length-1)
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>digitos</title>
</head>
<body>
    <h1>el primer y 3 digito de tu nombre</h1>
    <script>
    var nombre = prompt('coloca tu nombre');
    var digitos = nombre.charAt(0) + nombre.charAt(2);
    document.write('los dos digitos son '+ digitos);
    </script>
</body>
</html>****```

var UltimoCaracter = nombre.charAt(nombre.length - 1)

Dos formas de resolver el reto:

var nombre = 'Santiago'

var ultimaLetra = nombre.substr(-1, 1);
var ultimoCaracter = nombre.charAt(nombre.length-1);

Les comparto mi resumen

<script>

        var nombre = 'Marco', apellido = 'Aurelio';

        var nombreEnMayusculas = nombre.toUpperCase();
        var apellidoEnMinusculas = apellido.toLowerCase();
        var cantidadDeLetras = nombre.length;

        // Recuerda que se empieza a contar en 0
        // Nota que substr() es diferente a substring()
        var letraDeNombre = nombre.charAt(3);
        var subString = apellido.substring(2, 5);
        var subString2 = apellido.substr(2, 5);

        // Concatenacion clasica
        var nombreCompleto = nombre + " " + apellido;
        // Concatenando con Template Strings, interpolacion de texto 
        // NOTA: 
        // son comillas invertidas
        // lo que va entre ${} puede ser cualquier codigo JS
        var nombreCompleto2 = `${nombre} ${apellido}`;
        var largoDelNombre = `El largo de ${nombre} es ${nombre.length}`;
        var nombreCompleto3 = `Mi nombre es ${nombre} ${apellido.toUpperCase()}`;

        var ultimaLetra = `La ultima letra de ${nombre} es ${nombre.charAt(nombre.length - 1)}`;

    </script>```

otra manera de hacer el ejercicio:

var nombre= 'mauricio’
var cantidad = nombre.length
var can= cantidad - 1
var mostrarUltimaLetrNombre = nombre.substr(can)

Hola Comparto el Desafio.

En mi caso como todas las letras del nombre estaban en minuscula, hice esto para que me regresara la primera en mayúscula:

var primeraLetraDelNombre = nombre.charAt(0).toUpperCase()

let nombre = prompt("Cual es tu nombre? ");
let str = nombre.substr(-1)
console.log('La ultima letra de tu nombre es: ’ + str);

Navegando por la red encontré esta pagina que les comparto:

http://www.codexexempla.org/curso/curso_4_2_f.php#obj-array

La cual me pareció muy útil, porque acá podemos encontrar referencia muchos de lo métodos que se pueden utilizar en Java Script.

Código del desafío:

var nombre = prompt('Ingrese su nombre');

var ultimaLetra = nombre.substr(-1);

console.log('La última letra de su nombre es: '+ ultimaLetra);

Para el caso de la función de substr el primer valor indica en qué posición del texto se extraerá la información y el segundo cuantos caracteres serán extraídos (posición, cantidad)
Ejemplo:

var escuela = 'Platzi';
var str = escuela.substr(0,5);

Valor de str = ‘Platz’

var nameUser = prompt('¿Cúal es el tu nombre?');
var lastLetter = nameUser.substr(-1);
console.log(`La última letra de tu nombre es: ${lastLetter}`);

SUPER APUNTES AQUI: ![](

var nombre = 'Israel', apellido = 'Huerta'; /*Declarando variables */

var mayusNom = nombre.toUpperCase(); /*Convercion de mayusculas */
var minApellido = apellido.toLowerCase(); /*Convercion de Minusculas */

var primeraLetra = nombre.charAt(0);/*Extraes una letra segun la posicion de la cadena */
var cantidadNombre = nombre.length;/*Optienes la longitud de una variable de tipo string */

var nombreCompleto = `${nombre} ${apellido.toUpperCase()}`; /*Otro tipo de concatenación */

var str = nombre.substr(1,2)/*Extraer caracteres de una cadena segun la posición str.substr(Inicio,Fin) */

/*Reto Funciona para todos los nombres */
var len = nombre.length;
var ultima = nombre.substr(len - 1  , len);
console.log("Tu Nombre es: '"+nombre+"' La ultima letra de tu nombre es: '"+ ultima+"'");```

// Desafío: Ultima letra de su nombre
var ultimaLetraNombre = nombre.substr(nombre.length - 1, 1);

var nombre = “Fernando”;
console.log(la ultima leta de tu nombre ${nombre} es ${nombre.charAt(nombre.length-1)} :D);

Nuevo dato, no sabía la forma de concatenar utilizando el método de la comilla invertida. Excelente.

Aquí está mi solución al desafío:

//Definimos el nombre
var nombre = 'Stefanny'
//Ubicamos la última letra del nombre
var ultimaLetra = nombre.charAt(nombre.length-1) ```

Mi aporte al reto:

var lastChar = nombre.substr(-1)
var lastChar = nombre.substr(-1)
let nombre = 'Arturo';
console.log(nombre.substr(-1));

Desafio superado!!

Al ingresar cualquier nombre, el código arroja una descripción general de como esta compuesto.
-Nombre en mayúscula
-Cantidad de letras
-Letra inicial
-Letra final

comilla invertida alt + 96

<desafio.js>
var nombre = "Daniel", apellido = "Dominguez";

var ultimaLetraNombre = nombre.substr(-1);
var ultimaLetraApellido = apellido.substr(-1);

ultimocaracter=minombre.substring(minombre.length-1)

En mi teclado para las `` es con Alt + Control + la tecla para cerrar las llaves }]