Go Academy · Lección

Órdenes de ordenación personalizados

Defina funciones de comparación

Órdenes de ordenación personalizados es una lección gratuita de Go Academy en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Go Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Go Academy incluye 4 lecciones en total.

Más allá del orden predeterminado

La ordenación predeterminada es ascendente. Sin embargo, los datos reales necesitan reglas personalizadas: ordenar por longitud, por varios campos o por un valor calculado.

La función de comparación es donde expresa la regla que necesite.

La función less

Una función de comparación para sort.Slice tiene la firma func(i, j int) bool. Devuelve true cuando el elemento i debe ir antes que el elemento j.

package main

import (
	"fmt"
	"sort"
)

func main() {
	nums := []int{4, 1, 3}
	less := func(i, j int) bool { return nums[i] < nums[j] }
	sort.Slice(nums, less)
	fmt.Println(nums)
}

Ordenar por longitud de string

En lugar del orden alfabético, compare len() de cada string para ordenarlos por longitud.

package main

import (
	"fmt"
	"sort"
)

func main() {
	words := []string{"pear", "fig", "banana"}
	sort.Slice(words, func(i, j int) bool {
		return len(words[i]) < len(words[j])
	})
	fmt.Println(words)
}

Ordenar structs por campo

Elija cualquier campo del struct para la comparación. Aquí ordenamos los productos por precio.

package main

import (
	"fmt"
	"sort"
)

type Product struct {
	Name  string
	Price int
}

func main() {
	items := []Product{{"Pen", 3}, {"Book", 12}, {"Cup", 7}}
	sort.Slice(items, func(i, j int) bool {
		return items[i].Price < items[j].Price
	})
	fmt.Println(items)
}

Ordenación por varios campos

Para resolver los empates, compare un segundo campo cuando el primero sea igual. Ordene por edad y después por nombre.

package main

import (
	"fmt"
	"sort"
)

type Person struct {
	Name string
	Age  int
}

func main() {
	p := []Person{{"Zoe", 30}, {"Ann", 30}, {"Bob", 25}}
	sort.Slice(p, func(i, j int) bool {
		if p[i].Age != p[j].Age {
			return p[i].Age < p[j].Age
		}
		return p[i].Name < p[j].Name
	})
	fmt.Println(p)
}

Invertir el orden con sort.Reverse

sort.Reverse envuelve un sort.Interface para invertir su orden. Se combina con funciones auxiliares como sort.IntSlice.

package main

import (
	"fmt"
	"sort"
)

func main() {
	nums := []int{1, 4, 2, 3}
	sort.Sort(sort.Reverse(sort.IntSlice(nums)))
	fmt.Println(nums)
}

La interfaz sort.Interface

Para tener un control total, implemente sort.Interface: tres métodos, Len(), Less(i, j int) bool y Swap(i, j int).

package main

import (
	"fmt"
	"sort"
)

type ByLen []string

func (s ByLen) Len() int           { return len(s) }
func (s ByLen) Less(i, j int) bool { return len(s[i]) < len(s[j]) }
func (s ByLen) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }

func main() {
	w := []string{"ccc", "a", "bb"}
	sort.Sort(ByLen(w))
	fmt.Println(w)
}

Ordenar por un valor calculado

La comparación puede usar cualquier expresión. Ordene los números según su distancia absoluta respecto a cero.

package main

import (
	"fmt"
	"sort"
)

func abs(n int) int {
	if n < 0 {
		return -n
	}
	return n
}

func main() {
	nums := []int{-5, 2, -1, 3}
	sort.Slice(nums, func(i, j int) bool {
		return abs(nums[i]) < abs(nums[j])
	})
	fmt.Println(nums)
}

Ordenación sin distinguir mayúsculas y minúsculas

Use strings.ToLower dentro de la comparación para ignorar las mayúsculas y minúsculas al ordenar strings.

package main

import (
	"fmt"
	"sort"
	"strings"
)

func main() {
	w := []string{"banana", "Apple", "cherry"}
	sort.Slice(w, func(i, j int) bool {
		return strings.ToLower(w[i]) < strings.ToLower(w[j])
	})
	fmt.Println(w)
}

Slice frente a interfaz

Hay dos formas de personalizar el orden:

sort.Slice - función less rápida y definida en línea
sort.Interface - tipo con nombre reutilizable y tres métodos

Prefiera sort.Slice para ordenaciones puntuales.

Mantenga puras las comparaciones

Una función de comparación solo debe leer los elementos y devolver un booleano. No debe modificar el slice ni producir efectos secundarios, ya que la ordenación podría comportarse de forma impredecible.

Comprobación rápida

Quiere ordenar personas por edad y, cuando las edades sean iguales, por nombre. ¿Qué técnica debe usar?

Repaso

Puede definir cualquier orden:

La función less expresa su regla
Las ordenaciones por varios campos comparan un segundo campo en caso de empate
sort.Reverse invierte el orden y sort.Interface proporciona tipos reutilizables

Preguntas frecuentes

¿La lección «Órdenes de ordenación personalizados» es gratis?

Sí — el texto completo de «Órdenes de ordenación personalizados» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Go Academy, actualiza a CoddyKit PRO. El curso de Go Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Órdenes de ordenación personalizados»?

Defina funciones de comparación Practicas Go Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Go Academy?

No se requiere experiencia previa. Go Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «Órdenes de ordenación personalizados»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Go Academy?

Sí. Cada lección de Go Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Go Academy