¼¼ÊõÔĶÁÖÜ¿¯µÚÊ®ÆÚ

// Long form  
var message string  
message = "Hello, Golang!"  
  
// Shorthand  
message := "Hello, Golang!"

// Long form  
var a, b, c int  
a = 1  
b = 2  
c = 3  
  
// Shorthand  
a, b, c := 1, 2, 3

a, b := 1, 2  
  
// Long form  
temp := a  
a = b  
b = temp  
  
// Shorthand  
a, b = b, a

// Long form  
func cleanup() {  
// Cleanup logic  
}  
defer cleanup()  
  
// Shorthand  
defer func() {  
// Cleanup logic  
}()

// Long form  
value, exists := myMap[key]  
if !exists {  
    // Key doesn't exist in the map  
}  
  
// Shorthand  
if value, exists := myMap[key]; !exists {  
    // Key doesn't exist in the map  
}

// Long form  
for i := 0; i < len(numbers); i++ {  
fmt.Println(i, numbers[i])  
}  
  
// Shorthand  
for i, value := range numbers {  
fmt.Println(i, value)  
}

// Long form  
result, err := someFunction()  
if err != nil {  
// Handle the error  
}  
  
// Shorthand  
if result, err := someFunction(); err != nil {  
// Handle the error  
}

// Long form  
var x int  
ptr := &x  
  
// Shorthand  
ptr := new(int)

// Long form  
func add(x, y int) int {  
return x + y  
}  
  
// Shorthand  
add := func(x, y int) int {  
return x + y  
}

// Long form  
colors := make(map[string]string)  
colors["red"] = "#ff0000"  
colors["green"] = "#00ff00"  
  
// Shorthand  
colors := map[string]string{  
"red": "#ff0000",  
"green": "#00ff00",  
}

// Long form  
const pi float64 = 3.14159  
const maxAttempts int = 3  
  
// Shorthand  
const (  
 pi = 3.14159  
 maxAttempts = 3  
)

// Before
List<String> names = new ArrayList<>();  
for (Person person : people) {  
names.add(person.getName());  
}
// After
List<String> names = people.stream()  
.map(Person::getName)  
.collect(Collectors.toList());

Optional<String> maybeName = Optional.ofNullable(person.getName());  
String name = maybeName.orElse("Unknown");

List<Integer> evenNumbers = numbers.stream()  
.filter(num -> num % 2 == 0)  
.collect(Collectors.toList());

String s1 = "Hello";  
String s2 = " World";  
String s = String.format("%s%s", s1, s2);

import java.time.LocalDateTime;  
public interface TimeClient {  
void setTime(int hour, int minute, int second);  
void setDate(int day, int month, int year);  
void setDateAndTime(int day, int month, int year, int hour, int minute, int second);  
LocalDateTime getLocalDateTime();  
}

public class Main {
    enum Level { LOW, MEDIUM, HIGH }
    public static void main(String[] args) {
        Level myVar = Level.MEDIUM;
        System.out.println(myVar);
    }
}

try (FileReader fileReader = new FileReader("example.txt");
     BufferedReader bufferedReader = new BufferedReader(fileReader)) {
    String line = bufferedReader.readLine();
    // Process the file
} catch (IOException e) {
    // Handle the exception
}

package hello;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.web.reactive.config.EnableWebFlux;
import org.reactivestreams.Publisher;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import reactor.core.publisher.Mono;

@SpringBootApplication
@EnableWebFlux
@Controller
public class Application {

    public static void main(String[] args) throws Exception {
        SpringApplication.run(Application.class);
    }

    @GetMapping("/")
    @ResponseBody
    public Publisher<String> handler() {
        return Mono.just("Hello world!");
    }
}

// Vert.x
package com.example.starter;  
  
import io.vertx.core.AbstractVerticle;  
import io.vertx.core.Promise;  
import io.vertx.core.http.HttpServer;  
import io.vertx.ext.web.Router;  
  
public class MainVerticle extends AbstractVerticle {  
  
  @Override  
  public void start(Promise<Void> startPromise) throws Exception {  
    HttpServer server = vertx.createHttpServer();  
    Router router = Router.router(vertx);  
  
    router.get("/").respond(ctx -> ctx  
        .response()  
        .putHeader("Content-Type", "text/plain")  
        .end("hello world!"));  
  
    server.requestHandler(router).listen(3000);  
  }  
}

# Cherry pick more than 1 SHA.
#
# This could be useful if you have a handful of commits that you want to bring over,
# you'll likely want to order them with the oldest commit being first in the list.
git cherry-pick <SHA> <SHA>

# Edit the git commit message for the newly applied commit.
#
# This could be useful if want to customize the git commit message with extra context.
git cherry-pick <SHA> --edit

# Avoid automatically creating the commit which lets you edit the files first.
#
# This could be useful if you need to make manual code adjustments before committing,
# such as applying a security patch which uses an older library with a different API.
git cherry-pick <SHA> --no-commit