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

El alcance de las funciones

8/55
Recursos

En esta clase hablaremos del alcance que tienen las funciones. Si una variable no está definida dentro del cuerpo de una función hablamos de una variable global. Por el contrario, una variable definida dentro de una función es una variable local.

Para que la ejecución de una función no modifique una variable global usamos parámetros en lugar de pasar directamente la variable.

Es posible utilizar el mismo nombre para una variable global y para el parámetro de una función con un alcance local.

Aportes 320

Preguntas 37

Ordenar por:

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

funciones son pedazos de codigo reutilizablke
¿A que variables puede accender una funcion?
¿En que momentos tiene acceso?

En el navegador el objeto global donde esta mi variable es en
window.miVariable

console.log("inicializando archivo");
//Imprimiendo algo en la consola

var nombre = "Daniel";
//Una variable global

function imprimirNombreEnMayusculas(nombre) {
// n tiene alcance local
//Para declarar la variable local, simplemente la coloco en parametro


nombre = nombre.toUpperCase()
//Observaras que puede usar la variable global perfectamente

console.log(nombre);
}
/*
Esta funcion va a tener el efecto colateral de 
modificar la variable nombre tanto dentro como fuera 
de la funcion

Esto es algo que queremos evitar en nuestro codigo
*/

imprimirNombreEnMayusculas(nombre);
//De esta manera evito el efecto colateral y tengo un alcance local

Repaso
¿Que aprendi?
toda variable que no esta definida en una funcion esta
definida en el objeto global que en este caso
en el navegador es window

Aprendi que para crear una variable local asi tenga el mismo nombre que una global tengo que escribir su nombre como parametro en una funcion

Que en javascript en general queremos que una variable local no contamine todo el codigo
¿Que logre?
Logre crear una funcion usando tanto variables globales como variables locales

¿Que podre lograr?
Podre crear un codigo sostenible en el tiempo

Un programador evita efectos colaterales en su codigo

También funciona de esta manera sin afectar la variable global.

function imprimirNombreEnMayuscula()
{
console.log(${nombre.toUpperCase()});
}
imprimirNombreEnMayuscula();

En pocas palabras todo lo que se declare dentro de las llaves, muere cuando se termine de ejecutar la función.

SUPER APUNTES:
![](

  • El alcance de una función se mide en base a que variables puede acceder

  • Si una variable no esta definida dentro del cuerpo de una función, esta será una variable global

  • El objeto global depende del entorno en el que se ejecuta Js, en el caso del Browser es ** window. **

  • Cuando una función accede a una variable global modificando su valor inicial, esto se le conoce como **Side Effect ** , Efecto de lado o si quieres sonar muy peliculero Daño colateral

  • A un nivel profesional el Side Effect no es algo deseado, y para evitarlo es necesario crearle un parametro a la función

**NOTA: ** El parámetro puede llamarse de la misma manera que la variable global.

El tema del alcance lo pueden consultar como scope, pero esta imagen puede aclarar un poco el tema

Algo importante es la diferencia entre función y procedimiento. Javascript los trabaja de forma indistinta, pero tradicionalmente, son dos cosas separadas. Una función es un bloque de código que ejecuta una serie de instrucciones y finalmente devuelve un valor, comunmente mediante la sentencia return. Un procedimiento, tambíen es un bloque de código que ejecuta una serie de instrucciones, pero que no necesariamente devuelve un valor al final de su ejecución. En el caso de este video, la función imprimirNombreEnMayusculas no devuelve un valor, sino que solo hace una impresión en pantalla, con lo cual se considera un procedimiento.
De nuevo, Javascript maneja esto de forma indistinta bajo el concepto de funciones, pero es bueno saberlo.

Otra cosa, el hecho de que Javascript nos permita usar el nombre de una variable global para usar como variable local en una función, no significa que debamos hacerlo. Es una mala práctica. Siempre se deben diferenciar los nombres de las variables

No te entiendo nada

Creo que aqui tambien se habla de que Var ya no se usa, sino Let y Const como variables?

Ejemplo de la clase:

Las variables globales pueden ser accedidas desde cualquier parte del código, y las variables locales solo están definidas dentro de las funciones y solo se puede acceder dentro de la función.
Esto evita modificar variables que no deben ser modificadas

No es buena práctica usar muchas variables globales. Pues no esta bien que una función haga modificaciones a registros que no tienen que ver con tal función.

un poco confuso pero despues de experiementar todo queda mas claro:)

Mis primero lenguajes fueron java y php, se me hacer muuuy raro escribir codigo sin terminar cada linea con un ;

Lo del alcance de las variables locales fue un dolor de cabeza en mis talleres de JavaScript en la unversidad.

Ámbito
En JavaScript, las instrucciones que se encuentran fuera de una función se considera que están en el ámbito global. Este es el espacio en el que escribimos las instrucciones hasta que se
define una función u otra clase de estructura de datos. Las variables definidas en el ámbito global tienen un alcance global y, por lo tanto, se pueden usar desde cualquier parte del código, pero las declaradas dentro de las funciones tienen un alcance local, lo que significa que solo se pueden usar dentro de la función en la que se han declarado. Esta es otra ventaja de las funciones; son lugares especiales en el código donde podemos almacenar información a la que no se podrá acceder desde otras partes del código. Esta segregación nos ayuda a evitar generar duplicados que pueden conducir a errores, como sobrescribir el valor de una variable cuando el valor anterior aún era requerido por la aplicación.
El siguiente ejemplo ilustra cómo se definen los diferentes ámbitos y qué debemos esperar cuando accedemos desde un ámbito a variables que se han definido en un ámbito diferente.

var variableGlobal = 5;
function mifuncion(){
 var variableLocal = "El valor es ";
 alert(variableLocal + variableGlobal); // "El valor es 5"
}
mifuncion();
alert(variableLocal); 

Toda variable que no este definida en una función, esta definida en el ambito global

El Scope o Ambito en español, es como el computador mantiene rastro de las variables dentro del programa. El ambito determina en que partes del programa una variable puede ser usada.
Existen dos tipos: Global Scope y Local Scope.

El Local Scope es cuando la variable es declarada dentro de un bloque de codigo o una función. Esta variable nacé , es usada y mueré dentro de ese bloque donde fue definida y no puede ser usada afuera de dicho bloque. Esto es cierto siempre y cuando la variable sea declarada usando let.

Muy importante entender esto.

var nombre = 'Luis'

function imprimirNombreEnMayusculas(n){
  // Asignar una variable local
  n = n.toUpperCase()
  console.log(n)
}

imprimirNombreEnMayusculas(nombre)```

Una recomendacion muy importante, al declarar las variables estas deben ser autodescriptivas, como diria fredy, ¡¡es una buena practica!!.
Es mucho mas facil entender un codigo en el que cada variable dice que almacena.

Esta clase me encanta! Lo que se explica en esta clase es el concepto de Pure Functions vs Inpure Functions. que es un tema muy importante de aprender sobre todo en Reac.js ya que cuando Todos los cambios que se realizan al Stado deben deser puros. 😃

maldito freddy, hiba muy rapido.

tengo una duda como es que JS sabe que estoy utilizando la variable nombre con solo ponerle n como es que sabe exactamente que variable usar o modificar dentro de la función ?

Esa función se puede resumir más fácilmente si se coloca así
console.log(n.toUpperCase())

Una practica personal que les comparto segun lo aprendido en las ultimas lecciones

//Alcance de las funciones
// Reto Personal: Convertir el nombre y apellido a mayusculas y seleccionar la longitud, la primera letra y ultima de ambos.

var Nombre, Apellido;

Nombre = prompt("Por favor Inserta el Nombre");
Apellido = prompt("Por favor Inserta el apellido");

function Longitud(Name, LastName){
 Name = Name.length;
 LastName = LastName.length;
 
 console.log(`La longitud de ${Nombre} es ${Name} y la Longitud de ${Apellido} es ${LastName}`);

}

function PrimeraLetra(Name, Lastname)
{
  Name = Name.charAt(0);
  Lastname = Lastname.charAt(0);
  console.log(`La primera letra de ${Nombre} es ${Name}`);
  console.log(`La primera letra de ${Apellido} es ${Lastname}`);

}

function UltimaLetra(Name, LastName)
{

    Name = Name.charAt((Name.length)-1);
    LastName = LastName.charAt((LastName.length)-1);
    console.log(`La ultima letra de ${Nombre} es ${Name}`);
    console.log(`La ultima letra de ${Apellido} es ${LastName}`);
  
}




Longitud(Nombre, Apellido);
PrimeraLetra(Nombre, Apellido);
UltimaLetra(Nombre, Apellido);

Recomendación si es la primera ves que pasan por el curso, después de cierto tiempo, digamos 1 mes, vuelvan a ver el curso, notaran que cobra mas sentido las explicaciones, y se van entendiendo otros conceptos que en la primera vez no, intentenlo y verán lo que les digo, saludos 😃

Más aportes

// Si una variable no esta definida dentro del cuerpo de una función se dice que se trata de una variable de ámbito global. Es decir, le pertenece al objeto global window
var nombre = 'Alejandro'
var apellidos = 'González Reyes'

function imprimirNombreEnMayusculas() {
    // La función provoca un efecto colateral, ya que al invocarla, modificará el contenido de la variable global nombre... 
    nombre = nombre.toUpperCase()
    console.log(nombre)
    // Recomendación: Se recomienda hacer uso de window.variable para mejor compresión del código en cuanto a variables globales se refiere.
}

imprimirNombreEnMayusculas()

console.error(nombre)


// Para que una función no modifique una variable global usamos parámetros en lugar de invocar directamente la variable dentro del cuerpo de la función
function printNameUpperCase(apellidos) {
    // Una variable definida dentro del cuerpo de una funcion se dice que es una variable de ámbito local
    var edad = 18
    // Aquí nombre es una viariable local.
    var nombre = 'Miguel Angel'
    
    apellidos = apellidos.toUpperCase()

    // Si dentro de la función se quiere tener acceso a una variable global. Se invoca desde el objeto global window.variable
    console.warn('Hola', nombre, apellidos, 'tu edad es', edad, 'años. Tu eres hermano de', window.nombre)
}

// Los parámetros pasados a una función se pasan por valor, es decir, se crean copias del valor de la variable usada como parámetro. En este sentido, jamás se mutará su contenido.
printNameUpperCase(apellidos)

console.error(apellidos)

Mis apuntes ! 😃

var nombre = 'Juan Manuel'

function get_nombre_local(name) {
    console.log(`Su nombre local es ${nombre.toUpperCase()} y su nombre global es ${window.nombre}`)
  }

  get_nombre_local(nombre)

El alcance de las variables también se conoce como Scope, y obviamente se divide en Scope Global y Scope Local. Aún así, declarar variables globales no es una práctica recomendable, porque podemos repetirlas en varias partes del código sin darnos cuenta.

Cosa muy importante a destacar y que suele pasar inadvertida:

Uno en python y javascript cuando tiene una variable que es por ejemplo 5, en realdiad no es que la variable realmente tenga el numero 5, sino que apunta a un objeto con muchas propiedades, entre ellas que si se le pide ser impreso en pantalla muestre 5. Parece una diferencia sin importancia pero es fundamental.

Porque? Porque si no se entiende esto y realmente creen que tienen el valor guardado en la variable jamas entenderán por qué, esta operación SI tiene efecto de lado:

x=[ ]
function a(miLista){
miLIsta.push(1)
}
a(x)
a(x)
a(x)

Fijense que cada vez que llaman a a enviando x, el valor de x al retorno de la función es diferente. Por que se usa un parametro la lista se modifica por fuera tambien.

Por qué es esto? Porque tanto “miLista” como “x” son referencias a un objeto cuyos elemntos son vacios. Al ejecutar el metodo push ( y no una asignación) lo que estoy haciendo es que el objeto al que apuntan las dos variables se modificado en si mismo. En cambio si yo hago miLIsta=5 no estoy modificando al objeto de la lista, sino que simplente miLista estará apuntando a otro objeto diferente cuyo valor es un 5. Es muy dificil de entender pero vale la pena pensarlo porque sino en el futuro les traerá problemas cuando esten debuggeando y no entiendan el efecto de lado que tienen ciertas funciones sobre variables locales o globales de su código.

Es interesante que podemos mostrar en la consola el nombre en mayúscula, usando la variable global sin tener que asignar alguna otra variable y sin cambiar su valor original.

console.log(windows.name.toUpperCase());

tambien podría obviarse el ‘windows’ si no se tiene otra variable con el mismo nombre en nuestra función.

😲Es muy importante saber como funciona el ámbito de las variables teniendo en cuenta que cada variable que declaremos dentro de una función tendrá vida dentro de si misma sabiendo que se declaro de manera local.
Y no de manera global como lo son las variables que se declaran fuera de ellas 🙂 .

Notas:
Toda variable que no este definida dentro de una funcion quiere decir que esta en el alcance global y podremos acceder a ella desde el objeto global.

var nameUser = 'Héctor',
    lastNameUser = 'Molero',
    emailUser = '[email protected]';

function printUserData(name,last,email){
     last = last.toUpperCase();
    console.log(`El email del Sr. ${name} ${last} es: ${email}`);
}
printUserData(nameUser,lastNameUser,emailUser);```

5. El alcance de las Funciones (Scope)

Cuando hablamos de alcance, hablamos de Scope de JavaScript, lo que quiere decir su alcance.

Hay dos tipos de alcance en JavaScript:

  1. Local: Solo puede ser usada dentro de unos corchetes { } que lo delimitan (dentro de una function, dentro de un if, dentro de un for, dentro de un while, etc. Ejemplo declarar una variable del tipo —> let
  2. Global: Al ser declaradas pueden ser usadas y son accesibles dentro de todo el archivo. Estas se declaran en el objeto global, en este caso de uso, se irán al objeto window (de ser usada en el browser), estas se usan declarando la variable con el tipo ——→ var

Paréntesis aquí, porque yo también me quedé cómo queeeeeeeeeeeeeeeeee.

Lo que pasa es que al declarar una variable para que sea usada de manera Global, JavaScript internamente busca asociarla al objeto contenedor más grande, como el root del CSS (al menos así lo entendí yo), sería el window del navegador (browser), entonces, al usar JavaScript y declarar una variable así:

var nombre = 'Aldo';

Lo que hace realmente JavaScript, es asignarla dentro del objeto contenedor más grande del browser, en este caso la misma ventana en sí, es decir, el objeto, window, entonces tras bambalinas, secretamente JavaScript hace esto (a pesar que no la declares así):

var window.nombre = 'Aldo';

Y toda variable de uso global que declaremos en el browser, será declarada dentro del objeto window 😃.

Cuando pasamos un valor a una función (argumento), el valor dentro de esta función solo puede ser usada dentro del **scope (**alcance) de la función.

Les comparto el código de la clase:

//5th Lesson: Functions scope
var myName2 = 'Aldo';

function printNameInUpperCase(n){
    n = n.toUpperCase();
    console.log(n);
}
printNameInUpperCase(myName2);
La variable n como sabe que es nombre???

¿Alguien sabe si en Platzi hay cursos que hagan referencia a las buenas prácticas en programación?, o si conocen algún material o sitio que me sirva podrian indicármelo por favor 😉

La Desestructuración no solo es valida para los objetos, podemos desestructurar variables.

var [ color1 , color2 ] = [ 'Rojo', 'Azul'];

console.log(color1); // Rojo
console.log(color2); // Azul

Aporte de resumen de la clase

// RESUMEN DE LA CLASE: 'ALCANCE DE FUNCIONES'
// - Declaramos la existencia de la variable 'nombre' cuyo valor, en este caso, 
//   es 'Fernando'
var nombre ='Fernando'

// - Ahora vamos a presentar 2 casos:
//   ---> 1er caso:

          function imprimir_Nombre_Mayusculas(){
            nombre = nombre.toUpperCase()
            console.log(nombre)
          }

          imprimir_Nombre_Mayusculas()   

//        En este caso, como a la funcion 'imprimir_Nombre_Mayusculas' 
//        no se definio ningun parametro, entonces, la variable 'nombre' 
//        seria un tipo de variable de alcance global por lo que el valor 
//        de esta variable se modificara dentro de la funcion. A esto le 
//        llamamos ' Side Effect '(Efecto de lado) o Daño colateral.

//   ---> 2do caso:
          function imprimirNombreEnMayusculas(nombre){
            nombre = nombre.toUpperCase()
            console.log(nombre)
          }

          imprimirNombreEnMayusculas(nombre)

//        En este caso a la funcion 'imprimirNombreEnMayusculas' se le 
//        definio un parametro 'nombre' (no importa si se nombra igual a 
//        la variable). El valor de la variable global 'nombre' no se 
//        cambiara dentro de la funcion ya que se le añadio un parametro 
//        a la funcion , para redundar. 

var nombre
nombre= 'francisco’
var apellido
apellido= 'Velasco’
var edad
edad=51
console.log('Hola su nombre es: ’ + ‘’ + nombre + ’ ’ +‘como estas? tu edad es de’+ ’ ’ + edad);
//var nombreEnMayuscula
var nombreEnMayuscula = nombre.toUpperCase()
var apellidoEnMinuscula = apellido.toLowerCase()
var ultimoCaracterNombre = apellido.charAt(1)
var longitudApellido = apellido.length
var nombreCompleto = ${nombre} ${apellido.toLowerCase()}

Resumen de la clase
Hay dos tipos de variables: Globales y Locales
-Variables Globales -> Pueden ser accedidas desde cualquier función
-Variables Locales -> Pueden ser utilizadas solamente en la función declarada

RESUMEN:

En esta clase vemos el Scope de las funciones. En el siguiente resumen, incluyo código comentariado, y esta vez la palabra reservada let, que es una forma de declarar variables de manera explícitamente local.


// El scope habla sobre alcance que tienen las variables dentro de nuestro código
var name= " Alejandro-sin " // Esto es una variable global, pues todas las funciones pueden acceder a esta variable, se asigna a un objeto global.

function imprimeNombreGlobal(){
    console.log(name);
    console.log(n);// Me retorna undefined, ya que n solo existe en imprimeNombreLocal(),por lo que no puedo llamarla.
}
imprimeNombreGlobal()

// Variables locales solo existe dentro de la función.

function imprimeNombre(n){
    n= "Etrx"
    console.log(n);
}
imprimeNombreLocal()

//JS permite usar los mismos nombres dentro de las funciones. Así nomrbe puede existir dentro y fuera de la función. No afecta a la variable global.

function imprimeNombre(name){
    name= "Etrx"
    console.log(n);
}
imprimeNombreLocal()

// Cabe aclarar que existe una forma de declarar variables mediante let. Let solo existe de manera local.

let name = "Alejandro-Sin"
console.log(name);

function imprimeNombre(){
    console.log(name); // Debido a que let solo declara de manera local, la función no reconoce a name.
}
imprimeNombreLocal()

Toda función en JavaScript es un objeto Function. Ver Function para obtener información sobre las propiedades y métodos de los objetos Function.

Las funciones no son lo mismo que los procedimientos. Una función siempre devuelve un valor, pero un procedimiento, puede o no puede devolver un valor.

Para devolver un valor especifico distinto del predeterminado, una función debe tener una sentencia return, que especifique el valor a devolver. Una función sin una instrucción return devolverá el valor predeterminado. En el caso de un constructor llamado con la palabra clave new, el valor predeterminado es el valor de su parametro. Para el resto de funciones, el valor predeterminado es undefined.

Los parámetros en la llamada a una función son los argumentos de la función. Los argumentos se pasan a las funciones por valor. Si la función cambia el valor de un argumento, este cambio no se refleja globalmente ni en la llamada de la función. Sin embargo, las referencias a objetos también son valores, y son especiales: si la función cambia las propiedades del objeto referenciado, ese cambio es visible fuera de la función

No entiendo la parte de Window.nombre, alguien me podria explicar??

Explicación sencilla cualquier variable que este declarada en una función solo vivira en si misma osea en la función

Clase indispensable para el correcto uso de las funciones.

Excelente explicación, he comprendido a detalle el alcance de las funciones. Muchas gracias!

Tambien hay q definir q las funciones se cargan de primero en memoria antes q el resto de codigo

profe, quisiera aportar de que existen varios tipos de variables , como lo son: constantes , variables var y variables less, seria excententen hablar de sus diferencias

Está clase es muy importante el saber el uso de variables globales y locales ya que podemos tener un error que no encontramos y no lo señala.

Está buena practica se lleva a cabo en creación de frameworks.

Se debe evitar al máximo contaminar el scope global…

hubiera estado bueno aca tambien profundizar con respecto a var y let

Side Effect
Efecto de lado es cuando en una función manejas variables que no están definidas dentro de ella. Toca cosas que no le corresponde.

En otro curso de JavaScript mencionaban el Hoisting.
Para evitar el hoisting debemos declarar las variables y funciones antes de la ejecución del código.

Es muy interesante el uso del mismo nombre para la variable, tanto local como global, pero siento que después puede dificultar la lectura del código.

<var nombre = 'john';

function imprimirNombreEnMayus(nombre) {
    console.log(window.nombre); // global

    nombre = nombre.toUpperCase();
    console.log(nombre); // local

}
// alcance local solo existe en el cuerpo de la funcion
// alcance global var nombre windows.nombre 
imprimirNombreEnMayus('johncito');>

Un resumen de la clase.

var nombre = 'Daniel'; // Variable global, accesible desde cualquier parte del codigo

// function imprimirNombreEnMayusculas(){
//   nombre = nombre.toUpperCase(); // efecto de lado, se modifica la variable global, lo cual no deberia pasar
//   console.log(nombre);
// }

// imprimirNombreEnMayusculas();

function imprimirNombreEnMayusculas(nombre){
  nombre = nombre.toUpperCase(); // Evitando efecto de lado, definiendo una variable local
  console.log(nombre);
}

imprimirNombreEnMayusculas(nombre);

Las variables globales son las que están declaradas en el ámbito más amplio posible, mientras que las variables locales son aquellas a las que solo accederemos dentro del lugar donde se ha declarado.

Aqui algo de información acerca de el Scope en Js, esta imagen nos permite visualizar de que podemos alcanzar desde una función o desde un objeto global, la grafica inicia desde el centro.

“El scope de una variable hace referencia al lugar donde esta va a vivir , o podrá ser accesible. … Podríamos decir también que scope es el alcance que determina la accesibilidad de las variables en cada parte de nuestro código”

Pondré ejemplos muy variados de lo que he entendido al experimentar

var nombre = "Dann"
functionconvertirMayusculas1 (n) {
    console.log("1 " + n)  //"Antes de ser modificada" Solo se le pasó como  parametro el valor
    n = n.toUpperCase()   
    console.log("2 " + n)  //Ya fue modificada pero NO existe en scope global
}  convertirMayusculas1(nombre);
//------------------------------------------------------->>
var nombree = "Dann"
functionconvertirMayusculas2 () {
    console.log("3 " + nombree)  //No encontro el parametro y lo busco en el scope superior, que es el global
    nombree = nombree.toUpperCase() 
    console.log("4 " + nombree)   //Ya fue modificada TAMBIEN en scope global por que fue reasignado su valor, ya que se trajo la variable global a este scope, por lo que si puede vivir fuera
}                                
convertirMayusculas2();
//-------------------------------------------------------->>
var nombreee = "Dann"
functionconvertirMayusculas3 (persona) {
    nombreee = persona.toUpperCase()
    console.log("5 " + nombreee) //Ya fue modificada y TAMBIEN en scope global por reasignación, ya que se trajo la variable global a este scope, por lo que si puede vivir fuera
    console.log("6 " + persona)  //No fue modificada por supuesto y NO existe en scope global porque fue declarada dentro dentro de la función de forma implicita como parametro
}
convertirMayusculas3(nombreee)
// ------------------------------------------------------>>
var nombreeee = "Dann"
var convertirMayusculas4 = (persona) => {
    var nombreeee = persona.toUpperCase()
    console.log("7 " + nombreeee) //Ya fue modificado pero NO en scope global porque esta variable fue declarada en este scope y no puede vivir fuera
    console.log("8 " + persona)  //No fue modificada por supuesto y NO existe en scope global porque fue declarada dentro de la función de forma implicita como parametro
}
convertirMayusculas4(nombreeee)

Bueno, este código lo puedes copiar y revisar en la consola de la siguiente forma y ver como cambia o no en el scope global comparando lo que salió de los console.log y al declarar el global, aun lado del código puse una explicación del porque en cada caso

Luego ir revisando cada uno de estos que menciono, te das cuenta que así funciona, aunque bueno, eso es lo que creo al interpretar su comportamiento, espero les sirva.

les recomiendo el cuso de javascript básico antes de este curso!

Leyendo los comentarios vi algo sobre definir variables con let así que mi pregunta es ¿ Cuándo usar var y cuando usar let. ?

Las variables globales son, de hecho, propiedades del objeto global. En las página web el objeto global es window, puede establecer y acceder a las variables globales usando la sintaxis window.variable.

Por lo tanto, puedes acceder a variables globales declaradas en una ventana o frame de otra ventana o frame especificando el nombre de la ventana o frame. Por ejemplo, si una variable denominada phoneNumber es declarada en un documento, puede consultar a esta variable desde un iframe como parent.phoneNumber.

Al declarar una variable sin la palabra reservada var la variable pasa a estar disponible en el contexto global.

function local() {
     nombre = "bryan";
    //console.log(nombre)
}
local();
console.log(nombre)

Por qué ocurre esto ?

Hola que tal veo que la mayoria que vienen a este curso poseen poco conocimiento de programacion, les recomiendo ver el curso de Java Basico SE para que este curso en particular se les haga completamente facil. Saludos a todos.

Algo a no olvidar es lo poco tipado que es JS, puede ser buno o malo

// declaracion de variables

// variable global
var nombre = ‘Claudia’

//funcion
//variable local n

function imprimirnombreenmayusculas(nombre) {
window.nombre //para llamar a la variable global
nombre = nombre.toUpperCase()
console.log(nombre)
}

imprimirnombreenmayusculas(nombre)

Los alcances de las variables locales creo que es un tema de mucho cuidado, aún no me queda muy clara la última parte.

Muy buena explicación, de cualquier forma deben saber que una buena practica de escritura de código es no llamar a **dos ****variables **de la **misma **forma, simplemente no es practico.

antes del segundo 0.45, pause el video y lo trata de hacer por mi misma, salio feo pero funciona

<code>
function nMuyuscula()
{
    console.log(`${nombre.toUpperCase()}`)
}

nMuyuscula()

Genial!

En ingles, es llamado Scope

Muy buena clase y me quedo claro el concepto de variable local y global. Anteriormente había estudiado otros materiales, pero no me había quedado tan claro como hasta ahora.

En conclusión se puede decir que las funciones tienen solo alcance de funcionalidad dentro de ellas mismas.

Por ejemplo si definimos una variable dentro de una función esta variable va a ser exclusiva de la función y su valor asignado igual.

Por eso como lo dice Freddy en el curso de programación básica
Si vamos a usar una variable en mas de una función debemos definirla fuera de estas

en el minuto 6:15 hablas sobre la variable n, pero n nunca fue definida como variable, n solo es parametro. corrijanme si me equivoco.

La mejor explicación sobre el alcance de las variables.
Creo que entender este punto, es esencial para usar cualquier lenguaje de programación.

// var nombre: es una variable global
var nombre = 'Carlos';

//El parametro es: nombre
function imprimirNombreEnMayusculas(nombre){
  // var nombre: es una variable local en este caso. Se le asigna el valor del parametro
  nombre = nombre.toUpperCase();
  console.log(nombre);
}

imprimirNombreEnMayusculas(nombre);```

Side effect (efecto secundario): cuando se modifican cosas que están fuera del alcance de la función. En este caso se cambia el estado de la variable global "nombre".

Toda Variable que no este definida
dentro de una Funcion va a estar definida
dentro del alcance global y vamos a poder
acceder a ella atrabes del objeto global,
(en el caso del navegador es “Window”,
en un worker es “WorkerGlobalScope”,
en Node desde “global”)

Notas de la clase:

//Variable de alcance global (porque está fuera de una función):
var nombre1 = 'Mirna'
var nombre2 = 'Mabel'

//Función con Side Efect (modifica la variable de alcance global):
function imprimirNombreEnMayusculas() {
    nombre1 = nombre1.toUpperCase()
    console.log(nombre1)
}

imprimirNombreEnMayusculas()
//Como vemos, cambia el valor de la variable global  nombre
console.log(nombre1)

//Para modificar sólo la variable de alcance local:
function imprimirNombreEnMayusculas1(n) {
    n = n.toUpperCase()
    console.log(n)
}

imprimirNombreEnMayusculas1(nombre2)
//Como vemos, no cambia el valor de la variable global nombre2
console.log(nombre2)

//También se puede hacer local a la variable global sin modificarla en el ámbito global:
function imprimirNombreEnMayusculas2(nombre2) {
    nombre2 = nombre2.toUpperCase()
    console.log(nombre2)
}

imprimirNombreEnMayusculas2(nombre2)
//Como vemos, no cambia el valor de la variable global nombre2
console.log(nombre2)

por eso nacio el let

ALCANCE DE LAS FUNCIONES

- Si la variable no esta definida dentro de una funcion se le llama alcance GLOBAL
- Se puede acceder desde cualquier funcion
- Si la variable es global se le asigna al objeto global llamado WINDOW
- SIDE EFECT - Es un efecto de lado/colateral, afecta variables que no estan definidas dentro de funciones
               Cambiar el valor de una variable global dentro de un metodo
               Si se agrega un parametro dentro del método con eso cambia

Apuntes:

Las variables globales son las que están declaradas en el ámbito más amplio posible, mientras que las variables locales son aquellas a las que solo accederemos dentro del lugar donde se ha declarado.

es un poco complicado entenderlo al principio pero con un poco de practica se va entendiendo mucho mejor

Resumiendo. el alcance hace referencia a cuáles variables puede acceder una función.
 
Las variables dentro de una función se denominan Locales y solo son accesibles por dicha función, no sucede así con las de afuera (window), llamadas Globales.
 
En el ejemplo, tenemos una variable global (‘Sacha’) y una función la cual su instrucción es convertir a Mayúsculas la variable local (de mismo nombre).
 

 
 Para evitarlo, agregamos un atributo a la función, siendo en este caso nombre y no afectará el Side Effect, porque dicha declaración fuerza a la variable local.
 

Excelente!

Alcance de las funciones:
Si una variable no está definida dentro del cuerpo de una función, se dice que es de alcance global.
Para poder reutilizar una función es necesario que acepte parámetros.
Side Effect: va a modificar cosas que no le corresponden.
Para no modificar una variable dentro de una función se envían parámetros.
Parámetros: solo existe enel cuerpo de la función.
Se puede utilizar el mismo nombre en una variable global y en un parámetro.
Toda variable que no esté definida dentro de una función va a estar definida dentro del alcance global y se va a poder acceder a ella a través del objeto global.

Variable global

Objeto global

Interesante

nombre: Existe en el alcance global
n: Existe solo en el alcance local de la función imprimirNombreMayusculas()

var nombre = 'KarlxS'

function imprimirNombreMayusculas(n)
{
    n = n.toUpperCase()
    console.log(n)
}

imprimirNombreMayusculas(nombre)```

Si queremos que **nombre** exista en el local y global al mismo tiempo, el parámetro **n** lo reemplazamos por **nombre**
//El alcance de las funciones

//Variable global: accesible por todos
var nombre = 'Alison';

//funcion que devuelve una variable String en Mayusculas
function imprimirNombreEnMayusculas1(){
  //Se obtiene el valor desde la variable global "nombre", esto provocará un cambio en el valor de la variable global. Cosa que no es recomendada
  nombre = nombre.toUpperCase();
  console.log(nombre)
}

 //llamamos a la funcion
imprimirNombreEnMayusculas();

//para poder evitar una modificacion indeseada de la variable global se define en la funcion su alcance, es decir, se utiliza una variable local que llega por parametro

//declaramos una funcion que solicita un parametro "n"
function imprimirNombreEnMayusculas2(n){
  //Se obtiene n a traves del parametro de la funcion, solo se modificará el valor de n dentro de la función
  n = n.toUpperCase();
  console.log(n);
}

//llamamos a la funcion y le entregamos la variable "nombre" para que sea modificada SOLO dentro de la funcion, asi la variable global queda intacta
imprimirNombreEnMayusculas2(nombre);

``var nombre = ‘tomas’, apellido = ‘herrou’, edad = 28;
function datosPersonales(n, a, e) {

console.log(${n} de apellido ${a} tiene ${e} años )

}
datosPersonales(nombre, apellido, edad);
datosPersonales (‘tomas’, ‘herrou’, 28);
datosPersonales (‘maria’, ‘gonzalez’, 20);
datosPersonales (‘luciano’, ‘herrou’, 40);`

`

Excelente explicación sobre las funciones, es la manera correcta de hablarle a un principiante, tantas variables repetidas me mareaban y hasta ahora comprendo cada detalle.
buen maestro Sacha.

var nombre = 'Alberto'

function imprimirNombreEnMayusculas(nombre)
{
    nombre = nombre.toUpperCase()
    console.log(nombre)
}

imprimirNombreEnMayusculas(nombre)```

😃

En la descripción de esta clase se habla del alcance de las funciones, debería llamarse El Alcance o Ambito de las Variables. (Variables Globales, Variables Locales). Pero como diría Freddy. ¿A quien le importa? bla, bla, bla, bla…