Wie überprüfe ich, ob ein Cookie vorhanden ist?

Wie kann ich überprüfen, ob ein Cookie vorhanden ist?

Bedingungen:

Cookie existiert wenn

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

Cookie existiert nicht wenn

cookie=;
//or
<blank>

Sie können die Funktion getCookie mit dem Namen des gewünschten Cookies aufrufen und dann überprüfen, ob es = null ist.

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

Ich habe eine alternative Nicht-jQuery-Version erstellt:

document.cookie.match(/^(.*;)?\s*MyCookie\s*=\s*[^;]+(.*)?$/)

Es werden nur die Existenz von Cookies getestet. Eine kompliziertere Version kann auch den Cookie-Wert zurückgeben:

value_or_null = (document.cookie.match(/^(?:.*;)?\s*MyCookie\s*=\s*([^;]+)(?:.*)?$/)||[,null])[1]

Geben Sie Ihren Cookie-Namen anstelle von ein MyCookie.

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

Es wird zurückgegeben, -1wenn dieses Cookie nicht vorhanden ist.

ps Der einzige Nachteil ist (wie in den Kommentaren erwähnt), dass es fehlerhaft ist, wenn ein Cookie mit einem solchen Namen gesetzt wird: any_prefix_cookie_name

( Quelle )

BEACHTUNG! Die gewählte Antwort enthält einen Fehler (Jacs Antwort).

Wenn Sie mehr als ein Cookie haben (sehr wahrscheinlich ..) und das Cookie, das Sie abrufen, das erste in der Liste ist, wird die Variable "end" nicht festgelegt und daher wird die gesamte Zeichenfolge nach dem "cookieName" zurückgegeben = "innerhalb der document.cookie-Zeichenfolge!

Hier ist eine überarbeitete Version dieser Funktion:

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, ''); 
}

Wenn Sie jQuery verwenden, können Sie das Plugin jquery.cookie verwenden .

Das Abrufen des Werts für ein bestimmtes Cookie erfolgt wie folgt:

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

regexObject. test (String) ist schneller als string. Spiel (RegExp).

Die MDN-Site beschreibt das Format für document.cookie und verfügt über einen Beispiel-Regex zum Abrufen eines Cookies ( document.cookie.replace(/(?:(?:^|.*;\s*)test2\s*\=\s*([^;]*).*$)|^.*$/, "$1");). Basierend darauf würde ich mich für Folgendes entscheiden:

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

Die Frage scheint nach einer Lösung zu fragen, die beim Setzen des Cookies false zurückgibt, aber leer ist. In diesem Fall:

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

Tests

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

Dies ist eine alte Frage, aber hier ist der Ansatz, den ich verwende ...

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

Dies wird nullentweder zurückgegeben, wenn das Cookie nicht vorhanden ist oder wenn es den angeforderten Namen nicht enthält.
Andernfalls wird der Wert (des angeforderten Namens) zurückgegeben.

Ein Cookie sollte niemals ohne Wert existieren - denn worum geht es fairerweise? 😄
Wenn es nicht mehr benötigt wird, ist es am besten, alles zusammen loszuwerden.

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

Versuchte @jac Funktion, habe einige Probleme, hier ist, wie ich seine Funktion bearbeitet habe.

Anstelle der Cookie-Variablen würden Sie einfach document.cookie.split verwenden ...

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

Für alle, die Node verwenden, habe ich eine schöne und einfache Lösung mit ES6-Importen und dem gefunden cookie Modul gefunden!

Installieren Sie zuerst das Cookie-Modul (und speichern Sie es als Abhängigkeit):

npm install --save cookie

Dann importieren und verwenden:

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

Verwenden von Javascript:

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

Verwenden Sie stattdessen diese Methode:

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

Hier gibt es mehrere gute Antworten. Ich ziehe es jedoch [1] nicht einen regulären Ausdruck, und [2] unter Verwendung von Logik , die einfach zu lesen, und [3] eine kurze Funktion zu haben , dass [4] ist nicht wahr zurück , wenn der Name eine Teil eines anderes Cookie ist Name . Schließlich [5] können wir nicht für jede Schleife ein verwenden, da eine Rückgabe es nicht unterbricht.

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

Um ein Objekt von Cookies zu erhalten, rufen Sie einfach an getCookie()

Gehen Sie folgendermaßen vor, um zu überprüfen, ob ein Cookie vorhanden ist:

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

Oder verwenden Sie einfach einen ternären Operator.

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

Hinweis: Der Autor wollte, dass die Funktion false zurückgibt, wenn das Cookie leer ist, dh cookie=;dies wird mit der && !!valueBedingung erreicht. Entfernen Sie es, wenn Sie der Meinung sind, dass ein leeres Cookie noch vorhanden ist.