Name: Lodówka SAMSUNG RS68A884CB1 EF Side by Side No frost 178cm Grafitowa stal Podajnik wody Kostkarka cena, opinie, dane techniczne | sklep internetowy Electro.pl
Brand: SAMSUNG
SKU: 440011
Price: 6799.00 PLN
Availability: InStock

Opis i specyfikacja

Doskonalsza codzienność w zasięgu Twojej ręki dzięki SmartThings. Aplikacja uprzyjemni Ci obsługę różnych urządzeń, czyniąc ją prostszą i intuicyjną. Sprawdź w niej, ile czasu pozostało do końca prania, uruchom playlistę do gotowania oraz robota sprzątającego. Twój dom dopasuje się do Twoich potrzeb. Orzeźwiające powietrze po powrocie z pracy zapewni klimatyzator. O dopasowany do wieczornego seansu klimat zadbają automatycznie przyciemniane światła. Science fiction? Nie, to SmartThings.

(function() {

/**
   * Widget script environment runtime
   */

/**
 * This module is reponsible for populating window object with proper values.
 */
// setup widget repository object as empty object initially
window.__forge2_widgets = {};
window.__forge2_themes = {};
// create runtime context object with useful methods in runtime
window.__forge2_context = {
    /**
     * Returns theme with particular ID from registered themes
     */
    getTheme: function (themeId) {
        // check if theme exists on runtime
        if (!window.__forge2_themes[themeId]) {
            throw new Error("Theme with name " + themeId + " does not exist in runtime.");
        }
        // get widget runtime class and create its instance
        var themeClass = window.__forge2_themes[themeId];
        return new themeClass();
    },
};
// setup register function for runtime
window.__forge2_widget_register = function (widgetType, widgetClass) {
    if (window.__forge2_widgets[widgetType]) {
        throw new Error("Error: trying to register widget " + widgetType + " more than once!");
    }
    window.__forge2_widgets[widgetType] = widgetClass;
};
// setup theme register function for runtime
window.__forge2_theme_register =
    function (widgetType, themeId, themeClass) {
        if (window.__forge2_themes[themeId]) {
            throw new Error("Error: trying to register theme " + themeId + " more than once!");
        }
        window.__forge2_themes[themeId] = themeClass;
    };

/**
   * Widget scripts
   */

/**
 * Runtime implementation for w-video widget
 */
// runtime widget behaviour class
var WVideoWidget = /** @class */ (function () {
    function WVideoWidget() {
        var _this = this;
        /**
         * Called when someone clicks on the image
         */
        this.handleImageClick = function () {
            // hiding the miniature
            _this.mVideoImageEl.style.display = 'none';
            if (_this.mVideoIframeEl) {
                // returns URL's `?` or `&` sign, depending on context
                var properUrlQueryChar = _this.mVideoIframeEl.getAttribute('src').includes('?') ? '&' : '?';
                // overload video and auto play
                _this.mVideoIframeEl.setAttribute('src', "" + _this.mVideoIframeEl.getAttribute('src') + properUrlQueryChar + "autoplay=1");
            }
            else {
                // auto play video
                _this.videoEl.play();
            }
        };
    }
    /**
     * Initializes w-video widget behaviour
     */
    WVideoWidget.prototype.init = function (htmlElement) {
        // get element containing miniature
        this.mVideoImageEl = htmlElement.querySelector('.m-video_image');
        // get element containing iframe
        this.mVideoIframeEl = htmlElement.querySelector('.m-video_iframe');
        // get element containing file manager video
        this.videoEl = htmlElement.querySelector('video');
        // Called when the miniature source image exists
        // an someone clicks on the miniature
        if (this.mVideoImageEl) {
            this.mVideoImageEl.addEventListener('click', this.handleImageClick);
            this.mVideoImageEl.style.cursor = 'pointer';
            // show the miniature
            this.mVideoImageEl.style.display = 'flex';
        }
    };
    /**
     * Called when widget is no longer needed
     */
    WVideoWidget.prototype.destroy = function () {
        if (this.mVideoImageEl) {
            this.mVideoImageEl.removeEventListener('click', this.handleImageClick);
        }
    };
    return WVideoWidget;
}());
window.__forge2_widget_register('e-video', WVideoWidget);

/**
 * Runtime implementation for w-accordion widget
 */
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var __generator = (this && this.__generator) || function (thisArg, body) {
    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
    function verb(n) { return function (v) { return step([n, v]); }; }
    function step(op) {
        if (f) throw new TypeError("Generator is already executing.");
        while (_) try {
            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
            if (y = 0, t) op = [op[0] & 2, t.value];
            switch (op[0]) {
                case 0: case 1: t = op; break;
                case 4: _.label++; return { value: op[1], done: false };
                case 5: _.label++; y = op[1]; op = [0]; continue;
                case 7: op = _.ops.pop(); _.trys.pop(); continue;
                default:
                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
                    if (t[2]) _.ops.pop();
                    _.trys.pop(); continue;
            }
            op = body.call(thisArg, _);
        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
    }
};
// runtime widget behaviour class
var WAccordionWidget = /** @class */ (function () {
    function WAccordionWidget() {
        // holds list of possible animations
        this.fAnimateFunctions = new Map();
        // holds if view is currently animating
        this.fIsAnimating = false;
    }
    /**
     * Initializes w-accordion widget behaviour
     */
    WAccordionWidget.prototype.init = function (htmlElement) {
        var _this = this;
        // store html element for later
        this.fHtmlElement = htmlElement;
        // register animation functions
        this.registerAnimationFunctions();
        // parse data of widget stored in html attribute
        this.fData = JSON.parse(htmlElement.getAttribute('data-widget-data'));
        // get element containing cylinder children on export
        var childrenElement = htmlElement;
        // get elements with 'on' and 'off' state
        var onHtmlElement = childrenElement.children.item(0);
        var offHtmlElement = childrenElement.children.item(1);
        // if section should be visible initially
        if (this.fData.initialVisible) {
            // initially hide 'off' element and show 'on' element
            this.changeElementVisibility(offHtmlElement, false);
            this.changeElementVisibility(onHtmlElement, true);
        }
        else {
            // otherwise, show 'off' state, hide 'on' state and hide target element
            if (!this.fData.forceOnState) {
                this.changeElementVisibility(offHtmlElement, true);
                this.changeElementVisibility(onHtmlElement, false);
            }
            else {
                this.changeElementVisibility(offHtmlElement, false);
                this.changeElementVisibility(onHtmlElement, true);
            }
            // query scene element that was set as target
            var targetElement = document.querySelector(".c-" + this.fData.targetId);
            // if target element exists
            if (targetElement) {
                this.changeElementVisibility(targetElement, false);
                targetElement.classList.add('accordion-is-hidden');
            }
        }
        // add click handler
        htmlElement.addEventListener('click', function (evt) { return __awaiter(_this, void 0, void 0, function () {
            var targetElement;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        // check if its already transitioning
                        if (this.fIsAnimating) {
                            return [2 /*return*/];
                        }
                        // set that we are animating toggle action now to prevent multiple
                        // events and timeouts conflicts
                        this.fIsAnimating = true;
                        // prevent default action, because we are controlling behaviour
                        evt.preventDefault();
                        targetElement = document.querySelector(".c-" + this.fData.targetId);
                        if (!targetElement) return [3 /*break*/, 6];
                        if (!targetElement.classList.contains('accordion-is-hidden')) return [3 /*break*/, 3];
                        // swap on/off displays
                        this.changeElementVisibility(offHtmlElement, false);
                        this.changeElementVisibility(onHtmlElement, true);
                        // toggle out other widgets from same group
                        return [4 /*yield*/, this.toggleOutFromSameGroup()];
                    case 1:
                        // toggle out other widgets from same group
                        _a.sent();
                        // toggle target container
                        return [4 /*yield*/, this.toggleContainer(targetElement, true)];
                    case 2:
                        // toggle target container
                        _a.sent();
                        return [3 /*break*/, 5];
                    case 3:
                        if (!(!this.fData.groupName || this.fData.allowAllClosed)) return [3 /*break*/, 5];
                        // 'off' can be only used for widgets without group name
                        // (eg: checkbox type)
                        // swap on/off displays
                        this.changeElementVisibility(offHtmlElement, true);
                        this.changeElementVisibility(onHtmlElement, false);
                        // toggle target container
                        return [4 /*yield*/, this.toggleContainer(targetElement, false)];
                    case 4:
                        // toggle target container
                        _a.sent();
                        _a.label = 5;
                    case 5:
                        // toggle hidden state
                        targetElement.classList.toggle('accordion-is-hidden');
                        return [3 /*break*/, 7];
                    case 6:
                        console.warn("Warning: No target element for accordion: ' + " + this.fData.targetId);
                        _a.label = 7;
                    case 7:
                        // reset animating flag
                        this.fIsAnimating = false;
                        return [2 /*return*/];
                }
            });
        }); });
    };
    /**
     * Called when widget is no longer needed
     */
    WAccordionWidget.prototype.destroy = function () {
        // no action required here
    };
    /**
     * Fills animation functions map with possible animation types
     */
    WAccordionWidget.prototype.registerAnimationFunctions = function () {
        var _this = this;
        // standard animation
        this.fAnimateFunctions.set('standard', function (element, isVisible) { return __awaiter(_this, void 0, void 0, function () {
            return __generator(this, function (_a) {
                return [2 /*return*/];
            });
        }); });
        // slide type animation
        this.fAnimateFunctions.set('slide', function (element, isVisible) { return __awaiter(_this, void 0, void 0, function () {
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0: 
                    // animate slide
                    return [4 /*yield*/, this.animateSlide(element, isVisible)];
                    case 1:
                        // animate slide
                        _a.sent();
                        return [2 /*return*/];
                }
            });
        }); });
    };
    /**
     * Toggles target container with proper state, based on selected animation
     */
    WAccordionWidget.prototype.toggleContainer = function (container, isVisible) {
        return __awaiter(this, void 0, Promise, function () {
            var animationFunction;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        animationFunction = this.fAnimateFunctions.get(this.fData.animationType);
                        // if it does not exist, throw an error
                        if (!animationFunction) {
                            throw new Error("Error: Animation function of type " + this.fData.animationType + " does not exist.");
                        }
                        // set that we are currently animating
                        this.fIsAnimating = true;
                        // otherwise, use proper animation function and await until its finished
                        return [4 /*yield*/, animationFunction(container, isVisible)];
                    case 1:
                        // otherwise, use proper animation function and await until its finished
                        _a.sent();
                        // and then force display styles on target element
                        if (isVisible) {
                            container.style.removeProperty('display');
                        }
                        else {
                            this.changeElementVisibility(container, false);
                            // this is a hack for video widget that will be hidden, sigh
                            this.videoWidgetHack(container);
                        }
                        return [2 /*return*/];
                }
            });
        });
    };
    /**
     * This hack stops all e-video widgets that are currently playing.
     * This should be done in more nice way but I do not want to implement
     * event system for single case.
     */
    WAccordionWidget.prototype.videoWidgetHack = function (container) {
        // get array of <iframes> with youtube
        var videoElements = Array.from(container.querySelectorAll('.e-video_iframe'));
        // iterate over array
        videoElements.forEach(function (videoElement) {
            // get iframe object from element, TS does not have typings for this
            // so I must cast it as any
            var iframe = videoElement.contentWindow;
            // just safetly check
            if (iframe) {
                // compose msg to youtube iframe
                var msgData = {
                    event: 'command',
                    func: 'pauseVideo',
                    args: '',
                };
                // and post it to pause video
                iframe.postMessage(JSON.stringify(msgData), '*');
            }
        });
    };
    /**
     * Toggles other accordion widgets from same group name
     */
    WAccordionWidget.prototype.toggleOutFromSameGroup = function () {
        return __awaiter(this, void 0, Promise, function () {
            var groupClass, groupedAccordions, promises;
            var _this = this;
            return __generator(this, function (_a) {
                // if this accordion does not have group set, ignore this function
                if (!this.fData.groupName) {
                    return [2 /*return*/, []];
                }
                groupClass = "group-" + this.fData.groupName;
                groupedAccordions = Array.from(document.querySelectorAll(".e-accordion." + groupClass))
                    .filter(function (el) { return el !== _this.fHtmlElement; });
                promises = groupedAccordions.map(function (accordionElement) { return __awaiter(_this, void 0, void 0, function () {
                    var childrenElement, onHtmlElement, offHtmlElement, accordionData, targetElement;
                    return __generator(this, function (_a) {
                        switch (_a.label) {
                            case 0:
                                childrenElement = accordionElement;
                                onHtmlElement = childrenElement.children.item(0);
                                offHtmlElement = childrenElement.children.item(1);
                                accordionData = JSON.parse(accordionElement.getAttribute('data-widget-data'));
                                // "turn off" accordion (if no 'force on' option if present)
                                if (!accordionData.forceOnState) {
                                    this.changeElementVisibility(onHtmlElement, false);
                                    this.changeElementVisibility(offHtmlElement, true);
                                }
                                targetElement = document.querySelector(".c-" + accordionData.targetId);
                                if (!targetElement) return [3 /*break*/, 2];
                                targetElement.classList.add('accordion-is-hidden');
                                return [4 /*yield*/, this.toggleContainer(targetElement, false)];
                            case 1:
                                _a.sent();
                                return [3 /*break*/, 3];
                            case 2:
                                console.warn("Warning: No target element for accordion: ' + " + accordionData.targetId);
                                _a.label = 3;
                            case 3: return [2 /*return*/];
                        }
                    });
                }); });
                return [2 /*return*/, Promise.all(promises)];
            });
        });
    };
    /**
     * Makes 'slide' animation on target element
     */
    WAccordionWidget.prototype.animateSlide = function (element, isVisible) {
        var ANIMATION_TIME = 300;
        return new Promise(function (resolve, reject) {
            if (isVisible) {
                $(element).slideDown(ANIMATION_TIME, resolve);
            }
            else {
                $(element).slideUp(ANIMATION_TIME, resolve);
            }
        });
    };
    /**
     * Helper function that displays/hides target html element.
     * During hiding saves original display of the element, to return it to original value during showing.
     */
    WAccordionWidget.prototype.changeElementVisibility = function (element, value) {
        var currentDisplay = window.getComputedStyle(element).display;
        // If we want to hide element, and it has no saved display value, save it
        if (!value && !element.dataset.display) {
            element.dataset.display = currentDisplay;
        }
        // Hide or show element
        if (!value) {
            element.style.setProperty('display', 'none');
        }
        else if (currentDisplay === 'none') {
            // Toggle visibility "on" only if element is already hidden, default to block
            element.style.setProperty('display', element.dataset.display || 'block');
        }
    };
    return WAccordionWidget;
}());
window.__forge2_widget_register('e-accordion', WAccordionWidget);

/**
   * End of widget scripts
   */

/**
   * Widget themes
   */

/**
   * End of widget themes
   */

/**
   * Basic runtime code
   */
  
  /**
 * This module is reponsible for providing support for runtime widgets.
 */
/**
 * Define enableWidget function that will accept widgetType and will inject
 * runtime behaviour to DOM element based on widgetType argument.
 */
function enableWidget(widgetType) {
    // if this widget type does not have runtime behaviour class,
    // just skip it
    if (!window.__forge2_widgets[widgetType]) {
        return;
    }
    // get widget runtime class for particular widget type
    var widgetClass = window.__forge2_widgets[widgetType];
    // get all elements with class matching widget type (eg: w-countdown -> .w-countdown)
    var elements = Array.from(document.querySelectorAll("." + widgetType));
    // initialize all widgett elements found
    elements.forEach(function (rootElement) {
        // create widget class instance for this element
        var widgetClassInstance = new widgetClass();
        // and inject it
        widgetClassInstance.init(rootElement, window.__forge2_context);
    });
}
/**
 * Called when window is fully loaded, enables all widgets runtime behaviour.
 */
window.addEventListener('load', function () {
    // get array of widget types from repository
    var widgetTypes = Array.from(Object.keys(window.__forge2_widgets));
    // enable all widgets
    widgetTypes.forEach(function (widgetType) { return enableWidget(widgetType); });
});

})();

Techniczne

Pojemność [l]	409 chłodziarka + 226 zamrażarka
Bezszronowa (No Frost)	Pełny No Frost
Położenie zamrażarki	Side by Side
Kompresor inwerterowy	Tak
Liczba drzwi	2
Sterowanie	Elektroniczne
Zmiana kierunku otwierania drzwi	Nie
Czas utrzymania temperatury w przypadku braku zasilania [h]	7
Kolor producenta	Grafitowa stal
Kolor / wykończenie boków	Grafitowa stal
Kolor / wykończenie frontu	Grafitowa stal
Szklane wykończenie drzwi	Nie
Licowane drzwi	Nie
Liczba agregatów	1
Liczba termostatów	2
Wyświetlacz	Wewnętrzny
Funkcje dodatkowe	All Around Cooling, Metal Cooling, Oświetlenie LED, Precise Chef Cooling, Smart Convertible 5in1, Space Max, Tryb wakacyjny, TWIN Cooling Plus
Rodzaj	Side By Side
Seria lodówki	RS8000
Sterowanie smartfonem	Nie
Retro	Nie
Bezpieczeństwo użytkowania	Alarm niedomkniętych drzwi, Półki z "bezpiecznego szkła"
Szerokość [cm]	91.2
Wysokość [cm]	178
Głębokość [cm]	71.6

Efektywność energetyczna

Nowa klasa energetyczna	C
Roczne zużycie prądu	225 kWh = 258.75 zł
Poziom hałasu [dB]	35
Klasa zamrażarki	/**
Klasa klimatyczna	N, SN, ST, T
Roczne zużycie energii [kWh]	225
Klasa emisji hałasu	B

Parametry zewnętrzne

Głębokość opakowania [cm]	77.6
Szerokość opakowania [cm]	98
Waga z opakowaniem [kg]	138.00, 145.00
Wysokość opakowania [cm]	190.7
Szerokość z otwartymi drzwiami [cm]	97.2

Chłodziarka

Pojemność komory schładzania [l]	409
Sposób odszraniania (rozmrażania) chłodziarki	No-Frost
Rodzaj półek	Szklane
Liczba półek	4
Liczba pojemników na warzywa	2
Liczba półek na butelki	1
Szybkie chłodzenie	Tak
Komora zero	Nie
Dystrybutor wody	Tak (wymaga podłączenia do bieżącej wody)
Komora świeżości	Nie
Szuflada z kontrolą wilgotności	Nie

Zamrażarka

Pojemność komory mrożącej [l]	226
Sposób odszraniania (rozmrażania) zamrażalnika	No-Frost
Zdolność zamrażania [kg/24h]	15
Liczba pojemników w zamrażarce	2
Szybkie zamrażanie	Tak
Kostkarka do lodu	Kostkarka automatyczna (wymaga podłączenia do bieżącej wody)

Gwarancja

20 lat na kompresor, 24 miesiące

Dokumenty do pobrania

Szczegółowe warunki gwarancji	Pobierz
Instrukcja obsługi	Pobierz

Producent

Nazwa producenta/importera

Samsung Electronics Polska sp. z o.o.

Akcesoria

Opinie

Gwarancje

Lodówka SAMSUNG RS68A884CB1 EF Side by Side No frost 178cm Grafitowa stal Podajnik wody Kostkarka	Gwarancja Plus Pełna Ochrona	Gwarancja Plus	STANDARDOWA GWARANCJA PRODUCENTA
Urządzenie nie włącza się? Naprawa awarii możliwa nawet do 5 lat od zakupu.
Naprawa po gwarancji producenta okaże się niemożliwa? Wymienimy sprzęt na nowy.
Awaria sprzętu o wartości do 300 PLN? Otrzymasz nowy sprzęt bez próby naprawy.
Urządzenie przestało działać w wyniku przepięcia prądu? Naprawimy lub wymienimy, jeśli naprawa okaże się niemożliwa.
Urządzenie uszkodzone w wyniku nieszczęśliwego wypadku? Nic straconego, zgłoś i opisz szkodę, a naprawimy Twój sprzęt.
Zalanie sprzętu w wyniku nieszczęśliwego wypadku? Nie martw się, ochrona przed zalaniem działa już od dnia sprzedaży.
Ilość lat pakietu gwarancyjnego Warunki ubezpieczenia	Do 3 lat 1224,00 34 złco miesiąc/mc Do 5 lat 1768,00 29 złco miesiąc/mc	Do 3 lat 680,00 19 złco miesiąc/mc Do 5 lat 1360,00 23 złco miesiąc/mc	Standardowa gwarancja

Warunki ubezpieczenia

Dodaj z produktem

Raty i Leasing

Raty

Leasing

Prowadzisz firmę? Weź produkt w leasing

Dowiedz się więcej o leasingu

Weź produkt w leasing

Dowiedz się więcej o leasingu

Usługi

Wybierz usługi, które chcesz zamówić razem z produktem

Usługi realizowane przy dostawie kurierem

Wniesienie

109,99zł

WybieramWybrane

Pakiet Standard (Lodówka SBS)

Wniesienie, rozpakowanie, ustawienie i wypoziomowanie

Dowiedz się więcej

159,99zł

WybieramWybrane

Pakiet Pełen Komfort (Lodówka SBS)

Wniesienie, rozpakowanie, ustawienie, wypoziomowanie, usunięcie zabezpieczeń, montaż półek, podłączenie, zabranie opakowania.

Dowiedz się więcej

269,99zł

WybieramWybrane

Wymiary (WxSxG) [cm]	178 x 91.2 x 71.6
Szerokość z otwartymi drzwiami [cm]	97.2
Pojemność [l]	409 chłodziarka + 226 zamrażarka
Roczne zużycie prądu	225 kWh = 258.75 zł
Bezszronowa (No Frost)	Pełny No Frost
Poziom hałasu [dB]	35
Funkcje	Szybkie chłodzenie, Szybkie zamrażanie, Dystrybutor wody
Kod produktu	440011
Karta informacyjna produktu Zakres od A do G

Lodówka SAMSUNG RS68A884CB1 EF Side by Side No frost 178cm Grafitowa stal Podajnik wody Kostkarka

Bezszronowa (No Frost)

Kompresor inwerterowy

Sterowanie

Zmiana kierunku otwierania drzwi

Czas utrzymania temperatury w przypadku braku zasilania [h]

Licowane drzwi

Liczba agregatów

Liczba termostatów

Szerokość [cm]

Wysokość [cm]

Głębokość [cm]

Nowa klasa energetyczna

Roczne zużycie prądu

Klasa zamrażarki

Klasa klimatyczna

Szerokość z otwartymi drzwiami [cm]

Pojemność komory schładzania [l]

Szybkie chłodzenie

Komora zero

Dystrybutor wody

Pojemność komory mrożącej [l]

Zdolność zamrażania [kg/24h]

Szybkie zamrażanie

Kostkarka do lodu