Forem: Rakesh Mothukuri

Building an RSocket based Springboot application

Rakesh Mothukuri — Sun, 11 Oct 2020 12:59:24 +0000

Introduction

RSocket translates to Reactive socket is a messaging protocol that works over TCP or Websockets. Communication modes this protocol provides are fire-and-forget, request-response and streaming. Since RSocket is fully reactive, it's ideal for high-throughput applications.

In this post, we will explore three communications modes which are fire-and-forget, request-response and streaming and test with RSocket Client CLI (RSC) a postman type application but to test application over the socket.

Setup

Install Java preferably >8.
Spring boot skeleton project

Navigate to start.spring.io, select RSocket as a dependency and a stable version of spring boot version at the point of time and click on Generate should give a zip file with skeleton project which good to get going.

Initial project structure looks as

Application configuration

Next, setting up the port on which this application runs by modifying the file application.properties

spring.rsocket.server.port=7000
spring.main.lazy-initialization=true

Client to test the server application:

Here I am using RSC client created by Toshiaki Maki. Set-up instructions are on his GitHub page.

Data model:

We create a new POJO class representing the data being exchanged by client and server. This class will consist of two member variables for now which are message created

package com.example.rsocket;

import java.time.Instant;

public class Message {

  private String message; 
  private long created = Instant.now().getEpochSecond(); 

  public Message(String message) {
    this.message = message;
  }

  public String getMessage() {
    return message;
  }

  public void setMessage(String message) {
    this.message = message;
  }

  public long getCreated() {
    return created;
  }

  public void setCreated(long created) {
    this.created = created;
  }
}

This should get the base project set-up and ready for writing code and expose via Socket.

Communication mode 1: Request-Response

Development

Request-Response is a classic way of communication where each request made by the client will get a response back. This is achieved by including below snippet (full code is available in the Github repository: https://github.com/rockey5520/rsocket )

@MessageMapping("request-response")
    Mono<Message> requestResponse(final Message message) {
        System.out.println("Received request-response message: {}"+message);
        return Mono.just(new Message("You said: " + message.getMessage()));
    }

The key part of the above code is @MessageMapping("request-response") where we are letting spring boot know that this method requestResponse should be invoked when client makes a call using request-response communication mode. Here we are using the POJO class Message as the payload for both receiving from client and responding to client.

Since this is a request and response model where server sends response to requests made by client Mono of Spring Reactor reactor.core is perfect where there is only need to send response once for each request.

Testing

using the RSC client installed if you pass below instruction

rsc --debug --request --data "{\"message\":\"Hello\"}" --route request-response --stacktrace tcp://localhost:7000

should it run successfully you would see an output as below

Frame => Stream ID: 1 Type: REQUEST_RESPONSE Flags: 0b100000000 Length: 49
Metadata:
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| fe 00 00 11 10 72 65 71 75 65 73 74 2d 72 65 73 |.....request-res|
|00000010| 70 6f 6e 73 65                                  |ponse           |
+--------+-------------------------------------------------+----------------+
Data:
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 7b 22 6d 65 73 73 61 67 65 22 3a 22 48 65 6c 6c |{"message":"Hell|
|00000010| 6f 22 7d                                        |o"}             |
+--------+-------------------------------------------------+----------------+
2020-10-11 10:15:29.750 DEBUG --- [actor-tcp-nio-1] i.r.FrameLogger : receiving -> 
Frame => Stream ID: 1 Type: NEXT_COMPLETE Flags: 0b1100000 Length: 56
Data:
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 7b 22 6d 65 73 73 61 67 65 22 3a 22 59 6f 75 20 |{"message":"You |
|00000010| 73 61 69 64 3a 20 48 65 6c 6c 6f 22 2c 22 63 72 |said: Hello","cr|
|00000020| 65 61 74 65 64 22 3a 31 36 30 32 34 31 31 33 32 |eated":160241132|
|00000030| 39 7d                                           |9}              |
+--------+-------------------------------------------------+----------------+
{"message":"You said: Hello","created":1602411329}

This response received is constructed in 3 message frames

Frame 1

First frame is labelled as metadata shows the routing metadata ( request-response) sent to the server

Frame 2

Second frame shows the data we sent to the server ( here in this example it is "Hello") a JSON string

Frame 3

Third frame shows the server response sent back to the client.

Communication mode 2: Fire-and-Forget

Development

Fire and forget is another way of communication where request made by client but wont get a response back from server. This is achieved by including below snippet (full code is available in the github repository : https://github.com/rockey5520/rsocket )

    @MessageMapping("fire-and-forget")
    public Mono<Void> fireAndForget(final Message message) {
        System.out.println("Received fire-and-forget request: {}"+ message);
        return Mono.empty();
    }

The key part of the above code is @MessageMapping("fire-and-forget") where we are letting spring boot know that this method fireAndForget should be invoked when client makes a call using fire-and-forget communication mode. Here we are using the POJO classMessage` as the payload for both receiving from client.

Testing

using the RSC client installed if you pass below instruction

bash rsc --debug --fnf --data "{\"message\":\"Hello\"}" --route fire-and-forget --stacktrace tcp://localhost:7000

should it run successfully you would see an output as below

bash 2020-10-11 10:31:28.398 DEBUG --- [ parallel-2] i.r.FrameLogger : sending -> Frame => Stream ID: 1 Type: REQUEST_FNF Flags: 0b100000000 Length: 48 Metadata: +-------------------------------------------------+ | 0 1 2 3 4 5 6 7 8 9 a b c d e f | +--------+-------------------------------------------------+----------------+ |00000000| fe 00 00 10 0f 66 69 72 65 2d 61 6e 64 2d 66 6f |.....fire-and-fo| |00000010| 72 67 65 74 |rget | +--------+-------------------------------------------------+----------------+ Data: +-------------------------------------------------+ | 0 1 2 3 4 5 6 7 8 9 a b c d e f | +--------+-------------------------------------------------+----------------+ |00000000| 7b 22 6d 65 73 73 61 67 65 22 3a 22 48 65 6c 6c |{"message":"Hell| |00000010| 6f 22 7d |o"} | +--------+-------------------------------------------------+----------------+

This response received is constructed in 2 message frames

Frame 1

First frame is labelled as metadata shows the routing metadata ( request-response) sent to the server

Frame 2

Second frame shows the data we sent to the server ( here in this example it is "Hello") a JSON string

Communication mode 3: Request-Stream

Development

This communication mode is for the communication where a client makes a single request and server responds with stream of responses. This is achieved by including below snippet (full code is available in the github repository : https://github.com/rockey5520/rsocket )

java @MessageMapping("request-stream") Flux<Message> stream(final Message message) { return Flux // create a new indexed Flux emitting one element every second .interval(Duration.ofSeconds(1)) // create a Flux of new Messages using the indexed Flux .map(index -> new Message("You said: " + message.getMessage() + ". Response #" + index)) // show what's happening .log(); }

The key part of the above code is @MessageMapping("request-stream") where we are letting spring boot know that this method stream should be invoked when client makes a call using request-stream communication mode. Here we are using the POJO class Message as the payload for both receiving from client and send a stream of responses of type Message every 1 second which is achieved by using Flux.

Testing

using the RSC client installed if you pass below instruction

bash rsc --debug --stream --data "{\"message\":\"Hello\"}" --route request-stream --stacktrace tcp://localhost:7000

should it run successfully you would see an output as below

`bash
2020-10-11 10:42:40.638 DEBUG --- [ parallel-2] i.r.FrameLogger : sending ->
Frame => Stream ID: 1 Type: REQUEST_STREAM Flags: 0b100000000 Length: 51 InitialRequestN: 9223372036854775807
Metadata:
+-------------------------------------------------+
| 0 1 2 3 4 5 6 7 8 9 a b c d e f |
+--------+-------------------------------------------------+----------------+
|00000000| fe 00 00 0f 0e 72 65 71 75 65 73 74 2d 73 74 72 |.....request-str|
|00000010| 65 61 6d |eam |
+--------+-------------------------------------------------+----------------+
Data:
+-------------------------------------------------+
| 0 1 2 3 4 5 6 7 8 9 a b c d e f |
+--------+-------------------------------------------------+----------------+
|00000000| 7b 22 6d 65 73 73 61 67 65 22 3a 22 48 65 6c 6c |{"message":"Hell|
|00000010| 6f 22 7d |o"} |
+--------+-------------------------------------------------+----------------+
2020-10-11 10:42:41.749 DEBUG --- [actor-tcp-nio-1] i.r.FrameLogger : receiving ->
Frame => Stream ID: 1 Type: NEXT Flags: 0b100000 Length: 69
Data:
+-------------------------------------------------+
| 0 1 2 3 4 5 6 7 8 9 a b c d e f |
+--------+-------------------------------------------------+----------------+
|00000000| 7b 22 6d 65 73 73 61 67 65 22 3a 22 59 6f 75 20 |{"message":"You |
|00000010| 73 61 69 64 3a 20 48 65 6c 6c 6f 2e 20 52 65 73 |said: Hello. Res|
|00000020| 70 6f 6e 73 65 20 23 30 22 2c 22 63 72 65 61 74 |ponse #0","creat|
|00000030| 65 64 22 3a 31 36 30 32 34 31 32 39 36 31 7d |ed":1602412961} |
+--------+-------------------------------------------------+----------------+
{"message":"You said: Hello. Response #0","created":1602412961}
2020-10-11 10:42:42.707 DEBUG --- [actor-tcp-nio-1] i.r.FrameLogger : receiving ->
Frame => Stream ID: 1 Type: NEXT Flags: 0b100000 Length: 69
Data:

This response received is a stream of responses back to rsc client.

Communication mode 4: Channel

Development

This communication mode is for the communication where client and server can send a stream of messages, essentially streaming messages in both directions. This is achieved by including below snippet (full code is available in the Github repository: https://github.com/rockey5520/rsocket )

java @MessageMapping("stream-stream") Flux<Message> channel(final Flux<Integer> input) { System.out.println("Received stream-stream (channel) request..."); return settings .doOnNext(input -> System.out.println("Requested interval is {} seconds."+ setting)) .doOnCancel(() -> System.out.println("The client cancelled the channel.")) .switchMap(input -> Flux.interval(Duration.ofSeconds(input)) .map(index -> new Message("Stream Response #" + index))) .log(); }

The key part of the above code is @MessageMapping("stream-stream") where we are letting spring boot know that this method channel should be invoked when client makes a call using stream-stream communication mode.

Here we are returning Flux for each request(input) sent as part of stream creating a new outbound flux using the Duration sent in input payload thereby achieving the back pressure where client controls the speed server response stream should be. This is a very good feature for the functionalities such as Video streaming where user controls the speed at which server should stream videos based on the client internet speed

Testing

using the RSC client installed if you pass below instruction

bash rsc --debug --channel --data - --route stream-stream --stacktrace tcp://localhost:7000

now command line waits for user input for interval in seconds, Given provided 1 server responds stream of messages every 1 second and while it's streaming you could change to 10 and see server changes its streaming speed from 1 second to 10 seconds which is amazing when you need to build an application where client needs to apply back pressure and let server know the speed at which it expects the responses.

`bash
rockey@ubuntu:~/projects/rsocket$ rsc --debug --channel --data - --route stream-stream --stacktrace tcp://localhost:7000
3
2020-10-11 11:06:39.843 DEBUG --- [ parallel-2] i.r.FrameLogger : sending ->
Frame => Stream ID: 1 Type: REQUEST_CHANNEL Flags: 0b100000000 Length: 32 InitialRequestN: 9223372036854775807
Metadata:
+-------------------------------------------------+
| 0 1 2 3 4 5 6 7 8 9 a b c d e f |
+--------+-------------------------------------------------+----------------+
|00000000| fe 00 00 0e 0d 73 74 72 65 61 6d 2d 73 74 72 65 |.....stream-stre|
|00000010| 61 6d |am |
+--------+-------------------------------------------------+----------------+
Data:
+-------------------------------------------------+
| 0 1 2 3 4 5 6 7 8 9 a b c d e f |
+--------+-------------------------------------------------+----------------+
|00000000| 33 |3 |
+--------+-------------------------------------------------+----------------+
2020-10-11 11:06:39.847 DEBUG --- [actor-tcp-nio-1] i.r.FrameLogger : receiving ->
Frame => Stream ID: 1 Type: REQUEST_N Flags: 0b0 Length: 10 RequestN: 9223372036854775807
Data:

2020-10-11 11:06:42.849 DEBUG --- [actor-tcp-nio-1] i.r.FrameLogger : receiving ->
Frame => Stream ID: 1 Type: NEXT Flags: 0b100000 Length: 59
Data:
+-------------------------------------------------+
| 0 1 2 3 4 5 6 7 8 9 a b c d e f |
+--------+-------------------------------------------------+----------------+
|00000000| 7b 22 6d 65 73 73 61 67 65 22 3a 22 53 74 72 65 |{"message":"Stre|
|00000010| 61 6d 20 52 65 73 70 6f 6e 73 65 20 23 30 22 2c |am Response #0",|
|00000020| 22 63 72 65 61 74 65 64 22 3a 31 36 30 32 34 31 |"created":160241|
|00000030| 34 34 30 32 7d |4402} |
+--------+-------------------------------------------------+----------------+
{"message":"Stream Response #0","created":1602414402}
10
2020-10-11 11:06:45.216 DEBUG --- [oundedElastic-1] i.r.FrameLogger : sending ->
Frame => Stream ID: 1 Type: NEXT Flags: 0b100100000 Length: 29
Metadata:
+-------------------------------------------------+
| 0 1 2 3 4 5 6 7 8 9 a b c d e f |
+--------+-------------------------------------------------+----------------+
|00000000| fe 00 00 0e 0d 73 74 72 65 61 6d 2d 73 74 72 65 |.....stream-stre|
|00000010| 61 6d |am |
+--------+-------------------------------------------------+----------------+
Data:
+-------------------------------------------------+
| 0 1 2 3 4 5 6 7 8 9 a b c d e f |
+--------+-------------------------------------------------+----------------+
|00000000| 31 30 |10 |
+--------+-------------------------------------------------+----------------+

This response received is a stream of responses back to rsc client.

Additional Reading material:

https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/web-reactive.html#rsocket-annot-responders

https://github.com/benwilcock/springone-2020-rsocket-talk/tree/master/rsocket-server

https://benwilcock.wordpress.com/2020/06/25/getting-started-with-rsocket-on-spring-boot/

The Command Pattern in Java

Rakesh Mothukuri — Tue, 23 Jun 2020 21:26:36 +0000

Introduction

You most likely have known about behavioural patterns by now. behavioral patterns are concerns about the wiring of Java objects. While there are around 12 design patterns that belongs to behavioral patterns, the command patters takes its special place as it is utilized frequently than other patterns. The motivation behind the order design is to decouple the rationale amongst commands and its consumers.

The key part of the command pattern is encapsulating all the data related to command in one object. Usually, this is done by a set of methods, their parameters and one or more objects to which these methods belong to called as Receiver. So the important point about decoupling is if you had to change any of these values, you only have to change one class.

In the classic version, implementing the command pattern involves five steps.

The Command interface: This is usually declared just a single method for executing the command.
The ConcreteCommand: This is an operation with parameters that pass the call to the receiver; In the classic approach, a command only invokes one or more methods of a Receiver rather than perform business logic.
The Receiver: is especially knows how to perform the action.
The Invoker: asks the command to carry out the request.
The Client: creates a ConcreteCommand object and sets the Receiver.

Example of the command pattern

Suppose you are going to build a home automation system where you need to turn on and off a Heating system. Both the commands are similar in most part of the sense. We could create one interface as Command and It will have only one method called execute().

public interface Command {
    void execute();
}

We will now create two classes that will implement the Command interface. These concrete classes encapsulate data required for the command to execute two commands, Heating On and Heating Off.

First. HeatingOnCommand will implement the Command interface.

public class HeatingOnCommand implements Command {

    private HeatingSystem heatingSystem;

    public HeatingOnCommand(HeatingSystem heatingSystem) {
        this.heatingSystem = heatingSystem;
    }

    @Override
    public void execute() {
        heatingSystem.heatOn();
    }
}

Next, HeatingOffCommand will implement the Command interface. HeatingOffCommand basically has the same code that HeatingOnCommand has.

public class HeatingOffCommand implements Command {

    private HeatingSystem heatingSystem;

    public HeatingOffCommand(HeatingSystem heatingSystem) {
        this.heatingSystem = heatingSystem;
    }

    @Override
    public void execute() {
        heatingSystem.heatOff();
    }
}

Next, we will create our Receiver class which is here HeatingSystem class

public class HeatingSystem  {

    public void heatOn() {
        System.out.println("Turn on heat");
    }

    public void heatOff() {
        System.out.println("Turn off heat");
    }
}

Next, we need to require the Invoker class. invoker class decides how the commands are executed. For example, the invoker can keep a list of commands that need to be executed in a specific order.

We will name the invoker class as Controller here.

public class Controller {

    private Command command;

    public void setCommand(Command command) {
        this.command = command;
    }

    public void executeCommand() {
        command.execute();
    }
}

Finally, our client or the main method will use the invoker to execute the command.

public class HomeHeatingSystemAutomation {

    public static void main(String[] args) {

        Controller controller = new Controller();
        HeatingSystem heatingSystem = new HeatingSystem();

        Command heatOn = new HeatingOnCommand(light);
        Command heatOff = new HeatingOffCommand(light);

        controller.setCommand(heatOn);
        controller.executeCommand();

        controller.setCommand(heatOff);
        controller.executeCommand();
    }
}

Basically, there are three significant steps in the main method.

Creating an object from the invoker class which is Controller in our application.
Creating objects from commands that we are going to execute.
Executing commands using invokers.

There could be other steps that are needed to support these three main steps. For example, This main() method has created a HeatingSystem object because a HeatingSystem object is needed to pass to create Command objects. When you execute this code, the following output will be produced.

Additional options

The Command pattern can be used together with the following options:

adding commands to a queue to execute them later;
supporting undo/redo operations;
storing a history of commands;
serializing commands to store them on a disk;

These options are not essential to the pattern but are often used in practice.

Conclusion

The main advantage of the command pattern is that it decouples the object that invokes the operation from the one that knows how to perform it. Various modifications of this pattern can be used to keep a history of requests, implement the undo functionality and create macro commands. However, application can become more complicated because this pattern as in adds another layer of abstraction.

An efficient way to compare strings in Go

Rakesh Mothukuri — Sun, 19 Apr 2020 15:18:30 +0000

Introduction

One of the most overlooked operations is comparing two strings and this might not cause system overhead but definitely, it is a good practice to write an efficient code where possible. These small dividends definitely pay at the end when the application is under real stress in production.

Note: I am amateur in Go if you are an experienced professional in Go and find anything wrong here don't be annoyed. If you could point the mistake I will correct those accordingly.

One of the often used string comparisons is

strings.ToLower(stringA) == strings.ToLower(stringB)

but this way of comparing takes a lot of time per operation and the reason is, In Go, a string is an immutable sequence of runes. rune in Go is an integer value represents code point

The more detailed and sensible explanation is given by Rob Pike in blog: https://blog.golang.org/strings Its a very nice bedtime read which gives a recap of basics of strings in programming languages.

Here ToLower a standard function in strings package which when used traverse through the entire string converts it to a lower case and returns a new string cause strings in Go is immutable which means strings.ToLower allocates new memory spaces for these two strings.

sample code:

func CompareStringsInCrudeWay(stringA, stringB string) (bool, error) {
    if strings.ToLower(stringA) == strings.ToLower(stringB) {
        return true, nil
    } else {
        return false, nil
    }
}

Benchmark:

Input:

  stringA = "rakesh123456789mothukuri123456789"

  stringB = "ramesh123456789mothukuri123456789"

BenchmarkCompare-8       8304722               151 ns/op               0 B/op          0 allocs/op

If we notice in earlier benchmark figures this operation takes 151 nanoseconds per operation. But is this too much we need to talk about? No, but if there is a simple change to way strings are compared and we could get this down to 30 nanoseconds why not?

Optimization

To optimize we could find a way instead traverse through runes of each string, compare each character in the string, if rune doesn't match we would convert rune to lowercase and compare again and if they still don't match we break the loop and break the loop and return strings are not same. This process will save operation time spent comparing string.

Pseudocode

func Compare(stringA, stringB string) bool {
    for i := 0; i < len(stringA); i++ {
        if stringA[i] == stringB[i] {
            continue
        }
        if unicode.ToLower(stringA[i]) != unicode.ToLower(stringB[i]) {
            return false
        }
    }
    return true
}

But this has more logic here to remember and implement every time we compare string only if there is an easy way to do. Go strings package has a method which performs in this fashion which is strings.EqualFold

sample code using EqualFold

func CompareStringsInEfficientWay(stringA, stringB string) (bool, error) {
   if strings.EqualFold(stringA, stringB) {
      return true, nil
   } else {
      return false, nil
   }
}

Benchmark:

Input:
  stringA = "rakesh123456789mothukuri123456789"
  stringB = "ramesh123456789mothukuri123456789"
BenchmarkCompare-8      76842292                17.1 ns/op             0 B/op          0 allocs/op

Now, it took 17 nanoseconds per operation, These small wins over a period of time will definitely payback, not only they pay back it also helps promote an efficient way of writing code.

This is the end of the blog if you think there is a more efficient way of comparing string in Go please drop me a message I will attribute you and amend the content.

8 Most used functions of strings package in Go

Rakesh Mothukuri — Fri, 10 Apr 2020 23:04:52 +0000

Introduction

The standard Go library strings package provides many string related functions. This blog lists description of most frequently used function of strings package in Go, Since there are a lot of functions available and it's not easy to remember each one of those straight away, it worth bookmarking as it might be handy when needed. Below is a list of function with small example snippet code.

Note: I am amateur in Go if you are an experienced professional in Go and find anything wrong here don't be annoyed if you could point the mistake I will correct those accordingly.

1 .Compare

compares two string lexicographically Outcome of this function is an integer and could be either 0, -1 or 1

Function signature :

func Compare(a, b string) int

Example:

package main

import (
    "fmt"
    "strings"
)

func main() {
    fmt.Println(strings.Compare("gopher19", "gopher20"))
    fmt.Println(strings.Compare("gopher19", "gopher19"))
    fmt.Println(strings.Compare("gopher20", "gopher19"))
}

Output :
-1
0
1

2 .Contains

contains function returns an appropriate Boolean value if given substring present in the string being searched.

Function signature :

func Contains(s, substr string) bool

Example:

package main

import (
    "fmt"
    "strings"
)

func main() {
    fmt.Println(strings.Contains("gopher-20", "20"))
    fmt.Println(strings.Contains("gopher-20", "30"))
    fmt.Println(strings.Contains("gopher-20", ""))
    fmt.Println(strings.Contains("", ""))
}

output:
true
false
true
true

3 .Count

I find this most useful especially in coding challenges where they ask you to find number of times a character repeated in a string.

This function takes two strings as input and checks number of times second string argument appears in first string argument and returns count as an integer.

Function signature :

func Count(s, substr string) int

Example:

package main

import (
    "fmt"
    "strings"
)

func main() {
    fmt.Println(strings.Count("gopher-gopher-gopher", "g"))
    fmt.Println(strings.Count("gopher", "g"))
}

output:
3
1

4 .Fields

If you ever wanted to split a string into string array by white space characters

This function takes a string as input and splits into an array by white space characters in the string and returns a string array.

Function signature :

func Fields(s string) []string

Example:

package main

import (
    "fmt"
    "strings"
)

func main() {
    fmt.Printf("Fields are: %q", strings.Fields("gopher is sleeping."))
}

output:
Fields are: ["gopher" "is" "sleeping."]

5 .HasPrefix

This function takes two strings as input and checks if the second argument string is present in starting characters of the first argument string.

.HasPrefix has his brother called .HasSuffix does exactly same but this time it checks at the ending part of the string.

Function signature :

func HasPrefix(s, prefix string) bool

Example:

package main

import (
    "fmt"
    "strings"
)

func main() {
    fmt.Println(strings.HasPrefix("gopher", "go"))
    fmt.Println(strings.HasPrefix("gopher", "java"))
    fmt.Println(strings.HasPrefix("gopher", ""))
}

output:
true
false
true

6 .Replace

This function takes four parameters as input

culprit string
old string
new string
number of times new string will replace old string in culprit string

if n < 0 there is no limit on a number of replacements.

Function signature :

func Replace(s, old, new string, n int) string

Example:

package main

import (
    "fmt"
    "strings"
)

func main() {
    fmt.Println(strings.Replace("no-banana no-banana no-banana", "no", "yes", 2))
    fmt.Println(strings.Replace("no-banana no-banana no-banana", "no", "yes", -1))
}

output:
yes-banana yes-banana no-banana
yes-banana yes-banana yes-banana

another version of .Replace is .ReplaceAll which basically replace all.

7 .Split

This function takes two strings as input and returns a slice of the substrings based on the second argument string.

Function signature :

func Split(s, sep string) []string

Example:

package main

import (
    "fmt"
    "strings"
)

func main() {
    fmt.Printf("%q\n", strings.Split("gopher,19,gopher", ","))
}

output:
["gopher" "19" "gopher"]

There are few more variations of .Split exists which are .SplitAfter .SplitAfterN .SplitN

8 .TrimSpace

One of the most used feature to remove white spaces, this function takes a string as input and returns a string with trailing and leading spaces removed.

Function signature :

func TrimSpace(s string) string

Example:

package main

import (
    "fmt"
    "strings"
)

func main() {
    fmt.Println(strings.TrimSpace(" \t\n Covid-19's vaccine will be invented and out soon to rescue us all from this insane. \n\t\r\n"))
}

output:
Covid-19's vaccine will be invented and out soon to rescue us all from this insane.

This is the end of the most-used strings functions I think are, but if you think there is something which you think must go into this list please drop me a message and I will include it in here.