GoLang Ordenar segmento de estructuras

  2. HowTo
  3. Ir a Howtos
  4. GoLang Ordenar segmento de estructuras
Sheeraz Gul 20 junio 2023
Go Go Slice Go Struct
  1. GoLang Ordenar segmento de estructuras
  2. Ordenar rebanada de estructuras por un campo
  3. Ordenar segmento de estructuras por múltiples campos
GoLang Ordenar segmento de estructuras

Este tutorial demuestra cómo ordenar la porción de estructuras en GoLang.

GoLang Ordenar segmento de estructuras

GoLang proporciona dos métodos para clasificar una porción de estructuras; uno es sort.Slice, y el otro es sort.SliceStable. También necesitamos usar una función menos junto con estos dos métodos para ordenar una porción de estructuras.

La sintaxis para estos métodos es:

//sort.Slice
func Slice(x StructSlice, less func(i, j int) bool)

//sort.SliceStable
func Slice(x StructSlice, less func(i, j int) bool)

Donde x es la porción de estructuras, la porción se ordenará según la función menos. Intentemos implementar algunos ejemplos para comprender cómo ordenar segmentos de estructuras en GoLang.

Ordenar rebanada de estructuras por un campo

Ordenar una porción de estructuras por un campo es el ejemplo básico para ordenar una porción de estructuras. Donde comparamos un valor de un miembro de un segmento de estructura con el otro miembro del mismo segmento de estructura en función del campo, veamos un ejemplo.

package main

import (
    "fmt"
    "sort"
)

type Employee struct {
    Name   string
    Salary int
}

func main() {
    // Sort in Ascending order
    employees := []Employee{
        {Name: "John", Salary: 1500},
        {Name: "Joe", Salary: 3000},
        {Name: "Jack", Salary: 3400},
    }

    sort.Slice(employees, func(i, j int) bool {
        return employees[i].Salary < employees[j].Salary
    })

    fmt.Println(employees)

    // Sort in Descending order
    employees1 := []Employee{
        {Name: "John", Salary: 1500},
        {Name: "Joe", Salary: 3000},
        {Name: "Jack", Salary: 3400},
    }

    sort.Slice(employees1, func(i, j int) bool {
        return employees1[i].Salary > employees1[j].Salary
    })

    fmt.Println(employees1)
}

El código anterior contiene una estructura Empleado que tiene dos campos Nombre y Salario, luego crea una porción de la estructura y la clasifica en orden ascendente según el campo Salario usando el método Porción y luego ordenar otra porción en orden descendente.

Ver la salida:

[{John 1500} {Joe 3000} {Jack 3400}]
[{Jack 3400} {Joe 3000} {John 1500}]

Ahora no podemos usar el sort.SliceStable en este tipo de rebanadas, que incluyen pares clave-valor (mapas) del nombre y valor archivados. Con sort.SliceStable, podemos ordenar segmentos simples de estructuras que solo contienen valores.

package main

import (
    "fmt"
    "sort"
)

type Employee struct {
    Name   string
    Salary int
}

func main() {
    // Sort in Ascending order
    employees := []Employee{
        {"John", 1500},
        {"Joe", 3000},
        {"Jack", 3400},
    }

    sort.SliceStable(employees, func(i, j int) bool {
        return employees[i].Salary < employees[j].Salary
    })

    fmt.Println(employees)

    // Sort in Descending order
    employees1 := []Employee{
        {"John", 1500},
        {"Joe", 3000},
        {"Jack", 3400},
    }

    sort.SliceStable(employees1, func(i, j int) bool {
        return employees1[i].Salary > employees1[j].Salary
    })

    fmt.Println(employees1)
}

El código anterior ordenará de manera similar la porción de estructuras en función de un campo sin los pares clave-valor de nombres y valores en la porción de estructuras.

Ver la salida:

[{John 1500} {Joe 3000} {Jack 3400}]
[{Jack 3400} {Joe 3000} {John 1500}]

Ordenar segmento de estructuras por múltiples campos

También es posible ordenar una porción de estructuras por múltiples campos. Tenemos que extender la función menos; probemos un ejemplo.

package main

import (
    "fmt"
    "sort"
)

type Employee struct {
    Name     string
    Position string
}

func main() {
    // Sort in Descending order
    employees := []Employee{
        {"Michael", "Developer"},
        {"Jack", "Manager"},
        {"Joe", "CEO"},
        {"Leonard", "Intern"},
        {"Sheldon", "Developer"},
    }

    sort.SliceStable(employees, func(i, j int) bool {
        if employees[i].Position != employees[j].Position {
            return employees[i].Position < employees[j].Position
        }

        return employees[i].Name < employees[j].Name
    })

    fmt.Println(employees)

    // Sort in Ascending order
    employees1 := []Employee{
        {"Michael", "Developer"},
        {"Jack", "Manager"},
        {"Joe", "CEO"},
        {"Leonard", "Intern"},
        {"Sheldon", "Developer"},
    }

    sort.SliceStable(employees1, func(i, j int) bool {
        if employees1[i].Position != employees1[j].Position {
            return employees1[i].Position > employees1[j].Position
        }

        return employees1[i].Name > employees1[j].Name
    })

    fmt.Println(employees1)
}

El código anterior se ordenará según el “Nombre” y el “Puesto”, donde si el puesto de dos empleados es el mismo, se ordenará según el campo “Nombre”. El segmento de la estructura se ordenará en orden descendente y ascendente.

Ver la salida:

[{Joe CEO} {Michael Developer} {Sheldon Developer} {Leonard Intern} {Jack Manager}]
[{Jack Manager} {Leonard Intern} {Sheldon Developer} {Michael Developer} {Joe CEO}]
Autor: Sheeraz Gul
Sheeraz Gul avatar Sheeraz Gul avatar

Sheeraz is a Doctorate fellow in Computer Science at Northwestern Polytechnical University, Xian, China. He has 7 years of Software Development experience in AI, Web, Database, and Desktop technologies. He writes tutorials in Java, PHP, Python, GoLang, R, etc., to help beginners learn the field of Computer Science.

LinkedIn Facebook

Artículo relacionado - Go Slice

Artículo relacionado - Go Struct