Método sort

Taller Práctico de JavaScript: Matemáticas y Estadística Básica

Contenido del curso

Introducción

1
¿Ya tomaste el Curso Práctico de JavaScript?
08:20 min

Matemáticas en JavaScript

Porcentajes

Estadística básica

Análisis de salarios

Próximos pasos

30
Toma el Taller Práctico de JavaScript: Videojuegos
04:27 min

Tomar examen

Método sort

Todos los cursos GRATIS

Se acaba en:

00díasd:00hrsh:00minm:00segs

Comentarios41

Sebastian Silva

Estudiante

Hace 4 años

La verdad, la verdad, la verdad.... hace un par de clases que me perdi, pero aqui seguimos, tratando de entenderle sin que me explote la cabeza jeje

Julio Peña

Estudiante

Hace 4 años

A lo mejor es un poquito tarde para darte un consejo xd pero a todos los demás que se sientes perdidos les doy un par de consejos:

Repitan los videos las veces que sean necesarias 2.Intenten hacer los retos por su propia cuenta, y si después de intentarlo y no lograrlo, vean las soluciones que publican aquí. 3.Todas las cosas que no entiendan búsquenlas por fuera, ya sean tutoriales de YT o documentación en línea. 4.Una vez ya tengan una idea más sólida de cada método traten de hacer/replicar código por su propia cuenta, jueguen con su código.

A mí me ha costado bastante pero siguiendo estos consejos he logrado entender muchas clases e incluso adelantarme un poco a lo que Juan vaya a explicar, mucho ánimo!!

Henry Alexander Velásquez Rosas

Estudiante

Hace 3 años

Si no entienden algo, pregunten a un Chat con IA. 😃✌

Dave Juanes

Estudiante

Hace 4 años

Revisando la documentación oficial JS Sort, encontre esta misma logica, la función ordernarLista es opcional, los parametros a, b siempre hacen una diferencia pero en base al valor UNICODE. Si usamos array.sort() en el caso de un array [1,10,2,20] seria correcto por sus valores UNICODE, pero en este caso nuestra funcion ordernarLista es lo correcto para hacer un ordenamiento real de numeros. Les dejo el enlace JavaScript - Sort :rocket:

Sebastian Pacheco Lopez

Estudiante

Hace 4 años

hola profe y compañeros, creo que me quedo claro el método .sort pero me queda una duda, es posible que la lista no quede ordenada por completo en un solo recorrido por el array, el método sigue iterando hasta que ya no se tenga que cambiar ninguna posición o debemos tener eso en cuenta?

Juan Castro

Profesor

Hace 4 años

¡Exactamente! JS lo que hará es dar y dar vueltas de la forma en que te expliqué hasta que pase sin cambios y así pueda determinar que la lista quedó ordenada. :D

Precisamente este tipo de "problemas" son los que estudiamos a más profundidad con los algoritmos de ordenamiento y la complejidad algorítmica. :100:

Sergio Alejandro Saldaña Rangel

Estudiante

Hace 4 años

Dejo mis apuntes de la clase por si te sirven de algo ✨

Apuntes chidos 📝

sebastian ramos

Estudiante

Hace 4 años

gracias

Mateo Arias Correa

Estudiante

Hace 4 años

Implemente le método Sort para que ordene de menor a mayor, recomiendo el curso de manejo de arrays con js, de verdad que hacerlo, me ha ayudado mucho a entender este.

////Función para hallar el Promedio
function average(array){
    console.log('Los datos que ingreso fueron: ',array)
    const suma= array.reduce((sum,item)=>item+sum,0);
    return averageResult=suma/(array.length)
}

/// Función para saber si es par o impar 
function median(array){
    console.log('la lista desordenada es:', array)
    let orderedList=array.sort((a,b)=>a-b)
    console.log('la lista ordenada es:', orderedList);
    const number=(orderedList.length)%2; 
    if(number==0){
        //es par
        let iUno= Math.floor((orderedList.length/2));
        let iDos= Math.floor((orderedList.length/2)+1);
        let resultmedian=average([iUno,iDos]);
        console.log('El resultado de la mediana es:',resultmedian )
    }else{
        //es impar
        let iUno=Math.floor((orderedList.length/2));
        let iDos=Math.floor((orderedList.length/2)-1);
        let resultmedian=average([iUno,iDos]);
        console.log('El resultado de la mediana es:',resultmedian )
    }
};
median([1,6,3,8,5,9,7]);

Lautaro Emanuel

Estudiante

Hace 4 años

Entonces si retorna positivo hace el flip y si retorna negativo o 0 no?

Juan Castro

Profesor

Hace 4 años

Correcto

JORGE ALEXANDER MÚNERA CANABAL

Estudiante

Hace 4 años

Un aporte, hay que tener en cuenta que el metodo sort() modifica nuestro array original y si por alguna razón necesitamos la lista en el orden original vamos a tener problemas despues. Por tanto utilizaria el operador de propagacion, que me crea una copia con una referencia en memoria diferente, por tanto la lista original queda igual. La función calcularMediana me quedaría asi

//es par
const isEven= (arr)=> arr.length%2 === 0 ? true : false;

//es impar
const isOdd = (arr)=> !isEven(arr);

//calcular Mediana
function calcularMediana(arr){
    const arrOrdenado=[...arr].sort((a,b)=>a-b)
    console.log(arrOrdenado);
    let mediana
    if(isEven(arrOrdenado)){
        mediana = (arrOrdenado[arrOrdenado.length/2]+arrOrdenado[(arrOrdenado.length/2)-1])/ 2
        return mediana
    }
    else {
        mediana = arrOrdenado[(arrOrdenado.length-1)/ 2]
        return mediana
    }
}

Ezequiel Dastolfo

Estudiante

Hace 4 años

Con el método sort, cuando se trata de strings no es necesario pasar argumentos:

let names = ['Charles','John', 'Peter', 'Adam', 'Christian']
names.sort ();
console.log (names);

// Con números no da el resultado sin pasar argumentos por la forma en la que Javascript le da jerarquía a las letras y los números (tabla ascii)
numbers2.sort ();
console.log (numbers2);

El método sort con números entonces también se puede pasar con una función flecha, de forma acscendente o descendente:

let numbers2 = [200, 50, 1000, 20, 30, 8]

const ascendente = numbers2.sort ((a,b) => a - b);
console.log (ascendente);

const descendente = numbers2.sort ((a,b) => b - a);
console.log (descendente);

Diego Fernando Ortiz Gamboa

Estudiante

Hace 4 años

Así realicé mis algoritmos

// ! Explanation of the reduce method.

const arrayTest = [1,2,3,4,5,6,7,8,9];
// Esta función se va a enviar como parámetro.

function reduceEngine(initialValue, SumValue){
    // The initial value is a value that is the position that is sent to the method
    // Sum is the result of the process.
    return initialValue + SumValue ;
}

// Here we put the function of how the engine works in the reduce method 
const reduceMethodWithArrays = arrayTest.reduce(reduceEngine);

// ! End of the explanation of the reduce method.


//! Calculation of the median

// Second challenge to know if a number is odd or even.
const checkEven = (number) => (number % 2 != 0) ? false : true;

// Engine to the sort function works!
// * Basically works using the a, as the initial position and b, as the second position. If b is higher ll be reposition the a as b and reverse. 
function sortEngine(a, b) {
    return a - b ;
};

// If the array is on its length odd, ll be return the position as the middle character of the array and, if its even ll return two positions the middle and the middle plus one.

let positionA;
let positionB;
function calculatePosition(array) {
    if (!checkEven(array.length)) {
        positionA = Math.floor(array.length / 2);
        return positionA
    } else {
        positionA = Math.floor(array.length / 2);
        positionB = Math.floor(array.length / 2) - 1;
    }
};

// Result of the array sorted
const arraySorted = (array) => (array.sort(sortEngine));
const sortedArray = arraySorted(arrayTest);

// Median algorithm.

let medianValue;
function calculateMedian(array) {
    calculatePosition(array);
    indexOne = positionA;
    indexTwo = positionB;
    (!indexTwo) ? medianValue = array[indexOne] : medianValue = (array[indexOne] + array[indexTwo]) / 2 ;
    console.log(medianValue);
}

calculateMedian(sortedArray);

Andres Felipe Avila Rojas

Estudiante

Hace 3 años

const lista = [1, 23, 39, 4, 67, 90];
let mediana = 0;

//Funcion para validar si un arreglo es par o impar 
function esPar(lista) {
    let validador = lista.length % 2 == 0 ? true : false;
    return validador;
}

//Funcion para ordenar los elementos del arreglo mediante sort 


function ordenarLista(listaDesordenada){
    return listaDesordenada.sort((valorAcumulado,valorNuevo) => {return valorAcumulado-valorNuevo}); 
}
function calcularMediana(lista) {
    if (esPar(lista)) {
        let ordenarListas = ordenarLista(lista); 
        const posicion1 = (lista.length / 2) - 1;
        const posicion2 = lista.length / 2;
        console.log(posicion1, posicion2);
        mediana = lista.reduce(() => {
            return (lista[posicion1] + lista[posicion2]) / 2
        });
        return mediana;
    } else {
        const posicion = Math.floor((lista.length / 2));
        mediana = lista[posicion];
        return mediana;
    }
}
calcularMediana(lista);

Kevin Ivan Garcia Hernandez

Estudiante

Hace 3 años

Ojala sigan haciendo más cursos que sean más enfocados a las soluciones en general, como el de diseño de patrones. Uno de algoritmos de ordenamiento estaría genial

Juan Castro

Profesor

Hace 3 años

Mira: https://platzi.com/cursos/ordenamiento/

Regina Victoria Juárez Miranda

Estudiante

Hace 4 años

Si el resultado es negativo, a se ordena antes que b.
Si el resultado es positivo, b se ordena antes de a.
Si el resultado es 0, nada cambia. https://www.freecodecamp.org/espanol/news/ordenar-arreglos-en-javascript-como-usar-el-metodo-sort/

Enrique Carrillo Vásquez

Estudiante

Hace 3 años

Mi solución: const numbersArray = [40, 10, 50, 20,1000,4500];

function calculaPromedioReduce(numbers) { const suma = numbers.reduce((sum, value) => sum + value); return suma / numbers.length; }

function isPar(numbers) { return !(numbers.length % 2); }

function calculaMediana(numbers) { const arraySorted = numbers.sort((a, b) => a - b); let pos = Math.floor(arraySorted.length / 2); return isPar(arraySorted) ? calculaPromedioReduce([arraySorted[pos], arraySorted[pos - 1]]) : arraySorted[pos]; }

console.log(calculaMediana(numbersArray));

Javi Johan Rodríguez Giraldo

Estudiante

Hace 3 años

Pueden crear una función que haga el Sort

function sortList(array) {
    return array.sort((a, b) => a - b)
}

y así solo la invocan, recuerden que Sort es un método mutable y cambia el array original

let arraySalarios = [288, 92, 765, 437, 666, 495, 342, 123, 156, 992, 906, 732, 448, 331, 254, 454, 703, 745, 983, 473, 946, 714, 954, 691, 618, 892, 722, 505, 548, 429, 710, 27, 348, 514, 372, 264, 912, 534, 840, 888, 838, 954, 832, 559, 935, 847, 54, 491, 411, 905, 376, 141, 85, 641, 516, 710, 808, 409, 836, 437, 541, 902, 280, 693, 812, 731, 168, 151, 487, 290, 667, 643, 695, 738, 37, 809, 955, 758, 654, 497, 938, 576, 547, 708, 751, 84, 97, 726, 877, 278, 73, 767, 256, 745, 514, 950, 137, 129, 57, 104, 242, 24, 396, 459]


console.log(calcularMediana(sortList(arraySalarios)));

Alejandro Ramos

Estudiante

Hace 3 años

gracias al metodo reduce entendi el metodo sort :D

Silvia Corrales

Estudiante

Hace 4 años

Mis notas de la clase:

Método sort:

Ordena los elementos de un arreglo (array) localmente y devuelve el arreglo ordenado.

Sintaxis:

Este método recibe una función callback que se encargara de hacer la comparacion entre cada uno de los elementos del array. arr.sort([compareFunction]): arrayDesordenado.sort((a, b) => a - b);

Paso a paso de la clase:

Para encapsular nuestro codigo y poder reutilizarlo creamos la funcion ordenarArray dentro de la cual vamos a aplicar el metodo sort a nuestro array:

function ordenarArray(arrayDesordenado) {

	const arrayOrdenado = arrayDesordenado.sort();

	return arrayOrdenado;
}

En este ejemplo creamos la función que recibe el método sort fuera del mismo, en este caso llamadaordenarArraySort que recibe dos argumentos: valorAcumulado y nuevoValor. Dentro de esta funcion comparamos uno por uno los valores del array ingresando a cada una de sus posiciones de acuerdo a estos dos argumentos que recibe la funcion y retornando tres valores posibles dependiendo de la comparación realizada para cada uno:

function ordenarArray(arrayDesordenado) {
	function ordenarArraySort(valorAcumulado, nuevoValor) {
		if(valorAcumulado > nuevoValor){
			return 1;
		} else if (valorAcumulado == nuevoValor) {
			return 0;
		} else if (valorAcumulado < nuevoValor) {
			return -1;
		}
	}

	const arrayOrdenado = arrayDesordenado.sort(ordenarArraySort);

	return arrayOrdenado;
}

Se retorna 0 si queremos que el método no haga nada, pues, los valores son iguales, por ende, no importa el orden y no hace falta moverlos.
Se retorna 1 si queremos que el nuevoValor (menor) pase a estar antes que el valorAcumulado (mayor). Esto quiere decir que el nuevoValor se colocará al principio, o hacia la izquierda de valorAcumulado.
Se retorna -1 si queremos que nuevoValor (mayor) se quede en esa posición en la que se encuentra con respecto al valorAcumulado (menor). O sea, si al compararlos nuevoValor es mayor que valorAcumulado, el nuevoValor se quedara a la derecha de valorAcumulado.

Al retornar un valor negativo, cero o positivo para cada comparación, se van ordenando/posicionando de manera correcta los elementos del array.

Forma simplificada del código anterior:

function ordenarArray(arrayDesordenado) {

	function ordenarArraySort(valorAcumulado, nuevoValor) {
		return valorAcumulado - nuevoValor;
	}

	const arrayOrdenado = arrayDesordenado.sort(ordenarArraySort);

	return arrayOrdenado;
}

Si valorAcumulado es menor que nuevoValor la función va a retornar un numero negativo. Ejemplo: 5 - 10 = -5
Si valorAcumulado es igual a nuevoValor, la función va a retornar 0. Ejemplo: 5 - 5 = 0
Si valorAcumulado es mayor que nuevoValor, la función va a retornar un numero positivo.

Nota:

Si queremos que el método sort ordene el contenido del array de menor a mayor (ascendente) hacemos el calculo que retorna la funcion de la siguiente manera: arrayDesordenado.sort((a, b) => a - b);. Si queremos que el método sort ordene el contenido del array de mayor a menor (descendente) hacemos el calculo que retorna la funcion de la siguiente manera: arrayDesordenado.sort((a, b) => b - a);

Calcular mediana con el metodo sort:

const arrayDesordenado = [10, 20, 60, 40];

//Funcion para identificar si un array es par o impar:
function esPar(arrayDesordenado) {
	return !(arrayDesordenado.length % 2);
}

//Funcion para calcular la mediana:
function calcularMediana(arrayDesordenado) {
	//Pasar como parametro el array desordenado para que la funcion ordenarArray lo ordene:
	const array = ordenarArray(arrayDesordenado);

	const arrayPar = esPar(array);
	
	if(arrayPar) {
		//Calcular mediana par
		const indexMitad1 = array[(array.length / 2) - 1];
		const indexMitad2 = array[array.length / 2];

		const arrayMitades = [indexMitad1, indexMitad2];

		//Llamado a la funcion de calcularPromedio:
		const medianaArray = calcularPromedio(arrayMitades);

		//Retornar valor luego de calcular el promedio:
		return medianaArray;

	} else {
		//Calcular mediana impar
		const posicionNumeroIntermedio = Math.floor(array.length / 2);
		console.log(posicionNumeroIntermedio);
		
		//Asignar el valor del elemento intermedio encontrado a una variable:		
		const medianaImpar = array[posicionNumeroIntermedio];

		//Retornar elemento:
		return medianaImpar;
	}

}

//Funcion para calcular promedio:
function calcularPromedio(arrayItem) {
	function sumarElementos (valorAcumulado, nuevoValor) {
		return valorAcumulado + nuevoValor;
	}
	const sumaArray = arrayItem.reduce(sumarElementos);

	const promedio = sumaArray / arrayItem.length;
	return promedio;
}

//Funcion para ordenar array:
function ordenarArray(arrayDesordenado) {
	function ordenarArraySort(valorAcumulado, nuevoValor) {
		return valorAcumulado - nuevoValor;
	}

	const arrayOrdenado = arrayDesordenado.sort(ordenarArraySort);

	return arrayOrdenado;
}

console.log(calcularMediana(arrayDesordenado));

Gualberto Montiel

Estudiante

Hace 4 años

!metodo sort

Alexis Villablanca

Estudiante

Hace 4 años

Excelente!

Leopoldo Martinez

Estudiante

Hace 4 años

Mi solucion al Metodo Sort

function calcularMediana() {
  let med;
  arrSueldos.sort((a,b)=> a-b) // Aqui es donde ordeno el arreglo
  console.log(arrSueldos)
  if (esPar(arrSueldos)) {
    valor1 = arrSueldos.length / 2;
    valor2 = arrSueldos.length / 2 - 1;
    med = (arrSueldos[valor1] + arrSueldos[valor2]) / 2;
    mediana.innerHTML = `La mediana es ${med}`;
  } else {
    med = Math.floor(arrSueldos.length / 2);
    mediana.innerHTML = `La mediana es ${arrSueldos[med]}`;
  }
}

function calcularModa() {}

Gustavo Liendo

Estudiante

Hace 4 años

En mi caso siento que en mucho más sencillo emplementar un arrow function así quedó ** JS**

// media

document.getElementById("middle").addEventListener("click", function() {

    let media = allnumbers.map(function (x){return parseInt(x, 10)});
    const mediaOrdenada = media.sort((a,b) => a-b);
    
        if (allnumbers.length % 2 === 0) {
            const medianapar1 = Math.floor(media.length / 2);
            const medianapar2 = Math.floor(media.length / 2) - 1;
            const medianaListapar = (mediaOrdenada[medianapar1] + mediaOrdenada[medianapar2]) / 2;
            console.log("La mediana es: " + medianaListapar);
            console.log("Y sus valores son: " + mediaOrdenada[medianapar1] +", "+ mediaOrdenada[medianapar2]);
            console.log(mediaOrdenada);
            return medianaListapar;
        } else {
          const medianaImpar = Math.floor(media.length / 2) + 1;
          const medianaListaImpar = media[medianaImpar - 1];
          console.log("La mediana es: " + medianaImpar);
          console.log("Y su valor es: " + medianaListaImpar);
          return medianaListaImpar;
        }
    });

////Función para hallar el Promedio
function average(array){
    console.log('Los datos que ingreso fueron: ',array)
    const suma= array.reduce((sum,item)=>item+sum,0);
    return averageResult=suma/(array.length)
}

/// Función para saber si es par o impar 
function median(array){
    console.log('la lista desordenada es:', array)
    let orderedList=array.sort((a,b)=>a-b)
    console.log('la lista ordenada es:', orderedList);
    const number=(orderedList.length)%2; 
    if(number==0){
        //es par
        let iUno= Math.floor((orderedList.length/2));
        let iDos= Math.floor((orderedList.length/2)+1);
        let resultmedian=average([iUno,iDos]);
        console.log('El resultado de la mediana es:',resultmedian )
    }else{
        //es impar
        let iUno=Math.floor((orderedList.length/2));
        let iDos=Math.floor((orderedList.length/2)-1);
        let resultmedian=average([iUno,iDos]);
        console.log('El resultado de la mediana es:',resultmedian )
    }
};
median([1,6,3,8,5,9,7]); 

//es par
const isEven= (arr)=> arr.length%2 === 0 ? true : false;

//es impar
const isOdd = (arr)=> !isEven(arr);

//calcular Mediana
function calcularMediana(arr){
    const arrOrdenado=[...arr].sort((a,b)=>a-b)
    console.log(arrOrdenado);
    let mediana
    if(isEven(arrOrdenado)){
        mediana = (arrOrdenado[arrOrdenado.length/2]+arrOrdenado[(arrOrdenado.length/2)-1])/ 2
        return mediana
    }
    else {
        mediana = arrOrdenado[(arrOrdenado.length-1)/ 2]
        return mediana
    }
}

let names = ['Charles','John', 'Peter', 'Adam', 'Christian']
names.sort ();
console.log (names);

// Con números no da el resultado sin pasar argumentos por la forma en la que Javascript le da jerarquía a las letras y los números (tabla ascii)
numbers2.sort ();
console.log (numbers2);

let numbers2 = [200, 50, 1000, 20, 30, 8]

const ascendente = numbers2.sort ((a,b) => a - b);
console.log (ascendente);

const descendente = numbers2.sort ((a,b) => b - a);
console.log (descendente);

// ! Explanation of the reduce method.

const arrayTest = [1,2,3,4,5,6,7,8,9];
// Esta función se va a enviar como parámetro.

function reduceEngine(initialValue, SumValue){
    // The initial value is a value that is the position that is sent to the method
    // Sum is the result of the process.
    return initialValue + SumValue ;
}

// Here we put the function of how the engine works in the reduce method 
const reduceMethodWithArrays = arrayTest.reduce(reduceEngine);

// ! End of the explanation of the reduce method.


//! Calculation of the median

// Second challenge to know if a number is odd or even.
const checkEven = (number) => (number % 2 != 0) ? false : true;

// Engine to the sort function works!
// * Basically works using the a, as the initial position and b, as the second position. If b is higher ll be reposition the a as b and reverse. 
function sortEngine(a, b) {
    return a - b ;
};

// If the array is on its length odd, ll be return the position as the middle character of the array and, if its even ll return two positions the middle and the middle plus one.

let positionA;
let positionB;
function calculatePosition(array) {
    if (!checkEven(array.length)) {
        positionA = Math.floor(array.length / 2);
        return positionA
    } else {
        positionA = Math.floor(array.length / 2);
        positionB = Math.floor(array.length / 2) - 1;
    }
};

// Result of the array sorted
const arraySorted = (array) => (array.sort(sortEngine));
const sortedArray = arraySorted(arrayTest);

// Median algorithm.

let medianValue;
function calculateMedian(array) {
    calculatePosition(array);
    indexOne = positionA;
    indexTwo = positionB;
    (!indexTwo) ? medianValue = array[indexOne] : medianValue = (array[indexOne] + array[indexTwo]) / 2 ;
    console.log(medianValue);
}

calculateMedian(sortedArray);

const lista = [1, 23, 39, 4, 67, 90];
let mediana = 0;

//Funcion para validar si un arreglo es par o impar 
function esPar(lista) {
    let validador = lista.length % 2 == 0 ? true : false;
    return validador;
}

//Funcion para ordenar los elementos del arreglo mediante sort 


function ordenarLista(listaDesordenada){
    return listaDesordenada.sort((valorAcumulado,valorNuevo) => {return valorAcumulado-valorNuevo}); 
}
function calcularMediana(lista) {
    if (esPar(lista)) {
        let ordenarListas = ordenarLista(lista); 
        const posicion1 = (lista.length / 2) - 1;
        const posicion2 = lista.length / 2;
        console.log(posicion1, posicion2);
        mediana = lista.reduce(() => {
            return (lista[posicion1] + lista[posicion2]) / 2
        });
        return mediana;
    } else {
        const posicion = Math.floor((lista.length / 2));
        mediana = lista[posicion];
        return mediana;
    }
}
calcularMediana(lista);

let arraySalarios = [288, 92, 765, 437, 666, 495, 342, 123, 156, 992, 906, 732, 448, 331, 254, 454, 703, 745, 983, 473, 946, 714, 954, 691, 618, 892, 722, 505, 548, 429, 710, 27, 348, 514, 372, 264, 912, 534, 840, 888, 838, 954, 832, 559, 935, 847, 54, 491, 411, 905, 376, 141, 85, 641, 516, 710, 808, 409, 836, 437, 541, 902, 280, 693, 812, 731, 168, 151, 487, 290, 667, 643, 695, 738, 37, 809, 955, 758, 654, 497, 938, 576, 547, 708, 751, 84, 97, 726, 877, 278, 73, 767, 256, 745, 514, 950, 137, 129, 57, 104, 242, 24, 396, 459]

console.log(calcularMediana(sortList(arraySalarios)));

function ordenarArray(arrayDesordenado) {
	function ordenarArraySort(valorAcumulado, nuevoValor) {
		if(valorAcumulado > nuevoValor){
			return 1;
		} else if (valorAcumulado == nuevoValor) {
			return 0;
		} else if (valorAcumulado < nuevoValor) {
			return -1;
		}
	}

	const arrayOrdenado = arrayDesordenado.sort(ordenarArraySort);

	return arrayOrdenado;
}

function ordenarArray(arrayDesordenado) {

	function ordenarArraySort(valorAcumulado, nuevoValor) {
		return valorAcumulado - nuevoValor;
	}

	const arrayOrdenado = arrayDesordenado.sort(ordenarArraySort);

	return arrayOrdenado;
}

const arrayDesordenado = [10, 20, 60, 40];

//Funcion para identificar si un array es par o impar:
function esPar(arrayDesordenado) {
	return !(arrayDesordenado.length % 2);
}

//Funcion para calcular la mediana:
function calcularMediana(arrayDesordenado) {
	//Pasar como parametro el array desordenado para que la funcion ordenarArray lo ordene:
	const array = ordenarArray(arrayDesordenado);

	const arrayPar = esPar(array);
	
	if(arrayPar) {
		//Calcular mediana par
		const indexMitad1 = array[(array.length / 2) - 1];
		const indexMitad2 = array[array.length / 2];

		const arrayMitades = [indexMitad1, indexMitad2];

		//Llamado a la funcion de calcularPromedio:
		const medianaArray = calcularPromedio(arrayMitades);

		//Retornar valor luego de calcular el promedio:
		return medianaArray;

	} else {
		//Calcular mediana impar
		const posicionNumeroIntermedio = Math.floor(array.length / 2);
		console.log(posicionNumeroIntermedio);
		
		//Asignar el valor del elemento intermedio encontrado a una variable:		
		const medianaImpar = array[posicionNumeroIntermedio];

		//Retornar elemento:
		return medianaImpar;
	}

}

//Funcion para calcular promedio:
function calcularPromedio(arrayItem) {
	function sumarElementos (valorAcumulado, nuevoValor) {
		return valorAcumulado + nuevoValor;
	}
	const sumaArray = arrayItem.reduce(sumarElementos);

	const promedio = sumaArray / arrayItem.length;
	return promedio;
}

//Funcion para ordenar array:
function ordenarArray(arrayDesordenado) {
	function ordenarArraySort(valorAcumulado, nuevoValor) {
		return valorAcumulado - nuevoValor;
	}

	const arrayOrdenado = arrayDesordenado.sort(ordenarArraySort);

	return arrayOrdenado;
}

console.log(calcularMediana(arrayDesordenado));

function calcularMediana() {
  let med;
  arrSueldos.sort((a,b)=> a-b) // Aqui es donde ordeno el arreglo
  console.log(arrSueldos)
  if (esPar(arrSueldos)) {
    valor1 = arrSueldos.length / 2;
    valor2 = arrSueldos.length / 2 - 1;
    med = (arrSueldos[valor1] + arrSueldos[valor2]) / 2;
    mediana.innerHTML = `La mediana es ${med}`;
  } else {
    med = Math.floor(arrSueldos.length / 2);
    mediana.innerHTML = `La mediana es ${arrSueldos[med]}`;
  }
}

function calcularModa() {}

// media

document.getElementById("middle").addEventListener("click", function() {

    let media = allnumbers.map(function (x){return parseInt(x, 10)});
    const mediaOrdenada = media.sort((a,b) => a-b);
    
        if (allnumbers.length % 2 === 0) {
            const medianapar1 = Math.floor(media.length / 2);
            const medianapar2 = Math.floor(media.length / 2) - 1;
            const medianaListapar = (mediaOrdenada[medianapar1] + mediaOrdenada[medianapar2]) / 2;
            console.log("La mediana es: " + medianaListapar);
            console.log("Y sus valores son: " + mediaOrdenada[medianapar1] +", "+ mediaOrdenada[medianapar2]);
            console.log(mediaOrdenada);
            return medianaListapar;
        } else {
          const medianaImpar = Math.floor(media.length / 2) + 1;
          const medianaListaImpar = media[medianaImpar - 1];
          console.log("La mediana es: " + medianaImpar);
          console.log("Y su valor es: " + medianaListaImpar);
          return medianaListaImpar;
        }
    });

Método sort

Introducción

¿Ya tomaste el Curso Práctico de JavaScript?

Matemáticas en JavaScript

Fórmulas matemáticas en JavaScript

Math en JavaScript

Reto: altura de un triángulo

Playground: Calcula la Altura de un Triángulo Escaleno

Porcentajes

Cómo calcular porcentajes

Calculando descuentos con JavaScript

Ejercicio de crear cupones de descuento

Método find vs. método filter

Playground: Encuentra el ID

Estadística básica

Qué es promedio, moda y mediana

Calculando el promedio

Método reduce

Calculando la mediana en una lista impar

Calculando la mediana en una lista par

Método sort

Calculando la moda: objetos a partir de arrays

Calculando la moda: arrays a partir de objetos

Playground: Transforma Objetos en Arrays

Promedio Ponderado en JavaScript: Fórmulas y Casos de Uso

PlatziMath: clases y métodos estáticos

Análisis de salarios

Cómo estructurar información en proyectos de software

Análisis salarial con JavaScript

Proyección salarial personal

Reestructurando información sobre la marcha

Salarios empresariales

Proyección de salarios por empresas

Top 10% de salarios

Análisis de la Mediana Salarial con HTML, CSS y JavaScript

Próximos pasos

Toma el Taller Práctico de JavaScript: Videojuegos

Todos los cursos GRATIS