javascript - how - js-cookie npm

Obtener cookie por nombre

Question

Tengo un captador para obtener el valor de una cookie.

Ahora tengo 2 cookies por el nombre shares= y por el nombre obligations= .

Quiero hacer este captador solo para obtener los valores de la cookie de obligaciones.

¿Cómo hago esto? Así que ''for'' divide los datos en valores separados y los coloca en una matriz.

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

Answer 1

Utilice object.defineProperty

Con esto, puedes acceder fácilmente a las cookies.

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

De ahora en adelante solo puedes hacer:

alert( Cookies.obligations );

Esto también se actualizará automáticamente, por lo que si cambia una cookie, las Cookies también cambiarán.

Answer 2

4 años después, ES6 es una versión más sencilla.

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

También he creado un gist para usarlo como un objeto de Cookie . por ejemplo, Cookie.set(name,value) y Cookie.get(name)

Esto lee todas las cookies en lugar de escanear. Está bien para una pequeña cantidad de galletas.

Answer 3

Al parecer, MDN nunca ha oído hablar de la clase de caracteres de expresión regular de límite de palabra /b , que coincide con /w+ contiguo que está delimitado por ambos lados con /W+ :

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

var obligations = getCookie(''obligations'');

Answer 4

Aquí hay una versión bastante corta.

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

Tenga en cuenta que hice uso de las cadenas de plantillas de ES6 para componer la expresión regular.

Answer 5

Ejemplo de cookies: example 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;
   }
}

Almacena matrices y objetos con json o xml

Answer 6

En mis proyectos utilizo la siguiente función para acceder a las cookies por nombre

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

Answer 7

Función simple para obtener cookie con nombre de 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] : "";
}

Answer 8

Haría algo como esto:

function getCookie(cookie){
  return cookie
    .trim()
    .split('';'')
    .map(function(line){return line.split('','');})
    .reduce(function(props,line) {
      var name = line[0].slice(0,line[0].search(''=''));
      var value = line[0].slice(line[0].search(''=''));
      props[name] = value;
      return props;
    },{})
}

Esto devolverá su cookie como un objeto.

Y luego puedes llamarlo así:

getCookie(document.cookie)[''shares'']

Answer 9

He modificado la función que Jonathan proporcionó aquí, mediante el uso de expresiones regulares puede obtener un valor de cookie por su nombre como este:

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

Si devuelve una cadena vacía, significa que la cookie existe pero no tiene valor, si devuelve falso, entonces la cookie no existe. Espero que esto ayude.

Answer 10

La siguiente función devolverá un par key-value de la cookie requerida, donde key es el nombre de la cookie y el value será el valor de la 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;
};

Answer 11

Lo he hecho así. de modo que obtenga un objeto al que acceder para separar los valores. Con esto, u puede pasar la cookie a los padres y luego puede acceder a sus valores mediante las teclas como

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

Answer 12

Los métodos en algunas de las otras respuestas que usan una expresión regular no cubren todos los casos, en particular:

1. Cuando la cookie es la última cookie. En este caso, no habrá un punto y coma después del valor de la cookie.
2. Cuando otro nombre de cookie termina con el nombre buscado. Por ejemplo, está buscando la cookie llamada "one", y hay una cookie llamada "done".
3. Cuando el nombre de la cookie incluye caracteres que no se interpretan como ellos mismos cuando se usan en una expresión regular a menos que estén precedidos por una barra invertida.

El siguiente método maneja estos casos:

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

Esto devolverá null si no se encuentra la cookie. Devolverá una cadena vacía si el valor de la cookie está vacío.

Notas:

1. Esta función supone que los nombres de las cookies distinguen entre mayúsculas y minúsculas .
2. document.cookie : cuando aparece en el lado derecho de una asignación, representa una cadena que contiene una lista de cookies separadas por punto y coma, que a su vez son pares name=value . Parece que hay un solo espacio después de cada punto y coma.
3. String.prototype.match() : devuelve null cuando no se encuentra ninguna coincidencia. Devuelve una matriz cuando se encuentra una coincidencia, y el elemento en el índice [1] es el valor del primer grupo coincidente.

Notas de expresiones regulares:

1. (?:xxxx) - forma un grupo no coincidente.
2. ^ - coincide con el inicio de la cadena.
3. | - Separa patrones alternativos para el grupo.
4. ;//s* : coincide con un punto y coma seguido de cero o más caracteres de espacio en blanco.
5. = - coincide con un signo igual.
6. (xxxx) - forma un grupo coincidente.
7. [^;]* - coincide con cero o más caracteres distintos de un punto y coma. Esto significa que coincidirá con los caracteres hasta, pero sin incluir, un punto y coma o hasta el final de la cadena.

Answer 13

Me gusta usar un cierre para obtener valores de cookies por nombre. El cierre a continuación le permitirá obtener un valor de cookie por nombre, pero solo analizará la cadena de cookies si se ha actualizado.

Puede recuperar el valor de una cookie con lo siguiente:

var foo = cookies.get( "bar" );

Código:

var cookies = ( function() {
    var cookieString = null;
    var cookieArray = [];

    function getValOf( name ) {
        if ( newCookies() ) {
            parseCookieString()
        }
        return cookieArray[ name ];
    }

    // Check if new cookies have been added
    function newCookies() {
        return cookieString === document.cookie;
    }

    function parseCookieString() {
        cookieString = document.cookie;

        // Separate cookies
        var cookies = cookieString.split( ";" );

        // Empty previous cookies
        cookieArray = [];

        // Update cookieArray with new name-value pairs
        for ( var i in cookies ) {

            // Separate name and value
            var nameVal = cookies[ i ].split( "=" );
            var name = nameVal[ 0 ].trim();
            var value = nameVal[ 1 ].trim();

            // Add cookie name value pair to dictionary
            cookieArray[ name ] = value;
        }
    }

    return {

        /**
         * Returns value or undefined
         */
        get: function( name ) {
            return getValOf( name );
        }  
    };
})();

Answer 14

Me parece que podría dividir los pares clave-valor de cookie en una matriz y basar su búsqueda en eso:

var obligations = getCookieData("obligations");

Que ejecuta lo siguiente:

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/

O posiblemente incluso lo siguiente:

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

Answer 15

Mi solución es la siguiente:

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

Esta función utiliza la función Underscorejs _.find-function. Devuelve undefined si el nombre de la cookie no existe

Answer 16

Preferiría usar una única coincidencia de expresión regular en la cookie:

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

Mejorado gracias a Scott Jungwirth en los comentarios.

Answer 17

Puede usar la biblioteca js-cookie para obtener y configurar las cookies de JavaScript.

Incluya a su HTML:

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

Para crear una cookie:

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

Para leer una cookie:

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

Answer 18

Sé que es una vieja pregunta, pero también encontré este problema. Solo para el registro, hay una pequeña API en document.cookie desarrolladores.

Yoy puede obtener cualquier cookie por nombre usando solo JS. El código también es más limpio IMHO (excepto por la línea larga, que estoy seguro de que puede corregir fácilmente).

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

Como se indica en los comentarios, tenga en cuenta que este método asume que la clave y el valor se codificaron mediante encodeURIComponent (). Elimine decode & encodeURIComponent () si la clave y el valor de la cookie no fueron codificados.

Answer 19

Si solo necesita comprobar si existe alguna cookie, simplemente haga esto:

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

si existe una cookie registrada = verdadera, obtendrá 2, si no 1.

log = true: cámbialo a tu nombre de cookie = valor, o solo un nombre

Answer 20

Si usa jQuery, le recomiendo que use este complemento:

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

Así que puedes leer una cookie como esta:

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

También puedes escribir cookie:

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

Eliminar cookie:

$.removeCookie(''obligations'');

Answer 21

Solo para agregar una respuesta "oficial" a esta respuesta, estoy copiando / pegando la solución para configurar y recuperar cookies de MDN (aquí está el JSfiddle

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

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

    function alertCookieValue() {
      alert(cookieValue);
    }

En tu caso particular, usarías la siguiente función

    function getCookieValue() {
      return document.cookie.replace(/(?:(?:^|.*;/s*)obligations/s*/=/s*([^;]*).*$)|^.*$/, "$1");
    }

Tenga en cuenta que solo reemplacé "test2" del ejemplo, con "obligaciones".

Answer 22

Un enfoque funcional para encontrar las cookies existentes. Devuelve una matriz, por lo que admite varias apariciones del mismo nombre. No admite la coincidencia parcial de claves, pero es trivial reemplazar el === en el filtro con una expresión regular.

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

Answer 23

Un enfoque, que evita la iteración sobre una matriz, sería:

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

Recorrido

La división de una cadena por token producirá, ya sea una matriz con una cadena (el mismo valor), en caso de que la ficha no exista en una cadena, o una matriz con dos cadenas, en caso de que la ficha se encuentre en una cadena.

El primer elemento (izquierda) es la cadena de lo que estaba antes del token, y el segundo (derecha) es la cadena de lo que estaba después de la ficha.

(NOTA: en caso de que la cadena comience con un token, el primer elemento es una cadena vacía)

Teniendo en cuenta que las cookies se almacenan de la siguiente manera:

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

para recuperar un valor de cookie específico, solo necesitamos obtener una cadena que esté después de "; {name} =" y antes de next ";". Antes de realizar cualquier procesamiento, agregamos la cadena de cookies con ";", de modo que cada nombre de cookie, incluido el primero, se incluya con ";" y "=":

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

Ahora, primero podemos dividir por "; {nombre} =", y si el token se encuentra en una cadena de cookies (es decir, tenemos dos elementos), el segundo elemento será una cadena que comienza con nuestro valor de cookie. Luego lo sacamos de una matriz (es decir, pop), y repetimos el mismo proceso, pero ahora con ";" como un token, pero esta vez extrayendo la cadena izquierda (es decir, shift) para obtener el valor del token real.

Answer 24

Ya hay respuestas agradables aquí para obtener la cookie. Sin embargo, aquí está mi propia solución:

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

uso: `

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

Answer 25

establecido por javascript

document.cookie = ''cookiename=tesing'';

consigue jquery con el https://github.com/carhartl/jquery-cookie

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

alert(value);

Answer 26

referencia: 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);

Answer 27

siempre funciona bien:

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

No hay requisitos para jQuery ni nada. JavaScript puro y antiguo.

Answer 28

usar un script para obtener cookies:

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

entonces llámalo:

var value = readCookie(''obligations'');

Robé el código de arriba de la página de cookies de quirksmode. deberias leerlo

Answer 29

Kirlich dio una buena solución. Sin embargo, falla cuando hay dos valores de cookie con nombres similares, aquí hay una solución simple para esta situación:

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

Answer 30

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