Limpando todos os cookies com JavaScript

Como você exclui todos os cookies do domínio atual usando JavaScript?

function deleteAllCookies() {
    var cookies = document.cookie.split(";");

    for (var i = 0; i < cookies.length; i++) {
        var cookie = cookies[i];
        var eqPos = cookie.indexOf("=");
        var name = eqPos > -1 ? cookie.substr(0, eqPos) : cookie;
        document.cookie = name + "=;expires=Thu, 01 Jan 1970 00:00:00 GMT";
    }
}

Observe que este código tem duas limitações:

• Ele não excluirá os cookies com o HttpOnlysinalizador definido, pois o HttpOnlysinalizador desativa o acesso do Javascript ao cookie.
• Ele não excluirá os cookies que foram definidos com um Pathvalor. (Isso ocorre apesar do fato de esses cookies aparecerem document.cookie, mas você não pode excluí-lo sem especificar o mesmo Pathvalor com o qual foi definido.)

Um forro

Caso você queira colá-lo rapidamente ...

document.cookie.split(";").forEach(function(c) { document.cookie = c.replace(/^ +/, "").replace(/=.*/, "=;expires=" + new Date().toUTCString() + ";path=/"); });

E o código para um bookmarklet:

javascript:(function(){document.cookie.split(";").forEach(function(c) { document.cookie = c.replace(/^ +/, "").replace(/=.*/, "=;expires=" + new Date().toUTCString() + ";path=/"); }); })();

E aqui está uma para limpar todos os cookies em todos os caminhos e todas as variantes do domínio (www.mydomain.com, mydomain.com etc):

(function () {
    var cookies = document.cookie.split("; ");
    for (var c = 0; c < cookies.length; c++) {
        var d = window.location.hostname.split(".");
        while (d.length > 0) {
            var cookieBase = encodeURIComponent(cookies[c].split(";")[0].split("=")[0]) + '=; expires=Thu, 01-Jan-1970 00:00:01 GMT; domain=' + d.join('.') + ' ;path=';
            var p = location.pathname.split('/');
            document.cookie = cookieBase + '/';
            while (p.length > 0) {
                document.cookie = cookieBase + p.join('/');
                p.pop();
            };
            d.shift();
        }
    }
})();

Depois de um pouco de frustração com isso, reuni essa função que tentará excluir um cookie nomeado de todos os caminhos. Basta chamar isso para cada um de seus cookies e você deve estar mais perto de excluir todos os cookies do que antes.

function eraseCookieFromAllPaths(name) {
    // This function will attempt to remove a cookie from all paths.
    var pathBits = location.pathname.split('/');
    var pathCurrent = ' path=';

    // do a simple pathless delete first.
    document.cookie = name + '=; expires=Thu, 01-Jan-1970 00:00:01 GMT;';

    for (var i = 0; i < pathBits.length; i++) {
        pathCurrent += ((pathCurrent.substr(-1) != '/') ? '/' : '') + pathBits[i];
        document.cookie = name + '=; expires=Thu, 01-Jan-1970 00:00:01 GMT;' + pathCurrent + ';';
    }
}

Como sempre, navegadores diferentes têm comportamentos diferentes, mas isso funcionou para mim. Aproveitar.

Se você tiver acesso ao plugin jquery.cookie , poderá apagar todos os cookies desta maneira:

for (var it in $.cookie()) $.removeCookie(it);

Tanto quanto sei, não há como fazer uma exclusão geral de qualquer conjunto de cookies no domínio. Você pode limpar um cookie se souber o nome e se o script estiver no mesmo domínio que o cookie.

Você pode definir o valor como vazio e a data de validade em algum lugar no passado:

var mydate = new Date();
mydate.setTime(mydate.getTime() - 1);
document.cookie = "username=; expires=" + mydate.toGMTString(); 

Há um excelente artigo aqui sobre a manipulação de cookies usando javascript.

Mais simples. Mais rápido.

function deleteAllCookies() {
 var c = document.cookie.split("; ");
 for (i in c) 
  document.cookie =/^[^=]+/.exec(c[i])[0]+"=;expires=Thu, 01 Jan 1970 00:00:00 GMT";    
}

Uma resposta influenciada pela segunda resposta aqui e pelo W3Schools

document.cookie.split(';').forEach(function(c) {
  document.cookie = c.trim().split('=')[0] + '=;' + 'expires=Thu, 01 Jan 1970 00:00:00 UTC;';
});

Parece estar trabalhando

edit: wow quase exatamente o mesmo que o interessante de Zach, como Stack Overflow os coloca um ao lado do outro.

edit: NVM temporariamente aparentemente

Imaginei que compartilharia esse método para limpar cookies. Talvez possa ser útil para outra pessoa em algum momento.

var cookie = document.cookie.split(';');

for (var i = 0; i < cookie.length; i++) {

    var chip = cookie[i],
        entry = chip.split("="),
        name = entry[0];

    document.cookie = name + '=; expires=Thu, 01 Jan 1970 00:00:01 GMT;';
}

Você pode obter uma lista consultando a variável document.cookie. Limpá-los todos é apenas uma questão de percorrer todos eles e limpá-los um por um.

Não sei por que a primeira resposta votada não funciona para mim.

Como esta resposta dizia:

Não existe uma solução 100% para excluir os cookies do navegador.

O problema é que os cookies são identificados exclusivamente não apenas pelo "nome" principal, mas também pelo "domínio" e pelo "caminho".

Sem conhecer o "domínio" e o "caminho" de um cookie, você não poderá excluí-lo com segurança. Esta informação não está disponível no document.cookie do JavaScript. Também não está disponível no cabeçalho HTTP Cookie!

Então, minha ideia é adicionar um controle de versão de cookies com o conjunto completo de configurações, obtenção e remoção de cookies:

var cookie_version_control = '---2018/5/11';

function setCookie(name,value,days) {
    var expires = "";
    if (days) {
        var date = new Date();
        date.setTime(date.getTime() + (days*24*60*60*1000));
        expires = "; expires=" + date.toUTCString();
    }
    document.cookie = name+cookie_version_control + "=" + (value || "")  + expires + "; path=/";
}

function getCookie(name) {
    var nameEQ = name+cookie_version_control + "=";
    var ca = document.cookie.split(';');
    for(var i=0;i < ca.length;i++) {
        var c = ca[i];
        while (c.charAt(0)==' ') c = c.substring(1,c.length);
        if (c.indexOf(nameEQ) == 0) return c.substring(nameEQ.length,c.length);
    }
    return null;
}

function removeCookie(name) {   
    document.cookie = name+cookie_version_control+'=; Max-Age=-99999999;';  
}

Eu tenho um módulo de controle de cookie mais sofisticado e orientado para OOP. Ele também contém um deleteAllmétodo para limpar todos os cookies existentes. Observe que esta versão do deleteAllmétodo possui uma configuração path=/que causa a exclusão de todos os cookies no domínio atual. Se você precisar excluir cookies apenas de algum escopo, precisará atualizar esse método, adicionando pathparâmetro dinâmico a esse método.

Há Cookieclasse principal :

import {Setter} from './Setter';

export class Cookie {
    /**
     * @param {string} key
     * @return {string|undefined}
     */
    static get(key) {
        key = key.replace(/([\.$?*|{}\(\)\[\]\\\/\+^])/g, '\\$1');

        const regExp = new RegExp('(?:^|; )' + key + '=([^;]*)');
        const matches = document.cookie.match(regExp);

        return matches
            ? decodeURIComponent(matches[1])
            : undefined;
    }

    /**
     * @param {string} name
     */
    static delete(name) {
        this.set(name, '', { expires: -1 });
    }

    static deleteAll() {
        const cookies = document.cookie.split('; ');

        for (let cookie of cookies) {
            const index = cookie.indexOf('=');

            const name = ~index
                ? cookie.substr(0, index)
                : cookie;

            document.cookie = name + '=;expires=Thu, 01 Jan 1970 00:00:00 GMT;path=/';
        }
    }

    /**
     * @param {string} name
     * @param {string|boolean} value
     * @param {{expires?:Date|string|number,path?:string,domain?:string,secure?:boolean}} opts
     */
    static set(name, value, opts = {}) {
        Setter.set(name, value, opts);
    }
}

O método setter de cookies ( Cookie.set) é bastante complexo, então eu o decomponho em outra classe. Existe um código deste:

export class Setter {
    /**
     * @param {string} name
     * @param {string|boolean} value
     * @param {{expires?:Date|string|number,path?:string,domain?:string,secure?:boolean}} opts
     */
    static set(name, value, opts = {}) {
        value = Setter.prepareValue(value);
        opts = Setter.prepareOpts(opts);

        let updatedCookie = name + '=' + value;

        for (let i in opts) {
            if (!opts.hasOwnProperty(i)) continue;

            updatedCookie += '; ' + i;

            const value = opts[i];

            if (value !== true)
                updatedCookie += '=' + value;
        }

        document.cookie = updatedCookie;
    }

    /**
     * @param {string} value
     * @return {string}
     * @private
     */
    static prepareValue(value) {
        return encodeURIComponent(value);
    }

    /**
     * @param {{expires?:Date|string|number,path?:string,domain?:string,secure?:boolean}} opts
     * @private
     */
    static prepareOpts(opts = {}) {
        opts = Object.assign({}, opts);

        let {expires} = opts;

        if (typeof expires == 'number' && expires) {
            const date = new Date();

            date.setTime(date.getTime() + expires * 1000);

            expires = opts.expires = date;
        }

        if (expires && expires.toUTCString)
            opts.expires = expires.toUTCString();

        return opts;
    }
}

Aqui está um código simples para excluir todos os cookies em JavaScript .

function deleteAllCookies(){
   var cookies = document.cookie.split(";");
   for (var i = 0; i < cookies.length; i++)
     deleteCookie(cookies[i].split("=")[0]);
}

function setCookie(name, value, expirydays) {
 var d = new Date();
 d.setTime(d.getTime() + (expirydays*24*60*60*1000));
 var expires = "expires="+ d.toUTCString();
 document.cookie = name + "=" + value + "; " + expires;
}

function deleteCookie(name){
  setCookie(name,"",-1);
}

Execute a função deleteAllCookies()para limpar todos os cookies.

Abordagem Funcional + ES6

const cookieCleaner = () => {
  return document.cookie.split(";").reduce(function (acc, cookie) {
    const eqPos = cookie.indexOf("=");
    const cleanCookie = `${cookie.substr(0, eqPos)}=;expires=Thu, 01 Jan 1970 00:00:00 GMT;`;
    return `${acc}${cleanCookie}`;
  }, "");
}

Nota: Não manipula caminhos

//Delete all cookies
function deleteAllCookies() {
    var cookies = document.cookie.split(";");
    for (var i = 0; i < cookies.length; i++) {
        var cookie = cookies[i];
        var eqPos = cookie.indexOf("=");
        var name = eqPos > -1 ? cookie.substr(0, eqPos) : cookie;
        document.cookie = name + '=;' +
            'expires=Thu, 01-Jan-1970 00:00:01 GMT;' +
            'path=' + '/;' +
            'domain=' + window.location.host + ';' +
            'secure=;';
    }
}

Depois de testar quase sempre o método listado em vários estilos de navegadores em vários estilos de cookies, descobri que quase nada aqui funciona nem 50%.

Por favor, ajude a corrigir conforme necessário, mas eu vou jogar meus 2 centavos aqui. O método a seguir detalha tudo e basicamente cria a cadeia de valor do cookie com base nas partes das configurações, além de incluir uma construção passo a passo da cadeia de caminho, começando com/ naturalmente.

Espero que isso ajude os outros e espero que qualquer crítica possa vir na forma de aperfeiçoar esse método. No começo, eu queria um liner simples como outros procuravam, mas os cookies JS são uma daquelas coisas que não são tão fáceis de lidar.

;(function() {
    if (!window['deleteAllCookies'] && document['cookie']) {
        window.deleteAllCookies = function(showLog) {
            var arrCookies = document.cookie.split(';'),
                arrPaths = location.pathname.replace(/^\//, '').split('/'), //  remove leading '/' and split any existing paths
                arrTemplate = [ 'expires=Thu, 01-Jan-1970 00:00:01 GMT', 'path={path}', 'domain=' + window.location.host, 'secure=' ];  //  array of cookie settings in order tested and found most useful in establishing a "delete"
            for (var i in arrCookies) {
                var strCookie = arrCookies[i];
                if (typeof strCookie == 'string' && strCookie.indexOf('=') >= 0) {
                    var strName = strCookie.split('=')[0];  //  the cookie name
                    for (var j=1;j<=arrTemplate.length;j++) {
                        if (document.cookie.indexOf(strName) < 0) break; // if this is true, then the cookie no longer exist
                        else {
                            var strValue = strName + '=; ' + arrTemplate.slice(0, j).join('; ') + ';';  //  made using the temp array of settings, putting it together piece by piece as loop rolls on
                            if (j == 1) document.cookie = strValue;
                            else {
                                for (var k=0;k<=arrPaths.length;k++) {
                                    if (document.cookie.indexOf(strName) < 0) break; // if this is true, then the cookie no longer exist
                                    else {
                                        var strPath = arrPaths.slice(0, k).join('/') + '/'; //  builds path line 
                                        strValue = strValue.replace('{path}', strPath);
                                        document.cookie = strValue;
                                    }
                                }
                            }
                        }
                    }
                }
            }
            showLog && window['console'] && console.info && console.info("\n\tCookies Have Been Deleted!\n\tdocument.cookie = \"" + document.cookie + "\"\n");
            return document.cookie;
        }
    }
})();

Jquery:

var cookies = $.cookie();
for(var cookie in cookies) {
$.removeCookie(cookie);
}

JS baunilha

function clearListCookies()
{   
 var cookies = document.cookie.split(";");
 for (var i = 0; i < cookies.length; i++)
  {   
    var spcook =  cookies[i].split("=");
    deleteCookie(spcook[0]);
  }
  function deleteCookie(cookiename)
   {
    var d = new Date();
    d.setDate(d.getDate() - 1);
    var expires = ";expires="+d;
    var name=cookiename;
    //alert(name);
    var value="";
    document.cookie = name + "=" + value + expires + "; path=/acc/html";                    
}
window.location = ""; // TO REFRESH THE PAGE
}

Encontrei um problema no IE e Edge. Os navegadores Webkit (Chrome, safari) parecem mais tolerantes. Ao configurar cookies, sempre defina o "caminho" como algo, porque o padrão será a página que configurou o cookie. Portanto, se você tentar expirar em uma página diferente sem especificar o "caminho", o caminho não corresponderá e não expirará. odocument.cookie valor não mostra o caminho ou a expiração de um cookie, portanto, você não pode derivar onde o cookie foi definido olhando o valor.

Se você precisar expirar os cookies de páginas diferentes, salve o caminho da página de configuração no valor do cookie para poder retirá-lo mais tarde ou sempre anexá "; path=/;"-lo ao valor do cookie. Então ele expirará em qualquer página.