Kurs vibe coding z Claude Code · Moduł 7: Klon LinkedIna

Książeczka żeglarska: profil zawodowy i pierwszy własny skill

10 min czytania
W tej lekcji12

Ahoj! W portowych tawernach kapitanowie szukają nawigatorów, a nawigatorzy dobrych statków, tylko nikt nie wie, kto co potrafi. W tej lokacji budujesz Crew Connections, zawodową sieć piratów w stylu LinkedIna. W Kraken's Call, klonie Twittera, liczyły się luźne wpisy i polubienia, a tutaj stanowiska, staż i umiejętności potwierdzone przez załogę. Profil działa jak książeczka żeglarska: pokazuje, gdzie pływałeś i co umiesz.

Czego się nauczysz

  • zlecić Claude Code profil z doświadczeniem i potwierdzeniami umiejętności;
  • czytać formularz z Server Action, walidacją na serwerze i błędami pod polami;
  • sprawdzić, czy zasad pilnuje serwer, a nie tylko przycisk;
  • zapisać powtarzalną procedurę jako własny skill Claude Code i przeczytać jego plik.

Nowy port: projekt crew-connections

Sieć zawodowa to osobna aplikacja, więc zakładasz ją poleceniem z lekcji 1_2, zmieniając tylko nazwę. Zanim klikniesz Yes, porównaj komendę z tą:

npx create-next-app@latest crew-connections --ts --eslint --tailwind --app --no-src-dir --no-cache-components --agents-md --no-agent-feedback --use-npm

Dalej znana pętla: sesja w folderze crew-connections, CLAUDE.md z importem @AGENTS.md, Vitest z tą samą poprawką @types/node co w lekcji 4_1 i pierwszy commit.

Problem: trzy podobne formularze

Pirat chce poprawić swój nagłówek zawodowy, kapitan chce dodać ofertę pracy, a kandydat wysłać zgłoszenie. To trzy formularze z tym samym ryzykiem: przeglądarka sprawdzi tylko to, co jej każesz, a do serwera każdy może wysłać, co zechce. Dlatego zasad pilnuje serwer. Pierwszy formularz zbudujesz porządnie, a potem zapiszesz przepis, żeby Claude odtwarzał go jednym poleceniem.

Polecenie dla Claude Code:

/plan Zbuduj w Crew Connections profil zawodowy. Strona /in/[handle]:
nagłówek (imię, headline, port, liczba kontaktów), doświadczenie ze
stażem liczonym z dat (brak endDate = praca trwa) i umiejętności
z potwierdzeniami. Potwierdzić można tylko cudzą umiejętność i tylko
raz; pilnuje tego serwer. Strona /profile/edit z formularzem: zapis
przez Server Action, walidacja na serwerze według przewodnika Forms
z node_modules/next/dist/docs, błędy pod polami, wpisane wartości
zostają po błędzie. Logowania jeszcze nie ma: zalogowany pirat
z jednej funkcji w lib/session.ts. Dane w data/*.json. Formatowanie
dat w lib/format.ts, najpierw testy. Na koniec testy, lint, typy, build.

W planie szukasz trzech rzeczy: walidacji w pliku z "use server", pirata z lib/session.ts zamiast z pola formularza i testów przed kodem formatowania. Claude zaproponował bibliotekę Zod, którą przewodnik Forms podaje do walidacji na serwerze. To jedna paczka, więc zgoda.

Co napisał Claude: profil w typach

Otwórz w Cursorze types/profile.ts. Typ Profile ma handle (krótka nazwa w adresie, jak redbeard), imię, headline, czyli tytuł zawodowy w rodzaju "Kapitan i nawigator na Czarnej Perle", port, opis "O mnie", liczbę kontaktów oraz listy doświadczenia i umiejętności. Pól tweets czy likes nie ma, to inny świat. Pod nim stoją dwa mniejsze typy:

export interface Experience {
  id: string;
  title: string;
  company: string;
  startDate: string; // "2023-03": rok i miesiąc jako tekst ISO
  endDate?: string; // brak = praca trwa nadal
  description?: string;
}

export interface Skill {
  id: string;
  name: string;
  endorsedBy: string[]; // handle osób, które potwierdziły umiejętność
}

Brak endDate oznacza stanowisko, które trwa. Potwierdzenie (ang. endorsement) to jedno kliknięcie, którym ręczysz, że ktoś naprawdę zna nawigację, więc endorsedBy trzyma, kto już poręczył. Rekomendacja to coś innego: pisemna referencja o całej współpracy, którą dodasz później.

Staż liczony z dat

Otwórz lib/format.ts. Claude najpierw napisał testy, potem funkcję:

export function formatDuration(start: string, end?: string, today = new Date()): string {
  const until = end ?? `${today.getFullYear()}-${String(today.getMonth() + 1).padStart(2, "0")}`;
  const months = monthsBetween(start, until);
  if (months < 1) return "mniej niż miesiąc";
  const years = Math.floor(months / 12);
  const rest = months % 12;
  const parts: string[] = [];
  if (years > 0) parts.push(formatYears(years));
  if (rest > 0) parts.push(`${rest} mies.`);
  return parts.join(" ");
}

monthsBetween liczy miesiące między datami, a potem funkcja dzieli je na lata i resztę: od marca 2023 do sierpnia 2025 to 29 miesięcy, czyli "2 lata 5 mies.". Bez daty końca liczy do today, a parametr pozwala testom podać stałą datę. formatYears z tego samego pliku wybiera formę przez wbudowane Intl.PluralRules("pl-PL"): 1 rok, 22 lata, ale 5 lat. W ExperienceSection wiersz daty wygląda tak: formatMonth(job.startDate) - obecnie · formatDuration(...), na przykład "mar 2023 - obecnie".

Potwierdzenia: decyduje serwer

Server Action to funkcja z dyrektywą "use server", która działa na serwerze, a przeglądarka wywołuje ją, wysyłając formularz. Otwórz components/profile/SkillsSection.tsx (klasy pominięte):

{!isOwn && (
  <form action={endorseSkill.bind(null, profile.handle, skill.id)}>
    <button disabled={endorsed}>{endorsed ? "Potwierdzone" : "+ Potwierdź"}</button>
  </form>
)}

bind dokleja do akcji handle profilu i identyfikator umiejętności; tak dokumentacja przekazuje dodatkowe argumenty. Na własnym profilu przycisków nie ma, a wyłączony przycisk to tylko podpowiedź. Dokumentacja Server Actions ostrzega, że żądanie da się wysłać z pominięciem interfejsu, więc endorseSkill w app/in/[handle]/actions.ts sprawdza wszystko jeszcze raz: pyta getCurrentUser(), odrzuca własny profil i drugie potwierdzenie, dopisuje handle do endorsedBy, zapisuje i woła revalidatePath, żeby strona pokazała nową liczbę.

Formularz: zasady w schemacie

Otwórz lib/validation/profile.ts. Schemat Zod to opis poprawnych danych:

export const profileSchema = z.object({
  name: z.string().trim().min(2, "Podaj imię (co najmniej 2 znaki).").max(60, "Najwyżej 60 znaków."),
  headline: z.string().trim().min(5, "Opisz się w kilku słowach (co najmniej 5 znaków).").max(120, "Najwyżej 120 znaków."),
  location: z.string().trim().max(60, "Najwyżej 60 znaków."),
  about: z.string().trim().max(1000, "Najwyżej 1000 znaków."),
});

trim() obcina spacje, zanim zadziała min, więc imię z samych spacji nie przejdzie. Schemat niczego nie zapisuje i nie rzuca wyjątków: jego safeParse zwraca albo poprawione dane, albo listę błędów.

Formularz: akcja na serwerze

Otwórz app/profile/edit/actions.ts:

export async function updateProfile(
  _prevState: FormState<ProfileInput>,
  formData: FormData,
): Promise<FormState<ProfileInput>> {
  const user = await getCurrentUser();
  const values = {
    name: String(formData.get("name") ?? ""),
    headline: String(formData.get("headline") ?? ""),
    location: String(formData.get("location") ?? ""),
    about: String(formData.get("about") ?? ""),
  };

  const result = profileSchema.safeParse(values);
  if (!result.success) {
    return { values, errors: z.flattenError(result.error).fieldErrors };
  }

  const profile = await getProfile(user.handle);
  if (!profile) {
    return { values, errors: {}, message: "Nie znaleziono Twojego profilu." };
  }

  await saveProfile({ ...profile, ...result.data });
  revalidatePath(`/in/${user.handle}`);
  redirect(`/in/${user.handle}`);
}

Akcja czyta z FormData tylko cztery oczekiwane pola, a czyj to profil, wie z sesji, nie z formularza. Przy błędzie zwraca wpisane wartości i błędy w rodzaju { name: ["Podaj imię (co najmniej 2 znaki)."] }, niczego nie zapisując. Przy sukcesie saveProfile zapisuje profil przez lib/store.ts do pliku data/profiles.json (katalog data Claude dopisał do .gitignore), revalidatePath odświeża stronę profilu, a redirect na nią przenosi; kod po redirect już się nie wykona.

Formularz: błędy pod polami

Otwórz components/profile/ProfileForm.tsx. To Client Component z hookiem useActionState z Reacta, który pamięta ostatni wynik akcji (klasy przycisku pominięte):

const [state, formAction, pending] = useActionState(updateProfile, { values: initial, errors: {} });

return (
  <form action={formAction} className="space-y-4">
    <Field label="Imię i nazwisko" name="name" defaultValue={state.values.name} errors={state.errors.name} maxLength={60} />
    {/* headline, port i "O mnie" tak samo */}
    <button type="submit" disabled={pending}>{pending ? "Zapisuję..." : "Zapisz profil"}</button>
  </form>
);

state to ostatni wynik, formAction trafia do formularza, a pending blokuje przycisk w trakcie wysyłki. Field rysuje etykietę, pole i błąd połączony z polem przez aria-describedby, więc czytnik ekranu przeczyta go razem z polem.

Przegląd kapitana

  1. Spacje zamiast imienia. Uruchom npm run dev, wpisz w imieniu trzy spacje i zmień nagłówek. Przeglądarka przepuszcza, serwer odpowiada "Podaj imię (co najmniej 2 znaki).", a nowy nagłówek zostaje w polu. Typowy błąd agenta to defaultValue={initial.name}: React po akcji przywraca formularz do wartości domyślnych, więc u nas po błędzie zniknął nowy nagłówek, a pod polem z dawnym imieniem wisiał komunikat, że imienia brak.
  2. Przykład z dokumentacji w innej wersji. Pierwszy schemat miał invalid_type_error i .flatten(), przepisane z przewodnika Forms, a npx tsc --noEmit zgłosił, że invalid_type_error nie istnieje. npm zainstalował Zod 4 (stan na listopad 2026: 4.6.7), w którym tej opcji już nie ma, a .flatten() jest przestarzałe. Przewodnik i paczka mogą mówić o różnych wersjach; rozstrzyga kompilator.
  3. Strona edycji po buildzie. Uruchom npm run build i npm start, zapisz nowy nagłówek i wróć do /profile/edit. U nas formularz pokazał stary, bo build oznaczył stronę znakiem ○, czyli statyczną, i wyrenderował ją raz. Poprawka: getCurrentUser() woła await connection() z next/server, jak prawdziwa sesja, która czyta żądanie. Po nowym buildzie strona ma znak ƒ.

Skill: przepis zapisany na pergaminie

Skill to plik z instrukcją, którą Claude Code wczytuje do rozmowy dopiero wtedy, gdy jest potrzebna: gdy wpiszesz jej komendę albo gdy Claude uzna, że pasuje do zadania. Skill projektu leży w .claude/skills/<nazwa>/SKILL.md i staje się komendą /nazwa. CLAUDE.md to prawo okrętowe czytane w każdej sesji, a skill to przepis wyjmowany z kufra, gdy jest potrzebny.

Polecenie dla Claude Code:

Zapisz, jak zbudowaliśmy formularz profilu (walidacja, zapis po
stronie serwera, komunikaty błędów), jako skill /nowy-formularz
w .claude/skills/. Tylko ja mogę go uruchamiać. Nazwę formularza
podam jako argument. Skill ma najpierw zapytać mnie o pola, a na
koniec uruchomić testy, lint, typy i build.

Otwórz .claude/skills/nowy-formularz/SKILL.md. Na górze stoi frontmatter, czyli ustawienia między liniami ---:

---
name: nowy-formularz
description: Buduje formularz Crew Connections według wzorca formularza profilu (Server Action, walidacja Zod na serwerze, błędy przy polach).
argument-hint: "[co zapisuje formularz, np. oferta pracy]"
disable-model-invocation: true
---

name daje komendę /nowy-formularz, a argument-hint podpowiedź przy wpisywaniu. disable-model-invocation: true spełnia Twoje "tylko ja": Claude nie uruchomi skilla sam, a według dokumentacji nawet jego opis nie siedzi w kontekście, dopóki nie wpiszesz komendy. Pod spodem jest treść:

# Nowy formularz: $ARGUMENTS

Zbuduj formularz, który zapisuje: $ARGUMENTS. Wzorcem jest formularz profilu:
- lib/validation/profile.ts i lib/validation/profile.test.ts (schemat i testy),
- app/profile/edit/actions.ts (Server Action),
- components/profile/ProfileForm.tsx i components/ui/Field.tsx (formularz).

## Zanim napiszesz kod

1. Wypisz pola: nazwa, typ, czy wymagane, limity, dozwolone wartości.
2. Napisz, kto może wysłać formularz i czego dotyczy (czyj profil, która oferta).
3. Zapytaj mnie, czy lista się zgadza. Nie zaczynaj bez odpowiedzi.

## Kroki

1. Testy schematu w lib/validation/<nazwa>.test.ts: poprawne dane, pole wymagane z samych spacji, za długi tekst, wartość spoza listy. Najpierw testy, potem schemat.
2. Schemat Zod 4 w lib/validation/<nazwa>.ts: komunikaty po polsku, .trim() na polach tekstowych, zamknięte listy jako tablica `as const` i z.enum. Bez invalid_type_error i .flatten() (to API Zod 3).
3. Server Action w actions.ts obok strony, z "use server" na górze pliku:
   - zalogowany pirat tylko z getCurrentUser() z lib/session.ts, nigdy z pól formularza;
   - czytaj z FormData tylko oczekiwane pola;
   - przy błędzie zwróć { values, errors } z z.flattenError(...).fieldErrors i niczego nie zapisuj;
   - autora, status i daty ustawia serwer;
   - zapis przez lib/store.ts, potem revalidatePath i redirect.
4. Formularz jako Client Component z useActionState: każde pole przez Field, defaultValue ze state.values (React czyści pola po akcji), przycisk wyłączony, gdy pending.

## Sprawdzian

- npm run test -- --run, npm run lint, npx tsc --noEmit, npm run build.
- W wyniku builda strona z formularzem jest oznaczona ƒ, a nie ○.
- Pokaż mi wyniki i listę zmienionych plików. Nowych bibliotek nie dodawaj bez pytania.

$ARGUMENTS Claude Code zamieni na to, co wpiszesz po komendzie. Zwróć uwagę, że trzy znaleziska z przeglądu trafiły do skilla jako zasady: wartości ze state.values, Zod 4 i znak ƒ. Folderu .claude/skills nie było, gdy zaczynałeś sesję, a dokumentacja mówi, że taki katalog trzeba raz wczytać komendą /reload-skills. Potem /skills pokaże skill na liście.

Następny krok

Gdy przegląd przejdzie, poproś o commit, na przykład "Profil zawodowy, formularz edycji i skill nowy-formularz". Skill jedzie w commicie razem z kodem, więc dostanie go każdy, kto sklonuje projekt. Potem mały krok z testem:

Wydziel z endorseSkill czystą funkcję canEndorse w lib/endorse.ts.
Najpierw testy: własna umiejętność, drugie potwierdzenie, nieznana
umiejętność. Pokaż porażkę, potem kod. Testów nie zmieniaj.

W edytorze poniżej czeka profil w miniaturze: staż liczony z dat, potwierdzenia i formularz, którego "serwer" sprawdza te same zasady co schemat. Przełącz na swój profil, wpisz w imieniu same spacje i zobacz, co zostaje w polach.

Pamiętaj: książeczkę żeglarską podpisuje kapitan portu, a nie sam żeglarz, i tak samo zasady formularza podpisuje serwer.

Kod do tej lekcji: App.jsx
// Książeczka żeglarska w miniaturze: staż z dat, potwierdzenia i formularz z "serwerem".
// W projekcie zasady sprawdza Server Action ze schematem Zod; tu ten sam zestaw zasad
// sprawdza funkcja serverUpdateProfile, która odpowiada z opóźnieniem jak prawdziwy serwer.
import { useState } from 'react';

const TODAY = '2026-11';
const VIEWER = 'redbeard';
const yearWords = { one: 'rok', few: 'lata', many: 'lat', other: 'roku' };
const plural = new Intl.PluralRules('pl-PL');
const monthYear = new Intl.DateTimeFormat('pl-PL', { month: 'short', year: 'numeric' });

function monthsBetween(start, end) {
  const [sy, sm] = start.split('-').map(Number);
  const [ey, em] = end.split('-').map(Number);
  return (ey - sy) * 12 + (em - sm);
}

function formatDuration(start, end) {
  const months = monthsBetween(start, end ?? TODAY);
  if (months < 1) return 'mniej niż miesiąc';
  const years = Math.floor(months / 12);
  const rest = months % 12;
  const parts = [];
  if (years > 0) parts.push(years + ' ' + yearWords[plural.select(years)]);
  if (rest > 0) parts.push(rest + ' mies.');
  return parts.join(' ');
}

function formatMonth(value) {
  const [year, month] = value.split('-').map(Number);
  return monthYear.format(new Date(year, month - 1, 1));
}

const initialProfiles = {
  redbeard: {
    handle: 'redbeard', name: 'Kapitan Redbeard', headline: 'Kapitan i nawigator na Czarnej Perle',
    experience: [
      { id: 'e1', title: 'Kapitan', company: 'Czarna Perła', startDate: '2023-03' },
      { id: 'e2', title: 'Pierwszy oficer', company: 'Latający Holender', startDate: '2018-06', endDate: '2023-02' },
    ],
    skills: [
      { id: 's1', name: 'Nawigacja', endorsedBy: ['anne', 'jack'] },
      { id: 's2', name: 'Kartografia', endorsedBy: ['anne'] },
    ],
  },
  anne: {
    handle: 'anne', name: 'Anne Bonny', headline: 'Pierwsza oficer, specjalistka od abordażu',
    experience: [{ id: 'e3', title: 'Pierwsza oficer', company: 'Zemsta Królowej Anny', startDate: '2024-01' }],
    skills: [
      { id: 's4', name: 'Abordaż', endorsedBy: ['jack'] },
      { id: 's5', name: 'Szermierka', endorsedBy: [] },
    ],
  },
};

// "Serwer": te same zasady co schemat profileSchema w projekcie.
function validateProfile(values) {
  const errors = {};
  const name = values.name.trim();
  const headline = values.headline.trim();
  if (name.length < 2) errors.name = 'Podaj imię (co najmniej 2 znaki).';
  else if (name.length > 60) errors.name = 'Najwyżej 60 znaków.';
  if (headline.length < 5) errors.headline = 'Opisz się w kilku słowach (co najmniej 5 znaków).';
  else if (headline.length > 120) errors.headline = 'Najwyżej 120 znaków.';
  return { errors, data: { name, headline } };
}

function serverUpdateProfile(values) {
  return new Promise((resolve) => setTimeout(() => resolve(validateProfile(values)), 600));
}

// "Serwer" potwierdzeń: własnej umiejętności i drugiego potwierdzenia nie przyjmie.
function canEndorse(viewer, profile, skill) {
  return viewer !== profile.handle && !skill.endorsedBy.includes(viewer);
}

export default function App() {
  const [profiles, setProfiles] = useState(initialProfiles);
  const [shown, setShown] = useState('anne');
  const [values, setValues] = useState({ name: initialProfiles.redbeard.name, headline: initialProfiles.redbeard.headline });
  const [errors, setErrors] = useState({});
  const [pending, setPending] = useState(false);
  const profile = profiles[shown];
  const isOwn = shown === VIEWER;

  const endorse = (skill) => {
    if (!canEndorse(VIEWER, profile, skill)) return;
    setProfiles((prev) => ({
      ...prev,
      [shown]: {
        ...profile,
        skills: profile.skills.map((s) => (s.id === skill.id ? { ...s, endorsedBy: [...s.endorsedBy, VIEWER] } : s)),
      },
    }));
  };

  const handleSubmit = async (event) => {
    event.preventDefault();
    setPending(true);
    const result = await serverUpdateProfile(values);
    setPending(false);
    setErrors(result.errors);
    if (Object.keys(result.errors).length === 0) {
      setProfiles((prev) => ({ ...prev, redbeard: { ...prev.redbeard, ...result.data } }));
      setValues(result.data);
    }
  };

  return (
    <div className="min-h-screen bg-gray-100 p-4 text-gray-900">
      <div className="mx-auto max-w-2xl space-y-4">
        <div className="flex gap-2 text-sm">
          <span className="py-1">Oglądasz:</span>
          {Object.values(profiles).map((p) => (
            <button
              key={p.handle}
              type="button"
              onClick={() => setShown(p.handle)}
              className={shown === p.handle ? 'rounded-full bg-blue-600 px-3 py-1 text-white' : 'rounded-full border border-gray-300 bg-white px-3 py-1'}
            >
              {p.handle === VIEWER ? 'Twój profil' : p.name}
            </button>
          ))}
        </div>

        <section className="rounded-lg border border-gray-200 bg-white p-5">
          <h1 className="text-2xl font-bold">{profile.name}</h1>
          <p className="text-gray-700">{profile.headline}</p>
          <h2 className="mt-4 font-bold">Doświadczenie</h2>
          <ul className="divide-y divide-gray-200">
            {profile.experience.map((job) => (
              <li key={job.id} className="py-2">
                <p className="font-semibold">{job.title}, {job.company}</p>
                <p className="text-sm text-gray-500">
                  {formatMonth(job.startDate)} - {job.endDate ? formatMonth(job.endDate) : 'obecnie'} · {formatDuration(job.startDate, job.endDate)}
                </p>
              </li>
            ))}
          </ul>
          <h2 className="mt-4 font-bold">Umiejętności</h2>
          <ul className="divide-y divide-gray-200">
            {profile.skills.map((skill) => {
              const endorsed = skill.endorsedBy.includes(VIEWER);
              return (
                <li key={skill.id} className="flex items-center justify-between py-2">
                  <span>{skill.name} <span className="text-sm text-gray-500">(potwierdzenia: {skill.endorsedBy.length})</span></span>
                  {!isOwn && (
                    <button
                      type="button"
                      disabled={endorsed}
                      onClick={() => endorse(skill)}
                      className="rounded-full border-2 border-blue-600 px-3 py-0.5 text-sm font-semibold text-blue-600 disabled:border-gray-200 disabled:text-gray-500"
                    >
                      {endorsed ? 'Potwierdzone' : '+ Potwierdź'}
                    </button>
                  )}
                </li>
              );
            })}
          </ul>
        </section>

        {isOwn && (
          <form onSubmit={handleSubmit} noValidate className="space-y-3 rounded-lg border border-gray-200 bg-white p-5">
            <h2 className="font-bold">Edytuj profil</h2>
            {[['name', 'Imię i nazwisko'], ['headline', 'Nagłówek zawodowy']].map(([field, label]) => (
              <div key={field}>
                <label htmlFor={field} className="block font-semibold">{label}</label>
                <input
                  id={field}
                  value={values[field]}
                  onChange={(e) => setValues({ ...values, [field]: e.target.value })}
                  aria-invalid={errors[field] ? true : undefined}
                  aria-describedby={errors[field] ? field + '-error' : undefined}
                  className="w-full rounded-lg border border-gray-300 px-3 py-2"
                />
                {errors[field] && <p id={field + '-error'} className="text-sm text-red-600">{errors[field]}</p>}
              </div>
            ))}
            <button type="submit" disabled={pending} className="rounded-full bg-blue-600 px-5 py-2 font-semibold text-white disabled:bg-gray-300">
              {pending ? 'Zapisuję...' : 'Zapisz profil'}
            </button>
          </form>
        )}
      </div>
    </div>
  );
}

Widzisz błąd w tej lekcji?

Sprawdź się

Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.

  1. 1. Które pola NIE należą do typu Profile w Crew Connections?

  2. 2. Co zwróci formatDuration("2023-03", "2025-08")?

To 2 z 6 pytań do tej lekcji. Pozostałe rozwiążesz w grze.

Zadania praktyczne w grze

  • Edytor kodu

    Professional profile header

  • Układanie w pionie

    Uporządkuj elementy nagłówka profilu (ProfileHeader) od góry do dołu:

  • Klikanie w kolejności

    Ułóż odczyt błędów przy polach z wyniku walidacji: z.flattenError(result.error).fieldErrors

  • Klikanie w kolejności

    Ułóż odczyt liczby kontaktów z profilu: profile.connections

  • Klikanie w kolejności

    Ułóż przypięcie akcji do formularza potwierdzenia: endorseSkill.bind(null, profile.handle, skill.id)

  • Układanie w pionie

    Uporządkuj, co się dzieje po kliknięciu + Potwierdź na cudzym profilu:

  • Edytor kodu

    Skills section component

  • Układanie w poziomie

    Ułóż w jednej linii wiersz daty z ExperienceSection: formatMonth(job.startDate) - obecnie · formatDuration(...)

  • Układanie w pionie

    Uporządkuj kroki Server Action updateProfile:

  1. PytanieQuiz: Pola typu Profile
  2. PytanieQuiz: Wynik formatDuration
  3. Zadanie z kodemPraktyka: Profile header
  4. PytanieQuiz: Pole headline
  5. PytanieQuiz: Praca, która trwa
  6. Ułóż w kolejnościSortowanie: Nagłówek profilu od góry
  7. Kliknij w kolejnościSortowanie: Odczyt błędów walidacji
  8. Kliknij w kolejnościSortowanie: Odczyt profile.connections
  9. Kliknij w kolejnościSortowanie: Akcja z dodatkowymi argumentami
  10. PytanieQuiz: Potwierdzenia umiejętności
  11. PytanieQuiz: recommendations vs endorsements
  12. Ułóż w kolejnościSortowanie: Potwierdzenie umiejętności na serwerze
  13. Zadanie z kodemPraktyka: Skills with endorsements
  14. Ułóż w kolejnościSortowanie: Linia daty zatrudnienia
  15. Ułóż w kolejnościSortowanie: Kroki akcji updateProfile

Przydatne artykuły