Credito: Foto de ethan en Unsplash
Un analizador de texto es una aplicación para extraer información útil de un texto utilizando diversas técnicas, como el procesamiento del lenguaje natural (NLP), el aprendizaje automático (ML) y el análisis estadístico. Estas aplicaciones pueden proporcionar una variedad de métricas que brindan información básica sobre la longitud y la estructura del texto como por ejemplo, el conteo de palabras, el conteo de caracteres, el conteo de oraciones y el conteo de párrafos. Otras métricas incluyen el análisis de sentimientos, que utiliza técnicas de NLP para determinar el tono general positivo, negativo o neutral del texto, y el análisis de legibilidad, que utiliza algoritmos para evaluar la complejidad y la legibilidad del texto.
En general, las aplicaciones de análisis de texto brindan información valiosa y métricas sobre los textos que pueden ayudar a los usuarios a tomar decisiones informadas y sacar conclusiones significativas. Mediante el uso de estas herramientas de análisis, los usuarios pueden obtener una comprensión más profunda de los textos.
En este proyecto implementarás un analizador de texto web para calcular y mostrar métricas de un texto enviado por el usuario.
El listado de funcionalidades es el siguiente:
La aplicación debe permitir al usuario ingresar un texto escribiéndolo en un cuadro de texto.
La aplicación debe calcular las siguientes métricas y actualizar el resultado en tiempo real a medida que el usuario escribe su texto:
La aplicación debe permitir limpiar el contenido de la caja de texto haciendo clic en un botón.
La lógica del proyecto debe estar implementada completamente en JavaScript. En este proyecto NO está permitido usar librerías o frameworks, solo JavaScript puro también conocido como Vanilla JavaScript.
Para comenzar este proyecto tendrás que hacer un fork y clonar este repositorio que contiene un boilerplate con tests (pruebas). Un boilerplate es la estructura básica de un proyecto que sirve como un punto de partida con archivos y configuración inicial de dependencias y tests.
El boilerplate que les damos contiene esta estructura:
./
├── .babelrc
├── .editorconfig
├── .eslintrc
├── .gitignore
├── README.md
├── package.json
├── src
│ ├── analyzer.js
│ ├── index.html
│ ├── index.js
│ └── style.css
└── test
├── .eslintrc
└── analyzer.spec.js
README.md
: debes modificarlo para explicar la información necesaria para el
uso de tu aplicación
web, así como una introducción a la aplicación, su funcionalidad y decisiones
de diseño que tomaron..github/workflows
: esta carpeta contine la configuracion para la ejecution
de Github Actions. No debes modificar esta carpeta ni su contenido.docs/images
: contiene las imagenes de este README.read-only/
: esta carpeta contiene las pruebas de criterios mínimos de
aceptación y end-to-end. No debes modificar esta carpeta ni su contenido.src/index.html
: este es el punto de entrada a tu
aplicación. Este archivo debe contener tu HTML.src/style.css
: este archivo debe contener las reglas de
estilo. Queremos que escribas tus propias reglas, por eso NO está permitido el
uso de frameworks de CSS (Bootstrap, Materialize, etc).src/analyzer.js
: acá debes implementar el objeto
analyzer
, el cual ya está exportado en el boilerplate. Este objeto
(analyzer
) debe contener seis métodos:
analyzer.getWordCount(text)
: esta función debe retornar el recuento de
palabras que se encuentran en el parámetro text
de tipo string
.analyzer.getCharacterCount(text)
: esta función debe retornar el recuento
de caracteres que se encuentran en el parámetro text
de tipo string
.analyzer.getCharacterCountExcludingSpaces(text)
: esta función debe retornar
el recuento de caracteres excluyendo espacios y signos de puntuación que se
encuentran en el parámetro text
de tipo string
.analyzer.getNumberCount(text)
: esta función debe retornar cúantos números
se encuentran en el parámetro text
de tipo string
.analyzer.getNumberSum(text)
: esta función debe retornar la suma de todos
los números que se encuentran en el parámetro text
de tipo string
.analyzer.getAverageWordLength(text)
: esta función debe retornar la longitud
media de palabras que se encuentran en el parámetro text
de tipo string
.
En este caso usa 2 dígitos decimales.Para ejemplo de uso de cada función recomendamos ver el archivo
test/analyzer.spec.js
.
Nota: para simplificar las funcionalidades, definiremos las palabras como
un grupos de caracteres separados por espacios. Por ejemplo las palabras del
texto de entrada ¡Si, Tú puedes hacerlo!
son cuatro:
¡Si,
Tú
puedes
hacerlo!
src/index.js
: acá debes escuchar eventos del DOM, invocar
los métodos del objeto analyzer
según sea necesario y actualizar el resultado
en la UI (interfaz de usuario).test/analyzer.spec.js
: este archivo contiene las
pruebas unitarias para los métodos del objeto analyzer
.Hacer que los sitios estén publicados (o desplegados) para que usuarias de la web puedan acceder a él es algo común en proyectos de desarrollo de software.
En este proyecto, utilizaremos Github Pages para desplegar nuestro sitio web.
El comando npm run deploy
puede ayudarte con esta tarea y también puedes
consultar su documentación oficial.
A continuación encontrarás los criterios de aceptación mínimos del proyecto relacionados con cada objetivo de aprendizaje.
Uso de HTML semántico
La aplicación tiene un encabezado conformado por un
<header>
que es padre de un
<h1>
con texto Analizador de texto
. Para que puedas practicar más, estos
elementos no pueden tener atributos id
, ni name
, ni class
.
La aplicación usa un
<textarea>
con un el atributo name
en el valor user-input
para permitir al usuario
ingresar un texto. Para que puedas practicar más, este elemento no puede
tener atributos id
, ni class
.
La aplicación usa un
<ul>
con 6 hijos <li>
,
uno para mostrar cada métrica. Para que puedas practicar más, estos
elementos no pueden tener atributos id
ni name
.
La aplicación tiene un pie de página conformado por un
<footer>
que es padre de un
<p>
que tiene como texto el nombre de la estudiante desarrolladora de la aplicación.
Para que puedas practicar más, estos elementos no pueden
tener atributos id
, ni name
, ni class
.
La aplicación usa un
<button>
con el atributo id
en el valor reset-button
para permitir al usuario,
mediante un clic, limpiar el contenido de la caja de texto.
Uso de selectores de CSS
La aplicación usa
selectores CSS de tipo
para darle estilo al
<header>
y al
<footer>
.
La aplicación usa
selectores CSS de class
para darle estilo al
<ul>
descrito anteriormente.
y sus hijos
<li>
.
La aplicación usa
selectores de atributo
para darle estilo al
<textarea>
usando el atributo name
.
La aplicación usa
selectores CSS de ID
para darle estilo al
<button>
con el atributo id
en el valor reset-button
.
Modelo de caja (box model): border, margen, padding
clases css
de los
<li>
hijos del
<ul>
definen un estilo usando las propiedades del
modelo de caja,
(background
,
border
,
margin
,
padding
).Uso de selectores del DOM
La aplicación usa el
selector del DOM querySelector
.
La aplicación usa el
selector del DOM getElementById
.
Manejo de eventos del DOM (listeners, propagación, delegación)
La aplicación registra un
Event Listener
para escuchar el evento keyup
del <textarea>
para actualizar las métricas
cuando se haga escriba en el cuadro de texto.
La aplicación registra un
Event Listener
para escuchar el evento click
del <button>
que limpia el contenido de la
caja de texto.
Manipulación dinámica del DOM
textContent
o
innerHTML
de los <li>
que mostrar las métricas del texto.Tipos de datos primitivos
string
a tipo number
.Strings (cadenas de caracteres)
Variables (declaración, asignación, ámbito)
Uso de condicionales (if-else, switch, operador ternario, lógica booleana)
if..else
para evaluar condiciones.Uso de bucles/ciclos (while, for, for..of)
for
para crear un bucle.Funciones (params, args, return)
El objeto analyzer
contiene un método getWordCount
para calcular el
recuento de palabras de un texto.
El objeto analyzer
contiene un método getCharacterCount
para calcular
el recuento de caracteres de un texto.
El objeto analyzer
contiene un método getCharacterCountExcludingSpaces
para calcular el recuento de caracteres excluyendo espacios y signos de
puntuación de un texto.
El objeto analyzer
contiene un método getNumbersCount
para contar
cúantos números hay en un texto.
El objeto analyzer
contiene un método getNumbersSum
para la suma
longitud media de los números en un texto.
El objeto analyzer
contiene un método getAverageWordLength
para
calcular la longitud media de las palabras en un texto.
Pruebas unitarias (unit tests)
Módulos de ECMAScript (ES Modules)
Uso de linter (ESLINT)
Uso de identificadores descriptivos (Nomenclatura y Semántica)
GitHub: Creación de cuenta y repos, configuración de llaves SSH
La estudiante creó una cuenta en Github.
La estudiante configuró su cuenta de Github con una llave SSH.
Git: Control de versiones con git (clone, add, commit, push)
La estudiante creó un fork para su proyecto.
La estudiante clonó su repositorio usando una llave SSH.
La estudiante creó commits y los guardó en Github.
GitHub: Despliegue con GitHub Pages
Diseñar en distintos niveles de fidelidad
Seguir los principios básicos de diseño visual
Este proyecto cuenta con 3 conjuntos de pruebas que te ayudarán a conocer si cumples los criterios mínimos de aceptación.
Una prueba unitaria es una técnica de prueba de software en la que se comprueba que cada componente individual de un programa o sistema funciona correctamente de manera aislada. En otras palabras, se prueba cada unidad de código por separado para asegurarse de que cumpla con los requisitos y especificaciones.
Las pruebas unitarias de este proyecto ejecutarán los métodos getWordCount
,
getCharacterCount
, getCharacterCountExcludingSpaces
, getNumbersCount
,
getNumbersSum
y getAverageWordLength
con diferentes argumentos y se
confirmará que los valores retornados sean los esperados.
Puedes ejecutar estas pruebas con el comando npm run test
como se muestra
en la siguiente imagen:
El boilerplate incluye tareas que ejecutan eslint y
htmlhint para verificar el HTML
y
JavaScript
con respecto a una guías de estilos. Ambas tareas se ejecutan
automáticamente antes de ejecutar las pruebas unitarias cuando usamos el comando
npm run test
. En el caso de JavaScript
estamos usando un archivo de
configuración de eslint
que se llama .eslintrc
que contiene un mínimo de
información sobre el parser que usar (qué version de JavaScript/ECMAScript), el
entorno (browser en este caso) y
las reglas recomendadas (eslint:recommended
).
En cuanto a reglas/guías de estilo en sí,
usaremos las recomendaciones por defecto de tanto eslint
como htmlhint
.
Estas pruebas analizarán tus archivos
index.html
,
index.js
,
analyzer.js
y
style.css
para verificar que cumples con los
criterios minimos de aceptacion.
Cada criterio esta relacionado con un objetivo de aprendizaje.
Puedes ejecutar todas estas pruebas con el comando npm run test:oas
como se muestra en la siguiente imagen:
Puedes ejecutar las pruebas de cada grupo de objetivos de aprendizaje de manera individual con los siguientes comandos:
npm run test:oas-html
npm run test:oas-css
npm run test:oas-web-api
npm run test:oas-js
Una prueba end-to-end (E2E) es una técnica de prueba de software en la que se verifica el funcionamiento de todo el sistema desde el inicio hasta el final. En otras palabras, se prueba el flujo completo del software, simulando la interacción del usuario con la aplicación, para asegurarse de que todas las partes del sistema funcionan correctamente en conjunto.
Puedes ejecutar estas pruebas con el comando npm run test:e2e
como se muestra
en la siguiente imagen:
Este repositorio usa una GitHub Action para ejecutar automáticamente las pruebas unitarias, pruebas de criterios mínimos de aceptación y y pruebas end-to-end cada vez que se hagas un push en la rama main de tu repositorio.
Puedes consultar el resultado de esta Github Action en la pestaña Actions de tu repositorio en Github como se muestra en la siguiente imagen:
Antes de comenzar instala lo siguiente:
Después en GitHub:
Luego en una shell ejecuta lo siguiente. Si estas en Windows puedes usar Git Bash:
npm install
playwright
con npx playwright install chromium --with-deps
npm start
y dirígete a
http://localhost:3000
en tu navegador.Súmate al canal de Slack #project-text-analyzer
Antes de agendar tu Project Feedback con un coach, asegúrate que tu proyecto:
npm run test:oas
npm run test
npm run test:e2e
eslint
al ejecutar npm run test
Además recuerda que debes hacer: llenado de sprint check out de cierre de proyecto, una autoevaluación de objetivos de aprendizaje y autoevaluación de life skills desde tu dashboard de estudiante. Acá el link del flujo para que puedas ver el proceso.
Si no has completado todo lo anterior, no consideramos que estás lista para tu sesión de Project Feedback. (acá te dejamos el link de esta instancia).
Reflexiona y luego marca los objetivos que has llegado a entender y aplicar en tu proyecto. Piensa en eso al decidir tu estrategia de trabajo.
Uso de HTML semántico
* [HTML semántico](https://curriculum.laboratoria.la/es/topics/html/02-html5/02-semantic-html) * [Semantics - MDN Web Docs Glossary](https://developer.mozilla.org/en-US/docs/Glossary/Semantics#Semantics_in_HTML)
</p></details>
Uso de selectores de CSS
* [Intro a CSS](https://curriculum.laboratoria.la/es/topics/css/01-css/01-intro-css) * [CSS Selectors - MDN](https://developer.mozilla.org/es/docs/Web/CSS/CSS_Selectors)
</p></details>
Modelo de caja (box model): borde, margen, padding
* [Box Model & Display](https://curriculum.laboratoria.la/es/topics/css/01-css/02-boxmodel-and-display) * [The box model - MDN](https://developer.mozilla.org/en-US/docs/Learn/CSS/Building_blocks/The_box_model) * [Introduction to the CSS box model - MDN](https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Box_Model/Introduction_to_the_CSS_box_model) * [CSS display - MDN](https://developer.mozilla.org/pt-BR/docs/Web/CSS/display) * [display - CSS Tricks](https://css-tricks.com/almanac/properties/d/display/)
</p></details>
Uso de selectores del DOM
* [Manipulación del DOM](https://curriculum.laboratoria.la/es/topics/browser/02-dom/03-1-dom-methods-selection) * [Introducción al DOM - MDN](https://developer.mozilla.org/es/docs/Web/API/Document_Object_Model/Introduction) * [Localizando elementos DOM usando selectores - MDN](https://developer.mozilla.org/es/docs/Web/API/Document_object_model/Locating_DOM_elements_using_selectors)
</p></details>
Manejo de eventos del DOM (listeners, propagación, delegación)
* [Introducción a eventos - MDN](https://developer.mozilla.org/es/docs/Learn/JavaScript/Building_blocks/Events) * [EventTarget.addEventListener() - MDN](https://developer.mozilla.org/es/docs/Web/API/EventTarget/addEventListener) * [EventTarget.removeEventListener() - MDN](https://developer.mozilla.org/es/docs/Web/API/EventTarget/removeEventListener) * [El objeto Event](https://developer.mozilla.org/es/docs/Web/API/Event)
</p></details>
Manipulación dinámica del DOM
* [Introducción al DOM](https://developer.mozilla.org/es/docs/Web/API/Document_Object_Model/Introduction) * [Node.appendChild() - MDN](https://developer.mozilla.org/es/docs/Web/API/Node/appendChild) * [Document.createElement() - MDN](https://developer.mozilla.org/es/docs/Web/API/Document/createElement) * [Document.createTextNode()](https://developer.mozilla.org/es/docs/Web/API/Document/createTextNode) * [Element.innerHTML - MDN](https://developer.mozilla.org/es/docs/Web/API/Element/innerHTML) * [Node.textContent - MDN](https://developer.mozilla.org/es/docs/Web/API/Node/textContent)
</p></details>
Tipos de datos primitivos
* [Valores primitivos - MDN](https://developer.mozilla.org/es/docs/Web/JavaScript/Data_structures#valores_primitivos)
</p></details>
Strings (cadenas de caracteres)
* [Strings](https://curriculum.laboratoria.la/es/topics/javascript/06-strings) * [String — Cadena de caracteres - MDN](https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Global_Objects/String)
</p></details>
Variables (declaración, asignación, ámbito)
* [Valores, tipos de datos y operadores](https://curriculum.laboratoria.la/es/topics/javascript/01-basics/01-values-variables-and-types) * [Variables](https://curriculum.laboratoria.la/es/topics/javascript/01-basics/02-variables)
</p></details>
Uso de condicionales (if-else, switch, operador ternario, lógica booleana)
* [Estructuras condicionales y repetitivas](https://curriculum.laboratoria.la/es/topics/javascript/02-flow-control/01-conditionals-and-loops) * [Tomando decisiones en tu código — condicionales - MDN](https://developer.mozilla.org/es/docs/Learn/JavaScript/Building_blocks/conditionals)
</p></details>
Uso de bucles/ciclos (while, for, for..of)
* [Bucles (Loops)](https://curriculum.laboratoria.la/es/topics/javascript/02-flow-control/02-loops) * [Bucles e iteración - MDN](https://developer.mozilla.org/es/docs/Web/JavaScript/Guide/Loops_and_iteration)
</p></details>
Funciones (params, args, return)
* [Funciones (control de flujo)](https://curriculum.laboratoria.la/es/topics/javascript/02-flow-control/03-functions) * [Funciones clásicas](https://curriculum.laboratoria.la/es/topics/javascript/03-functions/01-classic) * [Arrow Functions](https://curriculum.laboratoria.la/es/topics/javascript/03-functions/02-arrow) * [Funciones — bloques de código reutilizables - MDN](https://developer.mozilla.org/es/docs/Learn/JavaScript/Building_blocks/Functions)
</p></details>
Pruebas unitarias (unit tests)
* [Empezando con Jest - Documentación oficial](https://jestjs.io/docs/es-ES/getting-started)
</p></details>
Módulos de ECMAScript (ES Modules)
* [import - MDN](https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Statements/import) * [export - MDN](https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Statements/export)
</p></details>
Uso de linter (ESLINT)
Uso de identificadores descriptivos (Nomenclatura y Semántica)
Git: Instalación y configuración
Git: Control de versiones con git (init, clone, add, commit, status, push, pull, remote)
GitHub: Creación de cuenta y repos, configuración de llaves SSH
GitHub: Despliegue con GitHub Pages
* [Sitio oficial de GitHub Pages](https://pages.github.com/)
</p></details>
Diseñar en distintos niveles de fidelidad
Seguir los principios básicos de diseño visual
Si terminaste con todas las funcionalidades requeridas, intenta implementar las siguientes funcionalidades opcionales para profundizar en los objetivos de aprendizaje del proyecto:
Puedes habilitar las pruebas unitarias y en end to end de estos casos en los archivos test/analyzer.spec.js y read-only/test/e2e/app.spec.js.