Nasza specjalność? Elektronika i druk 3D
Szybka dostawa 30 dni na zwrot
Magazyn i serwis? U nas, w Polsce!
Doradzamy i inspirujemy +1,7 mln zamówień
Nasza specjalność? Elektronika i druk 3D
Szybka dostawa 30 dni na zwrot
Magazyn i serwis? U nas, w Polsce!
Doradzamy i inspirujemy +1,7 mln zamówień

Zaufało nam już ponad 500 000 klientów. U nas masz:

 

wysyłkę tego samego dnia przy produktach z oznaczeniem „Wysyłka 24h”

 

własny serwis w Polsce

 

30 dni na zwrot i darmową dostawę w Polsce od 500 zł

 

4,9/5 w TrustMate i 4,9/5 w Google (prawie 4000 opinii)

 

fakturę VAT, leasing i raty dla firm

Dla firm

 

indywidualna wycena przy większych ilościach

 

leasing i raty od 1000 zł

 

faktura VAT

Dla szkół i uczelni

 

0% VAT na wybrane produkty

 

faktura z terminem płatności

 

pomoc w doborze zestawów do pracowni

Złóż zapytanie ofertowe - odpowiadamy szybko.

Indeks: KSZ-05008
EAN: 9788383223445

Czysty kod. Podręcznik dobrego programisty - Robert C. Martin

Tłumaczenie: Paweł Gonera Wydawnictwo: Helion. W książce opisane są zasady i wzorce pisania dobrego, "czystego" kodu bez błedów.

Cena:
Cena netto:

Produkt wycofany ze sprzedaży

Ten model nie jest już produkowany i nie wróci do naszej oferty.

Uwaga!

Sprzedaż produktu została zakończona. Sprawdź inne w tej kategorii.

Opis produktu: Czysty kod. Podręcznik dobrego programisty - Robert C. Martin

Chcesz dowiedzieć się czym charakteryzuje się "czysty" kod i jak napisać dobry program bez błędów? W tej książce przeczytasz o technikach solidnego i skutecznego programowania. Zapoznasz się z zasadami i wzorcami pisania składnego kodu. Nauczysz się jak tworzyć nazwy funkcji i obiektów oraz jak pisać testy jednostkowe. W lekturze opisanych jest kilka przykładów porządkowania kodu, dzięki którym nauczysz się jak sprawić by twój program spełniał przyjęte standardy.

W książce zostały zawarte takie zagadnienia jak:

  • Nazwy klas i metod
  • Funkcje i listy argumentów
  • Rozdzielanie poleceń i zapytań
  • Stosowanie wyjątków
  • Komentarze
  • Formatowanie
  • Obiekty i struktury danych
  • Obsługa błędów
  • Testy jednostkowe
  • Klasy i systemy
  • Współbieżność
  • Oczyszczanie kodu
Czysty kod. Podręcznik dobrego programisty - Robert C. Martin

Czysty kod. Podręcznik dobrego programisty - Robert C. Martin.

Przykładowe projekty wykorzystane w książce dostępne do pobrania. Fragment ksiązki do przeczytania on-line.

Spis treści

Słowo wstępne (13)

Wstęp (19)

1. Czysty kod (23)

  • Niech stanie się kod... (24)
  • W poszukiwaniu doskonałego kodu... (24)
  • Całkowity koszt bałaganu (25)
    • Rozpoczęcie wielkiej zmiany projektu (26)
    • Postawa (27)
    • Największa zagadka (28)
    • Sztuka czystego kodu? (28)
    • Co to jest czysty kod? (28)
  • Szkoły myślenia (34)
  • Jesteśmy autorami (35)
  • Zasada skautów (36)
  • Poprzednik i zasady (36)
  • Zakończenie (36)
  • Bibliografia (37)

2. Znaczące nazwy (39)

  • Wstęp (39)
  • Używaj nazw przedstawiających intencje (40)
  • Unikanie dezinformacji (41)
  • Tworzenie wyraźnych różnic (42)
  • Tworzenie nazw, które można wymówić (43)
  • Korzystanie z nazw łatwych do wyszukania (44)
  • Unikanie kodowania (45)
    • Notacja węgierska (45)
    • Przedrostki składników (46)
    • Interfejsy i implementacje (46)
  • Unikanie odwzorowania mentalnego (47)
  • Nazwy klas (47)
  • Nazwy metod (47)
  • Nie bądź dowcipny (48)
  • Wybieraj jedno słowo na pojęcie (48)
  • Nie twórz kalamburów! (49)
  • Korzystanie z nazw dziedziny rozwiązania (49)
  • Korzystanie z nazw dziedziny problemu (49)
  • Dodanie znaczącego kontekstu (50)
  • Nie należy dodawać nadmiarowego kontekstu (51)
  • Słowo końcowe (52)

3. Funkcje (53)

  • Małe funkcje! (56)
    • Bloki i wcięcia (57)
  • Wykonuj jedną czynność (57)
    • Sekcje wewnątrz funkcji (58)
  • Jeden poziom abstrakcji w funkcji (58)
    • Czytanie kodu od góry do dołu - zasada zstępująca (58)
  • Instrukcje switch (59)
  • Korzystanie z nazw opisowych (61)
  • Argumenty funkcji (62)
    • Często stosowane funkcje jednoargumentowe (62)
    • Argumenty znacznikowe (63)
    • Funkcje dwuargumentowe (63)
    • Funkcje trzyargumentowe (64)
    • Argumenty obiektowe (64)
    • Listy argumentów (65)
    • Czasowniki i słowa kluczowe (65)
  • Unikanie efektów ubocznych (65)
    • Argumenty wyjściowe (66)
  • Rozdzielanie poleceń i zapytań (67)
  • Stosowanie wyjątków zamiast zwracania kodów błędów (67)
    • Wyodrębnienie bloków try-catch (68)
    • Obsługa błędów jest jedną operacją (69)
    • Przyciąganie zależności w Error.java (69)
  • Nie powtarzaj się (69)
  • Programowanie strukturalne (70)
  • Jak pisać takie funkcje? (70)
  • Zakończenie (71)
  • SetupTeardownIncluder (71)
  • Bibliografia (73)

4. Komentarze (75)

  • Komentarze nie są szminką dla złego kodu (77)
  • Czytelny kod nie wymaga komentarzy (77)
  • Dobre komentarze (77)
    • Komentarze prawne (77)
    • Komentarze informacyjne (78)
    • Wyjaśnianie zamierzeń (78)
    • Wyjaśnianie (79)
    • Ostrzeżenia o konsekwencjach (80)
    • Komentarze TODO (80)
    • Wzmocnienie (81)
    • Komentarze Javadoc w publicznym API (81)
  • Złe komentarze (81)
    • Bełkot (81)
    • Powtarzające się komentarze (82)
    • Mylące komentarze (84)
    • Komentarze wymagane (85)
    • Komentarze dziennika (85)
    • Komentarze wprowadzające szum informacyjny (86)
    • Przerażający szum (87)
    • Nie używaj komentarzy, jeżeli można użyć funkcji lub zmiennej (88)
    • Znaczniki pozycji (88)
    • Komentarze w klamrach zamykających (88)
    • Atrybuty i dopiski (89)
    • Zakomentowany kod (89)
    • Komentarze HTML (90)
    • Informacje nielokalne (91)
    • Nadmiar informacji (91)
    • Nieoczywiste połączenia (91)
    • Nagłówki funkcji (92)
    • Komentarze Javadoc w niepublicznym kodzie (92)
    • Przykład (92)
  • Bibliografia (95)

5. Formatowanie (97)

  • Przeznaczenie formatowania (98)
  • Formatowanie pionowe (98)
    • Metafora gazety (99)
    • Pionowe odstępy pomiędzy segmentami kodu (99)
    • Gęstość pionowa (101)
    • Odległość pionowa (101)
    • Uporządkowanie pionowe (105)
  • Formatowanie poziome (106)
    • Poziome odstępy i gęstość (106)
    • Rozmieszczenie poziome (107)
    • Wcięcia (109)
    • Puste zakresy (110)
  • Zasady zespołowe (110)
  • Zasady formatowania wujka Boba (111)

6. Obiekty i struktury danych (113)

  • Abstrakcja danych (113)
  • Antysymetria danych i obiektów (115)
  • Prawo Demeter (117)
    • Wraki pociągów (118)
    • Hybrydy (118)
    • Ukrywanie struktury (119)
  • Obiekty transferu danych (119)
    • Active Record (120)
  • Zakończenie (121)
  • Bibliografia (121)

7. Obsługa błędów (123)

  • Użycie wyjątków zamiast kodów powrotu (124)
  • Rozpoczynanie od pisania instrukcji try-catch-finally (125)
  • Użycie niekontrolowanych wyjątków (126)
  • Dostarczanie kontekstu za pomocą wyjątków (127)
  • Definiowanie klas wyjątków w zależności od potrzeb wywołującego (127)
  • Definiowanie normalnego przepływu (129)
  • Nie zwracamy null (130)
  • Nie przekazujemy null (131)
  • Zakończenie (132)
  • Bibliografia (132)

8. Granice (133)

  • Zastosowanie kodu innych firm (134)
  • Przeglądanie i zapoznawanie się z granicami (136)
  • Korzystanie z pakietu log4j (136)
  • Zalety testów uczących (138)
  • Korzystanie z nieistniejącego kodu (138)
  • Czyste granice (139)
  • Bibliografia (140)

9. Testy jednostkowe (141)

  • Trzy prawa TDD (142)
  • Zachowanie czystości testów (143)
    • Testy zwiększają możliwości (144)
  • Czyste testy (144)
    • Języki testowania specyficzne dla domeny (147)
    • Podwójny standard (147)
  • Jedna asercja na test (149)
    • Jedna koncepcja na test (150)
  • F.I.R.S.T. (151)
  • Zakończenie (152)
  • Bibliografia (152)

10. Klasy (153)

  • Organizacja klas (153)
    • Hermetyzacja (154)
  • Klasy powinny być małe! (154)
    • Zasada pojedynczej odpowiedzialności (156)
    • Spójność (158)
    • Utrzymywanie spójności powoduje powstanie wielu małych klas (158)
  • Organizowanie zmian (164)
    • Izolowanie modułów kodu przed zmianami (166)
  • Bibliografia (167)

11. Systemy (169)

  • Jak budowałbyś miasto? (170)
  • Oddzielenie konstruowania systemu od jego używania (170)
    • Wydzielenie modułu main (171)
    • Fabryki (172)
    • Wstrzykiwanie zależności (172)
  • Skalowanie w górę (173)
    • Separowanie (rozcięcie) problemów (176)
  • Pośredniki Java (177)
  • Czyste biblioteki Java AOP (178)
  • Aspekty w AspectJ (181)
  • Testowanie architektury systemu (182)
  • Optymalizacja podejmowania decyzji (183)
    • Korzystaj ze standardów, gdy wnoszą realną wartość (183)
  • Systemy wymagają języków dziedzinowych (184)
  • Zakończenie (184)
  • Bibliografia (185)

12. Powstawanie projektu (187)

  • Uzyskiwanie czystości projektu przez jego rozwijanie (187)
  • Zasada numer 1 prostego projektu - system przechodzi wszystkie testy (188)
  • Zasady numer 2 - 4 prostego projektu - przebudowa (188)
  • Brak powtórzeń (189)
  • Wyrazistość kodu (191)
  • Minimalne klasy i metody (192)
  • Zakończenie (192)
  • Bibliografia (192)

13. Współbieżność (193)

  • W jakim celu stosować współbieżność? (194)
    • Mity i nieporozumienia (195)
  • Wyzwania (196)
  • Zasady obrony współbieżności (196)
    • Zasada pojedynczej odpowiedzialności (197)
    • Wniosek - ograniczenie zakresu danych (197)
    • Wniosek - korzystanie z kopii danych (197)
    • Wniosek - wątki powinny być na tyle niezależne, na ile to tylko możliwe (198)
  • Poznaj używaną bibliotekę (198)
    • Kolekcje bezpieczne dla wątków (198)
  • Poznaj modele wykonania (199)
    • Producent-konsument (199)
    • Czytelnik-pisarz (200)
    • Ucztujący filozofowie (200)
  • Uwaga na zależności pomiędzy synchronizowanymi metodami (201)
  • Tworzenie małych sekcji synchronizowanych (201)
  • Pisanie prawidłowego kodu wyłączającego jest trudne (202)
  • Testowanie kodu wątków (202)
    • Traktujemy przypadkowe awarie jako potencjalne problemy z wielowątkowością (203)
    • Na początku uruchamiamy kod niekorzystający z wątków (203)
    • Nasz kod wątków powinien dać się włączać (203)
    • Nasz kod wątków powinien dać się dostrajać (204)
    • Uruchamiamy więcej wątków, niż mamy do dyspozycji procesorów (204)
    • Uruchamiamy testy na różnych platformach (204)
    • Uzbrajamy nasz kod w elementy próbujące wywołać awarie i wymuszające awarie (205)
    • Instrumentacja ręczna (205)
    • Instrumentacja automatyczna (206)
  • Zakończenie (207)
  • Bibliografia (208)

14. Udane oczyszczanie kodu (209)

  • Implementacja klasy Args (210)
  • Args - zgrubny szkic (216)
  • Argumenty typu String (228)
  • Zakończenie (261)

15. Struktura biblioteki JUnit (263)

  • Biblioteka JUnit (264)
  • Zakończenie (276)

16. Przebudowa klasy SerialDate (277)

  • Na początek uruchamiamy (278)
  • Teraz poprawiamy (280)
  • Zakończenie (293)
  • Bibliografia (294)

17. Zapachy kodu i heurystyki (295)

  • Komentarze (296)
    • C1. Niewłaściwe informacje (296)
    • C2. Przestarzałe komentarze (296)
    • C3. Nadmiarowe komentarze (296)
    • C4. Źle napisane komentarze (297)
    • C5. Zakomentowany kod (297)
  • Środowisko (297)
    • E1. Budowanie wymaga więcej niż jednego kroku (297)
    • E2. Testy wymagają więcej niż jednego kroku (297)
  • Funkcje (298)
    • F1. Nadmiar argumentów (298)
    • F2. Argumenty wyjściowe (298)
    • F3. Argumenty znacznikowe (298)
    • F4. Martwe funkcje (298)
  • Ogólne (298)
    • G1. Wiele języków w jednym pliku źródłowym (298)
    • G2. Oczywiste działanie jest nieimplementowane (299)
    • G3. Niewłaściwe działanie w warunkach granicznych (299)
    • G4. Zdjęte zabezpieczenia (299)
    • G5. Powtórzenia (300)
    • G6. Kod na nieodpowiednim poziomie abstrakcji (300)
    • G7. Klasy bazowe zależne od swoich klas pochodnych (301)
    • G8. Za dużo informacji (302)
    • G9. Martwy kod (302)
    • G10. Separacja pionowa (303)
    • G11. Niespójność (303)
    • G12. Zaciemnianie (303)
    • G13. Sztuczne sprzężenia (303)
    • G14. Zazdrość o funkcje (304)
    • G15. Argumenty wybierające (305)
    • G16. Zaciemnianie intencji (305)
    • G17. Źle rozmieszczona odpowiedzialność (306)
    • G18. Niewłaściwe metody statyczne (306)
    • G19. Użycie opisowych zmiennych (307)
    • G20. Nazwy funkcji powinny informować o tym, co realizują (307)
    • G21. Zrozumienie algorytmu (308)
    • G22. Zamiana zależności logicznych na fizyczne (308)
    • G23. Zastosowanie polimorfizmu zamiast instrukcji if-else lub switch-case (309)
    • G24. Wykorzystanie standardowych konwencji (310)
    • G25. Zamiana magicznych liczb na stałe nazwane (310)
    • G26. Precyzja (311)
    • G27. Struktura przed konwencją (312)
    • G28. Hermetyzacja warunków (312)
    • G29. Unikanie warunków negatywnych (312)
    • G30. Funkcje powinny wykonywać jedną operację (312)
    • G31. Ukryte sprzężenia czasowe (313)
    • G32. Unikanie dowolnych działań (314)
    • G33. Hermetyzacja warunków granicznych (314)
    • G34. Funkcje powinny zagłębiać się na jeden poziom abstrakcji (315)
    • G35. Przechowywanie danych konfigurowalnych na wysokim poziomie (316)
    • G36. Unikanie nawigacji przechodnich (317)
  • Java (317)
    • J1. Unikanie długich list importu przez użycie znaków wieloznacznych (317)
    • J2. Nie dziedziczymy stałych (318)
    • J3. Stałe kontra typy wyliczeniowe (319)
  • Nazwy (320)
    • N1. Wybór opisowych nazw (320)
    • N2. Wybór nazw na odpowiednich poziomach abstrakcji (321)
    • N3. Korzystanie ze standardowej nomenklatury tam, gdzie jest to możliwe (322)
    • N4. Jednoznaczne nazwy (322)
    • N5. Użycie długich nazw dla długich zakresów (323)
    • N6. Unikanie kodowania (323)
    • N7. Nazwy powinny opisywać efekty uboczne (323)
  • Testy (324)
    • T1. Niewystarczające testy (324)
    • T2. Użycie narzędzi kontroli pokrycia (324)
    • T3. Nie pomijaj prostych testów (324)
    • T4. Ignorowany test jest wskazaniem niejednoznaczności (324)
    • T5. Warunki graniczne (324)
    • T6. Dokładne testowanie pobliskich błędów (324)
    • T7. Wzorce błędów wiele ujawniają (324)
    • T8. Wzorce pokrycia testami wiele ujawniają (325)
    • T9. Testy powinny być szybkie (325)
  • Zakończenie (325)
  • Bibliografia (325)

A: Współbieżność II (327)

  • Przykład klient-serwer (327)
    • Serwer (327)
    • Dodajemy wątki (329)
    • Uwagi na temat serwera (329)
    • Zakończenie (331)
  • Możliwe ścieżki wykonania (331)
    • Liczba ścieżek (332)
    • Kopiemy głębiej (333)
    • Zakończenie (336)
  • Poznaj używaną bibliotekę (336)
    • Biblioteka Executor (336)
    • Rozwiązania nieblokujące (337)
    • Bezpieczne klasy nieobsługujące wątków (338)
  • Zależności między metodami mogą uszkodzić kod współbieżny (339)
    • Tolerowanie awarii (340)
    • Blokowanie na kliencie (340)
    • Blokowanie na serwerze (342)
  • Zwiększanie przepustowości (343)
    • Obliczenie przepustowości jednowątkowej (344)
    • Obliczenie przepustowości wielowątkowej (344)
  • Zakleszczenie (345)
    • Wzajemne wykluczanie (346)
    • Blokowanie i oczekiwanie (346)
    • Brak wywłaszczania (346)
    • Cykliczne oczekiwanie (346)
    • Zapobieganie wzajemnemu wykluczaniu (347)
    • Zapobieganie blokowaniu i oczekiwaniu (347)
    • Umożliwienie wywłaszczania (348)
    • Zapobieganie oczekiwaniu cyklicznemu (348)
  • Testowanie kodu wielowątkowego (349)
  • Narzędzia wspierające testowanie kodu korzystającego z wątków (351)
  • Zakończenie (352)
  • Samouczek. Pełny kod przykładów (352)
    • Klient-serwer bez wątków (352)
    • Klient-serwer z użyciem wątków (355)

B: org.jfree.date.SerialDate (357)

C: Odwołania do heurystyk (411)

Epilog (413)

Skorowidz (415)
Nazwa Wartość
Książka - Autor Robert C. Martin
Książka - ISBN 978-83-246-2188-0
Książka - Oprawa miękka
Książka - Wydawnictwo Helion
Tematyka Podstawy
Szerokość 16,5 cm
Wysokość 24 cm
Głębokość 2 cm
Waga 0,2 kg

Darmowa dostawa od 500,00 zł

Przy zamówieniach o wartości 500,00 zł i więcej koszt przesyłki pokrywamy my, niezależnie od wybranego przewoźnika. Dotyczy dostawy do kraju: Polska.

Sposób dostawy Czas dostawy Koszt
GLS Automaty Dostawa 24h od 8,99 zł
InPost Paczkomat® 24/7 Dostawa 24h (ubezpieczenie do 200 zł) od 13,99 zł
InPost Kurier Dostawa 24h od 14,99 zł
Kurier GLS Dostawa 24h od 14,99 zł
InPost Paczka w Weekend Dostawa w sobotę od 19,99 zł
InPost Kurier (pobranie) Dostawa 24h od 22,99 zł
Ambro Express (bez wniesienia) Dostawa 1-2 dni od 150,00 zł
Ambro Express (z wniesieniem) Dostawa 1-2 dni od 200,00 zł

Szczegółowe warunki dostawy znajdziesz na stronie Dostawa i płatności.

Zasady składania reklamacji towaru

Zgodnie z obowiązującymi przepisami, ponosimy odpowiedzialność na zasadach określonych w Kodeksie Cywilnym za wady fizyczne i prawne.

Po wykryciu wady Kupujący ma prawo:

  • złożyć oświadczenie o żądaniu obniżenia ceny,
  • złożyć oświadczenie o odstąpieniu od umowy, ale nie wtedy kiedy wada jest nieistotna,
  • żądać wymiany rzeczy na wolną od wad,
  • żądać usunięcia wady.

Informujemy, że Dział Reklamacji firmy Botland rozpatruje zgłoszenia w ciągu 14 dni kalendarzowych od daty ich wpłynięcia. Botland odpowiada z tytułu rękojmi jeśli wada fizyczna zostanie stwierdzona przed upływem dwóch lat od momentu wydania rzeczy.

Informacje dotyczące korzystania z prawa odstąpienia od umowy

Zgodnie z aktualnymi przepisami prawnymi Konsument ma prawo odstąpić od umowy kupna-sprzedaży w terminie 30 dni bez podania przyczyny. Termin ten wygasa po upływie 30 dni od momentu, w którym Konsument wszedł w posiadanie rzeczy lub w którym osoba trzecia inna niż przewoźnik i wskazana przez Konsumenta weszła w posiadanie rzeczy.

Informujemy, że zgodnie z obowiązującymi przepisami oraz §4 Regulaminu zwrot towaru przysługuje wyłącznie Konsumentom (zakup niezwiązany bezpośrednio działalnością gospodarczą lub zawodową). Zwroty nie przysługują Klientom (zakup związany bezpośrednio działalnością gospodarczą lub zawodową).

Przebieg reklamacji / zwrotu

W celu zgłoszenia reklamacji prosimy postępować zgodnie z instrukcją:

  1. Zapoznaj się z zasadami reklamacji / zwrotu.
  2. Wypełnij formularz, który znajduje się poniżej.
  3. Zapoznaj się z treścią otrzymanej odpowiedzi.
  4. Po otrzymaniu wiadomości e-mail ze statusem „Oczekiwanie na przesyłkę”, zabezpiecz i zapakuj niesprawny produkt.
  5. Wyślij przesyłkę na podany niżej adres wraz z wydrukowanym formularzem oraz dowodem zakupu.
Formularz reklamacyjny

W celu rozpoczęcia procedury reklamacyjnej / zwrotu, wypełnij formularz.

Adres do wysyłki

BOTLAND - SERWIS
Gola 25A
63-640 Bralin

Zasady reklamacji

W celu sprawnego przeprowadzenia procesu reklamacji, prosimy o zapoznanie się z opisanymi poniżej zasadami:

  1. Przed odesłaniem sprzętu prosimy o upewnienie się, iż produkt faktycznie jest niesprawny.
  2. W celu sprawnego przebiegu reklamacji prosimy o wypełnienie formularza reklamacyjnego oraz dołączenie go do przesyłki.
  3. Do reklamowanych produktów prosimy dołączyć dowód zakupu (np. paragon, fakturę lub potwierdzenie wykonania przelewu).
  4. Towar należy starannie zapakować, aby zapewnić bezpieczny transport i zapobiec kolejnym uszkodzeniom.
  5. Firma Botland nie odbiera paczek reklamacyjnych wysłanych za pobraniem oraz paczek nadawanych do automatów paczkowych np. urządzeń Paczkomat.
  6. Zwrot kosztów przesyłki następuje po uznaniu reklamacji. Jest to kwota zgodna z najtańszą oferowaną formą dostawy.
  7. Po uznaniu reklamacji zwrot środków nastąpi w ciągu 14 dni. Zwrotu dokonamy przy użyciu takich samych sposobów płatności oraz w tej samej walucie, jakie zostały użyte w pierwotnej transakcji, chyba że Kupujący wyraził zgodę na inne rozwiązanie lub je zaproponował.
  8. Sprzęt prosimy odsyłać kompletny razem z akcesoriami. Produkty niekompletne zostaną odesłane bez rozpatrzenia na koszt nadawcy.
  9. Samodzielna naprawa, przeprowadzona przez osoby nieuprawnione, tj. niebędąca naprawą przez firmę Botland, pozbawia Kupującego prawa do dalszego reklamowania.
  10. O sposobie rozpatrzenia reklamacji Kupujący zostanie poinformowany drogą elektroniczną (poprzez wiadomość e-mail).
  11. Szczegółowe informacje dotyczące aktualnych kosztów wysyłki znajdują się na stronie www.botland.com.pl w zakładce Dostawa.
  12. Odesłanie sprzętu jest równoznaczne z zapoznaniem się z powyższymi zasadami.

Zasady zwrotu towaru

  1. W celu skorzystania z prawa odstąpienia od umowy, Konsument zobowiązany jest poinformować Sprzedającego o swojej decyzji poprzez jednoznaczne oświadczenie.
  2. W celu sprawnego przeprowadzenia procesu zwrotu prosimy o wypełnienie formularza. Konsument może również skorzystać z innego oświadczenia niż zamieszczony formularz.
  3. W przypadku odstąpienia od umowy zwracamy wszystkie otrzymane płatności, w tym koszty dostarczenia rzeczy do Konsumenta (z wyjątkiem dodatkowych kosztów wynikających z wybranego przez Konsumenta sposobu dostarczenia innego niż najtańszy przez nas oferowany). Konsument ponosi koszty przesyłki zwrotnej. Zwrot środków nastąpi w ciągu 14 dni od dnia, w którym zostaliśmy poinformowani o decyzji odstąpienia od umowy. Zwrotu dokonamy przy użyciu takich samych sposobów płatności oraz w tej samej walucie, jakie zostały użyte w pierwotnej transakcji, chyba że Konsument wyraził zgodę na inne rozwiązanie lub je zaproponował.
  4. Możemy wstrzymać się ze zwrotem płatności do czasu otrzymania rzeczy lub dostarczenia nam dowodu jej odesłania, w zależności od tego, które zdarzenie nastąpi wcześniej.
  5. Prosimy o odesłanie lub przekazanie nam rzeczy niezwłocznie, a w każdym razie nie później niż 14 dni od dnia, w którym zostaliśmy poinformowani o odstąpieniu od umowy. Prosimy również o staranne zapakowanie towaru przed wysyłką.
  6. Konsument odpowiada tylko za zmniejszenie wartości produktu wynikającej z korzystania w sposób inny niż było to konieczne do stwierdzenia cech i funkcjonalności.
  7. Firma Botland nie odbiera paczek zwrotnych wysłanych za pobraniem oraz paczek nadawanych do automatów paczkowych np. urządzeń Paczkomat.

Zadaj pierwsze pytanie o ten produkt!

Instrukcje i dokumenty

Dane GPSR

Kraj pochodzenia Polska
Dane kontaktowe producenta Helion.pl sp. z o.o. ul. Kościuszki 1c 44-100 Gliwice [email protected]
Dane kontaktowe wprowadzającego na rynek UE Helion.pl sp. z o.o. ul. Kościuszki 1c 44-100 Gliwice [email protected]
Inni klienci oglądali również

Brak opinii dla tego produktu.