Jak sprawdzić, czy plik cookie istnieje?

Jaki jest dobry sposób sprawdzenia, czy plik cookie istnieje?

Warunki:

Plik cookie istnieje, jeśli

cookie1=;cookie1=345534;
//or
cookie1=345534;cookie1=;
//or
cookie1=345534;

Plik cookie nie istnieje, jeśli

cookie=;
//or
<blank>

Możesz wywołać funkcję getCookie z nazwą pliku cookie, który chcesz, a następnie sprawdzić, czy jest = null.

function getCookie(name) {
    var dc = document.cookie;
    var prefix = name + "=";
    var begin = dc.indexOf("; " + prefix);
    if (begin == -1) {
        begin = dc.indexOf(prefix);
        if (begin != 0) return null;
    }
    else
    {
        begin += 2;
        var end = document.cookie.indexOf(";", begin);
        if (end == -1) {
        end = dc.length;
        }
    }
    // because unescape has been deprecated, replaced with decodeURI
    //return unescape(dc.substring(begin + prefix.length, end));
    return decodeURI(dc.substring(begin + prefix.length, end));
} 

function doSomething() {
    var myCookie = getCookie("MyCookie");

    if (myCookie == null) {
        // do cookie doesn't exist stuff;
    }
    else {
        // do cookie exists stuff
    }
}

document.cookie.indexOf('cookie_name=');

Zwróci, -1jeśli ten plik cookie nie istnieje.

ps Jedyną wadą jest to (jak wspomniałem w komentarzach), że pomyli się, jeśli istnieje plik cookie o takiej nazwie: any_prefix_cookie_name

( Źródło )

UWAGA! wybrana odpowiedź zawiera błąd (odpowiedź Jaca).

jeśli masz więcej niż jeden plik cookie (bardzo prawdopodobne ...) i plik cookie, który pobierasz, jest pierwszy na liście, nie ustawia zmiennej „end” i dlatego zwróci cały ciąg znaków następujący po „cookieName” = "w ciągu document.cookie!

tutaj jest poprawiona wersja tej funkcji:

function getCookie( name ) {
    var dc,
        prefix,
        begin,
        end;

    dc = document.cookie;
    prefix = name + "=";
    begin = dc.indexOf("; " + prefix);
    end = dc.length; // default to end of the string

    // found, and not in first position
    if (begin !== -1) {
        // exclude the "; "
        begin += 2;
    } else {
        //see if cookie is in first position
        begin = dc.indexOf(prefix);
        // not found at all or found as a portion of another cookie name
        if (begin === -1 || begin !== 0 ) return null;
    } 

    // if we find a ";" somewhere after the prefix position then "end" is that position,
    // otherwise it defaults to the end of the string
    if (dc.indexOf(";", begin) !== -1) {
        end = dc.indexOf(";", begin);
    }

    return decodeURI(dc.substring(begin + prefix.length, end) ).replace(/\"/g, ''); 
}

Jeśli używasz jQuery, możesz użyć wtyczki jquery.cookie .

Pobieranie wartości dla konkretnego pliku cookie odbywa się w następujący sposób:

$.cookie('MyCookie'); // Returns the cookie value

regexObject. test (String) jest szybszy niż string. dopasowanie (RegExp).

Witryna MDN opisuje format pliku document.cookie i zawiera przykładowe wyrażenie regularne do pobierania pliku cookie ( document.cookie.replace(/(?:(?:^|.*;\s*)test2\s*\=\s*([^;]*).*$)|^.*$/, "$1");). Na tej podstawie wybrałbym to:

/^(.*;)?\s*cookie1\s*=/.test(document.cookie);

Pytanie wydaje się prosić o rozwiązanie, które zwraca fałsz, gdy plik cookie jest ustawiony, ale pusty. W tym wypadku:

/^(.*;)?\s*cookie1\s*=\s*[^;]/.test(document.cookie);

Testy

function cookieExists(input) {return /^(.*;)?\s*cookie1\s*=/.test(input);}
function cookieExistsAndNotBlank(input) {return /^(.*;)?\s*cookie1\s*=\s*[^;]/.test(input);}
var testCases = ['cookie1=;cookie1=345534;', 'cookie1=345534;cookie1=;', 'cookie1=345534;', ' cookie1 = 345534; ', 'cookie1=;', 'cookie123=345534;', 'cookie=345534;', ''];
console.table(testCases.map(function(s){return {'Test String': s, 'cookieExists': cookieExists(s), 'cookieExistsAndNotBlank': cookieExistsAndNotBlank(s)}}));

To stare pytanie, ale oto podejście, które stosuję ...

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

Zwraca nullto, gdy plik cookie nie istnieje lub nie zawiera żądanej nazwy.
W przeciwnym razie zwracana jest wartość (żądanej nazwy).

Ciasteczko nie powinno nigdy istnieć bez wartości - bo, szczerze mówiąc, jaki to ma sens? 😄
Jeśli nie jest już potrzebny, najlepiej pozbyć się go razem.

function deleteCookie(name) {
    document.cookie = name +"=; Path=/; Expires=Thu, 01 Jan 1970 00:00:01 GMT;";
}

function getCookie(name) {

    var dc = document.cookie;
    var prefix = name + "=";
    var begin = dc.indexOf("; " + prefix);
    if (begin == -1) {
        begin = dc.indexOf(prefix);
        if (begin != 0) return null;
        else{
            var oneCookie = dc.indexOf(';', begin);
            if(oneCookie == -1){
                var end = dc.length;
            }else{
                var end = oneCookie;
            }
            return dc.substring(begin, end).replace(prefix,'');
        } 

    }
    else
    {
        begin += 2;
        var end = document.cookie.indexOf(";", begin);
        if (end == -1) {
            end = dc.length;
        }
        var fixed = dc.substring(begin, end).replace(prefix,'');
    }
    // return decodeURI(dc.substring(begin + prefix.length, end));
    return fixed;
} 

Wypróbowałem funkcję @jac, miałem problemy, oto jak edytowałem jego funkcję.

zamiast zmiennej cookie użyłbyś po prostu document.cookie.split ...

var cookie = 'cookie1=s; cookie1=; cookie2=test';
var cookies = cookie.split('; ');
cookies.forEach(function(c){
  if(c.match(/cookie1=.+/))
   console.log(true);
});

Dla każdego, kto używa Node, znalazłem ładne i proste rozwiązanie z importem ES6 i cookiemodułem!

Najpierw zainstaluj moduł cookie (i zapisz jako zależność):

npm install --save cookie

Następnie zaimportuj i użyj:

import cookie from 'cookie';
let parsed = cookie.parse(document.cookie);
if('cookie1' in parsed) 
    console.log(parsed.cookie1);

Korzystanie z JavaScript:

 function getCookie(name) {
      let matches = document.cookie.match(new RegExp(
        "(?:^|; )" + name.replace(/([\.$?*|{}\(\)\[\]\\\/\+^])/g, '\\$1') + "=([^;]*)"
      ));
      return matches ? decodeURIComponent(matches[1]) : undefined;
    }

zamiast tego użyj tej metody:

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

function doSomething() {
    var myCookie = getCookie("MyCookie");

    if (myCookie == null) {
        // do cookie doesn't exist stuff;
    }
    else {
        // do cookie exists stuff
    }
}

/// ************************************************ cookie_exists

/// global entry point, export to global namespace

/// <synopsis>
///   cookie_exists ( name );
///
/// <summary>
///   determines if a cookie with name exists
///
/// <param name="name">
///   string containing the name of the cookie to test for 
//    existence
///
/// <returns>
///   true, if the cookie exists; otherwise, false
///
/// <example>
///   if ( cookie_exists ( name ) );
///     {
///     // do something with the existing cookie
///     }
///   else
///     {
///     // cookies does not exist, do something else 
///     }

function cookie_exists ( name )
  {
  var exists = false;

  if ( document.cookie )
    {
    if ( document.cookie.length > 0 )
      {
                                    // trim name
      if ( ( name = name.replace ( /^\s*/, "" ).length > 0 ) )
        {
        var cookies = document.cookie.split ( ";" );
        var name_with_equal = name + "=";

        for ( var i = 0; ( i < cookies.length ); i++ )
          {
                                    // trim cookie
          var cookie = cookies [ i ].replace ( /^\s*/, "" );

          if ( cookie.indexOf ( name_with_equal ) === 0 )
            {
            exists = true;
            break;
            }
          }
        }
      }
    }

  return ( exists );

  } // cookie_exists

Jest tutaj kilka dobrych odpowiedzi. Ja jednak wolę [1] nie za pomocą wyrażenia regularnego, a [2] za pomocą logiki, która jest prosta do odczytania, a [3] , aby mieć krótkie funkcję [4] ma nie zwróci true, jeśli nazwa jest podciąg z innego pliku cookie Nazwa . Na koniec [5] nie możemy użyć for każdej pętli, ponieważ powrót jej nie przerywa.

function cookieExists(name) {
  var cks = document.cookie.split(';');
  for(i = 0; i < cks.length; i++)
    if (cks[i].split('=')[0].trim() == name) return true;
}

function getcookie(name = '') {
    let cookies = document.cookie;
    let cookiestore = {};
    
    cookies = cookies.split(";");
    
    if (cookies[0] == "" && cookies[0][0] == undefined) {
        return undefined;
    }
    
    cookies.forEach(function(cookie) {
        cookie = cookie.split(/=(.+)/);
        if (cookie[0].substr(0, 1) == ' ') {
            cookie[0] = cookie[0].substr(1);
        }
        cookiestore[cookie[0]] = cookie[1];
    });
    
    return (name !== '' ? cookiestore[name] : cookiestore);
}

Aby otrzymać obiekt ciasteczek wystarczy zadzwonić getCookie()

Aby sprawdzić, czy plik cookie istnieje, zrób to w następujący sposób:

if (!getcookie('myCookie')) {
    console.log('myCookie does not exist.');
} else {
    console.log('myCookie value is ' + getcookie('myCookie'));
}

Lub po prostu użyj operatora trójskładnikowego.

function hasCookie(cookieName){
return document.cookie.split(';')
.map(entry => entry.split('='))
.some(([name, value]) => (name.trim() === cookieName) && !!value);
}

Uwaga: autor chciał, aby funkcja zwracała fałsz, jeśli plik cookie jest pusty, czyli cookie=;jest to osiągane z && !!valuewarunkiem. Usuń go, jeśli uważasz, że pusty plik cookie nadal istnieje ...

Zauważ, że jeśli plik cookie jest bezpieczny, nie możesz sprawdzić po stronie klienta, czy istnieje, używając document.cookie(którego używają wszystkie odpowiedzi). Taki plik cookie można sprawdzić tylko po stronie serwera.