Crea una cuenta o inicia sesión

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

Elementos de un Lenguaje de Programación: Variables, Funciones y Sintaxis

4/30
Recursos

En JavaScript existe dos componentes principales: datos que guardamos en memoria y tareas que haremos con esos datos. Estos conforman los elementos de un lenguaje de programación.

Herramientas para ejecutar código JavaScript

Visual Studio Code es el editor de código que se recomienda utilizar para tus proyectos y ofrece varias características para mejorar tu experiencia en el desarrollo.Los archivos de JavaScript tienen la extensión .js al final.

La consola del navegador es importante si quieres probar código JavaScript directamente. Ingresas a la consola mediante la combinación de teclas Ctrl + Shift + I o clic derecho e “Inspeccionar” en tu navegador preferido (de preferencia Google Chrome).

También puedes utilizar codi.link. Codi.link es un editor de código para escribir HTML, CSS y JavaScript, de manera que se visualice el resultado a tiempo real. Si estás usando Visual Studio Code, instala la extensión Code Runner que te permite ejecutar bloques de JavaScript y mostrar el resultado en la terminal.

Comentarios en JavaScript

Los comentarios son descripciones que escribimos, pero que el compilador de JavaScript ignorará. ¿Cómo se establece esto? De dos maneras: en una sola línea con //; y en múltiples líneas utilizando /* */.

// Este es un comentario de una línea
/*
Este es un comentarios
con múltiples líneas
*/

Valores por consola

Para mostrar valores por consola, se utiliza la función console.log() para imprimir por consola. Hay una clase de funciones, así que ya aprenderás lo que es.

Ejecuta lo siguiente en la consola de tu navegador y observa lo que sucede.

console.log("Hola Mundo")

Tipos de datos

Los tipos de datos es la característica propia que tiene un valor. En JavaScript existen los tipos de datos primitivos y los no primitivos.

Datos primitivos

Los tipos de datos primitivos son los siguientes:

  • number: indica un valor numérico, ya sea entero o flotante (con decimales).
  • string: indica una cadena de caracteres, el valor está envuelto en comillas dobles " o simples '.
  • boolean indica un valor lógico binario, es decir, los valores true o false.
  • null: indica un valor nulo.
  • undefined: indica un valor no definido.

Existen dos tipos primitivos más: bigint y symbol, pero es un tema que aprenderás más adelante.

Tipos no primitivos o de objeto

Los tipos de datos de objeto o no primitivos son los siguientes:

  • function: indica una representación de función.
  • object: indica una representación de objetos.

Palabra reservada typeof

La palabra reservada typeof permite identificar el tipo de dato de un valor en JavaScript. Existe una excepción, al ejecutar typeof null, en la consola mostrará 'object', esto es un error dentro JavaScript.

Ingresa a la consola del navegador, ejecuta cada línea del siguiente ejemplo y observa cuál es la respuesta.

// Tipos de datos primitivos
typeof 5  // 'number'
typeof "hola" // 'string'
typeof true  // 'boolean'
typeof null  // 'object'
typeof undefined // 'undefined'

// Tipos de datos de objeto 
typeof console.log  // 'function'
typeof {tipo: "objeto"} // 'object'
typeof [1,2,3,4]  // 'object'

Contribución creada por Andrés Guano (Platzi Contributor).

Aportes 541

Preguntas 54

Ordenar por:

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

Árbolito de los tipo de datos en JS

Aquí les dejo esta infografía que es muy, muy buena 💚👍

PD: Por favor no me maten porque la infografía es de EdTeam, solo que hacen my buenas infografías jajaja 😅😅😅

Para que quede mas claro Null y undefined

The history of “typeof null”

null es un valor primitivo y es null NO es un “object”

typeof null // = "object"

es un error que no pueden corregir por que dejarían de funcionar las aplicaciones actuales.

un compañero @hidalgolopezdaniel en el futuro descubrió que existe esta pag: https://jsconsole.com/
y yo como buen Marty McFly se los traje al pasado

Principiantes, (como yo) no se alteren si se encuentran con cosas que de momento pueden parecer complicadas de entender o recordar. Nomás apliquen la regla 80/20. El 80% solo usás el 20% de lo aprendido. 😉
![](

VALORES

PRIMITIVOS: son los valores básicos que se utilizan para poder generar códigos.

  • Número: data sólo de tipo numérico, ejem: 1 2 3 4, etc.
  • Strig: texto, se utiliza entre comillas dobles. “Haciendo esto”, “Diego Hernández”
  • Boolean o Booleano: son valores creados por George Boolean dentro de lenguajes de programación para poder validar cosas y/o desiciones, por ello se utilizan: true (1) o false (0).
  • Empty values: null o undefined, se les conoce como valores “placeholders”, pero son valores reservados para un tipo de valor que queda faltante en memoria. También pueden ser tomados como valores de errores.

NO PRIMITIVOS O VALORES TIPO OBJETOS:

  • Array: se genera ocupando corchetes, los cuales dentro ocupan valores primitivos, ejem: [1,2,3] convirtiéndolos en valores tipo objeto.
  • Valor tipo Objeto: se generan con corchetes, los cuales dentro ocupan una data que se transforma en objeto, ejem de sintaxis: { nombre: “Diego”}.

min 5:43 : una aclaración, quien inventó los booleanos no se llamaba “George Boolean”, se llamaba “George Boole”

Hola!, Si usarán VScode, les recomiendo instalen estas exenciones:

Esta, les pinta los brackets “{ }” de forma que puedan saber si hay una función, ciclo o condición mal cerrado o abierto.

Esta monta un servidor desde VsCode, así no tienen que andar actualizando la pagina.

Hola a todos! Acá les comparto mis apuntes para esta clase.
Éxito!

**P.D.: **Iré dejando todos los apuntes en un tutorial, por acá --> https://platzi.com/tutoriales/1814-basico-javascript/9339-guia-completa-curso-basico-de-javascript/

Si quieren ver cuanto tiempo codean al dia o la semana, registrense en esta pagina e instalen la extension para su editor de texto preferido, https://wakatime.com, es gratis y ayuda a motivarse.

Cabe resaltar que hoy día existe un nuevo tipo de dato primitivo que se incluyó con ECMASCRIPT 6, este nuevo dato se le conoce como : Symbol.

Un Symbol es un valor primitivo único e inmutable y puede ser usado como la clave de una propiedad de un Object. En algunos lenguajes de programación, los Symbols son llamados átomos. Se pueden comparar con enumeraciones de nombres (enum) en C.

Espero y les sirva 😄

Valores primitivos:

number = valor tipo entero,
string =valor de cadena o texto,
boolean = True or false,
null, undefined = valores nulos

valores no primitivos

{} or [] = valores tipo objeto

Quería aportar esto.
En la parte donde pone “typeof oscar” sale “undefined” porque lo detecta como una variable que no tiene ningún valor. En javascript puedes usar variables sin haberlas definido antes.

/Valores numericos
40;
//valores de tipo string
("Luis");
//valores de tipo Boolean
true;
false;
//valores de tipo vacio:
null;
undefined; //tener cuidado con el undefine
//valores de tipo objeto:
//arrays
[1, 2, 3];
{
  nombre: "Luis";
}

//nota: en el navegador para ver que tipo de valor es colocas typeof ejemplo:
//typeof true
//y te va decir boleaan

Increíble profesor 👏👏.
Aunque ya tengo un poco de experiencia con js, siento que ahora sí lo estoy aprendiendo de la manera correcta.

Hola!

Para probar su código JavaScript, en lugar de hacer: click derecho -> inspeccionar, dentro de cualquier página, pueden abrir una página en blanco escribiendo en la barra de direcciones:

about:blank

Le dan Enter y el navegador mostrara una página en blanco.
Ahora apretan F12 y les va a aparecer la consola para que hagan sus pruebas.
(funciona en Firefox y Chrome)

Saludos,

Recordando mis viejas clases de la universidad de C y C++ Null se usa para enviar una referencia (puntero) a una localidad segura de memoria para “apartarla” Ojo, no apuntaba al abismo, si no puede que estuviera apuntada a datos basura, incluso si declarabas un array de null podías ver los segmentos de memoria que contenía al imprimirlos. Por tanto, sabiendo que el motor V8 está construido en C++ No se me hace nada raro que null retorne object porque simplemente es eso.

/*
--------------- Variables, Funciones y Sintaxis---------------
Existen 2 componentes importante en JS
Valores o Datos: Almacenan informacion 
Funciones: realizan acciones con la informacion.

*VALORES PRIMITIVOS y VALORES NO-PRIMITIVOS (VALORES TIPO OBJETO) 

Los datos pueden ser de VALORES PRIMITIVOS (basicos):
Numeros: 40
String: "Texto"
Booleanos: TRUE OR FALSE
Vacios o Empty value: null, undefined; cuando tenemos un valor en faltante, para guardar cosas cuando las necesitamos, una caja vacia. 

Tambien existen VALORES NO-PRIMITIVOS o VALORES TIPO OBJETO:
Array [ ] : [1,2,3] (son valores primitivos)
Valor tipo objeto { }: { name: "Platzi"}

---------------
*/

Deberían hacer un curso de VSCode, no creen?
Aporte: Setting Sync te permite hacer respaldo de tu configuración de VSCode y sincronizar en cualquier lugar.

Hola! Les recomiendo este video de Leonidas para que puedan configurar Visual Studio Code.
https://www.youtube.com/watch?v=o8iqG4bAN0s

Solo quería dejar esto por aquí, me pareció curioso.

De hecho es George Boole, no George Boolean.

😉🤷‍♀️

Excelente explicación. Recomiendo este libro que es gratuito para profundizar. Libro

//primivito

// String
const name = 'John Doe';
// Number
const age = 45;
// Boolean
const hasKids = true;
// Null
const car = null;
// Undefined
let test;
// Symbol
const sym = Symbol();

//  Objectos

// Array
const hobbies = ['movies', 'music'];
// Objecto literal
const address = {
  city: 'Boston',
  state: 'MA'
}
const today = new Date();
console.log(today);
console.log(typeof today);```

Visual Studio Code ❤️

Hola como estas? Espero que bien, aca te dejo esta exension de VS code que se llama code runner, en ella puedes ejecutar codigo de Javascript adentro del editor de texto si asi lo deseas:)

Ya tengo experiencia con JS pero sé que de esta manera reforzaré mis conocimientos de este lenguaje de programación.

😮 Visual Studio Code, es el editor más usado para realizar proyectos para la Web.

Aqui algunos tipos de datos

Les dejo el link para run js https://runjs.dev/ donde pueden escribir JavaScript sin tener que usar el navagador.

Editores de texto:
1.- Visual Studio Code
2.-Brackets
3.-Sublime Text
4.- Atom
5.-Notepad ++

etc… utiliza el que mas te acomodes

Existen 2 componentes principales en Javascript.

1-Datos que se guardan en memoria.
2-Tareas(Funciones) que hacemos con esos datos.

//_________Valores primitivos________

40 //number

"Ramon"//String

true//Boolean
false//Boolean

//Valores Vacios
null
undefined

//_________Valores tipo objeto y tipo Array________

[1,2,3]
{nombre: "Ramon"}```

Muy bueno, estas primeras clases ayudan mucho a hacer el entendimiento más fácil de otros cursos como programación básica y fundamentos de JS.

El valor de undefined, es undefined HAHAHAHAHA

Es mi primera vez en Platzi y quería participar apoyando un poco con los demás. Quizás ya esté comentado pero también quería participar (solo ignoren el diseño feo jaja). Es un breve resumen de la clase!

Tipos De Valores Basicos

//VALORES PRIMITIVOS


//valores Numericos
40
18

//valores Texto
"Cesar Mora"
"Diego De Granda"

//valores Booleano
true 
false

//valores Vacíos
null
undefined

//valor Array
[1, 2, 3]

//valor Objeto
{nombre: "Cesar"}

Les comparto mis anotaciones para esta clase.

Atom solo funciona hasta el 15 de diciembre de 2022, ya no le van a dar más soporte.

Valores primitivos

numericos

40
24.3
.4
3e4

cadenas de caracteres - string

“Hola, mundo!”

boolean

true
false

valores vacios

null - espacio reservado para poner algun valor
undefined - variable u objeto no definido

Valores no primitivos

[1, 2, 3] - valor tipo Array
{nombre: “franks”} - valor tipo Object

// Valores primitivos:

// Int =
40 

// String =
"Nahuel Farias" 

// Boleanos =
true
false 

// Valores reservados - Valores vacios - Se usan para reservar memoria =
null
undefined 


// Valores no primitivos:

// Valor tipo array =
[1, 2 ,3]

// Valor tipo objeto =
{ nombre: "Diego" } 

// Para comprobar los tipos de valores usamos la función "typeof"```

En Javascript existen 7 tipos de datos:
STRING: Cadenas de texto.
NUMBER: Valores numéricos.
BOOLEAN: Representa una entidad lógica y puede tener dos valores: true y false.
NULL: Es un valor asignado tiene el valor de “no valor”.
UNDEFINED:Una variable a la que no se le ha asignado ningún valor tiene el valor undefined.
SYMBOL: Nuevo en ECMAScript 2015.
OBJECT: Un valor en memoria al que podemos acceder por un identificador.
Estos tipos se dividen en dos grupos, Primitivos y de Objeto.

Tipos Primitivos
Los valores primitivos son inmutables, no pueden ser cambiados.

String, Number, Boolean, null, undefined y Symbol son tipos primitivos.

Los tipos primitivos no tienen métodos ni propiedades, aunque en los string, numbers y booleans podemos acceder a ellas grácias a los wrappers objects.

Tipos de Objeto
Un Objeto es un valor en memoria al que podemos acceder por un identificador.

En JavaScript los objetos pueden ser vistos como una colección de propiedades.

Un Objeto en notación literal tiene este aspecto:

var persona = { nombre: “Marcel”, edad: “38”, ciudad: “Alaior” };

Hola a todos, si no han visto temas de programación antes o si han rascado la superficie, algo muy importante es saber cómo funcionan los tipos de dados y los tipos de datos que hay.

Les dejo un link que me ayudó a entender como estos interactuan entre sí con bueno ejemplos.

Tipos de datos

Como es debilmente tipado, siento que es menos complejo de aprender, espero les ayude a entender por si llegan a tener problemas. :3

//valores primitivos

40 //tipo numero
"hola mundo "  //texto /string

//booleano
true
false

//valores vacios
null
undefined//valor reservado de  JS

//valores no primitivos / valores objetos

[1,2,34]
{nombre: "Junito"}```

VALORES PRIMITIVOS

- String
- Number
- Boolean
- VALORES VACIOS (EMPTY VALUES)
    -null
    -undefined

VALORES NO PRIMITIVOS O TIPO OBJETO

- Arreglo []
- Objeto {nombre: "Roberto"}

TYPEOF

- Nos dice de que tipo es el valor que ingresamos

Recuerden que como lo menciona Diego De Granda, hay otros editores de código: en la pestaña “Archivos y Enlaces” de esta clase (arriba a la derecha, bajo el buscador) no solo está el link al repositorio en GitHub de la clase sino también los links para Sublime, Atom y el mismo VSCode.

😉

Elementos de un lenguaje de programación: Variables, Funciones y Sintaxis.

1.-Data que guardamos en memoria, tipos de datos como strings, números, booleanos, nulos.

2.-Tareas (funciones) que haremos con esa data.

Existen diferentes tipos de datos, los primitivos y los no primitivos.

Primitivos:
-Numeros
-Strings
-Boleanos
-Vacios

Y los no primitivos:
-Arrays
-Objetos

denme mis dos puntitos :V

Datos o valores en Javascript:

  1. Valores primitivos:
  • Valor de tipo numérico por ejemplo 40, o cualquier número.

  • Valores de tipo de cadena de texto: “hola”, van entre comillas y se llaman strings.

  • Valor de tipo boleano: son true or false, verdadero o falso.

  • Valores vacios: son null y undefined. Se pueden usar para tener un espacio reservado para después colocar un valor. Pero también nos pueden aparecer como resultado de un error.

  1. Valores no primitivos
  • Valor array: los vamos a usar colocando corchetes [ ] y adentro poner otros valores, por lo general son todos valores primitivos. Una vez que le colocamos valores adentro [1,2,3] esto se transforma en un objeto.
  1. Valor de tipo objeto

Lo hacemos con llaves { } por ejemplo { nombre: “cristian” }; ésto sería un objeto y lo que contiene un valor tipo objeto.

Por último en la consola del navegador podemos ver de que tipo de valores son los datos, con typeof espacio y el valor que querramos.

Un ejemplo de código JS

/* 
VALORES:

Valor <40> es de tipo "number"
Valor <"Diego de la Vega"> es de tipo "string"
Valor primitivo <true> es de tipo "boolean"
Valor primitivo <false> es de tipo "boolean"
Valor primitivo <NULL> es de tipo "null"
Valor primitivo <> es de tipo "undefined"
Valor <[1,2,3]> es de tipo "object"
Valor <{nombre: "Diego"}> es de tipo "object"

TYPEOF:
"Typeof" es un comando para obtener el tipo de variable de un determinado valor.
*/

var numero1 = 40;
var cadena1 = "Hola Mundo"
var boleano1 = true;
var boleano2 = false;
var indefinido1;
var arreglo1 = [1,2,3];
var objeto1 = { nombre: "Diego"};

presentar(numero1);
presentar(cadena1);
presentar(boleano1);
presentar(boleano2);
presentar(indefinido1);
presentar(arreglo1);
presentar(objeto1);

function presentar(i){
    console.log("Valor: " + i + " | Tipo: " + typeof(i))
}

//Valores Primitivos:

//valor number
40

//Valor String
"Wil Garcia"

//Valor boolean
true
false

//Valor object
null
// undefined
undefined //vacio

//Valores tipo Objects
Array
[1,2,3]
Object
{nombre: “wil”}

Para facilitar el proceso de revisar codigo directamente desde la terminal les recomiendo usar WSL.
Aqui vamos a instalar nodejs 😄
sudo su

apt update
apt-get install nodejs
apt-get isntal npm

Ahora vamos a nustro vs code y creamos un archivo holaMundo.js

console.log('Hola mundo! Estoy usando javascript desde el editor')

abrimos una terminal ctlr+shft+` -> Seleccionaremos wsl
Aqui ejecutamos el siguiente comando nodejs holaMundo.js
^^
Tambien podemos ejecutar Javascript desde la misma terminal.
En la terminal escribimos nodejs, lo cual nos abrira node y aqui podemos probar cositas.

console.log('Hola Mundo! estoy en la terminal')

Espero sinceramente haberte ayudado aunque sea un poquito ^^

no sabia lo de typeof !

Las interpretaciones respectivas de los símbolos 0 y 1 en el sistema de lógica son Nada y Universo.
George Boole

Hay una extension en VS code que te presenta la consola en el mismo editor, se llama Quokka. Y para activarla vas: View>command palette y escriben: Quokka.js:start on current file

Dos componentes principales:

  • Datos: Que guardamos en memoria. Como números, string, objetos, arrays, etc.
  • Tareas: Funciones que crearemos para hacer cosas con los datos
//Let es una variable local
let valorUno = 10;
if (true) {
    let valorUno = 40; // let es una variable local por lo cual no tomara este valor
    console.log(valorUno)
}
console.log(valorUno);


//Es un valor constante que no puede ser cambiado
const valorConstante = "Victor Adrian Ramirez de la Cruz";
console.log(valorConstante);


//Var es una variable global
var valorDos = 20;
if (true) {
    var valorDos = 40;  //El var es una variable global por lo cual tomara el nuevo valor
    console.log(valorDos);
}
console.log(valorDos);

typeof (valor), me parece muy útil esto.

genial explicacion

✨ Hola chicos, les recomiendo runJS es una aplicación de escritorio que les permite correr JavaScript con el resultado en tiempo real.

👉

En la clase 19 de este curso, alguien comentó que había descubierto https://jsconsole.com/
Lo pongo aquí, en la clase en donde empiezan a usar la consola pues quizá podría ayudar a los estudiantes que recién están iniciando el curso! 😃

Corriendo JS en el Navegador

Valores tipo Objeto

Mi resumen para esta clase:

JS usa dos tipos de componentes principales:
Datos y Tareas.

Los datos es la información que se almacena en la memoria y sirve para ser usada en las tareas.
Hay dos tipos de valores, valores primitivos que engloban:
Valores numericos , Boolean (false, true) valores reservados e indefinidos: undefined y null.
Por otro lado están los datos no primitivos, que son los arrays (cadenas de texto) y los objetos que agrupan mayor cantida de información.

El segundo tipo de componente son las tareas, que no son otras que las funciones que se usan para cumplir un proposito involucrando los valores anteriormente mencionados para generar un resultado.****

ya no es necesario descargar el visual studio code ya lo tiene en web y lo puden utilizar desde su navegador, aqui les dejo el link: https://vscode.dev/

Vamos a darle con todo a este curco compas!

Estos son mis apuntes en el editor de texto:


/* VALORES PRIMITIVOS*/

40 /* Valor numérico*/

"Yordy Andrade" /* Cadena de texto*/

true /* Valor verdadero*/
false /* Valor falso*/

null  /* Valores vacíos o variables sin asignar valor*/
undefined /* Valores vacíos o variables sin asignar valor*/



/* VALORES NO PRIMITIVOS*/

[1,2,3] /* Array*/
{nombre: 'Yordy'} /* Valor tipo objeto*/

Apuntes

ELEMENTOS DE UN LENGUAJE DE PROGRAMACIÓN

Dos componentes principales:
1. Data que guardaremos en memoria.
◦ Tipos de Datos: Números, cadenas(strings), objetos, arrays(arreglos), etc.
◦ Estos tipos de datos serán para declarar el tipo de variables con las que vamos a trabajar.
2. Tareas (Funciones) que haremos con esa data.
◦ Con las tareas podremos hacer cosas con los datos que hemos guardado previamente.

Tipos de Valores:
1. Primitivos
◦ Número
◦ Cadena(string)
◦ Booleano(true or false)
◦ Vacíos( null, undefined)
2. No Primitivos u Objetos
◦ Array
◦ Objeto

lListo PROFESOR .Hecho !

De los elementos de un lenguaje de programación, se define en dos componentes principales:

  • Data que guardemos en memoria.
  • Tareas(Funciones) que haremos con esos datos.

Existen en JS, dos tipos de datos;

  • Primitivos
    • Números: que se declaran sin comillas ni otro carácter. 9.
    • Texto: Que su valor siempre tiene que ser entre comillas. “Hola”.
    • Boolean: Que solo se define con True & False, para saber si algo es verdadero o falso.
    • Tipo Nulo: Que pondremos cuando no queramos asignarle un valor a alguna variable. Null & Undefined
  • Objeto
    • Array: Este es un conjunto de valores primitos que puede agrupar varios.
    • Objeto: Que nos permitirá declararle varios atributos.

Podemos ejecutar este código en la parte de “Consola” en el Inspector de elementos de nuestro navegador.

Con la función “typeof” podremos ver de que valor es la variable que le asignemos.

Uhiii ese dato de arrastrar la carpetica no lo sabia!!!

Vengo de Java, y entiendo que JavaScript no es necesario las ;, pero me rompe la cabeza no verlas en las clases 😦

También cuentan los objetos de tipo json? [ { key:"value" } ]

Apuntes:

Volviendo a repasar…

me gusta mucho usar VS code porque es facilita muchas funciones, como por ejemplo la parte de git y github…no tienes que programar en consola, desde el mismo VS codese puden hacer las funciones principales

Elementos de un Lenguaje de Programación: Variables, Funciones y Sintaxis
Existen dos componentes principales en un lenguaje de programación:
• Datos que se van a guardar en memoria, pueden ser distintos tipos de datos.
• Las funciones que vamos a crear para utilizar los datos que previamente hemos guardado en memoria.
Los diferentes tipos de datos son los siguientes:
• Numéricos.
• Strings o cadenas de texto.
• Booleanos.
• Valores vacíos
Estos tipos de datos son conocidos como valores primitivos. Existen 2 tipos de valores mas que son los arrays y los de tipo objeto.

Antes de seguir con la clase recordé que planeé ver el curso de pensamiento lógico antes de ver javascript así que me fui y volví y tengo algunas cosas más claras pero no del todo, como una herrramienta importantes para lo que viene…El diagrama de flujo como paso vital para secuenciar procesos al resolver un problema, algunos quizás piensen que es básico y que está implícito al resolver un problema mediante programación pero, aunque les parezca sencillos algunos problemas que se harán en el curso el diagrama de flujo es ideal para problemas complejos y sobre todo largos(así cuando dan errores saber donde corregir). Les dejo un pdf sobre problemas de algoritmos resueltos con diagramas de flujo que encontré en el curso que comenté anteriormente:

Qué características debería tener una laptop para programar? Memoria RAM de cuánto? SSD?

Sitio acceder a una consola de js https://jsconsole.com/

Library Genesis touché!!! 😃

![]()![]()![](https://static.platzi.com/media/user_upload/image-4e1f88e1-34ef-4f8a-ae74-f8a02ec158cc.jpg) encontre este resumen de los conceptos

Dos componentes principales 1. Data que guardamos en memoria 2. Tareas (funciones) que haremos con esa data

True , false nos sirven para validar si tomamos una decision o no .

Cosas que sé, pero olvidé:
• typeOf: “te arroja o te menciona el tipo de valor que estás manejando: puede ser number, string, boolean, null, undefined”.

Debí tomar este curso antes de iniciar programación básica

  • En JavaScript, existen seis tipos de datos primitivos que se utilizan para almacenar valores simples:
  1. Número (Number): se utiliza para almacenar valores numéricos, como enteros y números decimales. Por ejemplo: 10, 3.14.

  2. Cadena (String): se utiliza para almacenar texto. Las cadenas se escriben entre comillas simples o dobles. Por ejemplo: “Hola, mundo!”.

  3. Booleano (Boolean): se utiliza para almacenar valores de verdadero o falso (true o false). Por ejemplo: true.

  4. Nulo (Null): se utiliza para representar la ausencia de cualquier valor. Por ejemplo: null.

  5. Indefinido (Undefined): se utiliza para representar una variable que no tiene un valor asignado. Por ejemplo: undefined.

  6. Símbolo (Symbol): se utiliza para almacenar valores únicos e inmutables que se pueden utilizar como identificadores de propiedad en objetos. Los símbolos se crean mediante la función Symbol(). Por ejemplo: Symbol(‘id’).

  • Estos tipos de datos primitivos se utilizan para almacenar valores simples y se copian

vengo del futuro de este curso para presentarles este link https://jsconsole.com

denada 😃

EJECUCIÓN DE CÓDIGO: APORTE

Para quienes deseen ejecutar el código directamente en Visual Studio Code, pueden instalar la extensión Code Runner, y para ejecutar (Windows) sería Ctrl + Alt + N, para Mac no sé cómo sería, pero creo que la misma extensión explica.

La importancia de saber el tipo de dato es poder dar orden y funcionamiento a tu codigo

Valores
var a;
typeof a; // “undefined”

a = “hello world”;
typeof a; // “string”

a = 42;
typeof a; // “number”

a = true;
typeof a; // “boolean”

a = null;
typeof a; // “object” – weird, bug

a = undefined;
typeof a; // “undefined”

a = { b: “c” };
typeof a; // “object”

Elementos de lenguaje de programacion:

  1. Valores
  2. Funciones

Tipos datos primitivos en js:

  • numéricos:
  • string o cadenas
  • booleanos
  • null (para reservar espacio) (objeto)
  • undefined (para reservar espacio) sin definir

datos/valores tipo objeto o no primitivos

  • array [x,x2,x3…]
  • {key: “value”}

typeof [valorx] retorna el tipo de valor

2:03 “Yo no lo descargo porque ya lo tengo” XD