Forem: Karen Molina

Variables, tipos de dato, scope.

Karen Molina — Wed, 07 Jun 2023 03:44:54 +0000

Hace casi dos años escribía un post sobre el mismo tema, pero en estos meses, he descubierto que además de la importancia de escribir en español. Que siempre es un mar de información en el que te tienes que andar metiendo para entender cosas, sobre todo con JS, que es raro, pero así lo queremos <3.

Tipo de datos

Los tipos de datos son importantes en cualquier lenguaje de programación. En el caso de JS, tenemos dos clases de datos: los primitivos y los de tipo objeto.

Datos primitivos

Booleano (Boolean): Pueden representar dos valores lógicos: verdadero (true) y falso (false).
Null: Representa un valor nulo.
Undefined: Representa una variable que no ha sido asignada por un valor.
Número (Number): Como su nombre lo indica, podemos representar cualquier número.
BigInt: En JS tenemos dos tipos de números, el BigInt representa un valor exacto como los exponentes, algo así como: 2n ** 53n.
Cadena de texto (String): Representa datos textuales, por ejemplo: "Hola olla".
Symbol

Datos tipo objeto

Objetos
Arreglos
Funciones

Los objetos y arreglos son los que conocemos de siempre.

Tuplas
Records

Éstos tipos de dato son nuevos y son muy similares al objeto y al array, pero cambia en unas cosas. Son inmutables, se trabaja con ellos por su valor y no por referencia... y tienen otras cosas medio chulas de las que iré escribiendo en otros posts.

Variables

Se pueden definir de dos maneras: 1) una variable es un espacio almacenado en la memoria, 2) una variable es un contenedor para algún dato o valor. En JS tenemos tres formas de declarar estos valores:

var
let
const

var

Antes de EcmaScript 6 teníamos una manera de declarar nuestras variables y era con la palabra reservada "var". Pero eso nos daba un par de problemas; el primero era que podíamos
duplicar las declaraciones y podríamos reasignar los valores. Suena a que no es un problema, pero si no teníamos el cuidado suficiente al trabajar nuestras variables, éstas podrían cambiar sin darnos cuenta. Ya que "var" nos permite la reasignación y la redeclaración.

//var

var sayHello = "Hola olla"

console.log(sayHello) // "Hola olla"

var sayHello= "Hi!"

console.log(sayHello) // "Hi"

let

Con la llegada de ES6, el problema de reasignación de variables con var, termina. Especialmente cuando usamos la palabra reservada let dentro de las llaves { }. Así que además de darnos una keyword nueva, nos introduce a un nuevo scope; llamado: Block scope o alcance de bloque.

//let 

let sayHello = "Hola olla"

console.log(sayHello) // "Hola olla"

sayHello = "Hi!"
console.log(sayHello) // "Hi"

let sayHello= "Hi!"

console.log(sayHello) // error: Identifier 'sayHello' has already been declared

const

La palabra reservada "const" nos ayuda a guardar valores que nunca tendrán que reasignarse.

// const

const sayHello = "Hola olla"

console.log(sayHello) // "Hola olla"

sayHello = "Hi!" // error: Assignment to constant variable. 

const sayHello= "Hi!" // error: Identifier 'sayHello' has already been declared

"const" es interesante, porque mientras lo relacionamos con variables constantes o que no cambian, en realidad no es tan así. De hecho se comporta diferente dependiendo el tipo de dato. En los datos primitivos tiene mucho sentido que con esta forma de declarar la variable, nos sea imposible reasignarla. Por lo que pareciera que "const" es de constante o para declarar variables inmutables, pero no es así.

En los datos primitivos, las variables con "const" funcionan como de sólo lectura. Pero en los datos de tipo objeto, podemos cambiar propiedades del valor asignado a la variable. ¿khá?


const gato = { name: "Simón" }

//Si queremos cambiar el nombre 
//NO tenemos que hacer lo siguiente

gato = { name: "Tito" }

// De la forma anterior, no estamos cambiando 
//una propiedad del valor asignado, estamos 
//reasignando el valor de const. Entonces, 
//para poder cambiar una propiedad, 
//lo tenemos que hacer de la siguiente manera: 

gato.name = "Tito"
console.log(gato.name) // "Tito"

// Ejemplo con arreglos

const frutas = ["Manzana", "Pera", "Fresa", "Melón"]
console.log(frutas[2]) // "Fresa"
frutas[2] = "Uvas"
console.log(frutas[2]) // "Uvas"

Scope

Ya llega la hora de hablar del scope. Entender el scope nos ayudará mucho a la hora no solo de declarar nuestras variables, sino a entender muchas cosas a la hora de programar y pensar cómo solucionar nuestros problemas técnicos. El scope determina el alcance de nuestras variables. Con JS tenemos tres tipos de scope: 1) global, 2) scope de función y 3) scope de bloque. Aunque en realidad podríamos agregar otros dos: local y de módulo.

Alcance global: Cuando declaramos variables fuera de cualquier función, automáticamente se convierte en una variable de alcance global.
Alcance de función: Cada vez que creamos funciones, se crea automáticamente un nuevo scope dentro de la nueva función. Eso significa que cada vez que declaramos variables dentro de una función, esa variable tendrá alcance o visibilidad dentro de esa función y no se podrá acceder a ella fuera de la función.
Alcance de bloque: el alcance de bloque llega a JS en 2015 con ES6, cuando se introducen let y const. Esto significa que cualquier variable declarada dentro de las llaves { } sólo pueden ser visibles dentro de ellas.
Alcance de Módulo: Cuando creamos un nuevo módulo, todas las variables que estén dentro del archivo aunque se encuentren fuera de funciones o llaves, en teoría podrían ser consideradas como variables globales; sin embargo, esas variables sólo tienen alcance a nivel de módulo, excepto cuando importamos explícitamente el módulo en otro archivo.

Extra || Valor o referencia en JS

Cuando declaramos una variable, ésta se almacena en algún lugar de la memoria. Pero, funciona diferente para los datos primitivos y los de tipo objeto. Así que vamos por un ejemplo:

let a = 1
console.log(a) // 1
let b = b
console.log(b) // 1
a = 2 
console.log(a) // 2
console.log(b) // 1

Acá pasa algo bien raro, bueno no raro, pero sí interesante. Cuando declaramos una variable y le asignamos un valor, éste queda almacenado en un lugar, pero cuando le asignamos la primera variable a otra variable, se crea una copia del valor y al mismo tiempo se vuelven independientes una de la otra; por lo tanto, por más que modifiquemos "a", el valor de "b" seguirá siendo 1.

Pero en el caso de los objetos pasa algo curioso:

const fruta = { name: "Fresa", color: "red" }

Ahí ya tenemos una variable que guarda un objeto. Que como ya sabemos, podemos modificar las propiedades de ese valor de fruta. Pero, a diferencia de los valores de los datos primitivos, en los objetos no se crean copias, lo que hace JS es apuntar al espacio de memoria donde guarda ese objeto y modifica sus propiedades. Entonces, si modificamos muchas veces las propiedades del objeto fruta, modificaremos los valores del objeto original, porque los cambios de hacen por referencia a ese espacio de memoria.

const fruta = { name: "Fresa", color: "red" }
const fruta2 = fruta
console.log(fruta) // { name: "Fresa", color: "red" }
console.log(fruta2) // { name: "Fresa", color: "red" }

fruta.name = "Manzana"
console.log(fruta) // { name: "Manzana", color: "red" }
console.log(fruta2) // { name: "Manzana", color: "red" }

Así que cuando trabajemos con datos primitivos podemos estar seguros que manejamos valores, mientras que cuando usemos objetos, estaremos trabajando con referencias. Es por ello que es importante conocer conceptos como inmutabilidad o la importancia de la inclusión de Records y Tuplas como nuevos tipos de dato.

Hoisting: Some exercises.

Karen Molina — Fri, 03 Dec 2021 00:28:16 +0000

Hello!

This time we will review the hoisting and the scope, one more time. Previously, we check them as concepts. But now, we going to realize come exercises to see how the hoisting and scope work inside the JS engine.

Remember in JS we have three ways to make a declaration: var, let and const.

console.log(variable) // undefined
var variable = "Hi";
console.log(variable) // Hi

In this case, if we call the variable with the keyword "var" before the initialization, JS returns an undefined value. That's happened because, with the hoisting, anything variable with a "var" keyword has been moved at the top. So, JS moves the initialization, but not the value or the assignation. The value has been assigned in line 2.

What happens if we try to call our variables with the keywords "let" and "const" before the initialization?
Let's see below:

console.log(variable2)
console.log(anotherVariable)

let variable2 = "Hi, i'm a let"
const anotherVariable = "Hi, i'm a const"

//ReferenceError: Cannot access anotherVariable' before initialization
//ReferenceError: Cannot access 'variable2' before initialization

In this case, we see that JS gives us an error, a specific error called: Reference Error, that's means that JS does not hoist the declarations with those keywords.

Another issue with the hoisting happens in the functions. In this case, we must see some examples as to how the some of functions can be affected by the hoisting.

console.log(sum(2,3)) //5
function sum(num, num2) {
    return num + num2
}

console.log(sum2(2,3)) //ReferenceError: Cannot access 'sum2' before initialization
const sum2 = function(num1, num2) {
    return num1 + num2
  }


console.log(sumNumbers(2,3)) // ReferenceError: Cannot access 'sumNumbers' before initialization
const sumNumbers = (num, num2) => num + num2

In this case and always all the functions as function declaration have moved at the top like the variable with "var", but with a small and important difference, in this case, the function work. Why? The reason is that JS moves not just the initialization as a variable, JS moves the scope too. Meanwhile, a function expression and the arrow functions never will be moved at the top, and JS shows us a reference error if we invoke them before an initialization.

Asynchronous JavaScript: callbacks, promises and async/await.

Karen Molina — Thu, 28 Oct 2021 02:40:45 +0000

Hi!

First JavaScript is a single-threaded programming language, which means only one thing can happen at a time. That happen, because the JavaScript engine can only process one statement at a time. So, the asynchronous is the action that do not happen at a time. And, Why is important understand the asynchronous in JS?. Always we work with data, sometimes we have to work with some APIs and depending the situation the server take some time to process the request at a time block the tread making the web unresponsive. That's where asynchronous comes into play.

JavaScript has three ways to handle the asynchronous: callbacks, promises and async/await.

Callbacks

A callback is a function passed into another functions as an argument.

function myName(name) {
  return name
}

function hello(callback) {
  console.log("Hello" + " " + callback)
}

hello(myName("Karen")) // Hello Karen

In this case, we have two functions, in the first, we need to get a value: name. So, we get it within a function. In the second function, we use the value that we returned at the first function and we use it in the second. So, to make it successful, we're going to passe the myName functions as a parameter inside the hello function.

Promises

A promise is a special object in JavaScript, 'cause that links the producer code and consuming code. When we talk about producer code, we must through something that takes time to be processed. And the consuming code as something to provide us a result.

A promise has two properties: the state and the result.
The state can be: pending, fulfilled and rejected.
The result can be: undefined, a result value or an error object.

Now the syntax for a promise is next:

let thePromise = new Promise(function(resolve, reject) {
  resolve("done");
  reject(new Error("…")); 
});

Inside a promise, we have two arguments: resolve and reject. Both arguments are callbacks provided by JS. The resolve callback is being executed if the job is finished successfully. Meanwhile, the reject is be executed if an error has occurred.

Async/Await

Make the promises easier to write within two keywords:
1.- Async: Makes a functions return a promise.
2.- Await: Makes a functions wait for a promise.

const myName = (name) => name

const hello = async () => {
  const result = await myName("Karen")
  console.log(`Hello ${result} `) // Hello Karen
}

Coding Interview: Functions and closure.

Karen Molina — Thu, 23 Sep 2021 04:53:02 +0000

Hi!

Now we going to review the functions and the closure.

Functions

A function is similar to a procedure. A set or statements that performs a task. Also, a function in JS is a high-level object.

We have many different ways to create functions.

A function has a particular syntax.

Function declaration

A function declarations is the most easy mode to create a functions, just we must to use the keyword "function", followed by the name of the functions, the parameter inside parenthesis and the curly brackets with the statements.

function sum (num1, num2) {
  return num1 + num2
}

sum(2,4) // => 6

Function expression

For the beginners is easy to confuse the function declaration and functions expression. 'Cause both look very similar.

But the functions expression does not start with "function" keyword. Here, the functions is created at the right side of the "assignment
expression" =:

const sum = function(num1, num2) {
  return num1 + num2
}

sum(2,4) // => 6

IIFE (Immediately Invoked Function Expression)

An IIFE is a way to execute a function immediately after creation.

(function() {
  console.log("Hello World") // Hello World
})()

Arrow Function

In 2015 with ES6, the arrow functions was introduced. This way to create functions allow us to write with a shorter syntax.

const sum = (num1, num2) => {
  return num1 + num2
}

sum(2,4) // => 6

Another feature introduce it was that return value by default. If the function has only one statement, the statement returns the value without the curly brackets

const sum = (num1, num2) => num1 + num2

sum(2,4) // => 6

Constructor

In JS, a constructor is used to create objects. The purpose of a constructor is to create an object and set some of values. Is a simple way to create an object because we don't need to explicitly state what to return. By default, return the values which the constructor has been created.

function User(first, last) {
  this.firstName = first
  this.lastName = last
}

let user1 = new User("Jon", "Snow")
console.log(user1)
let user2 = new User("Ned", "Stark")
console.log(user2)

Closure

First, when we invoke a function, this create a new scope, with local variables. A closure is a function which has accessibility to variables and parameters from another function's scope.

function sayHi() {
  let hello = "Hola"
  function innerSayHi(){
    console.log(hello)
  }
  return innerSayHi
}

let inner = sayHi()

sayHi() // "Hola"

JavaScript: Variables, tipos de dato, scope y el hoisting.

Karen Molina — Sat, 18 Sep 2021 04:38:30 +0000

¡Hola de nuevo! :3

Algunas de las cosas básicas que tenemos que entender a la hora de querernos meter a aprender JavaScript son: variables, tipos de datos, scope y el Hoisting. En realidad, siempre estaremos o casi siempre estaremos en interacción con datos, ya sea que vengan del lado de nuestros servicios o datos con lo que tenemos que nos va a brindar el usuario. Así que como no podemos escapar de ellos, tenemos que aprender a manejarlos.

Tipo de datos

Los tipos de datos son importantes en cualquier lenguaje de programación. En el caso de JS, tenemos dos clases de datos: los primitivos y los de tipo objeto. Dentro de los primitivos podemos encontrar diferentes tipos de datos:

Booleano (Boolean): Pueden representar dos valores lógicos: verdadero (true) y falso (false).
Null: Representa un valor nulo.
Undefined: Representa una variable que no ha sido asignada por un valor.
Número (Number): Como su nombre lo indica, podemos representar cualquier número.
BigInt: En JS tenemos dos tipos de números, el BigInt representa un valor exacto como los exponentes, algo así como: 2n ** 53n.
Cadena de texto (String): Representa datos textuales, por ejemplo: "Hola olla".

Variables

var
let
const

var

//var

var sayHello = "Hola olla"

console.log(sayHello) // "Hola olla"

var sayHello= "Hi!"

console.log(sayHello) // "Hi"

let

//let 

let sayHello = "Hola olla"

console.log(sayHello) // "Hola olla"

sayHello = "Hi!"
console.log(sayHello) // "Hi"

let sayHello= "Hi!"

console.log(sayHello) // error: Identifier 'sayHello' has already been declared

const

La palabra reservada "const" nos ayuda a guardar valores que nunca tendrán que reasignarse.

// const

const sayHello = "Hola olla"

console.log(sayHello) // "Hola olla"

sayHello = "Hi!" // error: Assignment to constant variable. 

const sayHello= "Hi!" // error: Identifier 'sayHello' has already been declared

Scope

Alcance global: Cuando declaramos variables fuera de cualquier función, automáticamente se convierte en una variable de alcance global.
Alcance de función: Cada vez que creamos funciones, se crea automáticamente un nuevo scope dentro de la nueva función. Eso significa que cada vez que declaramos variables dentro de una función, esa variable tendrá alcance o visibilidad dentro de esa función y no se podrá acceder a ella fuera de la función.
Alcance de bloque: el alcance de bloque llega a JS en 2015 con ES6, cuando se introducen let y const. Esto significa que cualquier variable declarada dentro de las llaves { } sólo pueden ser visibles dentro de ellas.
Alcance de Módulo: Cuando creamos un nuevo módulo, todas las variables que estén dentro del archivo aunque se encuentren fuera de funciones o llaves, en teoría podrían ser consideradas como variables globales; sin embargo, esas variables sólo tienen alcance a nivel de módulo, excepto cuando importamos explícitamente el módulo en otro archivo.

Hoisting

A veces JS hace cosas raras. Creo que el Hoisting es una de esas y si no lo entendemos podemos cometer algunos errores o bueno, tener algunos bugs algo raros. El Hoisting es un comportamiento que JS tiene por defecto y lo que hace es elevar todas las declaraciones. Cuando digo "elevar", me refiero a que coloca todas las declaraciones al inicio de su scope. Ese elevamiento no es literal, justo pasa cuando JS está en el proceso de compilación cuando JS hace un chequeo de todas las variables que requieren de algún espacio en la memoria.

Gracias por leer y con gusto espero feedback :D

HTML: Una cosa llamada !DOCTYPE

Karen Molina — Sat, 18 Sep 2021 02:41:30 +0000

¡Hola, ahora en español!

Pues la idea de la serie de conceptos sobre cosas de frontend, es poder ayudarles a preparar sus entrevistas técnicas y por otro lado, me ayuda a repasar cosas que de pronto se olvidan.

En HTML existe una cosa llamada !DOCTYPE. Primero, debemos de saber que no es una etiqueta del HTML. Ahora bien, aunque no es un tag, es una keyword o declaración importante dentro de nuestros archivos de HTML.

Primero, pues cualquier cosa que hagamos, el navegador es el encargado de interpretar lo que estamos construyendo. En un inicio se supone que el !DOCTYPE se encagaba de avisar al navegador el tipo de documento que tendría que esperar, pero actualmente lo que informa es el versionado del HTML que estamos usando en el proyecto.

En el caso de HTML 5, la declaración es muy fácil, pues solo tenemos que poner:

<!DOCTYPE html>

La declaración anterior no indica explícitamente que sea un archivo de HTML 5, en realidad es una declaración por default, dado que antes del HTML5 se tenían que agregar algunos elementos de DTD que sí especificaran la versión del HTML que estábamos usando.

Por ejemplo, para especificar un HTML 4, teníamos que colocar algo así:

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

Otra cosa a resaltar es que nuestro !DOCTYPE no es 'case sensitive', esto quiere decir que no importa si lo escribimos en mayúscula o minúscula; el navegador podrá interpretarlo.

Coding Interview: Variables, data types, scope and hoisting in JS

Karen Molina — Thu, 16 Sep 2021 05:36:29 +0000

Hi!

Some of things we have to know about JS are: variables, data types, scope and hoisting. Why? 'Cause every time we use, transform and manipulate a lot of data. No matter if the data came from our services or the frontend.

Data Types

The Data types are important in every programming languages. In JS we have two classes of types: primitives and objects. Primitives contains different data types:

Boolean: represent two logical values; true and false.
Null: literal represent a null value.
Undefined: A variable has not been assigned a value.
Number: Any number
BigInt: In JS we got two types of numbers, the BigInt means that we have to assign one exact value as: 2n ** 53n
String: represent textual data. Example: "Hola olla"

Variables

A variable is a container for a data or value. In Javascript we have 3 ways to declare it:

var
let
const

var

Before EcmaScript 6, we use only the keyword var to storage our values. But with only one way to declare variables, we got a problem, all the var variables can be redeclared and updated.

//var

var sayHello = "Hola olla"

console.log(sayHello) // "Hola olla"

var sayHello= "Hi!"

console.log(sayHello) // "Hi"

let

When ES6 arrived, the problem about updated the variables with var, has ended. Specially when we use variables inside curly brackets. So, ES6 introduce with let a new scope: the block scope.

//let 

let sayHello = "Hola olla"

console.log(sayHello) // "Hola olla"

sayHello = "Hi!"
console.log(sayHello) // "Hi"

let sayHello= "Hi!"

console.log(sayHello) // error: Identifier 'sayHello' has already been declared

const

Meanwhile let resolve the updated problem. Const resolve both problems. With const we can't updated or redeclared variables.

// const

const sayHello = "Hola olla"

console.log(sayHello) // "Hola olla"

sayHello = "Hi!" // error: Assignment to constant variable. 

const sayHello= "Hi!" // error: Identifier 'sayHello' has already been declared

Scope

Ok, let's talks about scope. The scope determines the visibility or accessibility of variables. We have 3 types of scope: 1) Global scope, 2) Function scope, 3) block scope. But I want to add the local scope and the module scope.

Global scope: All the variables declared outside any function have global scope.
Function scope: When we create any new functions, each function creates a new scope. That's mean, all the variables declared inside the function, don't be accesible from any other functions outside. Other way to recognize the functions scope can be as local scope. All variables declared within a functions, are local variables.
Block scope

The block scope has been introduced in ES6, with let and const. That's means, every variables declared inside the curly brackets { }, can't be accessed in other scope.

Module scope

When we create modules, any variables declared outside functions, can be considered as global variables, but no. Any variable declared inside the module just can be accessed inside that module, unless the module is explicitly exported.

Hoisting

Sometimes JS is weird. And hoisting can be part of that strange things. The hoisting is a behavior in any variable or function can be used before declare it. That happened more before ES6, when we use the keyword var.

After ES6, the hoisting is a default behavior of moving any declarations to the top of their scope. Remember, with let and const we have the block scope. So, any declaration is moved to the top.

Also, one more thing to know is, JS hoists the declarations but cannot initialized. For example, if we have a var declaration, this will be initialized with an undefined value as default.

I think hoisting is confused in the beginning, but, each time when JS has been compiled, all the declarations and functions are assigned in some memory space. So, the hoisting, move all declarations at top, to save that's declarations in the memory. Really, all the code stay how we wrote them.

The coding interview: !DOCTYPE

Karen Molina — Sun, 12 Sep 2021 03:37:32 +0000

Hi, once again!

Two years ago, I took my first job as frontend developer. Before that, I did workshops about STEAM for kids. And before at that I was studied Social Anthopology. So, a few months ago I applied to one of the big unicorns in LATAM, but I can't passed the proccess. My weakness: the theory.

For that reason, I have been studying and reviewing about programming fundamentals. And thats why I have been decided create a serie of posts about technical interviews. To help other new and future programmers to get their dream jobs. Or to help them to give their best in a future interview.

First we started with some of HTML. Why?, because, as a web developers the HTML is one of our three most important tools to create our projects.

What is the !DOCTYPE?

In every html file we must put !DOCTYPE in the first line, but, why?. First the !Doctype is not a html tag, but it's a keyword. This keyword works as a declaration to the browser. I mean, with that we says to the browser what document type must to expect. In that case, an HTML 5 file.

The complete declaration must be like:

<!DOCTYPE html>.

Before HTML5, the declaration was more confused, because we had used some thing called Document Type Definition. But, don't worry, now, we dont have to use that. But other thing we have to know and help us in the future is about the case sensitive. The !DOCTYPE is not case sensitive. So, we can write with capitalize, uppercase, lowercase, camelcase ways. Not matters!.

Guess the Number

Karen Molina — Wed, 16 Jun 2021 02:52:00 +0000

Hi!

It's me!

Remember my first post, Guess the Number with Python? Well, I decided to do the same exercise, now with Javascript.

Let's go.... hands on code!

const prompt = require("prompt-sync")({ sigint: true });
let guessesTaken = 0;

console.log("Hola crayola.... ¿Cómo te llamas?");
const name = prompt();

let number = Math.floor(Math.random() * 10) + 1;
console.log(`Hola ${name}.... Adivina el número en el que estoy pensando`);

while (guessesTaken < 6) {
  console.log("Dime un número");
  guess = prompt();
  guessesTaken = guessesTaken + 1;
  if( guess < number){
      console.log("Es un número más alto")
  } else if (guess > number) {
      console.log("Es un número menor")
  }else if (guess == number) {
    console.log(`Felicidades ${name}. ${number} es el número!!`);
    break;
  } else {
    console.log(`uy no ${name}, estaba pensando en ${number}`);
  }
}

At a first instance, we need to install prompt-sync node module to use it. Once time we have benn instaled the module, we can continue to code.

We have three variables, one of them we use to create a record or a counter as how many times we try to guess the number. The second variable are use to save the user name.
Then, we have a third variable, called number that we use the method math to get a randomly number between 1 to 10. And we have two console.log to create an interaction with the user, get the name and a number.

Next, we create a while loop. A while its a loop that execute the core over and over again. We create a loop that the conditional must be menor that 6. In that case, 6 is the number that the user got to try to guess.

Inside a while loop, we have a console.log and a varibale called guess. Then we have trhee conditional sentences. The first compare if the guess is menor that number. And the second if, gonna make a comparison if guess is mayor that number. Then we have anocher conditional that compare the guess and number varibales when the user knows the right number. In this block to code, we must return a succeful message as string, and we can brake the loop.

Finally, the four conditional statement will be retured an error message when the user fails the game.

Dragon game

Karen Molina — Tue, 15 Jun 2021 00:17:31 +0000

Hello!
Ok, let's start! Now, we can create a new game, you know the same book.
I'm gonna put the code first, then I gotta explain it.

import random
import time

def displayIntro():
    print("You are in a land full of dragons, In front of you,")
    print("you see two caves. In one cave, the dragons id friendly")
    print("and will share his treasure with you. The other dragon")
    print("is greedy and hungry, and will eat you in sight")

def chooseCave():
    cave = ""
    while cave != "1" and cave != "2":
        print("Which cave will you go into? (1 or 2)")
        cave = input()

    return cave

def checkCave(chooseCave):
    print("You approach the cave...")
    time.sleep(2)
    print("It is dark and spooky...")
    time.sleep(2)
    print("A large dragon jumps out in front of you! HE open his jaws...")
    print()
    time.sleep(2)

    friendlyCave = random.randint(1,2)

    if chooseCave == str(friendlyCave):
        print("Gives you his treasure!")
    else:
        print("Gobbles you down in one bite!")

playAgain = "yes"

while playAgain == "yes" or playAgain == "y":
    displayIntro()
    caveNumber = chooseCave()
    checkCave(caveNumber)
    print("Do you want to play again? (yes or no)")
    playAgain = input()

In this program we use two modules: random and time module.

Currently we use functions, the function is a way to say what to do and how. In python the functions has been writing with the statement defines or def. So, we have the firts block to code inside a function called displayIntro.
Inside displayIntro function, we write a few print methods to introduce the user inside the game.

Then we have the chooseCave function. Inside it, we put a empty varibale. Below we can write a while loop. Inside it, we have to compar two options or values: 1 and 2. Those values, are going to be the user options.

The next function we have is called checkCave. In this function we have to write a twice print methods to start the story. Then, we have to question to user which are the way to choose. Immediately we have to do the comparison between his choose and a random number. This is why we use random module. To choose randomdly two options: number 1 or 2. The options that we return to user, depends that return the random module.

Finnaly, we have to do another function to know if the user want to continue or left the game.

Guess the Number

Karen Molina — Sun, 13 Jun 2021 03:25:23 +0000

Hi!

Some months ago, I was thinking to practice my skills in python, but I don't want do stuff in backend. I had no idea how to start. So, one day, one friend at Twitter sais me: Hey! you can practice with that book!. The book called: Invent Your Own Games with Python by Al Sweigart.

The first game I would to recreate is called: Guess the Number. We have to use the input, conditionals, booleans, Modules, statements to iterate some things... and other stuffs. The objective is...

As a user. I have to write my name in the game to make a custom gretting at the beginning of the game. The game must return the greeting and said my name and give me the next instruction to continue the game.

Let's go.... hands on code!

import random 

guessesTaken = 0

print("Hola crayola.... ¿Cómo te llamas?")
myName = input()

number = random.randint(1,20)
print("Hola" + myName + "Adivina el número en el que estoy pensando")

while guessesTaken < 6:
    print("date con un número")
    guess = input()
    guess = int(guess)

    guessesTaken = guessesTaken + 1

    if guess < number:
        print("ay no!..... es un número más alto")

    if guess > number:
        print("estás muy muy arriba, ve más abajo")

    if guess == number:
        break

if guess == number:
    guessesTaken = str(guessesTaken)
    print("Esoooo" + myName + "es el bueno")

if guess != number:
    number = str(number)
    print("nope! ese no es. Estuve pensando en" + number)

First, we have to import the random Module. We need it to create a random variables... or numbers, in this case.

Next, we create a variable named guessesTaken, this variable we use to create a record or a counter as how many times we try to guess the number. At lines 6-7 we create the first interaction with the user, we ask the name.

At lines 9-10 we can use the random Module with the randint method. Inside the parentheses we can put two parameters, separated by commas. then randit(), return a random number between the parameters. The number been returned it be the number that the user going to try to guess.

In line 12 we has to create a loop... we must use a while. A while its a loop that execute the core over and over again. We create a loop that the conditional must be menor that 6. In that case, 6 is the number that the user got to try to guess.

Now, inside de While... we have few block to code. First, we ask to the user a number. Then we create two variables. One of then we use it for the number that the user write. The second varibale, we transform that value in a integrer. At line 17, we start the timer or the tryes that the user have. Remember... we created a loop with a six intents.

Then we have two if statements. Both are gonna make a comparison between the guess variable and the number to guess. But, the first if, gonna make a comparison if the guess is menor that number. And the second if, gonna make a comparison if guess is mayor that number.

Now, we have a third if statement inside while loop. That if indicate to the game that if guess is equal to number. The user has guessed the right number. At this moment.. the loop will be stoped.

Once outside the loop we have two more if statements.

Firts, a conditional that compare the guess and number varibales when the user knows the right number. In this block to code, we must return a succeful message as string, that why first we convert the guess varibale to string.

Finally, the second if statement will be retured an error message when the user fails the game.