No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Calculando la moda: objetos a partir de arrays

17/30
Recursos

Aportes 44

Preguntas 1

Ordenar por:

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

Yo lo hice con el método Array.prototype.forEach():

const arr2 = [1, 2, 6, 6, 3, 4, 5, 4, 5, 1, 2, 4, 4];

const histogram = array => {
    const obj = new Object();
    array.forEach(element => !obj[element] ? obj[element] = 1 : obj[element]++);
    return obj;
};
console.log(histogram(arr2));

Yo lo implementé similar a la clase, pero con operador ternario en vez de if-else, y para mostrar el mayor elemento, con un Math.max convirtiendo el objeto en arreglo:

const calculateModal = (arr) => {
	let obj = {};
	//Se hace un recorrido del array con map
	arr.map((el) => {
		/*
		Por cada elemento en el array, el método retornará dos cosas dependiendo de la condición en el ternario, si el elemento existe en el objeto, se le va a incrementar el contador de dicho objeto, si no, se crea la propiedad elemento en el objeto y se le asigna un 1.
		*/
		el in obj ? (obj[el] += 1) : (obj[el] = 1);
	});
	/*
	La función Math.max() encuentra el elemento más grande de una lista - arreglo, para ello, convertimos el objeto obj en un array y buscamos en todos los elementos del nuevo array con el spread operator (...)
*/
	console.log(Math.max(...Object.values(obj)));
};

Acá mi solución para determinar la moda, considerando que puede tratarse de bimodal, trimodal, etc.

Resultado bimodal cargado en un array mostrado en consola:

Adjuntaré el código por si quieren probarlo:

const arrayNum = [5, 30, 5, 4, 2, 1, 4];

function listarElementosRepetidos(arrayNum) {
  let objList = new Object();
  arrayNum.forEach((element) => {
    objList[element] = ++objList[element] || 1;
  });
  return objList;
}

function calcularModa(array) {
  const objListNum = listarElementosRepetidos(array);
  const arrayValors = Object.values(objListNum);
  const numeroMayor = Math.max(...arrayValors);
  const arrayObjListNum = Object.entries(objListNum);
  const arrayMatrizModal = arrayObjListNum.filter(
    (elementArrayActual) => elementArrayActual[1] === numeroMayor
  );
  const arrayModaElements = arrayMatrizModal.map((arrayActual) => {
    return arrayActual[0];
  });
  return arrayModaElements;
}

const moda = calcularModa(arrayNum);
console.log(moda);

Si quieren saber como Juan mueve toda una linea de codigo para arriba y para abajo sin necesidad de copiar y pegar con el mouse, simplemente tocan la linea de codigo que quieren mover, luego presionan la tecla alt y manteniendo presionado mueven con las flechitas. de nada 😃)

Este ejemplo muestra el ordenamiento de un objeto a su propiedad edad.

let people = [
    { name: "John", age: 30 },
    { name: "Mike", age: 25 },
    { name: "Sarah", age: 35 }
];
people.sort(function (a, b) {
    return a.age - b.age;
});
console.log(people);
/* Output:
[
    { name: "Mike", age: 25 },
    { name: "John", age: 30 },
    { name: "Sarah", age: 35 }
]
*/

Fue un poco complejo pero logré sacar la moda del array, aunque me tomó un buen rato jajaja:

No se si es la mejor forma y probablemente en la siguiente clase se verá una forma más sencilla, pero estoy contento con mi solución 😄 .

function moda (array){
  const ordenarLista = array.sort(ordenar = (a,b)=>a-b)
  const arrayFInal = [];
  const repeticion =[];
  let   resultado ;


console.log(ordenarLista);

ordenarLista.forEach((objeto,index,array)=>{       
  if (objeto == array[index+1] && !arrayFInal.includes(objeto)){
    arrayFInal.push(objeto);
    resultado = array.filter((a)=>{
    return a==objeto;
                                  })
    repeticion.push(resultado.length);    
        }
         
        })

for(let i= 0; i < repeticion.length; i++ ){
  console.log("El número "+arrayFInal[i],"se repite "+repeticion[i]+" veces")
          };
            
    const vecesMayor= Math.max(...repeticion);
    const indexVecesMayor = repeticion.indexOf(vecesMayor);
    console.log("La moda del Array indicado es " + arrayFInal[indexVecesMayor]) 
        }
      


moda([1,2,3,4,4,5,5,5]);

AGREGAR PROPIEDADES A UN OBJETO

Para agregar un valor podemos usar:

  1. la clave dentro de comillas y éstas dentro de corchetes. Esta manera se recomienda cuando la key tiene un nombre de dos o más palabras separadas

  2. La clave dentro de corchetes SIN COMILLAS. Esta manera se recomienda cuando la key hace referencia a una variable.

  3. la sintaxis del punto. Se recomienda usarla cuando la key tiene un nombre de una sola palabra

lo hice con for-of, me parece mas sencillo asi

const list = [1,2,2,3,'a','a','a']
const modaViewer = {}
for(let item of list){
    if(modaViewer[item]){
        modaViewer[item] +=1
    }
    else{

        modaViewer[item] = 1
    }
}

Yo soy más de guardar apuntes en libreta para repasarlos, aquí una mini explicación

FUNCIÓN PARA CALCULAR LA MODA (UNIMODAL, BIMODAL Y MULTIMODAL)

He utilizado los siguientes métodos:

  • Array Method: Array.prototype.find( )

  • Array Method: Array.prototype.indexOf( )

  • Array Method: Array.prototype.filter( )

  • Array Method: Array.prototype.push( )

  • Object Method: Object.keys( )

  • Object Method: Object.values( )

Slides:















Revisemos las características de un Objeto para entender mejor la función para calcular la moda


Utilizando varios metodos

const calcularModa = (array) => {
    let conteo = {}
    for(let element of array) {
        if (!conteo[element]) {
            conteo[element] = 0;
        }
        conteo[element] += 1;
    }

    let repticiones= Object.values(conteo).sort((a, b) =>  a - b)
    repticionesMasAltas = repticiones[repticiones.length -1]
    let indexMax = (Object.values(conteo).indexOf(repticionesMasAltas))
    let elementoMasRepetido = Object.keys(conteo)[indexMax]


    return `El elemnto que más se repite es ${elementoMasRepetido} con ${repticionesMasAltas} veces`
}

Asi los solucione yo

const unique = [];
const moda = [];

lista.forEach((l) => {
  if (!unique.includes(l)) {
    unique.push(l);
  }
});
// console.log(unique);

unique.forEach((e) => {
  let m = lista.filter((f) => f === e);
  moda.push({
    id: e,
    moda: m.length,
  });
});
// console.log(moda);

let max = 0;
let numModa = 0;

moda.forEach((m) => {
  if (m.moda > max) {
    max = m.moda;
    numModa = m.id;
  }
});

console.log(`La moda de la lista es ${numModa} con ${max} repeticiones`);

Con el método reduce:

function calcularModa(lista){
    const listaCount = lista.reduce((obj, elemento) => {
        if(!obj[elemento]){
            obj[elemento] = 1;
        }else{
            obj[elemento]++;
        }
        return obj;
    }, {});
    console.log(listaCount)
}
function calcModa(lista){
  const elementos={};

  for (let i=0; i<lista.length; i++){
    const elemento= lista[i];
    if(elementos[elemento]){
      elementos[elemento] += 1;
      console.log(elementos[elemento]);
    }else{
      elementos[elemento]=1;
      console.log(elementos[elemento])
    }
  }
  console.log(elementos);
}

Me encantó esta serie de ejercicios, desde un principio me propuse a integrarlos todos con un input del user.

Con un poquito de manipulación del DOM y algunos estilos pudiera mostrarles que tal quedaría, o si quieren que suba el código para que puedan interactuar con el avísenme 😃

Con el método de foreach.

const arrayTest2 = [1,2,3,4,5,6,7,8,9,9,9,9,9,9,9,9,9,9,'abc'];
function calculateModa(array) {

    let repeatedElements = {};

    array.forEach(element => {
        const index = element;

        if (repeatedElements[index]) {
            repeatedElements[index] += 1; 
        } else {
            repeatedElements[index] = 1; 
        }
    });
    console.log(repeatedElements);
}

calculateModa(arrayTest2);

Mi solución se basó en poder encontrar la moda sin la ayuda de objetos, es un poco más largo, pero se logró, funciona igual.

function moda(array){

    let acum = 0;
    const arrayValues = [...new Set(array)]
    
    const newArray = arrayValues.map((numA)=>{
        let acum = 0;
        array.map( numB => numB == numA ? acum++ : '' )
        return acum;
    });

    newArray.map(item => item > acum ? acum = item : '' );
    const indextMax = newArray.findIndex(item => item==acum);

    return arrayValues[indextMax];
}

Una forma más resumida (en mi opinión) sería la siguiente:

function listRepeatedElements(list) {
  const listCount = {};

  list.forEach(element => {
    listCount[element] = (listCount[element] || 0) + 1;
  });

  return listCount;
} 

Considero que con el método .filter puede conseguir los números repetidos (moda) y que estos se guarden en una variable.

Esta es mi solución para determinar la cantidad de veces que los elementos se encuentran en una lista de valores.

const moda = (array) => {
	let storage = {};
	let answerModa;
	for (let number of array) {
		//storage[number]-->key
		!storage[number] ? (storage[number] = 1) : storage[number]++;
	}
	let max = Math.max(...Object.values(storage));
	for (let key in storage) {
		if (storage[key] == max) {
			answerModa = key;
		}
	}
	return `La moda es ${answerModa} y se repite ${max} veces`;
};

Buenas a todos, aquí mí solución. creo que es simple pero funciona. 😃

function moda(arr){

    let arrComparador = [];
    let arrMayor = [];
    let moda;

    for (let i = 0; i < arr.length; i++) {
        arrComparador = arr.filter((e) => e == arr[i]);

        if(arrComparador.length > arrMayor.length){
            arrMayor = arrComparador;
        }
    }

    moda = arrMayor[0];
    console.log(`La moda es ${moda}`);
}

Mi solución es superlargo pero me retorna una lista de objetos con elementos que más se repiten

function getFashion(list) {
    const repeatedObjects = [];

    list.forEach(function (element) {
        // Si el "element" es repetido retorna ese objeto en findMatches
        const findMatches = repeatedObjects.find((object) => {
            return object.name == element;
        });

        // Si findMatches es distinto a undefined es porque ya exite ese objeto en la lista
        if (findMatches !== undefined) {
            findMatches.timesRepeated += 1;
        }
        // Sino, simplemente agrega ese nuevo objeto a la lista
        else {
            repeatedObjects.push({
                name: element,
                timesRepeated: 1,
            });
        }
    })

    // orderedListOfRepeatedTimes me retorna una lista ordenada de veces repetidas de manera descendiente
    const orderedListOfRepeatedTimes = repeatedObjects.sort((accValue, currValue) => {
        return accValue.timesRepeated - currValue.timesRepeated;
    });

    // obtenemos el último elemento porque es el elemento con más veces repetidas
    const lastElementOfTheOrderedList = orderedListOfRepeatedTimes[orderedListOfRepeatedTimes.length - 1];

    // obtenemos todos los elementos que tengan las misma cantidad de veces repetidas
    const fashion = orderedListOfRepeatedTimes.filter((object) => {
        return object.timesRepeated === lastElementOfTheOrderedList.timesRepeated;
    });
    return fashion;
};

Yo lo hice así

function calcularModa(lista) {
    const listaCount = {}
    lista.forEach(item => listaCount[item] = (listaCount[item] ?? 0) + 1)
    return listaCount
}
Resolví todo el ejercicio desde el inicio, pero les comparto solo donde creo el objeto con el contador de las repeticiones ```js function moda(arr){ const mod = arr.reduce((acc, num) => { if(!acc[num]){ acc[num] = (acc[num] || 0) + 1 }else{ acc[num] += 1 } return acc }, {}) return mod } ```
Donde se le suben la dificultad a los bots XD . ```js const dataModa = [1,1,1,1,1,1,115,4,2,9,8,7,3,6,10,100000,0,1,2,2,4,5,5,5,47,7,7,7,9,4]; const newModa = (data) => { const objData = {} data.forEach((num) => objData[num] = (objData[num] || 0) + 1) let maxData = ['', 0]; Object.entries(objData).forEach(([key, value]) => { if (value > maxData[1]) { maxData = [key, value] } }) return maxData } console.log(newModa(dataModa)) ```
Yo lo hice así: ```js function calcularModa(arr) { const element = {} arr.forEach(value => { if(element[value]){ element[value]++ } else{ element[value] = 1 } }); let moda = [] let mayor = 0 for (const key in element) { if(element[key] == mayor){ moda.push(+key) } else if(element[key] > mayor){ mayor = element[key] moda = [] moda.push(+key) } } return moda } console.log(calcularModa([1,1,1,2,3,4,5,6,6,6,6,3,4,2,1,8,8,8,8,9,9,9,9,7,7,7,7,7])) ```function calcularModa(arr) { const element = {} arr.forEach(value => { if(element\[value]){ element\[value]++ } else{ element\[value] = 1 } }); let moda = \[] let mayor = 0 for (const key in element) { if(element\[key] == mayor){ moda.push(+key) } else if(element\[key] > mayor){ mayor = element\[key] moda = \[] moda.push(+key) } } return moda } console.log(calcularModa(\[1,1,1,2,3,4,5,6,6,6,6,3,4,2,1,8,8,8,8,9,9,9,9,7,7,7,7,7]))
Este es mi aporte, trate de hacerlo con reduce: ```js function calcularModa (arr){ const frecuenciaDatos = arr.reduce((acc, elem) => { if(!acc[elem]){ acc[elem] = 1 } else { acc[elem] += 1 } return acc }, {}) moda = []; maxFrecuencia = 0; for (const key in frecuenciaDatos) { if (frecuenciaDatos[key] > maxFrecuencia) { moda = [key]; maxFrecuencia = frecuenciaDatos[key]; } else if(frecuenciaDatos[key] == maxFrecuencia){ moda.push(key) } } return console.log({moda}) } ```
Yo lo resolví así: ```js let ratings = [10, 10, 10, 10, 10, 5, 7, 7, 7, 7, 3, 3, 2]; //Moda const calculateMode = () => { const warehouseObject = {}; ratings.forEach((item) => { warehouseObject[item] = (warehouseObject[item] ?? 0) + 1; //console.log(warehouseObject); }) //console.log(warehouseObject); let keyArray = Object.keys(warehouseObject); //console.log(keyArray); let valueArray01 = Object.values(warehouseObject); //console.log(valueArray01); let valueArray = Object.values(warehouseObject); let orderValueArray = valueArray.sort((a, b) => { return a - b; }); let index = valueArray01.indexOf(orderValueArray.at(-1)) //console.log(index); console.log(keyArray[index]) return keyArray[index]; } calculateMode(ratings); ```
```js let arreglo = \[3, 2, 4, 1, 7, 4, 3, 4, 2, 4]; function createMap(arreglo){    let historigrama = new Map();    arreglo.forEach((e)=>{    let count = 0;        for(let i = 0; i < arreglo.length; i++){            if(e==arreglo\[i]){                count++;            }        }                historigrama.set(e,count);}); return historigrama;} let historigrama = createMap(arreglo);let moda = historigrama.get(1);let arregloKeys = \[...historigrama.keys()]; for(let i = 0; i < arregloKeys.length; i++ ){        if(historigrama.get(arregloKeys\[i]) > historigrama.get(moda)){                    moda = arregloKeys\[i];    }}console.log(`La moda es: ${moda}`) ```
Hola, aqui esta mi solucion. Observando la solucion de algunos aqui, me pregunto si no fue muy larga XD (si que lo fue) Pero, trabaje de la manera mas generica posible. ```js let arreglo = \[3, 2, 4, 1, 7, 4, 3, 4, 2, 4]; /\*Esta funcion cuenta cuantas veces se repite cada elemento, crea un Map, donde la clave de ese map es el elemento, y el valor es la cantidad de veces que se repite ese elmento. Use un map, por que cuando usaba un arreglo de objects, los elementos al agregarse, podian repetirse, asi que, para no gastar tiempo buscando una forma de evitar que se agregaranrepetidos, pues utilice un colection map, que se, no se repiten.  \*/function createMap(arreglo){    let historigrama = new Map();    arreglo.forEach((e)=>{    let count = 0;        for(let i = 0; i < arreglo.length; i++){            if(e==arreglo\[i]){                count++;            }        }                historigrama.set(e,count);}); return historigrama;} //pasamos el historigrama map, para luego identificar uno al azar como la actual moda, y trabajar de ahi en adelante. let historigrama = createMap(arreglo);let moda = historigrama.get(1);let arregloKeys = \[...historigrama.keys()]; for(let i = 0; i < arregloKeys.length; i++ ){        if(historigrama.get(arregloKeys\[i]) > historigrama.get(moda)){                    moda = arregloKeys\[i];    }}console.log(`La moda es: ${moda}`) ```

Mi humilde aporte aunque falta optimizar. ya que entra al bucle nuevamente cuando se repite

const BuscquedaModa = (arreglo, callback) => {
    let tipoModa=0;
    let contador = 0;
    let cuenta = 0;
    let modas=[];
    let mensaje='';
    
    arreglo.map(p => {
        cuenta = 0
        arreglo.map(x => {
            if (p == x) { cuenta++ }
        })
        
        if (cuenta > contador) {
            //unimodal
            contador = cuenta;
            modas.pop();
            modas.push(p);
        }else if(cuenta == contador && !modas.some(function(m){return m==p})){
            //bimodal && multimodal
            modas.push(p);
            indice=modas.length-1;
            tipoModa=1;
        }
    });
    
    modas.forEach(function(moda,i,lista){
        if (i==lista.length-2){
            mensaje+=moda+" y ";
        }else{
            mensaje+=moda+",";    
        }
    });
    
    mensaje=mensaje.substring(0,mensaje.length-1);
    
    if (tipoModa==0){
        callback(`La Moda es: ${mensaje}, se repite ${contador} veces.`);
    } else if (tipoModa==1){
        callback(
        `La Moda tiene los valores: ${mensaje}, el numero de veces que se repite es: ${contador}`);
    }
}

const arreglo = [2,3,4,3,5,3,4,5,3,6,7,8,4,4,5,6,5];
BuscquedaModa(arreglo, (respuesta) => {
    console.log(`${respuesta}`)
});

lista la tarea:
html

<!DOCTYPE html>
<html lang="es">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Promedios</title>
</head>
<body>
<form action="">
    <label for="name">Agregar un nuevo Integrante</label>
    <input type="text" id="name">
    <input type="number" id="age">
    <input type="button" id="addNewMember" value="Agregar Miembro">
    <input type="button" id="killMembers" value="Borrar a todos">
    <input type="button" id="calcAverage" value="Hacer el Promedio de edad">
    <input type="button" id="calcMid" value="Conseguir la Mediana de edad">
    <input type="button" id="calcModa" value="Conseguir la Moda de edad">
</form>

<h3>Integrantes:</h3>
<ul id="membersList">
</ul>

<p id="msg"></p>
<script src="function.js"></script>
</body>
</html>

JS

const addNewMemberBtn = document.getElementById('addNewMember');
const killMembersBtn = document.getElementById('killMembers');
const calcAverageBtn = document.getElementById('calcAverage');
const calcMidBtn = document.getElementById('calcMid');
const calcModaBtn = document.getElementById('calcModa');
let allMembers = [];



const addNewMember = (event) => {
    event.preventDefault();

    const nameInput = document.getElementById('name');
    const ageInput = document.getElementById('age');
    let name = nameInput.value;
    let age = ageInput.value;
    let list = document.getElementById('membersList');

    allMembers.push({
        'name': name,
        'age': age,
    });

    let newMember = document.createElement('li')
    newMember.setAttribute('class', 'memberList')
    
    newMember.textContent = `Nombre: ${name}, Edad:${age}.`
    list.appendChild(newMember);

    nameInput.value = '';
    ageInput.value = '';
}

const killMembers = (event) => {
    event.preventDefault();

    let list = document.getElementById('membersList');
    let msg = document.getElementById('msg'); 

    while(list.firstChild){
        list.removeChild(list.firstChild)
    }

    allMembers.length = 0;
    msg.textContent = '';
}

const calcAverage = (event) => {
    event.preventDefault();

    let msg = document.getElementById('msg');
    
    const counter = allMembers.reduce((totalValue, newValue) => totalValue + Number(newValue.age), 0)

    let average = counter / allMembers.length;
    msg.innerHTML = `El promedio de edad de los miembros es de ${average}`
}

const calcMid = (event) => {
    event.preventDefault();

    let msg = document.getElementById('msg');
    
    const order = allMembers.sort((a, b) => Number(a.age) - Number(b.age))
    
        if(allMembers.length % 2 != 0){
            const midIndex = Math.floor(allMembers.length / 2)

            msg.innerHTML = `La mediana de edad de los miembros es de ${order[midIndex].age}`

        } else {
            const indexOne = Math.floor(allMembers.length / 2);
            const indexTwo = indexOne - 1;
            
            const middValue = (Number(allMembers[indexOne].age) + Number(allMembers[indexTwo].age))/2

            msg.innerHTML = `La mediana de edad de los miembros es de ${middValue}`

        }
}

const calcModa = (event) => {
    event.preventDefault();

    let msg =  document.querySelector('#msg');
    const ageOfMembers = allMembers.map(member => member.age).sort((a,b) => a - b);

    let commonAge = null;
    let modaAge = null;
    let counter = 0;
    let modaCounter = 0;

    for(var i = 0; i < ageOfMembers.length; i++){
        if(ageOfMembers[i] === commonAge) {
            counter++;
        } else {
            counter = 1;
            commonAge = ageOfMembers[i]
        }

        if(counter > modaCounter) {
            modaAge = ageOfMembers[i];
            modaCounter = counter;
        }
    }

    if(modaCounter != 1) {
       msg.innerHTML = `La Moda etarea esta en los ${modaAge} anios de edad, con un total de ${modaCounter} miembros`

       const modaMembers = document.querySelectorAll('.memberList')
       
       modaMembers.forEach(listMember => {
        if(listMember.textContent.endsWith(`Edad:${modaAge}.`)){
            listMember.style.color = 'green';
            listMember.style.fontWeight = 'bold';
        }
       }

       )

    } else {
        msg.innerHTML = "Todos tienen edades distintas, por lo que no hay moda en este grupo."
    }

}

addNewMemberBtn.addEventListener('click', addNewMember);
killMembersBtn.addEventListener('click', killMembers);
calcAverageBtn.addEventListener('click', calcAverage);
calcMidBtn.addEventListener('click', calcMid);
calcModaBtn.addEventListener('click', calcModa);


Yo calculé la moda de un array de números de esta forma. ¿Qué ventajas tiene llevar la cuenta en un objeto de cuántas veces se repite un elemento respecto a esta manera que pensé yo?

array = [1, 10, 14, 3, 24, 14, 10, 10, 10, 10, 35, 13, 14];

function moda(arr) {
	let newArr = [];
	arr.forEach(element => {
		const arrFiltrado = arr.filter(el => el === element);
		if (arrFiltrado.length > newArr.length) {
			newArr = arrFiltrado;
		}
	});
	return newArr[0];
}

Hola, estoy tratando de hacer todos estos cursos con TypeScript. Les comparto mi código de Moda con TS:

const calcularModa = (list:(number| string)[]): void => {
    const listaCount:{[key: (string | number)]: number} = {};
    for(let i:number = 0; i < list.length; i++) {
        const elemento:(string |number) = list[i];
        if(listaCount[elemento]){
            listaCount[elemento] += 1;
        } else {
            listaCount[elemento] = 1;
        }
    }
    console.log(listaCount);
};

Pues al final era más fácil de lo que pensaba xd

Intente sacar la moda con el método del profesor y este fue mi resultado:

Me siento orgulloso :´)…me salió la moda tomando el reto que da el prof en el minuto 1 de la clase.

Esta es mi solucion, lo resolvi antes de ver la clase 😄
y por lo que veo habian maneras muuuuuuuuuucho mas cortas de hacerlo jajaja pero aun asi me enorgullece haberlo podido resolver :3

function moda (lista) {

    let listaDigitos = []

    function modaObjects(digito, repeticiones){
        this.digito = digito;
        this.repeticiones = repeticiones;
    }

    for (let i = 0; i < lista.length; i++) {

        let encontrarDigito = listaDigitos.find(function(numero){
            return numero.digito == lista[i];
        });

        if (encontrarDigito){
             
        } else {
            let rep = 0

            for (let j = 0; j < lista.length; j++) {
                if (lista[i] == lista[j]) {
                    ++rep;
                } else {
                    
                }
            }

            let digitoIndividual = new modaObjects(lista[i], rep);
            listaDigitos.unshift(digitoIndividual);
        }
    }    

    let listaRepeticiones = listaDigitos.map(function(rep){
        return rep.repeticiones;
    });

    let repeticionMayor = Math.max(...listaRepeticiones);

    let objetoModa = listaDigitos.find(function(objeto){
        return objeto.repeticiones == repeticionMayor;
    }); 

    console.log(listaDigitos);
    return `La moda seria --> ${objetoModa.digito}`;
}

Moda:

Elemento que mas veces se repite. En el contexto de JavaScript y de los arrays: será el elemento que mas veces se repita en un array.

Paso a paso de la clase:

Para encapsular nuestro código y poder reutilizarlo creamos la función calcularModa:

function calcularModa(array) {
	
}

Lo primero que debemos hacer para calcular la moda en JavaScript es guardar en algun lugar la cantidad de veces que aparece cada uno de los elementos en el array.

En este ejemplo crearemos un objeto en el que por cada elemento del array se va a crear una propiedad dentro del objeto, en caso de que se repita el elemento no se creará una nueva propiedad sino que se sumara al valor de la propiedad existente para dicho elemento. Esto lo logramos recorriendo el array con un ciclo for y sumando uno más si el elemento ya existe en el objeto y si no, creamos una nueva propiedad en el objeto:

function calcularModa(array) {
	const arrayCount = {};
	
	for (let i = 0; i < array.length; i++) {
		const elemento = array[i];

		if(arrayCount[elemento]) {
			arrayCount[elemento] += 1;
		} else {
			arrayCount[elemento] = 1;
		}

	}

		console.log(arrayCount);
}

Resumen:

Para calcular la moda de un array lo primero que debemos hacer es obtener la cantidad de veces que existe cada uno de los elementos dentro del array y esta información guardarla en algun lugar, para esto, podemos utilizar un objeto en el cual la propiedad será el mismo elemento y su valor inicial será 1, pero si se repite uno o varios de los elementos del array, el valor de la propiedad respectiva aumentará para dicho elemento.

Realicé esta implementación. Tienen en cuenta si existen varias modas:

  1. Recorrer la lista y almacenar en un objeto los números y sus frecuencias.
  2. Calcular la frecuencia más alta.
  3. Revisar en el objeto, cuál de sus propiedades (el número de la lista) coincide con la frecuencia más altan para almacenarla en un array de retornarlo.
const lista = [1, 3, 4, 14, 11, 12, 14, 10, 9, 14, 10, 10, 1, 1];

//Devuelve un array con la moda, esto en caso que la lista tenga varios elementos con la misma frecuencia
function getModa(lista) {
  //Contar las frecuencias para cada uno de los elementos de la lista
  //Los números de la lista se almacenan como propiedades y su frecuencia como el valor
  const contarFrecuencias = {};

  for (item in lista) {
    if (
      contarFrecuencias[lista[item]] === null ||
      contarFrecuencias[lista[item]] === undefined
    ) {
      contarFrecuencias[lista[item]] = 1;
    } else {
      contarFrecuencias[lista[item]] += 1;
    }
  }
  //Obtener la frecuencia más alta (revisando su frecuencia)
  values = Object.values(contarFrecuencias);
  maxValue = Math.max(...values);

  const modaArray = [];

  for (prop in contarFrecuencias) {
    if (contarFrecuencias[prop] === maxValue) {
      modaArray.push(prop);
    }
  }

  return modaArray;
}
console.log(getModa(lista));

Yo lo resolví con for of:

yo lo había hecho así