Programowanie to nie tylko tworzenie działającego kodu, ale również dbałość o jego jakość i utrzymywalność. Cursor AI to narzędzie, które może pomóc w pisaniu lepszego kodu, pod warunkiem że przestrzegasz kilku kluczowych zasad. Poniżej znajdziesz wskazówki, i gotowe treści promptów, przydatne, by pisać kod zrozumiały, czytelny i odporny na przyszłe zmiany, bazując na założeniach Cursor AI.
Spis treści
1. Pisz kod zrozumiały dla ludzi, nie tylko dla maszyn
Czytelny kod to podstawa dobrego programowania. Używaj intuicyjnych nazw zmiennych, funkcji i klas, aby każdy mógł zrozumieć, co robi Twój kod bez konieczności głębszego analizy. Unikaj skrótów, które mogą być niejasne dla innych programistów.
Przykład:
# ZŁA PRAKTYKA (dla maszyn)
def average(lst):
total = 0 # Total sum
n = len(lst) # Length of the listfor i in range(n):
total += lst[i] # Add element to the sum
return total / n # Divide by the number of elements
# DOBRA PRAKTYKA (dla ludzi)
def calculate_average(grades):
"""Oblicza średnią arytmetyczną z listy ocen"""total_sum = sum(grades) # Sum of all grades
number_of_grades = len(grades) # Count of grades
return total_sum / number_of_grades # Return the average
2. Określ cel zadania i rozbij je na mniejsze części
Zanim rozpoczęcie implementacji, jasno określ, co chcesz osiągnąć. Podziel większe zadania na mniejsze, bardziej manageable elementy. To ułatwi wdrożenie oraz przyszłą konserwację kodu.
Cursor AI może pomóc w planowaniu pracy, sugerując podział na funkcje i moduły.
3. Wybieraj odpowiednie algorytmy i struktury danych
Dobrze dobrane algorytmy i struktury danych mogą znaczną poprawić wydajność i czytelność Twojego kodu. Przykładowo, jeśli pracujesz z danymi hierarchicznymi, użyj drzewa zamiast listy.
Przykład:
# ZŁA PRAKTYKA (lista zagnieżdżona)
def find_supervisor(employees, target_id):
"""Recursively search through a nested list of employees."""for employee in employees:
# If the employee’s ID matches the target ID, return the supervisor
if employee[’id’] == target_id:
return employee[’supervisor’]
# If the target ID is in the employee’s team, recursively find the supervisor
supervisor_id = find_in_team(employee[’team’], target_id)
if supervisor_id:
return supervisor_id
# DOBRA PRAKTYKA (słownik relacji)
# Dictionary representing the organizational structure
organization_structure = {
1: {'name': 'CEO', 'subordinates': [2, 3]},
2: {'name': 'CTO', 'supervisor': 1},
3: {'name': 'CFO', 'supervisor': 1}
}def find_supervisor(employee_id):
„””Direct access through the dictionary to find the supervisor.”””
return organization_structure.get(employee_id, {}).get(’supervisor’)
4. Unikaj powtórzeń
Zasada DRY (Don’t Repeat Yourself) to jedna z podstawowych zasad dobrego kodowania. Powtórzenia zwiększają ryzyko błędów i utrudniają utrzymanie kodu.
Cursor AI pomaga w identyfikacji fragmentów kodu, które mogą zostać zrefaktorowane do wspólnej funkcji lub klasy.
Przykład:
import mathdef calculate_area_circle(radius):
„””Calculates the area of a circle.”””
return math.pi * radius ** 2
def calculate_area_rectangle(length, width):
„””Calculates the area of a rectangle.”””
return length * width
def calculate_area_triangle(base, height):
„””Calculates the area of a triangle.”””
return 0.5 * base * height
# DOBRA PRAKTYKA (DRY)
from math import pidef calculate_area(shape, **parameters):
„””Calculates area for various shapes using a dictionary of functions.”””
operations = {
'circle’: lambda: pi * parameters[’r’] ** 2,
'rectangle’: lambda: parameters[’a’] * parameters[’b’],
'triangle’: lambda: 0.5 * parameters[’a’] * parameters[’h’]
}
return operations.get(shape.lower(), lambda: None)()
5. Jasny format danych wejściowych i wyjściowych
Definiowanie standardowego formatu danych wejściowych i wyjściowych znacznie ułatwia testowanie i integrację aplikacji. Dobrą praktyką jest wykorzystanie typów danych i adnotacji.
Przykład:
# ZŁA PRAKTYKA (niejawne formaty)
def calculate_cost(order):
"""Calculates the total cost of an order."""
return sum(item[0] * item[1] for item in order)Przykład pokazuje, jak funkcja
calculate_cost nie precyzuje formatu danych wejściowych (order). Użycie ogólnego formatu, jak lista, utrudnia zrozumienie, jak dokładnie powinna wyglądać struktura danych.
# DOBRA PRAKTYKA (określony format)
from typing import List, TupleOrderItem = Tuple[str, float, int] # (name, price, quantity)
def calculate_validated_cost(order: List[OrderItem]) -> float:
„””Calculates the total cost of an order with validation.”””
return sum(price * quantity for _, price, quantity in order)
Przykład wprowadza typowanie za pomocą List[OrderItem], gdzie OrderItem to krotka z dokładnie określonymi typami (string, float, int). Taki sposób zapisu danych wejściowych i ich struktury ułatwia zrozumienie, jakie dane są wymagane, a także poprawia dokumentację kodu.
6. Przewiduj trudności i przypadki brzegowe
Już na etapie pisania kodu zastanów się, jakie problemy mogą się pojawić. Testuj kod na danych, które mogą być nietypowe lub ekstremalne.
7. Komentuj tylko to, co nieoczywiste
Dobre komentarze wyjaśniają „dlaczego”, a nie „co” robi kod. Unikaj nadmiarowych komentarzy, które mogą rozpraszać lub wprowadzać w błąd. A najlepiej stosuj docstringi.
Przykład:
# ZŁA PRAKTYKA (nadmiarowe komentarze)
def przetworz_liczby(dane):
# Inicjalizacja listy wynikowej
wynik = []# Iteracja przez wszystkie elementy
for liczba in dane:
# Sprawdzenie czy liczba jest parzysta
if liczba % 2 == 0:
# Dodanie liczby pomnożonej przez 2
wynik.append(liczba * 2)
else:
# Dodanie liczby bez zmian
wynik.append(liczba)
return wynik
# DOBRA PRAKTYKA (celowe komentarze)
def przetworz_liczby(dane: list[int]) -> list[int]:
"""
Przetwarza liczby według biznesowych zasad:
- Parzyste mnoży przez 2 (wymóg systemu legacy)
- Nieparzyste pozostawia bez zmian
- Pomija wartości None (zgodnie z RFC-1234)
"""
return [
num * 2 if num & 1 == 0 else num # Bitowe sprawdzenie parzystości (szybsze niż modulo)
for num in dane
if num is not None # Filtr dla danych z zewnętrznego API
]8. Nie musisz pamiętać o standardach kodowania i najlepszych praktykach
Agent Cursor odczytuje błędy lintera, aby automatycznie je naprawić, a Ty w tym czasie możesz iść pograć w piłkarzyki.
9. Optymalizuj wydajność z rozwagą
Wydajność jest ważna, ale nie kosztem czytelności. Unikaj przedwczesnej optymalizacji, która może utrudnić debugowanie i rozwój aplikacji.
10. Twórz testy
Testy automatyczne zapewniają stabilność i niezawodność kodu. Dobrze napisane przypadki testowe ułatwiają wprowadzanie zmian i wychwytywanie błędów. Cursor AI przydaje się o tyle, że potrafi wymyślić najbardziej nieprzewidywalne eage case scenarious.
Przykład testu w Pythonie:
def test_calculate_sum():
"""Test the calculate_sum function."""
result = calculate_sum([1, 2, 3])
expected = 6
assert result == expected, f"Expected {expected}, but got {result}"11. I NAJWAŻNIEJSZE: Cursor AI napisze za Ciebie dokumentacje 😎
Na podstawie kodu, który sam wytworzył.
Podsumowanie
Cursor AI to potężne narzędzie, które może pomóc w pisaniu czystego, czytelnego i wydajnego kodu. Kluczem do sukcesu jest stosowanie najlepszych praktyk programistycznych, takich jak zasada DRY, odpowiednie formatowanie kodu czy tworzenie testów.
Pamiętaj, że kodowanie to sztuka łącząca kreatywność z rygorem technicznym – dobre narzędzia, takie jak Cursor AI, mogą znacznie ułatwić to zadanie i stać się uzupełnieniem solidnych praktyk programistycznych.
