Enumeracja
Enumeracja to zbiór wartości zgrupowanych w typie zdefiniowanym przez użytkownika. W Swift enumerację tworzy się za pomocą słowa kluczowego: enum:
enum TimerState {
case start, pause, stop
}
Przy pomocy case określasz jakie wartości będzie mieć Twoja enumeracja.
Przykład:
enum TimerState {
case start, pause, stop
}
var timerState: TimerState = .start
print("timer state: \(timerState)")
Zauważ, że opcja start ma wartość... start. Jest to domyślne zachowanie.
Możesz jednak nadać opcji inną wartość niż ta domyślna. To tzw.: surowe wartości (ang.: raw values)
Surowe wartości
enum ClothesSize: String {
case S = "Small"
case M = "Medium"
case L = "Large"
}
var size: ClothesSize = .M
print(size)
print(size.rawValue)
Dla enumeracji ClothesSize zostały zdefiniowane trzy opcje. Do każdej opcji przypisane są wartości: Small, Medium, Large. To są właśnie wartości surowe.
Żeby się do nich dostać, użyj właściwości rawValue.
Opcjom enumeracji możesz nadać typ:
enum ClothesSize: Int {
case S, M, L
}
Jaką surową wartość będzie mieć opcja S? Będzie to 0, a kolejne 1 i 2.
Możesz też napisać tak:
enum ClothesSize: Int {
case S = 1, M, L
}
print(ClothesSize.S.rawValue)
Swift "domyśli" się, że kolejne wartości będą to 2 i 3.
Iteracja po enum
Możesz także iterować po wszystkich opcjach enumeracji. Żeby to zrobić, musisz rozszerzyć enumerację za pomocą protokołu: CaseIterable:
enum TimerState: CaseIterable {
case start, pause, stop
}
for current in TimerState.allCases {
print(current)
}
Żeby iterować po enumeracji, użyj właściwości allCases.
Możesz także iterować po surowych wartościach:
enum ClothesSize: String, CaseIterable {
case S = "Small"
case M = "Medium"
case L = "Large"
}
for current in ClothesSize.allCases {
print(current.rawValue)
}
Switch i enum
Do obsługi opcji możesz użyć instrukcji switch:
enum TimerState {
case start, pause, stop
}
var timerState: TimerState = .pause
switch timerState {
case .start:
print("Start timer")
case .pause:
print("Pause timer")
case .stop:
print("Stop timer")
}
Właściwości w enum
W enumeracji możesz użyć computed property:
enum TimerState {
case start, pause, stop
var label: String {
switch self {
case .start:
return "Timer s running"
case .pause:
return "Timer is paused"
case .stop:
return "Timer is stopped"
}
}
}
var timerState: TimerState = .start
print(timerState.label)
Za pomocą słowa kluczowego self pobierasz wartość, która przechowuje zmienna przy wywołaniu label.
Metody w enum
Swift umożliwia także używanie metod w enum:
enum TimerState {
case start, pause, stop
func getLabel() -> String {
switch self {
case .start:
return "Timer s running"
case .pause:
return "Timer is paused"
case .stop:
return "Timer is stopped"
}
}
}
var timerState: TimerState = .stop
print(timerState.getLabel())
Powiązane wartości
Enumeracja pozwala dołączyć do każdej opcji dodatkowe informacje. Nazywa się to: powiązane wartości (ang.: associated values).
Składnia wygląda następująco:
case someOption(Int)
Po podaniu nazwy opcji w nawiasach określasz dodatkową informację. Możesz dodać wiele opcji:
case someOption(Int, Int, String)
Dla jednego parametru możesz określić jakiś typ danych, a dla następnego użyć innego typu. Dodatkowo opcje mogą mieć różną liczbę parametrów:
case someOption(Int)
case otherOption(String, Double)
Przykład:
enum TimerState {
case start(String)
case pause(String)
case stop(String)
}
var timerState: TimerState = .start("Timer is starting")
switch timerState {
case .start(let label):
print("Label for start: \(label)")
case .pause(let label):
print("Label for pause: \(label)")
case .stop(let label):
print("Label for stop: \(label)")
}
Możesz także nadać etykiety powiązanym wartościom:
case someOption(value: Int)
Kolejny przykład:
enum ClothesSize {
case S(height: Int)
case M(height: Int)
case L(height: Int)
}
var size: ClothesSize = .S(height: 165)
switch size {
case .S(let height):
print("Height for S:", height)
case .M(let height):
print("Height for M:", height)
case .L(let height):
print("Height for L:", height)
}
Nie możesz używać powiązanych wartości wraz z surowymi wartościami, w tym samym czasie.
Testowanie klawiatury
Do symulacji obsługi klawiatury posłuży nam niezawodna biblioteka user-event.
Załóżmy, że mam zwykłe pole tekstowe. Po wpisaniu danych i wciśnięciu przycisku Enter wartość powinna zostać dodana do listy.
Przykład:
import { useState } from "react";
export function MyComponent() {
const [tasks, setTasks] = useState([]);
const [task, setTask] = useState('');
const onChangeTask = (e) => {
setTask(e.target.value)
};
const onAddTask = (e) => {
if (e.code == 'Enter' && task) {
setTasks([task, ...tasks]);
setTask('');
}
}
return (
<>
<div>
<label htmlFor="newTask">Task title:</label>
<input
type="text"
id="newTask"
value={task}
onChange={onChangeTask}
onKeyDown={onAddTask}
/>
</div>
<ul>
{
tasks.map((task, index) => (
<li key={index}>
{task}
</li>
))
}
</ul>
</>
)
}
Test:
import {render, screen, within} from '@testing-library/react';
const { getByLabelText, getByTestId } = screen;
const renderComponent = () => {
render(<MyComponent />);
const addTaskField = getByLabelText('Task title:');
const taskList = within(getByTestId('task-list'));
const addTask = async (newTask) => {
await userEvent.clear(addTaskField)
await userEvent.type(addTaskField, newTask);
await userEvent.keyboard('[Enter]');
}
return {
addTaskField,
taskList,
addTask
}
}
test('should add new task to the list', async () => {
const { taskList, addTask } = renderComponent();
await addTask('My task');
expect(taskList.getByText('My task'));
});
Za dodanie zadania do listy odpowiedzialna jest w tym teście funkcja addTask. Wywołana jest tam funkcja keyboard z biblioteki user event, która w tym przypadku symuluje wciśnięcie przycisku Enter na klawiaturze.
