Skip to main content

GO lang to print colored output 

package main

import (
	"fmt"
)

func Red(format string, args ...interface{}) {
	fmt.Printf("\033[31m"+format+"\033[0m", args...)
}

func Green(format string, args ...interface{}) {
	fmt.Printf("\033[32m"+format+"\033[0m", args...)
}

func Yellow(format string, args ...interface{}) {
	fmt.Printf("\033[33m"+format+"\033[0m", args...)
}

func Blue(format string, args ...interface{}) {
	fmt.Printf("\033[34m"+format+"\033[0m", args...)
}

func Magenta(format string, args ...interface{}) {
	fmt.Printf("\033[35m"+format+"\033[0m", args...)
}

func Cyan(format string, args ...interface{}) {
	fmt.Printf("\033[36m"+format+"\033[0m", args...)
}

func main() {
	// Set the foreground color to red
	Red("Hello, world!\n")
	Yellow("Hello, world!\n")
	Green("Hello, world!\n")
	Magenta("Hello, world!\n")
	Cyan("Hello, world!\n")
	Blue("Hello, world!\n")

}
<
Previous Post
Installing golang compiler in linux machine
>
Blog Archive
Archive of all previous blog posts

Comments

Post a Comment

Popular posts from this blog

Profiling CPU Usage in Go: Boosting Performance

Image
Profiling CPU Usage in Go Programs Profiling CPU usage in Go allows you to measure the time your program spends executing various functions and code paths. This insight is invaluable for optimizing your code. Go provides built-in tools to help you with this. To get started with CPU profiling, you'll need to: Import the net/http/pprof Package : This package exposes the profiling functionality via HTTP endpoints. Include it in your code like this: import _ "net/http/pprof" Start an HTTP Server : You'll want to start an HTTP server that serves profiling data. go func() { log.Println(http.ListenAndServe("localhost:6060", nil)) }() Instrument Your Code : Use the runtime/pprof package to start and stop CPU profiling within your application: import ( "net/http" _ "net/http/pprof" "os" "runtime/pprof" ) func main() { go func() { log.Println(http.Lis...
Read more

Creating Custom Error Types in Go

Error handling is a critical aspect of software development. It allows you to gracefully manage unexpected situations and provide meaningful feedback to users. While Go provides a built-in error interface that's simple and effective, there are cases where creating custom error types can greatly enhance error reporting and debugging. In this blog post, we'll explore the process of creating custom error types in Go and discuss how they can improve error handling in your applications. We'll also introduce a custom error package, myerror , to illustrate these concepts. The Need for Custom Error Types In Go, errors are represented by values that implement the error interface, which consists of a single method, Error() string . This simplicity is intentional, but sometimes it's not enough. Here are some scenarios where custom error types are beneficial: Additional Context : Custom error types can carry additional context information that helps identify the source and n...
Read more

Enhancing Database Security and Performance with Parameterized Queries

In the world of database programming, security and performance are paramount concerns. One technique that addresses both of these concerns is the use of parameterized queries or prepared statements. In this blog post, we'll explore the significance of parameterized queries, their role in preventing SQL injection, and how they can potentially improve query execution speed. We'll provide practical examples to illustrate the power and versatility of this essential query optimization technique. The Importance of Parameterized Queries Parameterized queries , also known as prepared statements , are a mechanism in which placeholders are used for data values in SQL queries. These placeholders are later bound to actual data values when the query is executed. Parameterized queries offer several crucial advantages: Protection Against SQL Injection: One of the primary benefits of parameterized queries is their ability to prevent SQL injection attacks. By separating SQL cod...
Read more