Jaka jest najkrótsza funkcja do odczytu ciasteczka według nazwy w JavaScript?

Jaka jest najkrótsza, dokładna i kompatybilna z różnymi przeglądarkami metoda odczytu pliku cookie w JavaScript?

Bardzo często budując samodzielne skrypty (w których nie mogę mieć żadnych zewnętrznych zależności), dodajęreadCookie() funkcję do czytania plików cookie i zwykle korzystam z metody QuirksMode.org (280 bajtów, 216 min.)

function readCookie(name) {
    var nameEQ = name + "=";
    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;
}

Robi robotę, ale jest brzydka i za każdym razem dodaje sporo wzdęci.

Metoda, w której jQuery.cookie używa czegoś takiego (zmodyfikowany, 165 bajtów, 125 minut):

function read_cookie(key)
{
    var result;
    return (result = new RegExp('(?:^|; )' + encodeURIComponent(key) + '=([^;]*)').exec(document.cookie)) ? (result[1]) : null;
}

Uwaga: nie jest to konkurs „Code Golf”: jestem prawnie zainteresowany zmniejszeniem wielkości mojej funkcji readCookie i upewnieniem się, że posiadane rozwiązanie jest prawidłowe.

Krótszy, bardziej niezawodny i skuteczniejszy niż obecnie najlepiej głosowana odpowiedź:

function getCookieValue(a) {
    var b = document.cookie.match('(^|;)\\s*' + a + '\\s*=\\s*([^;]+)');
    return b ? b.pop() : '';
}

Porównanie wydajności różnych podejść pokazano tutaj:

http://jsperf.com/get-cookie-value-regex-vs-array-functions

Kilka uwag na temat podejścia:

Metoda regex jest nie tylko najszybsza w większości przeglądarek, ale także zapewnia najkrótszą funkcję. Ponadto należy zauważyć, że zgodnie z oficjalną specyfikacją (RFC 2109) odstęp po średniku oddzielającym pliki cookie w dokumencie. Plik cookie jest opcjonalny i można argumentować, że nie można się na niego opierać. Dodatkowo spacja jest dozwolona przed i po znaku równości (=) i można argumentować, że ta potencjalna biała spacja powinna być uwzględniona w dowolnym wiarygodnym parserze document.cookie. Wyrażenie regularne powyżej uwzględnia oba powyższe warunki spacji.

To tylko raz trafi na document.cookie JEDEN raz. Każde kolejne żądanie będzie natychmiastowe.

(function(){
    var cookies;

    function readCookie(name,c,C,i){
        if(cookies){ return cookies[name]; }

        c = document.cookie.split('; ');
        cookies = {};

        for(i=c.length-1; i>=0; i--){
           C = c[i].split('=');
           cookies[C[0]] = C[1];
        }

        return cookies[name];
    }

    window.readCookie = readCookie; // or expose it however you want
})();

Obawiam się, że tak naprawdę nie ma szybszego sposobu niż ta ogólna logika, chyba że możesz swobodnie korzystać z .forEachfunkcji zależnych od przeglądarki (nawet wtedy nie oszczędzasz zbyt wiele)

Twój własny przykład lekko skompresowany do 120 bytes:

function read_cookie(k,r){return(r=RegExp('(^|; )'+encodeURIComponent(k)+'=([^;]*)').exec(document.cookie))?r[2]:null;}

Możesz to zrobić, 110 bytesjeśli uczynisz ją 1-literową nazwą funkcji, 90 bytesjeśli upuścisz encodeURIComponent.

Sprowadziłem się do tego 73 bytes, ale szczerze mówiąc, to 82 byteskiedy jestem nazwany, readCookiea 102 byteskiedy dodaje encodeURIComponent:

function C(k){return(document.cookie.match('(^|; )'+k+'=([^;]*)')||0)[2]}

Założenia

Na podstawie pytania uważam, że niektóre założenia / wymagania dotyczące tej funkcji obejmują:

• Będzie on używany jako funkcja biblioteki , a więc przeznaczony do umieszczenia w dowolnej bazie kodu;
• Jako taki będzie musiał działać w wielu różnych środowiskach , tj. Pracować ze starszym kodem JS, CMS o różnych poziomach jakości itp .;
• Aby współpracować z kodem napisanym przez inne osoby i / lub kodem, którego nie kontrolujesz, funkcja nie powinna przyjmować żadnych założeń dotyczących sposobu kodowania nazw lub wartości plików cookie . Wywołanie funkcji za pomocą łańcucha "foo:bar[0]"powinno zwrócić plik cookie (dosłownie) o nazwie „foo: bar [0]”;
• Nowe pliki cookie mogą być zapisywane i / lub istniejące pliki cookie modyfikowane w dowolnym momencie życia strony.

Zgodnie z tymi założeniami jasne jest, że encodeURIComponent/ decodeURIComponent nie należy używać ; Robiąc to, zakłada się, że kod, który ustawia plik cookie, również koduje go przy użyciu tych funkcji.

Metoda wyrażeń regularnych staje się problematyczna, jeśli nazwa pliku cookie może zawierać znaki specjalne. jQuery.cookie rozwiązuje ten problem, kodując nazwę pliku cookie (w rzeczywistości zarówno nazwę, jak i wartość) podczas przechowywania pliku cookie oraz dekodując nazwę podczas pobierania pliku cookie. Rozwiązanie wyrażeń regularnych znajduje się poniżej.

O ile nie czytasz tylko plików cookie, które kontrolujesz całkowicie, wskazane byłoby również odczytywanie plików cookie document.cookiebezpośrednio i nie buforowanie wyników, ponieważ nie ma sposobu, aby dowiedzieć się, czy pamięć podręczna jest nieprawidłowa bez document.cookieponownego czytania .

(Podczas gdy uzyskiwanie dostępu i parsowanie document.cookiesbędzie nieco wolniejsze niż w przypadku użycia pamięci podręcznej, nie będzie tak wolne jak czytanie innych części DOM, ponieważ pliki cookie nie odgrywają roli w drzewach DOM / renderowania).

Funkcja oparta na pętli

Oto odpowiedź Code Golf, oparta na funkcji PPK (pętli):

function readCookie(name) {
    name += '=';
    for (var ca = document.cookie.split(/;\s*/), i = ca.length - 1; i >= 0; i--)
        if (!ca[i].indexOf(name))
            return ca[i].replace(name, '');
}

który po zminimalizowaniu ma 128 znaków (nie licząc nazwy funkcji):

function readCookie(n){n+='=';for(var a=document.cookie.split(/;\s*/),i=a.length-1;i>=0;i--)if(!a[i].indexOf(n))return a[i].replace(n,'');}

Funkcja oparta na wyrażeniach regularnych

Aktualizacja: jeśli naprawdę potrzebujesz rozwiązania wyrażeń regularnych:

function readCookie(name) {
    return (name = new RegExp('(?:^|;\\s*)' + ('' + name).replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&') + '=([^;]*)').exec(document.cookie)) && name[1];
}

Pozwala to uniknąć znaków specjalnych w nazwie pliku cookie przed zbudowaniem obiektu RegExp. Zminimalizowane, zawiera 134 znaki (nie licząc nazwy funkcji):

function readCookie(n){return(n=new RegExp('(?:^|;\\s*)'+(''+n).replace(/[-[\]{}()*+?.,\\^$|#\s]/g,'\\$&')+'=([^;]*)').exec(document.cookie))&&n[1];}

Jak zauważyli Rudu i cwolves w komentarzach, wyrażenie regularne uciekające od wyrażenia regularnego można skrócić o kilka znaków. Myślę, że dobrze byłoby zachować spójność uciekającego wyrażenia regularnego (być może używasz go gdzie indziej), ale ich sugestie są warte rozważenia.

Notatki

Obie te funkcje nie będą obsługiwać nulllub undefined, tj. Jeśli istnieje plik cookie o nazwie „null”, readCookie(null)zwróci jego wartość. Jeśli musisz poradzić sobie z tą sprawą, odpowiednio dostosuj kod.

kod z google analytics ga.js

function c(a){
    var d=[],
        e=document.cookie.split(";");
    a=RegExp("^\\s*"+a+"=\\s*(.*?)\\s*$");
    for(var b=0;b<e.length;b++){
        var f=e[b].match(a);
        f&&d.push(f[1])
    }
    return d
}

Co powiesz na ten?

function getCookie(k){var v=document.cookie.match('(^|;) ?'+k+'=([^;]*)(;|$)');return v?v[2]:null}

Zliczono 89 bajtów bez nazwy funkcji.

Proszę bardzo ... Pozdrawiam!

function getCookie(n) {
    let a = `; ${document.cookie}`.match(`;\\s*${n}=([^;]+)`);
    return a ? a[1] : '';
}

Zauważ, że wykorzystałem ciągi szablonów ES6 do skomponowania wyrażenia regularnego.

w obiekcie, który można czytać, zapisywać, zastępować i usuwać pliki cookie.

var cookie = {
    write : function (cname, cvalue, exdays) {
        var d = new Date();
        d.setTime(d.getTime() + (exdays*24*60*60*1000));
        var expires = "expires="+d.toUTCString();
        document.cookie = cname + "=" + cvalue + "; " + expires;
    },
    read : function (name) {
        if (document.cookie.indexOf(name) > -1) {
            return document.cookie.split(name)[1].split("; ")[0].substr(1)
        } else {
            return "";
        }
    },
    delete : function (cname) {
        var d = new Date();
        d.setTime(d.getTime() - 1000);
        var expires = "expires="+d.toUTCString();
        document.cookie = cname + "=; " + expires;
    }
};

Obie te funkcje wyglądają równie poprawnie pod względem odczytu plików cookie. Możesz jednak ogolić kilka bajtów (i tak naprawdę dostaje się tutaj na terytorium Code Golf):

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

Wszystko, co z tym zrobiłem, to zwinięcie wszystkich deklaracji zmiennych w jedną instrukcję var, usunięcie niepotrzebnych drugich argumentów w wywołaniach podłańcuchu i zastąpienie jednego wywołania charAt dereferencją tablicową.

To wciąż nie jest tak krótkie jak druga funkcja, którą podałeś, ale nawet to może mieć kilka bajtów zdjętych:

function read_cookie(key)
{
    var result;
    return (result = new RegExp('(^|; )' + encodeURIComponent(key) + '=([^;]*)').exec(document.cookie)) ? result[2] : null;
}

Zmieniłem pierwsze podwyrażenie w wyrażeniu regularnym na przechwytywanie podwyrażenia i zmieniłem część wynikową [1] na wynikową [2], aby pokrywała się z tą zmianą; usunięto także niepotrzebne skrawki wokół wyniku [2].

Aby naprawdę usunąć jak najwięcej wzdęć, należy w ogóle nie używać funkcji otoki:

try {
    var myCookie = document.cookie.match('(^|;) *myCookie=([^;]*)')[2]
} catch (_) {
    // handle missing cookie
}

O ile znasz RegEx, kod ten jest dość czysty i łatwy do odczytania.

(edytuj: najpierw opublikowałem niewłaściwą wersję .. i niefunkcjonalną. Zaktualizowano do bieżącej, która używa funkcji unparam, która jest bardzo podobna do drugiego przykładu).

Fajny pomysł w pierwszym przykładzie cwolves. Zbudowałem oba w celu uzyskania dość zwartej funkcji odczytu / zapisu plików cookie, która działa w wielu subdomenach. Pomyślałem, że podzielę się, na wypadek, gdyby ktoś szukał tego wątku.

(function(s){
  s.strToObj = function (x,splitter) {
    for ( var y = {},p,a = x.split (splitter),L = a.length;L;) {
      p = a[ --L].split ('=');
      y[p[0]] = p[1]
    }
    return y
  };
  s.rwCookie = function (n,v,e) {
    var d=document,
        c= s.cookies||s.strToObj(d.cookie,'; '),
        h=location.hostname,
        domain;
    if(v){
      domain = h.slice(h.lastIndexOf('.',(h.lastIndexOf('.')-1))+1);
      d.cookie = n + '=' + (c[n]=v) + (e ? '; expires=' + e : '') + '; domain=.' + domain + '; path=/'
    }
    return c[n]||c
  };
})(some_global_namespace)

• Jeśli przekażesz rwCookie nic, wszystkie pliki cookie zostaną zapisane w pamięci plików cookie
• Przekazał rwCookie nazwę pliku cookie, pobiera wartość tego pliku cookie z pamięci
• Przeszedł wartość pliku cookie, zapisuje plik cookie i umieszcza wartość w pamięci
• Data wygaśnięcia jest domyślnie ustawiona na sesję, chyba że ją podasz

Używając odpowiedzi cwolves, ale nie używając zamknięcia ani wcześniej obliczonego skrótu:

// Golfed it a bit, too...
function readCookie(n){
  var c = document.cookie.split('; '),
      i = c.length,
      C;

  for(; i>0; i--){
     C = c[i].split('=');
     if(C[0] == n) return C[1];
  }
}

... i minimalizowanie ...

function readCookie(n){var c=document.cookie.split('; '),i=c.length,C;for(;i>0;i--){C=c[i].split('=');if(C[0]==n)return C[1];}}

... równa się 127 bajtów.

Oto najprostsze rozwiązanie z wykorzystaniem funkcji ciągu javascript.

document.cookie.substring(document.cookie.indexOf("COOKIE_NAME"), 
                          document.cookie.indexOf(";", 
                          document.cookie.indexOf("COOKIE_NAME"))).
  substr(COOKIE_NAME.length);

Poniższa funkcja pozwoli rozróżnić puste ciągi znaków i niezdefiniowane pliki cookie. Niezdefiniowane pliki cookie zostaną poprawnie zwrócone, undefineda nie pusty ciąg, w przeciwieństwie do niektórych innych odpowiedzi tutaj. Ale to nie będzie działać na IE7 i niższych, ponieważ nie pozwalają one na dostęp tablicy do indeksów ciągów.

    function getCookie(name) {
      return (document.cookie.match('(?:^|;) *'+name+'=([^;]*)')||"")[1];
    }