ตรวจสอบสถานการณ์การปรับโครงสร้างโค้ดและแนวทางปฏิบัติที่ดีที่สุด GitHub Copilot

เสร็จสมบูรณ์เมื่อ

โค้ดการปรับโครงสร้างใหม่คือกระบวนการในการจัดโครงสร้างโค้ดที่มีอยู่ใหม่โดยไม่เปลี่ยนแปลงลักษณะการทํางาน ประโยชน์ของการปรับโครงสร้างใหม่รวมถึงการปรับปรุงความสามารถในการอ่านโค้ด ลดความซับซ้อน ทําให้ง่ายต่อการบํารุงรักษาโค้ด และเพิ่มคุณสมบัติใหม่ให้ง่ายขึ้น การนําแนวทางปฏิบัติที่ดีที่สุด GitHub Copilot ไปใช้จะช่วยให้คุณทํางานได้อย่างมีประสิทธิภาพมากขึ้นและได้ผลลัพธ์ที่ดีขึ้น

แนวทางปฏิบัติแนะนํา GitHub Copilot

GitHub Copilot เป็นเครื่องมืออันทรงพลังที่สามารถช่วยคุณปรับโครงสร้างและปรับปรุงโค้ดของคุณได้ อย่างไรก็ตาม เพื่อให้ได้ผลลัพธ์ที่ดีที่สุด คุณควรปฏิบัติตามแนวทางปฏิบัติที่ดีที่สุดเมื่อใช้ GitHub Copilot

ปรับปรุงการตอบกลับด้วยพร้อมท์ที่ดีกว่า

คุณสามารถปรับปรุงคุณภาพของการตอบกลับของ GitHub Copilot ได้โดยการเขียนข้อความแจ้งที่มีประสิทธิภาพมากขึ้น ข้อความแจ้งที่ออกแบบมาอย่างดีสามารถช่วยให้ GitHub Copilot เข้าใจความต้องการของคุณดีขึ้นและสร้างคําแนะนําโค้ดที่เกี่ยวข้องมากขึ้น

หลักเกณฑ์ต่อไปนี้สามารถช่วยให้คุณเขียนพร้อมท์ได้ดียิ่งขึ้น:

• เริ่มใช้งานทั่วไป แล้วระบุข้อมูล

  Generate a Calculator class. Add methods for addition, subtraction, multiplication, division, and factorial. Don't use any external libraries and don't use recursion.
  

• ให้ตัวอย่างของสิ่งที่คุณต้องการ

  Generate a function that takes a string and returns the number of vowels in it. For example: findVowels("hello") returns 2, findVowels("sky") returns 0.
  

• แบ่งงานที่ซับซ้อนออกเป็นงานที่ง่ายขึ้น

  แทนที่จะขอให้ GitHub Copilot "สร้างแอปวางแผนมื้ออาหาร" ให้แบ่งข้อความแจ้งของคุณออกเป็นงานเล็กๆ

  เช่น:

  Generate a function that takes a list of ingredients and returns a list of recipes.
  

  Generate a function that takes a list of recipes and returns a shopping list.
  

  Generate a function that takes a list of recipes and returns a meal plan for the week.
  

• ระบุบริบทที่ถูกต้อง เช่น การเลือกโค้ด ไฟล์ เอาต์พุตของเทอร์มินัล และอื่น ๆ

  ตัวอย่างเช่น ใช้ตัวแปร #codebase เพื่ออ้างถึงฐานรหัสทั้งหมด: "connection string ฐานข้อมูลที่ใช้ใน #codebase อยู่ที่ไหน"

• ทําซ้ําบนพร้อมท์ของคุณ

  ให้พร้อมท์การติดตามผลเพื่อปรับปรุงหรือปรับเปลี่ยนการตอบกลับ

  ตัวอย่างเช่น หากคุณเริ่มต้นด้วยพร้อมท์ต่อไปนี้:

  "เขียนฟังก์ชันเพื่อคํานวณค่าแฟกทอเรียลของตัวเลข"

  คุณสามารถติดตามผลด้วย:

  "อย่าใช้การเกิดซ้ําและปรับให้เหมาะสมโดยใช้การแคช"

  แล้วก็:

  "ใช้ชื่อตัวแปรที่มีความหมาย"

• รักษาประวัติการแชทให้สอดคล้องกัน

  GitHub Copilot ใช้ประวัติการสนทนาเพื่อให้บริบท ลบคําถามและคําตอบในอดีตออกจากประวัติหากไม่เกี่ยวข้อง หรือเริ่มต้นเซสชันใหม่ถ้าคุณต้องการเปลี่ยนบริบท

ให้บริบทและเครื่องมือที่เหมาะสม

เพิ่มความรวดเร็วของคุณด้วยบริบทที่เกี่ยวข้องเพื่อให้ได้คําตอบที่ถูกต้องและเกี่ยวข้องมากขึ้นในการแชท ด้วยเครื่องมือที่เหมาะสม คุณสามารถเพิ่มประสิทธิผลนักพัฒนาของคุณได้

• ในเอเจนต์ ให้เลือกปุ่มเครื่องมือเพื่อกําหนดค่าเครื่องมือที่คุณต้องการใช้หรือเพิ่มลงในพรอมต์ของคุณอย่างชัดเจน

• ใช้ #codebase เพื่อให้ GitHub Copilot ค้นหาไฟล์ที่ถูกต้องโดยอัตโนมัติโดยทําการค้นหาโค้ด

• ใช้เครื่องมือ #fetch เพื่อดึงเนื้อหาจากหน้าเว็บ หรือใช้ #githubRepo เพื่อทําการค้นหาโค้ดบนที่เก็บ GitHub

• ไฟล์อ้างอิง โฟลเดอร์ หรือสัญลักษณ์ในพร้อมท์ของคุณโดยใช้ #<file name>#<folder name>หรือ#<symbol>

• ลากแล้วปล่อยไฟล์ โฟลเดอร์ หรือแท็บตัวแก้ไขลงในพร้อมท์แชท

• เพิ่มปัญหา ความล้มเหลวในการทดสอบ หรือผลลัพธ์ของเทอร์มินัลลงในพร้อมท์การสนทนาของคุณสําหรับบริบทเฉพาะของสถานการณ์

หมายเหตุ

เมื่อคุณใช้เอเจนต์ GitHub Copilot จะค้นหาไฟล์และบริบทที่เกี่ยวข้องให้คุณโดยอัตโนมัติ

สถานการณ์การปรับโครงสร้างโค้ดทั่วไป

GitHub Copilot สามารถช่วยคุณปรับโครงสร้างโค้ดได้อย่างรวดเร็วในหลายวิธี รายการต่อไปนี้ประกอบด้วยสถานการณ์ทั่วไปบางอย่างสําหรับการปรับโครงสร้างโค้ดใหม่:

• การปรับโค้ดที่ไม่มีประสิทธิภาพให้เหมาะสม
• การล้างโค้ดที่ซ้ํากัน
• การทําให้โค้ดรัดกุมมากขึ้น
• การแบ่งหน่วยที่ซับซ้อนของรหัส
• การเขียนโค้ดตามเงื่อนไขใหม่เพื่อให้อ่านง่ายขึ้น
• การจัดรูปแบบโค้ดใหม่เพื่อใช้โครงสร้างที่แตกต่างกัน

ใช้ GitHub Copilot เพื่อเพิ่มประสิทธิภาพโค้ดที่ไม่มีประสิทธิภาพ

GitHub Copilot สามารถช่วยคุณเพิ่มประสิทธิภาพโค้ดได้ ตัวอย่างเช่น คุณสามารถปรับโค้ดของคุณให้เหมาะสมเพื่อให้เรียกใช้โค้ดได้รวดเร็วยิ่งขึ้น

พิจารณาสคริปต์แบชต่อไปนี้:

#!/bin/bash
# Find all .txt files and count the number of lines in each file
for file in $(find . -type f -name "*.txt"); do
  wc -l "$file"
done

คุณสามารถใช้คุณลักษณะการสนทนาเพื่อประเมินตัวเลือกสําหรับการปรับให้เหมาะสมกับลักษณะที่แตกต่างกันของสคริปต์ เช่น ประสิทธิภาพการทํางาน

#!/bin/bash
# Find all .txt files and count the number of lines in each file (improved performance)
find . -type f -name "*.txt" -print0 | xargs -0 wc -l

ใช้ GitHub Copilot เพื่อล้างโค้ดที่ซ้ํากัน

การหลีกเลี่ยงการทําซ้ําจะทําให้การแก้ไขและแก้ไขจุดบกพร่องของโค้ดของคุณง่ายขึ้น ตัวอย่างเช่น ถ้ามีการดําเนินการคํานวณเดียวกันมากกว่าหนึ่งครั้งในตําแหน่งที่แตกต่างกันในไฟล์ คุณสามารถย้ายการคํานวณไปยังฟังก์ชันได้

ในตัวอย่าง JavaScript ง่าย ๆ ต่อไปนี้ การคํานวณเดียวกัน (ราคาสินค้าคูณด้วยจํานวนสินค้าที่ขาย) จะดําเนินการในสองตําแหน่ง

let totalSales = 0;
let applePrice = 3;
let appleSold = 100;
totalSales += applePrice * appleSold;

let orangePrice = 2;
let orangeSold = 50;
totalSales += orangePrice * orangeSold;

console.log(`Total: ${totalSales}`);

คุณสามารถขอให้ฟีเจอร์แชทย้ายการคํานวณซ้ําลงในฟังก์ชัน

function calculateTotal(price, quantity) {
    return price * quantity;
}
let totalSales = 0;
let applePrice = 3;
let appleSold = 100;
totalSales += calculateTotal(applePrice, appleSold);

let orangePrice = 2;
let orangeSold = 50;
totalSales += calculateTotal(orangePrice, orangeSold);
console.log(`Total: ${totalSales}`);

ใช้ GitHub Copilot เพื่อทําให้โค้ดกระชับยิ่งขึ้น

หากรหัสนั้นใช้ถกเถียงโดยไม่จําเป็น อาจเป็นเรื่องยากที่จะอ่านและคงไว้ GitHub Copilot สามารถแนะนําโค้ดที่เลือกในเวอร์ชันที่กระชับยิ่งขึ้นได้

โค้ด Python ต่อไปนี้จะส่งออกพื้นที่ของสี่เหลี่ยมผืนผ้าและวงกลม แต่โค้ดสามารถเขียนได้กระชับกว่านี้:

def calculate_area_of_rectangle(length, width):
    area = length * width
    return area

def calculate_area_of_circle(radius):
    area = 3.14 * radius * radius
    return area

rectangle_length = 5
rectangle_width = 10
rectangle_area = calculate_area_of_rectangle(rectangle_length, rectangle_width)
print(f"Area of rectangle: {rectangle_area}")

circle_radius = 7
circle_area = calculate_area_of_circle(circle_radius)
print(f"Area of circle: {circle_area}")

GitHub Copilot สามารถช่วยคุณปรับโครงสร้างโค้ดใหม่และทําให้กระชับยิ่งขึ้น

def calculate_area_of_rectangle(length, width):
    return length * width

def calculate_area_of_circle(radius):
    return 3.14 * radius * radius

rectangle_length = 5
rectangle_width = 10
print(f"Area of rectangle: {calculate_area_of_rectangle(rectangle_length, rectangle_width)}")

circle_radius = 7
print(f"Area of circle: {calculate_area_of_circle(circle_radius)}")

ใช้ GitHub Copilot เพื่อแยกหน่วยโค้ดที่ซับซ้อน

วิธีการหรือฟังก์ชันขนาดใหญ่ที่ดําเนินการหลายอย่างมีแนวโน้มที่จะให้โอกาสน้อยลงสําหรับการนํากลับมาใช้ใหม่น้อยกว่าฟังก์ชันที่เล็กกว่าและง่ายขึ้นซึ่งมุ่งเน้นไปที่การดําเนินการบางอย่าง นอกจากนี้ ยังอาจยากต่อการทําความเข้าใจและแก้จุดบกพร่องอีกด้วย

GitHub Copilot สามารถช่วยคุณแบ่งบล็อกโค้ดที่ซับซ้อนออกเป็นหน่วยเล็กๆ ที่เหมาะสําหรับการนํากลับมาใช้ใหม่มากกว่า

โค้ด Python ต่อไปนี้เป็นตัวอย่างที่ง่ายมาก แต่แสดงหลักการของการแยกฟังก์ชันเดียวออกเป็นสองฟังก์ชันที่ดําเนินการเฉพาะ

import pandas as pd
from pandas.io.formats.styler import Styler

def process_data(item, price):
    # Cleanse the data
    item = item.strip()    # Remove leading and trailing whitespace
    price = price.strip()  # Remove leading and trailing whitespace
    price = float(price)   # Convert price to a float
    # More cleansing operations can be added here

    # Create and print a DataFrame
    data = {'Item': [item], 'Price': [price]}
    df = pd.DataFrame(data)
    print(df.to_string(index=False))

# Example usage
item = "  Apple  "
price = "  1.50  "
process_data(item, price)

คุณสามารถใช้ GitHub Copilot เพื่อปรับโครงสร้างโค้ดใหม่เพื่อสร้างฟังก์ชันสําหรับการล้างข้อมูล การพิมพ์ข้อมูล และการประมวลผลข้อมูล

import pandas as pd
from pandas.io.formats.styler import Styler

def cleanse_data(item, price):
    # Cleanse the data
    item = item.strip()    # Remove leading and trailing whitespace
    price = price.strip()  # Remove leading and trailing whitespace
    price = float(price)   # Convert price to a float
    return item, price

def print_data(item, price):
    # Create and print a DataFrame
    data = {'Item': [item], 'Price': [price]}
    df = pd.DataFrame(data)
    print(df.to_string(index=False))

def process_data(item, price):
    item, price = cleanse_data(item, price)
    print_data(item, price)

# Example usage
item = "  Apple  "
price = "  1.50  "
item, price = cleanse_data(item, price)
print_data(item, price)

ใช้ GitHub Copilot เพื่อเขียนโค้ดตามเงื่อนไขใหม่เพื่อให้อ่านง่ายขึ้น

มีหลายวิธีในการเขียนโค้ดที่ทําได้หรือไม่ได้รับการดําเนินการขึ้นอยู่กับเงื่อนไขต่าง ๆ โครงสร้างแบบมีเงื่อนไขบางอย่างเหมาะสมกว่าโครงสร้างอื่นที่เหมาะสมกว่ากรณีการใช้งานเฉพาะ และในบางครั้งการเลือกโครงสร้างแบบมีเงื่อนไขทางเลือกอาจทําให้อ่านโค้ดได้ง่ายขึ้น

วิธีการ Java นี้ใช้ชุดคําสั่ง if และ else if เพื่อกําหนดการดําเนินการที่จะดําเนินการ:

public string getSound(String animal) {
    if (animal == null) {
        System.out.println("Animal is null");
    } else if (animal.equalsIgnoreCase("Dog")) {
        return "bark";
    } else if (animal.equalsIgnoreCase("Cat")) {
        return "meow";
    } else if (animal.equalsIgnoreCase("Bird")) {
        return "tweet";
    }
    return "unknown";
}

คําสั่งสลับอาจเป็นวิธีที่ดีกว่าในการใช้ตรรกะเดียวกัน

/**
    * Returns the sound made by the specified animal.
    *
    * @param animal the name of the animal
    * @return the sound made by the animal, or "unknown" if the animal is not recognized
    */
public String getAnimalSound(String animal) {
    return switch (animal) {
        case null -> "Animal is null";
        case "Dog" -> "bark";
        case "Cat" -> "meow";
        case "Bird" -> "tweet";
        default -> "unknown";
    };
}

ใช้ GitHub Copilot เพื่อจัดรูปแบบโค้ดใหม่เพื่อใช้โครงสร้างอื่น

สมมติว่าคุณมีฟังก์ชันต่อไปนี้ใน JavaScript:

function listRepos(o, p) {
    return fetch(`https://api.github.com/orgs/${o}/repos?per_page=${parseInt()}`)
        .then(response => response.json())
        .then( (data) => data);
}

ถ้ามาตรฐานการเข้ารหัสของคุณกําหนดให้คุณต้องใช้สัญกรณ์ลูกศรสําหรับฟังก์ชัน และชื่อที่สื่อความหมายสําหรับพารามิเตอร์ คุณสามารถใช้ GitHub Copilot เพื่อช่วยคุณทําการเปลี่ยนแปลงเหล่านี้ได้

const listRepositories = (organization, perPage) => {
    return fetch(`https://api.github.com/orgs/${organization}/repos?per_page=${parseInt(perPage)}`)
        .then(response => response.json())
        .then(data => data);
};

สรุป

GitHub Copilot สามารถช่วยคุณปรับโครงสร้างโค้ดได้หลายวิธี คุณสามารถใช้มุมมองแชทหรือแชทแบบอินไลน์เพื่อขอให้ GitHub Copilot เพิ่มประสิทธิภาพโค้ดที่ไม่มีประสิทธิภาพล้างโค้ดซ้ําทําให้โค้ดกระชับขึ้นแยกหน่วยโค้ดที่ซับซ้อนเขียนโค้ดตามเงื่อนไขใหม่เพื่อให้อ่านง่ายขึ้นและจัดรูปแบบโค้ดใหม่เพื่อใช้โครงสร้างอื่น