Uzyskaj plik cookie według nazwy

Mam getter, aby uzyskać wartość z pliku cookie.

Teraz mam 2 ciasteczka według nazwy shares=i nazwyobligations= .

Chcę, aby ten getter tylko pobierał wartości z pliku cookie zobowiązań.

Jak mam to zrobic? Więc fordzieli dane na osobne wartości i umieszcza je w tablicy.

 function getCookie1() {
    // What do I have to add here to look only in the "obligations=" cookie? 
    // Because now it searches all the cookies.

    var elements = document.cookie.split('=');
    var obligations= elements[1].split('%');
    for (var i = 0; i < obligations.length - 1; i++) {
        var tmp = obligations[i].split('$');
        addProduct1(tmp[0], tmp[1], tmp[2], tmp[3]);
    }
 }

Jednym z podejść, które pozwala uniknąć iteracji po tablicy, byłoby:

function getCookie(name) {
  const value = `; ${document.cookie}`;
  const parts = value.split(`; ${name}=`);
  if (parts.length === 2) return parts.pop().split(';').shift();
}

Przewodnik

Podział łańcucha na token spowoduje utworzenie tablicy z jednym łańcuchem (o tej samej wartości), na wypadek, gdyby token nie istnieje w łańcuchu, lub tablicy z dwoma łańcuchami, na wypadek gdyby token został znaleziony w łańcuchu.

Pierwszy (lewy) element to ciąg tego, co było przed tokenem, a drugi (prawy) to ciąg tego, co było po tokenie.

(UWAGA: w przypadku, gdy ciąg zaczyna się od tokena, pierwszym elementem jest pusty ciąg)

Biorąc pod uwagę, że pliki cookie są przechowywane w następujący sposób:

"{name}={value}; {name}={value}; ..."

aby pobrać konkretną wartość pliku cookie, wystarczy pobrać ciąg znaków następujący po „; {name} =” i przed następnym „;”. Przed jakimkolwiek przetwarzaniem poprzedzamy ciąg plików cookie znakiem „;”, tak aby każda nazwa pliku cookie, w tym pierwsza, była ujęta z „;” i „=”:

"; {name}={value}; {name}={value}; ..."

Teraz możemy najpierw podzielić przez „; {name} =", a jeśli token zostanie znaleziony w ciągu ciasteczka (tj. Mamy dwa elementy), to skończymy z drugim elementem będącym ciągiem rozpoczynającym się od naszej wartości ciasteczka. Następnie wyciągamy to z tablicy (np. Pop) i powtarzamy ten sam proces, ale teraz za pomocą „;” jako token, ale tym razem wyciągając lewy ciąg (tj. shift), aby uzyskać rzeczywistą wartość tokena.

Wolę używać pojedynczego dopasowania wyrażenia regularnego w pliku cookie:

window.getCookie = function(name) {
  var match = document.cookie.match(new RegExp('(^| )' + name + '=([^;]+)'));
  if (match) return match[2];
}

LUB Możemy również użyć jako funkcji, sprawdź poniższy kod.

function check_cookie_name(name) 
    {
      var match = document.cookie.match(new RegExp('(^| )' + name + '=([^;]+)'));
      if (match) {
        console.log(match[2]);
      }
      else{
           console.log('--something went wrong---');
      }
   }

Poprawione dzięki Scott Jungwirth w komentarzach.

użyj skryptu pobierania pliku cookie:

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;
}

nazwij to:

var value = readCookie('obligations');

ukradłem powyższy kod ze strony plików cookie quirksmode. powinieneś to przeczytać .

Jeśli używasz jQuery, polecam użyć tej wtyczki:

https://github.com/carhartl/jquery-cookie
https://github.com/carhartl/jquery-cookie/blob/master/jquery.cookie.js

<script type="text/javascript"
 src="//cdnjs.cloudflare.com/ajax/libs/jquery-cookie/1.4.1/jquery.cookie.min.js">

Abyś mógł odczytać taki plik cookie:

var value = $.cookie("obligations");

Możesz także napisać ciasteczko:

$.cookie('obligations', 'new_value');
$.cookie('obligations', 'new_value', { expires: 14, path: '/' });

Usuń ciasteczko:

$.removeCookie('obligations');

Metody w niektórych innych odpowiedziach, które wykorzystują wyrażenie regularne, nie obejmują wszystkich przypadków, w szczególności:

1. Kiedy plik cookie jest ostatnim plikiem cookie. W takim przypadku po wartości pliku cookie nie będzie średnika.
2. Gdy inna nazwa pliku cookie kończy się wraz z wyszukiwaniem nazwy. Na przykład szukasz pliku cookie o nazwie „jeden” i istnieje plik cookie o nazwie „gotowe”.
3. Gdy nazwa pliku cookie zawiera znaki, które nie są interpretowane jako same w wyrażeniu regularnym, chyba że są poprzedzone odwrotnym ukośnikiem.

Następująca metoda obsługuje te przypadki:

function getCookie(name) {
    function escape(s) { return s.replace(/([.*+?\^${}()|\[\]\/\\])/g, '\\$1'); };
    var match = document.cookie.match(RegExp('(?:^|;\\s*)' + escape(name) + '=([^;]*)'));
    return match ? match[1] : null;
}

Zwróci się, nulljeśli plik cookie nie zostanie znaleziony. Zwróci pusty ciąg, jeśli wartość pliku cookie jest pusta.

Uwagi:

1. Ta funkcja zakłada, że ​​w nazwach plików cookie rozróżniana jest wielkość liter .
2. document.cookie- Gdy pojawia się po prawej stronie zadania, oznacza ciąg zawierający listę plików cookie oddzielonych średnikami, które z kolei są name=valueparami. Wydaje się, że po każdym średniku jest spacja.
3. String.prototype.match()- Zwraca, nullgdy nie znaleziono dopasowania. Zwraca tablicę po znalezieniu dopasowania, a element w indeksie [1]jest wartością pierwszej pasującej grupy.

Uwagi na temat wyrażeń regularnych:

1. (?:xxxx) - tworzy niepasującą grupę.
2. ^ - dopasowuje początek łańcucha.
3. | - oddziela alternatywne wzorce dla grupy.
4. ;\\s* - pasuje do jednego średnika, po którym następuje zero lub więcej białych znaków.
5. = - pasuje do jednego znaku równości.
6. (xxxx) - tworzy pasującą grupę.
7. [^;]*- dopasowuje zero lub więcej znaków innych niż średnik. Oznacza to, że dopasuje znaki do średnika lub do końca łańcucha, ale nie w tym.

4 lata później wersja ES6 jest prostsza.

function getCookie(name) {
  let cookie = {};
  document.cookie.split(';').forEach(function(el) {
    let [k,v] = el.split('=');
    cookie[k.trim()] = v;
  })
  return cookie[name];
}

Stworzyłem również istotę, aby używać go jako Cookieobiektu. np. Cookie.set(name,value)iCookie.get(name)

Spowoduje to odczytanie wszystkich plików cookie zamiast skanowania. Jest odpowiedni dla niewielkiej liczby plików cookie.

Zmodyfikowałem funkcję podaną tutaj przez Jonathana, używając wyrażenia regularnego można uzyskać wartość cookie o nazwie takiej jak ta:

function getCookie(name){
    var pattern = RegExp(name + "=.[^;]*")
    var matched = document.cookie.match(pattern)
    if(matched){
        var cookie = matched[0].split('=')
        return cookie[1]
    }
    return false
}

Jeśli zwraca pusty ciąg znaków, oznacza to, że plik cookie istnieje, ale nie ma wartości, jeśli zwróci wartość false, wówczas plik cookie nie istnieje. Mam nadzieję, że to pomoże.

Oto jeden linijka, aby uzyskać ciasteczko o określonej nazwie bez potrzeby jakiejkolwiek zewnętrznej biblioteki lib:

var cookie = ("; "+document.cookie).split("; YOUR_COOKIE_NAME=").pop().split(";").shift();

Ta odpowiedź oparta jest na genialnym rozwiązaniu Kirlich . Jedynym kompromisem tego rozwiązania jest to, że otrzymasz pusty ciąg, gdy plik cookie nie istnieje. W większości przypadków nie powinno to jednak łamać porozumienia.

Wiem, że to stare pytanie, ale natknąłem się również na ten problem. Dla przypomnienia, na stronie Mozilli jest trochę API .

Yoy może uzyskać dowolny plik cookie według nazwy, używając tylko JS. Kod jest również czystszy IMHO (z wyjątkiem długiej linii, którą z pewnością można łatwo naprawić).

function getCookie(sKey) {
    if (!sKey) { return null; }
    return decodeURIComponent(document.cookie.replace(new RegExp("(?:(?:^|.*;)\\s*" + encodeURIComponent(sKey).replace(/[\-\.\+\*]/g, "\\$&") + "\\s*\\=\\s*([^;]*).*$)|^.*$"), "$1")) || null;
}

Jak stwierdzono w komentarzach, należy pamiętać, że ta metoda zakłada, że ​​klucz i wartość zostały zakodowane przy użyciu encodeURIComponent (). Usuń dekodowanie i kodowanieURIComponent (), jeśli klucz i wartość pliku cookie nie zostały zakodowane.

Możesz użyć biblioteki plików cookie js, aby uzyskać i ustawić pliki cookie JavaScript.

Dołącz do swojego HTML:

<script src="https://cdn.jsdelivr.net/npm/js-cookie@2/src/js.cookie.min.js"></script>

Aby utworzyć plik cookie:

Cookies.set('name', 'value');

Aby przeczytać plik cookie:

Cookies.get('name'); // => 'value'

Oto dość krótka wersja

 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.

Posługiwać się object.defineProperty

Dzięki temu możesz łatwo uzyskać dostęp do plików cookie

Object.defineProperty(window, "Cookies", {
    get: function() {
        return document.cookie.split(';').reduce(function(cookies, cookie) {
            cookies[cookie.split("=")[0]] = unescape(cookie.split("=")[1]);
            return cookies
        }, {});
    }
});

Od teraz możesz po prostu:

alert( Cookies.obligations );

To również automatycznie się zaktualizuje, więc jeśli zmienisz plik cookie, również Cookiessię zmieni.

Kirlich dał dobre rozwiązanie. Jednak zawiedzie, gdy istnieją dwie wartości plików cookie o podobnych nazwach, oto prosta poprawka dla tej sytuacji:

function getCookie(name) {
  var value = "; " + document.cookie;
  var parts = value.split("; " + name + "=");
  if (parts.length >= 2) return parts.pop().split(";").shift();
}

zawsze działa dobrze:

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

function setCookie(variable, value, expires_seconds) {
    var d = new Date();
    d = new Date(d.getTime() + 1000 * expires_seconds);
    document.cookie = variable + '=' + value + '; expires=' + d.toGMTString() + ';';
}

Brak wymagań dla jQuery lub czegokolwiek. Czysty stary dobry JavaScript.

function getCookie(name) {
    var pair = document.cookie.split('; ').find(x => x.startsWith(name+'='));
    if (pair)
       return pair.split('=')[1]
}

Prosta funkcja Pobierz plik cookie z nazwą pliku cookie:

function getCookie(cn) {
    var name = cn+"=";
    var allCookie = decodeURIComponent(document.cookie).split(';');
    var cval = [];
    for(var i=0; i < allCookie.length; i++) {
        if (allCookie[i].trim().indexOf(name) == 0) {
            cval = allCookie[i].trim().split("=");
        }   
    }
    return (cval.length > 0) ? cval[1] : "";
}

Najwyraźniej MDN nigdy nie słyszał o klasie znaków wyrażenia regularnego na granicy słowa \b, która pasuje do znaków ciągłych, \w+które są ograniczone po obu stronach \W+:

getCookie = function(name) {
    var r = document.cookie.match("\\b" + name + "=([^;]*)\\b");
    return r ? r[1] : null;
};

var obligations = getCookie('obligations');

Wydaje mi się, że możesz podzielić pary klucz-wartość ciasteczka na tablicę i na tym oprzeć swoje wyszukiwanie:

var obligations = getCookieData("obligations");

Który działa następująco:

function getCookieData( name ) {
    var pairs = document.cookie.split("; "),
        count = pairs.length, parts; 
    while ( count-- ) {
        parts = pairs[count].split("=");
        if ( parts[0] === name )
            return parts[1];
    }
    return false;
}

Fiddle: http://jsfiddle.net/qFmPc/

A może nawet następujące:

function getCookieData( name ) {
    var patrn = new RegExp( "^" + name + "=(.*?);" ),
        patr2 = new RegExp( " " + name + "=(.*?);" );
    if ( match = (document.cookie.match(patrn) || document.cookie.match(patr2)) )
        return match[1];
    return false;
}

W moich projektach korzystam z następującej funkcji, aby uzyskać dostęp do plików cookie według nazwy

function getCookie(cookie) {
    return document.cookie.split(';').reduce(function(prev, c) {
        var arr = c.split('=');
        return (arr[0].trim() === cookie) ? arr[1] : prev;
    }, undefined);
}

Jeśli chcesz tylko sprawdzić, czy istnieją jakieś pliki cookie, wykonaj następujące czynności:

document.cookie.split('logged=true').length == 2

jeśli plik cookie zalogowany = prawda istnieje, otrzymasz 2, jeśli nie 1.

logged = true - zmień to na cookie name = wartość lub po prostu nazwę

Tutaj są już fajne odpowiedzi na pytanie, jak uzyskać plik cookie, ale oto moje własne rozwiązanie:

function getcookie(cookiename){
var cookiestring  = document.cookie;
var cookiearray = cookiestring.split(';');
for(var i =0 ; i < cookiearray.length ; ++i){ 
    if(cookiearray[i].trim().match('^'+cookiename+'=')){ 
        return cookiearray[i].replace(`${cookiename}=`,'').trim();
    }
} return null;
}

użycie: `

     getcookie('session_id');
   // gets cookie with name session_id

ustawione przez javascript

document.cookie = 'cookiename=tesing';

zdobądź jquery dzięki wtyczce jquery-cookie

var value = $.cookie("cookiename");

alert(value);

odniesienie: https://developer.mozilla.org/en-US/docs/Web/API/Document/cookie

document.cookie = "test1=Hello";
document.cookie = "test2=World";

var cookieValue = document.cookie.replace(/(?:(?:^|.*;\s*)test2\s*\=\s*([^;]*).*$)|^.*$/, "$1");

  alert(cookieValue);

Moje rozwiązanie jest następujące:

function getCookieValue(cookieName) {
    var ca = document.cookie.split('; ');
    return _.find(ca, function (cookie) {
        return cookie.indexOf(cookieName) === 0;
    });
}

Ta funkcja korzysta z funkcji Underscorejs _.find. Zwraca niezdefiniowany, jeśli nazwa pliku cookie nie istnieje

Zrobiłem to w ten sposób. dzięki czemu mogę uzyskać dostęp do obiektu w celu oddzielenia wartości. Dzięki temu możesz przekazać plik cookie rodzicowi, a następnie możesz uzyskać dostęp do swoich wartości za pomocą klawiszy takich jak

var cookies=getCookieVal(mycookie);
alert(cookies.mykey);
function getCookieVal(parent) {
            var cookievalue = $.cookie(parent).split('&');
            var obj = {};
            $.each(cookievalue, function (i, v) {
                var key = v.substr(0, v.indexOf("="));
                var val = v.substr(v.indexOf("=") + 1, v.length);

                obj[key] = val;

            });
            return obj;
        }  

Funkcjonalne podejście do wyszukiwania istniejących plików cookie. Zwraca tablicę, więc obsługuje wiele wystąpień o tej samej nazwie. Nie obsługuje częściowego dopasowania klucza, ale banalne jest zastąpienie === w filtrze wyrażeniem regularnym.

function getCookie(needle) {
    return document.cookie.split(';').map(function(cookiestring) {
        cs = cookiestring.trim().split('=');

        if(cs.length === 2) {
            return {'name' : cs[0], 'value' : cs[1]};
        } else {
            return {'name' : '', 'value' : ''};
        }
    })
    .filter(function(cookieObject) { 
        return (cookieObject.name === needle);
    });
}

Wystarczy użyć następującej funkcji (czysty kod javascript)

const getCookie = (name) => {
 const cookies = Object.assign({}, ...document.cookie.split('; ').map(cookie => {
    const name = cookie.split('=')[0];
    const value = cookie.split('=')[1];

    return {[name]: value};
  }));

  return cookies[name];
};

Pobierz plik cookie według nazwy, po prostu przekaż nazwę pliku cookie do funkcji poniżej

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

Poniższa funkcja zwróci key-valueparę wymaganych plików cookie, gdzie keyjest nazwa pliku cookie i valuebędzie to wartość pliku cookie.

/**
 * Returns cookie key-value pair
 */
var getCookieByName = function(name) {
    var result = ['-1','-1'];
    if(name) {
        var cookieList = document.cookie.split(';');
        result = $.grep(cookieList,function(cookie) { 
            cookie = cookie.split('=')[0];
            return cookie == name;
        });
    }
    return result;
};

Przykład plików cookie: przykład JS:

document.cookies = {
   create : function(key, value, time){
     if (time) {
         var date = new Date();
         date.setTime(date.getTime()+(time*24*60*60*1000));
         var expires = "; expires="+date.toGMTString();
     }
     else var expires = "";
     document.cookie = key+"="+value+expires+"; path=/";
   },
   erase : function(key){
     this.create(key,"",-1);
   },
   read : function(key){
     var keyX = key + "=";
     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(keyX) == 0) return   c.substring(keyX.length,c.length);
     }
     return null;
   }
}

Przechowuj tablice i obiekty za pomocą json lub xml