How to Make Store Bought Cookies Crisp Again

Get AI Code Completions for Your IDE

Home   >   Tutorials   >   JavaScript   > How to Use Cookies with JavaScript

JavaScript - How to Use Cookies with JavaScript

Cookies brand it possible to store information about a web application'south user between requests.

After a web server sends a web page to a browser, the connexion shuts down and all information held by the server is lost. This makes maintaining user country challenging, as we cannot refer to the server for values specific to the current user's browser activity. Cookies overcome this obstruction by storing the required data on the user'south figurer in the form of a name=value string.

Cookies are often used to shop usernames, preferences, authentication tokens, and other like items.

It is of import to keep security in mind when storing sensitive information like authentication tokens. Cookies can be seen and modified past the user, potentially exposing sensitive data. For more about this issue run across the department Set a path for a cookie below.

Gear up a cookie

Setting a cookie uses the following syntax:

document.cookie = 'newCookie'

Let's break this downward into its components:

• document.cookie is the command used to create a new cookie.
• 'newCookie' is a cord that sets the cookie value. Information technology has its ain syntax to be aware of: proper noun=value
  • For readability reasons name should imply what the cookie stores (e.one thousand. username)
  • value is simply the value.

Below is an instance of setting a cookie using this syntax:

document.cookie = "username=Max Chocolate-brown";

The above code will store a cookie named "username" with the value "Max Brownish".

Annotation: Cookies expire automatically based on an expiration date that can be set in lawmaking. If no expiration date is set, the cookie volition exist deleted as soon as the browser is airtight. The adjacent section covers setting an expiration date for your cookies.

Set an expiration date for a cookie

Past default, cookies volition be automatically deleted once the browser is closed. This prevents users from re-using the cookie values on subsequent visits to your page. You can override this by setting an expiration date for your cookie. This tin can exist done easily by calculation expires=expirationDate in UTC separated by semicolon from the name=value, every bit seen in the post-obit example:

document.cookie = "username=Max Brown; expires=Wed, 05 Aug 2022 23:00:00 UTC";

The above example sets the "username" cookie to "Max Brown" as earlier, but it also adds an expiration appointment of Wednesday, August 5th, 2020, with an expiration time of 23:00:00 UTC. When this expiration fourth dimension is reached, the cookie value will exist deleted.

Note: UTC is a time standard (the coordinated universal fourth dimension).

Set up a path for a cookie

By default, cookies are associated with the page that sets them. This tin atomic number 82 to cookie values that are very easily traced past a curious user using developer tools. Equally such, it is not advisable to shop sensitive information on the root path for your application. Instead, you lot can provide a path where this data should exist stored. The syntax for this is as follows:

document.cookie = "username=Max Brown; expires=Wed, 05 Aug 2022 23:00:00 UTC; path=/"

In the above instance, we have gear up our "username" cookie with the value of "Max Brownish", and prepare its expiration to the same date as earlier. The difference is the path parameter, which modifies where the cookie is stored on the user'south automobile. This is very useful when trying to store sensitive data, every bit it makes the information harder to discover.

setCookie function

All of the higher up examples difficult-code the cookie values, which will be of express utility in well-nigh cases. Cookie values tin can besides be set using a JavaScript function. Take the following lawmaking for example:

let username = 'Max Brown';  // Prepare a Cookie function setCookie(cName, cValue, expDays) {         let date = new Date();         date.setTime(date.getTime() + (expDays * 24 * 60 * 60 * 1000));         const expires = "expires=" + appointment.toUTCString();         certificate.cookie = cName + "=" + cValue + "; " + expires + "; path=/"; }  // Apply setCookie setCookie('username', username, thirty);

This code defines a office, setCookie(). This function volition create a cookie with the name "username", value "Max Brown" with an expiration date of 30 days from the time it was created. Let'south explore this function line-by-line:

1. In the first line of the function body, variable date is created and given the current date and fourth dimension value in UTC as its initial value, This UTC timestamp will exist formatted using the UTC timestamp format (east.chiliad. Thu Aug 06 2022 12:41:34 GMT+0000 (UTC)). This value may be adjusted based on the user's fourth dimension zone.
2. The side by side line of code converts the UTC timestamp to a higher place into a number (E.g. 1599308841783). This number is an integer known as the "epoch" time, or Unix time unit, and can be converted to a UTC timestamp easily. This allows united states of america to easily dispense the fourth dimension using integer fourth dimension differentials. The second part of this row uses this epoch time to summate an expiration engagement for the cookie. It requires the number of milliseconds that you want your cookie expiration to take. The to a higher place code converts the parameter expDays (with a value of 30 as passed in above), and converts those requested days into an equivalent number of milliseconds. These milliseconds are and then added to the Unix epoch timestamp, creating the target expiration date and time for our cookie.
3. The third line declares a new variable expires, and gives information technology the value calculated for the expiration engagement in the previous line. This value is converted into a UTC cord, which e'er shows GMT time equally opposed to local time (due east.g. Sat, 05 Sep 2022 12:38:xvi GMT).
4. The final line of the part sets the new cookie with all of the parameters populated:
   username=Max Brown; expires=Sat, 05 Sep 2022 12:38:16 GMT; path=/

Update a cookie

To update a cookie, simply overwrite its value in the cookie object. You do this by setting a new cookie on the certificate with the same Proper noun, but a unlike Value. The following code shows this in activity:

username = 'Jen Brown';  setCookie('username', username, xxx);

In the above code, we did not create a new cookie, as we already take a value in the cookie "username" of "Max Dark-brown". This telephone call to setCookie() overwrites the value of the "username" cookie, changing information technology from "Max Brown" to "Jen Brown".

Delete a cookie

To delete a cookie, you tin but provide an expiration date that occurred in the past. When the browser sees that the cookie has expired, it will delete the cookie automatically.

Fun fact: the formal Unix time count began on Thursday, January 1st 1970 at midnight GMT. This is known as the "Epoch" time. Timestamps in integers are similarly besides known every bit "milliseconds since epoch", or the number of milliseconds that accept taken place since January 1st 1970.

To hands delete any cookie, only set up its expiration date equally the epoch timestamp:

document.cookie = "username=; expires=Thu, 01 Jan 1970 00:00:00 UTC; path=/";

This statement will delete a cookie named "username" if one exists.

Some browsers will non allow the deletion of a cookie if the path is not specified. Therefore, information technology is important to e'er specify the path when working with cookies.

Get cookies

Getting all cookies is very simple. Cookies are stored as a ready of strings separated by semicolons. You can access this value by calling document.cookie as seen in the instance below:

document.cookie = "username=Debra White; path=/"; document.cookie = "userId=wjgye264s; path=/"; let cookies = document.cookie; console.log(cookies); // expected output: username=Debra White; userId=wjgye264s

The above lawmaking sets ii cookies – username and userId, and returns the cookie values to the variable cookies equally a single semicolon-delimited string. Note that the return value does not include the specified path.

Get a cookie

Retrieving the value of a single cookie requires a piddling bit of legwork.

First, nosotros'll write a function that can decide the value of a cookie when given the cookie's proper name. Hither is our sample lawmaking:

function getCookie(cName) {       const name = cName + "=";       const cDecoded = decodeURIComponent(document.cookie); //to be conscientious       const cArr = cDecoded .split('; ');       permit res;       cArr.forEach(val => {           if (val.indexOf(name) === 0) res = val.substring(proper noun.length);       })       return res; }        

Exploring function getCookie() past line

The part getCookie takes a cookie's proper noun every bit a parameter, so performs the following steps:

1. The first line assigns the requested cookie name to a const variable name. It appends an equals sign to the end of the name. For example, passing in a cookie value 'username' will outcome in 'username=' being stored in the name variable.
2. The next line retrieves all of the cookies using document.cookie, so applies decodeURIComponent() to the result. This part "cleans" the string from "encoding traces" that may have been included in the cookie content. You have likely seen these encoding traces before, they look similar to this: %20%24username%20.
3. Every bit explained in the previous section, document.cookie returns results as a string containing all cookie values separated by semicolons (;). Hither I accept used the split() method, asking it to split the string's values apart when it encounters a semicolon followed by a blank space. The result will exist an array of cookie strings.
4. The following two lines define the render variable, res, and call the forEach() method on the array of cookies obtained in line 4 (cArr). The forEach() iterates through an array, executing a callback part in one case for each array element. In the above example, if the value stored in variable name appears at the offset of the cord (i.e. at index 0), the inner block assigns the content of the cookie (i.due east. the value after the "=" sign) to the variable res. The value length is larger than index by ane. This allows us to trim off both the full string name of the cookie, and the trailing equality sign past starting the trim at index = proper noun.length. For trimming I used the substring() method, which produces a substring of the specified length from the original input string.
5. If the forEach() method was not able to find the requested cookie, the value 'undefined' will be returned.

Keep in heed that in many cases, working with cookies will begin with fetching a cookie'south value, and then requesting information from the user if the requested cookie is not found.

Related Manufactures:

JavaScript – How to Utilize The Array forEach() Method

JavaScript – How to Utilize the Cord length Property

JavaScript – How to Get an Input's Value

manleyjohe1973.blogspot.com

Source: https://www.tabnine.com/academy/javascript/how-to-set-cookies-javascript/

Share this post