Any difference between nil check left on right

This is function takes two strings and returns struct or nil and I wrote a struct inside this function for use only this function.

type OrgFundingsDetailsFCT struct {
	ID           int     `db:"id"`
	OrgProfileID int     `db:"org_profile_id"`
	OrgID        int     `db:"org_id"`
	RefID        string  `db:"ref_id"`
	AmountUSD    float64 `db:"amount_usd"`
	FundingDate  string  `db:"funding_date"`
	Status       string  `db:"status"`
	Round        string  `db:"round"`
	CreatedBy    string  `db:"created_by"`
}

func (s *Server) getCompareOrgFundingsByRefID(refID, status string) (*OrgFundingsDetailsFCT, error) {
	type orgFunding struct {
		RefID  string `db:"ref_id"`
		Status string `db:"status"`
	}

	var orgFundingsDetailsFCT OrgFundingsDetailsFCT

	orgfunding := orgFunding{
		RefID:  refID,
		Status: status,
	}

	const query = `SELECT id,
					org_profile_id,
					org_id,
					ref_id,
					amount_usd,
					funding_date,
					status,round, 
					created_by 
					FROM org_fundings 
					WHERE ref_id=:ref_id AND status=:status`

	if err := s.db.NamedGet(&orgFundingsDetailsFCT, query, orgfunding); err == sql.ErrNoRows {
		s.logger.Infof("empty rows! getCompareOrgFundingsByRefID #111 %+v", err)
		return nil, nil
	} else if err != nil {
		s.logger.Infof("errors found! getCompareOrgFundingsByRefID#111  %+v", err)
		return nil, err
	}
	return &orgFundingsDetailsFCT, nil
}

Now I'm checking if this function return nil like this

    if nil != orgFundingsRefIdPending{
// logic
}

But my question is if I check like that is it same or not?

    if orgFundingsRefIdPending != nil{
//logic
}

If nil left side and check with my result is right side OR, my result is left side and check with nil is right side, Is it same? Does that mean the same thing happens if I put ‍‍‍‍‍‍nil on either side? also if I use struct on use only function is it valid thing?

The getCompareOrgFundingsByRefID() function returns a pointer and an error value. To check if the return value (the pointer) is nil, simply compare it to nil, e.g.:

var refID, status string
// Set input params
orgFundingsRefIdPending, err := getCompareOrgFundingsByRefID(refID, status)
if err != nil {
     // Handle error
}
if orgFundingsRefIdPending != nil {
    // Use orgFundingsRefIdPending
}

The == and != comparison operators can only be executed (their result can only be determined) if both of their operands are evaluated. Moreover, since these comparison operators are reflexive (meaning a == b is true only and only if b == a), the order does not matter. So a == b and b == a are equivalent.

The order matters if the operator would not be reflexive (e.g. < so a < b is not the same as b < a), or it could matter if not all operands would be needed for its result, such as the logical OR (||), because we know that if any of the operands of || is true, the result is true regardless of the other value. And since Go's || operator uses short-circuit evaluation (if the result is known before evaluating all operands, the rest are not evaluated, going from left-to-right), the order does matter in case of ||. E.g. in f() || g() if f() returns true, the g() function will not be called.

Note: Back to yoru case, if the returned pointer is not nil but you want to check if the pointed struct value is the zero value of its type, you may simply compare it to OrgFundingsDetailsFCT{}:

if orgFundingsRefIdPending != nil {
    // Use orgFundingsRefIdPending
    // Is it the zero value?
    if *orgFundingsRefIdPending == (OrgFundingsDetailsFCT{}) {
        // It's the zero value
    }
}

For details and more options, see https://stackoverflow.com/questions/28447297/how-to-check-for-an-empty-struct/28449449#28449449