Combine different sort in Go

    package main

import (
    "fmt"
    "sort"
)

type Article struct {
    Title       string
    NumComments int
}

func main() {
    a1 := Article{"Dog", 3}
    a2 := Article{"Tiger", 0}
    a3 := Article{"Cat", 4}
    a4 := Article{"Fish", 0}
    a5 := Article{"Whale", 8}

    articles := []Article{a1, a2, a3, a4, a5}

    sort.Slice(articles, func(i, j int) bool {

        if articles[i].NumComments == 0 && articles[j].NumComments == 0 {
            return articles[i].Title < articles[j].Title
        } else {
            return articles[i].NumComments < articles[j].NumComments
        }

    })

    fmt.Printf("articles: %v\n", articles)
}

Some of the type definitions are missing in your post. I have taken a simple strut example. I think this is what you may be looking for?

Assuming I'm understanding your requirement correctly you can use something like the following:

func sortArticles(articles []*Article) []*Article {
    topArticlesSlice := append([]*Article{}, articles[:]...)
    sort.SliceStable(topArticlesSlice, func(i, j int) bool {
        if topArticlesSlice[i].NumComments != nil && topArticlesSlice[j].NumComments != nil &&
            *topArticlesSlice[i].NumComments != *topArticlesSlice[j].NumComments {
            return *topArticlesSlice[i].NumComments < *topArticlesSlice[j].NumComments
        }
        if topArticlesSlice[i].Title != nil && topArticlesSlice[j].Title != nil &&
            *topArticlesSlice[i].Title != *topArticlesSlice[j].Title {
            return *topArticlesSlice[i].Title < *topArticlesSlice[j].Title
        } else if topArticlesSlice[i].StoryTitle != nil && topArticlesSlice[j].StoryTitle != nil {
            return *topArticlesSlice[i].StoryTitle < *topArticlesSlice[j].StoryTitle
        }
        return false
    })
    return topArticlesSlice
}

Try this in the playground.

Your compare function is far too complex. You need to refactor it into simpler more straightforward bits.

And, you haven't defined what your Article type looks like, so, for the purposes of example, I'm going to define it thus:

type Article struct {
    NumComments *int
    Title       *string
}

Your basic ask is that you want to sort, first by the number of comments, and then (if the number of comments is nil) alphabetically by title, correct?

From your original code, it would appear that

• NumComments is a pointer to int (*int), and
• Title is a pointer to string (*string)

That means that each comparison has four cases that have to be dealt with:

For the purposes of this exercise, I'm going to declare that nil collates high with respect to non-nil (but nil collating low with respect to non-nil is equally valid. An implementation choice).

Comparing 2 *int values is easy:

func compareIntPtr(x *int, y *int) int {
  var cc int
  
  switch {
  case x != nil && y != nil: cc = sign(*x - *y)
  case x == nil && y == nil: cc =  0
  case x == nil && y != nil: cc = +1
  case x != nil && y == nil: cc = -1
  }
  
  return cc
}

func sign(n int) int {
  var sign int

  switch {
  case n < 0: sign = -1
  case n > 0: sign = +1
  default:    sign =  0
  }

  return sign
}

As is comparing two *string values:

import "strings"
.
.
.
func compareStringPtr(x *string, y *string) int {
  var cc int
  
  switch {
  case x != nil && y != nil: cc =  strings.Compare(*x, *y)
  case x == nil && y == nil: cc =  0
  case x == nil && y != nil: cc = +1
  case x != nil && y == nil: cc = -1
  }

  return cc
}

Once you have those primitives, the comparer function for the sort is even simpler:

func sortArticles(articles []*Article) []*Article {
  
  topArticlesSlice := make([]*Article, 0)
  topArticlesSlice  = append(topArticlesSlice, articles[:]...)
  
  sort.SliceStable(topArticlesSlice, func(i, j int) bool {
    x := *topArticlesSlice[i]
    y := *topArticlesSlice[j]
    
    // compare numbers of comments
    cc := compareIntPtr(x.NumComments, y.NumComments)
    
    // if equal, compare the titles
    if cc == 0 {
      cc = compareStringPtr(x.Title, y.Title)
    }
    
    // return `true`  if `x` collates less than `y`, otherwise `false`
    return cc < 0
  })
  
  return topArticlesSlice
}