![js-dates.jpg](https://res.cloudinary.com/dh1srz69c/image/upload/v1618296129/js_dates_ebca0a0677.jpg)
In this article , we will learn all the important topics related to dates in javascript with help of proper examples.\
`Date` objects contain a `Number` that represents milliseconds since 1 January 1970 UTC.
## Creating A Date Object
We can create a `Date` object using `Date()` constructor with the following syntaxes - 
```js
new Date() //current date and time as of the time of instantiation.
new Date(value) // value is an integer value representing the number of milliseconds since January 1, 1970, 00:00:00
new Date(dateString) // A string value representing a date
new Date(year, monthIndex [, day [, hours [, minutes [, seconds [, milliseconds]]]]]) //Give at least a year and month
```

#### Examples
```js
let today = new Date();
console.log(today);
let myDay = new Date('January 16, 2001 05:39:00');
console.log(myDay);
myDay = new Date('2001-01-16T05:39:00');
console.log(myDay);
myDay = new Date(2001, 0, 16); // the month is 0-indexed
console.log(myDay);
myDay = new Date(1995, 0, 16, 5, 39, 0);
console.log(myDay);
```
#### Output
>2021-04-12T19:46:14.180Z\
2001-01-16T00:09:00.000Z\
2001-01-16T00:09:00.000Z\
2001-01-15T18:30:00.000Z\
1995-01-16T00:09:00.000Z

## Important Instance Methods
### getDate()
Returns the day of the month (1–31) for the specified date according to local time.
```js
console.log(myDay.getDate());
```
#### Output
>16

### getDay()
Returns the day of the week (0–6) for the specified date according to local time.
```js
console.log(myDay.getDay());
```
#### Output
>1

### getFullYear()
Returns the year (4 digits for 4-digit years) of the specified date according to local time.
```js
console.log(myDay.getFullYear());
```
#### Output
>1995

### getHours()
Returns the hour (0–23) in the specified date according to local time.
```js
console.log(myDay.getHours());
```
#### Output
>5

### getMinutes()
Returns the minutes (0–59) in the specified date according to local time.
```js
console.log(myDay.getMinutes());
```
#### Output
>39

### getSeconds()
Returns the seconds (0–59) in the specified date according to local time.
```js
console.log(myDay.getSeconds());
```
#### Output
>0

### getMonth()
Returns the month (0–11) in the specified date according to local time.
```js
console.log(myDay.getMonth());
```
#### Output
>0

***We also have similar methods with UTC as `getUTCDate()`,`getUTCDay()`,`getUTCFullYear()`,`getUTCHours()`,`getUTCMilliseconds()`,`getUTCMinutes()`,`getUTCMonth()` and `getUTCSeconds()` which will give similar results but according to universal time.***

***We also have similar setter methods with local time as well as with UTC which are `setUTCDate()`,`setUTCDay()`,`setUTCFullYear()`,`setUTCHours()`,`setUTCMilliseconds()`,`setUTCMinutes()`,`setUTCMonth()` and `setUTCSeconds()` which will set the particular parameters according to universal time. While `setDate()`,`setDay()`,`setFullYear()`,`setHours()`,`setMilliseconds()`,`setMinutes()`,`setMonth()` and `setSeconds()` will set the parameters according to lacale time.***


## Important Methods To Convert Date To String
### toDateString()
Returns the "date" portion of the Date as a human-readable string like `Tue Apr 13 2021`.

### toISOString()
Converts a date to a string following the ISO 8601 Extended Format like`1995-01-16T00:09:00.000Z` .

### toUTCString()
Converts a date to a string using the UTC timezone like `Mon, 16 Jan 1995 00:09:00 GMT`.

### toLocaleString()
Returns a string with a locality-sensitive representation of this date like `1/16/1995, 5:39:00 AM`.

### Calculating Elapsed Time
```js
let start = new Date()
// The event to time goes here:
doSomethingForALongTime()
let end = new Date()
let elapsed = end.getTime() - start.getTime() // elapsed time in milliseconds
```

### Get the number of seconds since the ECMAScript Epoch
```js
let seconds = Math.floor(Date.now() / 1000)
```

So , that is it for this article 😀. I hope you understand how to manipulate dates in javascript. And lastly as always , Thank You for reading.

thumbnail_js-dates.jpg

js-dates.jpg

In this article , we will learn all the important topics related to dates in javascript with help of proper examples.

📅 Master Javascript Dates In 2 Minutes

![string-methods.jpg](https://res.cloudinary.com/dh1srz69c/image/upload/v1616579676/string_methods_84bddaa500.jpg)

Manipulation of javascript strings are very important in most of the  web development projects. So , in this post we will take a look 😍 at some important and frequently used string methods in javascript. Below are the strings which we will used to learn this methods with.
```js
var stringOne = "Let's learn important javascript string methods."
var stringTwo = "Also we will see their examples."
```
## charAt()
The `String` object's `charAt()` method returns a new string consisting of the single UTF-16 code unit located at the specified offset into the string.If the `index` cannot be converted to the integer or no `index` is provided, the default is `0`, so the first character of string is returned.
```js
const index = 4;
console.log(`Character at index ${index} in stringOne is ${stringOne.charAt(index)}`);
```
**Output**
>Character at index 4 in stringOne is s

## concat()
The `concat()` method concatenates the string arguments to the calling string and returns a new string. If the arguments are not of the type string, they are converted to string values before concatenating.
```js
console.log(stringOne.concat(stringTwo));
console.log(stringOne.concat('And ', stringTwo));
```
**Output**
>Let's learn important javascript string methods.Also we will see their examples.\
Let's learn important javascript string methods.And Also we will see their examples.

## endsWith()
The `endsWith()` method determines whether a string ends with the characters of a specified string, returning `true` or `false` as appropriate. This method is case-sensitive. If second argument provided, it is used as the `length` of string. Defaults to `string.length`.
```js
console.log(stringOne.endsWith('methods.'));
console.log(stringOne.endsWith('javascript'));
console.log(stringOne.endsWith('javascript', 32));
```
**Output**
>true\
false\
true

## includes()
The `includes()` method performs a case-sensitive search to determine whether one string may be found within another string, returning `true` or `false` as appropriate. The second argument is position within the string at which to begin searching for searchString. (Defaults to 0.)
```js
console.log(stringOne.includes("Let's"));
console.log(stringOne.includes("Let's", 1)); //Start searching from first index
console.log(stringOne.includes("let's")); //Case sensitive
```
**Output**
>true\
false\
false

## indexOf()
The `indexOf()` method returns the index within the calling String object of the first occurrence of the specified value, starting the search at `fromIndex`. Returns `-1` if the value is not found. `fromIndex` is the second argument which is an integer representing the index at which to start the search. Defaults to 0.
```js
console.log(stringOne.indexOf('a'));
console.log(stringOne.indexOf('a', 15)); //Start searching from index 15
```
**Output**
>8\
18

## lastIndexOf()
The `lastIndexOf()` method is same as `indexOf()` method only difference is instead of first occurence it search for last occurence of a given string. It returns the `index` of the last occurrence of searchValue; `-1` if not found. 
```js
console.log(stringOne.lastIndexOf('a'));
```
**Output**
>25

## replace()
The `replace()` method returns a new string with some or all matches of a `pattern` replaced by a replacement. The pattern can be a `string` or a `RegExp`, and the replacement can be a `string` or a `function` to be called for each match. If pattern is a string, only the first occurrence will be replaced.\
The original string is left unchanged.
```js
console.log(stringOne.replace('methods', 'functions'));
console.log(stringOne.replace('important', 'must know'));
const regex = /Javascript/i;
console.log(stringOne.replace(regex, 'JS'));
```
**Output**
>Let's learn important javascript string functions.\
Let's learn must know javascript string methods.\
Let's learn important JS string methods.

**`replaceAll()` is also a similar method only difference is instead of replacing first match it will replace every match in the string.**

## startsWith()
The `startsWith()` method determines whether a string begins with the characters of a specified string, returning `true` or `false` as appropriate.The second argument is `position` in this string at which to begin searching for searchString. Defaults to 0.
```js
console.log(stringOne.startsWith("Let's"));
console.log(stringOne.startsWith("Let's", 5)); // Start searching from position at index 5
```
**Output**
>true\
false

## slice()
The `slice()` method **extracts a section of a string** and returns it as a new string, without modifying the original string. Its first argument is `beginIndex` - the zero-based index at which to begin extraction. And second srgument is `endIndex` - the zero-based index before which to end extraction. **The character at `endIndex` will not be included.**\
If any or both of the two `endIndex` and `beginIndex` are negative, then they are treated as `str.length + endIndex` and `str.length + beginIndex` . (For example, if endIndex is -3, it is treated as str.length - 3.)
```js
console.log(`Length of stringOne is ${stringOne.length}`);
console.log(stringOne.slice(6, 22)); // Start at index 6 and extract upto index 22 not including 22
console.log(stringOne.slice(6, -9)); // Start at index 6 and extract upto index 48 - 9 = 39 not including 39
console.log(stringOne.slice(6)); // Start at index 6 and extract whole string
console.log(stringOne.slice(50)); // As startIndex is greater than length return empty string
```
**Output**
>Length of stringOne is 48\
learn important \
learn important javascript string\
learn important javascript string methods.

## split()
The `split()` method divides a `String` into an ordered list of substrings, puts these substrings into an `array`, and returns the `array`.
```js
console.log(stringOne.split(' '));
console.log(stringOne.split('learn'));
```
**Output**
>[ "Let's", 'learn', 'important', 'javascript', 'string', 'methods.' ]\
[ "Let's ", ' important javascript string methods.' ]

## substr()
The `substr()` method returns a portion of the string, starting at the specified index and extending for a given number of characters afterwards.
```js
console.log(stringOne.substr(6)); // Start at index 6 and extract whole remaining string
console.log(stringOne.substr(6, 34)); // Start at index 6 and extract next 34 characters.
```
**Output**
>learn important javascript string methods.\
learn important javascript string

## trim()
The `trim()` method removes whitespace from both ends of a string. Whitespace in this context is all the whitespace characters (space, tab, no-break space, etc.) and all the [line terminator characters](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar) (LF, CR, etc.).
```js
var stringThree = '       remove whitespaces       ';
console.log(stringThree.trim());
```
**Output**
>remove whitespaces

**The `trimEnd()` and `trimStart()` are similar methods which removes whitespace from the end and start of the string respectively.**

## match()
The `match()` method retrieves the result of matching a string against a regular expression. You can learn about regular expression [here](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions) .
```js
const regex = /[A-Z]/g; // regex for capital characters
console.log(stringOne.match(regex));
```
**Output**
>[ 'L' ]

## toLowerCase()
The `toLowerCase()` method returns the calling string value converted to lower case.
```js
var stringThree = 'THIS IS DEMO STRING';
console.log(stringThree.toLowerCase());
```
**Output**
>this is demo string

## toUpperCase()
The `toUpperCase()` method returns the calling string value converted to upper case.
```js
var stringThree = 'this is demo string';
console.log(stringThree.totoUpperCase()());
```
**Output**
>THIS IS DEMO STRING

And that is it for this article. Thanks for reading 😇 .



thumbnail_string-methods.jpg

string-methods.jpg

Manipulation of javascript strings are very important in most of the  web development projects. So , in this post we will take a look 😍 at some important and frequently used string methods in javascript.

😬15 Very Important Javascript String Methods Every Developer Should Know

![js-array-methods.jpg](https://res.cloudinary.com/dh1srz69c/image/upload/v1615701416/js_array_methods_48cf5bebc3.jpg)


In this article , we will see 10 important javascript array methods which almost needed everywhere in javascript projects. We will quickly take a look at each method with example. Below is the data with which we will be working while taking examples of first 8 method.

```javascript

const studentData = [
	{ name: 'John', marks: 634, passed: true },
	{ name: 'Mark', marks: 467, passed: true },
	{ name: 'Randy', marks: 390, passed: true },
	{ name: 'Leo', marks: 149, passed: false },
	{ name: 'Chris', marks: 564, passed: true },
	{ name: 'Apu', marks: 456, passed: true },
	{ name: 'Naty', marks: 567, passed: true },
	{ name: 'James', marks: 98, passed: false },
	{ name: 'Andy', marks: 478, passed: true },
	{ name: 'Frank', marks: 180, passed: false },
	{ name: 'Don', marks: 123, passed: false }
];

```

## filter()
The `filter()` method **creates a new array** with all elements that pass the test implemented by the provided function.\
Let us  say we have to get only those students who have passed. So we will filter them as below
```js
const passedStudents = studentData.filter((student) => {
	return student.passed;
});
console.log(passedStudents);

```
Output : 
> [\
  { name: 'John', marks: 634, passed: true },\
  { name: 'Mark', marks: 467, passed: true },\
  { name: 'Randy', marks: 390, passed: true },\
  { name: 'Chris', marks: 564, passed: true },\
  { name: 'Apu', marks: 456, passed: true },\
  { name: 'Naty', marks: 567, passed: true },\
  { name: 'Andy', marks: 478, passed: true }\
]

## map()
The `map()` method **creates a new array** populated with the results of calling a provided function on every element in the calling array.
Say we want to get array of name of every student. So we can get it as follows
```js
const studentNames = studentData.map((student) => {
	return student.name;
});
console.log(studentNames);
```

Output:
>[\
  'John',  'Mark',\
  'Randy', 'Leo',\
  'Chris', 'Apu',\
  'Naty',  'James',\
  'Andy',  'Frank',\
  'Don'\
]

## find()
The `find()` method returns the value of the first element in the provided array that satisfies the provided testing function. If no values satisfy the testing function, `undefined` is returned. Say we want to get data of student whose name is 'Leo' then
```js
const dataOfLeo = studentData.find((student) => {
	return student.name === 'Leo';
});
console.log(dataOfLeo);
```
Output:
>{ name: 'Leo', marks: 149, passed: false }

## reduce()
The `reduce()` method executes a `reducer` function (that you provide) on each element of the array, resulting in single output value. It takes first parameter as `reducer` function and second parameter is `initial value`
Say we want to calculate sum of marks of all students then
```js
const totalMarksOfAll = studentData.reduce((currentTotal, student) => {
	return student.marks + currentTotal;
}, 0);
console.log(totalMarksOfAll);

```
Output:
>4106

## findIndex()
The `findIndex()` method returns the **index** of the first element in the array **that satisfies the provided testing function.** Otherwise , it returns `-1`, indicating that no element passed the test. Say we want to find the index of Leo's Data then
```js
const indexOfLeo = studentData.findIndex((student) => student.name === 'Leo');
console.log(indexOfLeo);
```
Output:
>3

## forEach()
The `forEach()` method executes a provided function once for each array element. It works similar to for loop. Say we want to print result status for each student then 
```js
studentData.forEach((student) => {
	console.log(
		`${student.name} has ${
			student.passed ? 'passed' :
			'failed'} !`
	);
});

```
Output:
>John has passed !\
Mark has passed !\
Randy has passed !\
Leo has failed !\
Chris has passed !\
Apu has passed !\
Naty has passed !\
James has failed !\
Andy has passed !\
Frank has failed !\
Don has failed !

## some()
The `some()` method tests whether at least one element in the array passes the test implemented by the provided function. It returns true if, in the array, it finds an element for which the provided function returns true; otherwise it returns false. It doesn't modify the array. Say we want to know if data have some failed students in it or not then
```js
const hasFailedStudents = studentData.some((student) => {
	return !student.passed;
});
console.log(hasFailedStudents);

```
Output:
>true

## every()
The `every()` method tests whether all elements in the array pass the test implemented by the provided function. It returns a Boolean value. It is similar to `some()` method the only difference is that the `some()` method will return true if any predicate is true while `every()` method will return true if all predicate are true. Say we want to check if all the students are passed or not then
```js
const hasAllPassed = studentData.every((student) => {
	return student.passed;
});
console.log(hasAllPassed);
```
Output:
>false

## New Data
Now , for remaining two methods lets use below data , 
```js
const languages = [
	'java',
	'cpp',
	'python',
	'javascript'
];
```
## includes()
The `includes()` method determines whether an array includes a certain value among its entries, returning `true` or `false` as appropriate.
Say we want to check if python and ruby are in above languages array or not then
```js
const includesRuby = languages.includes('ruby');
console.log(includesRuby)
const includesPython = languages.includes('python');
console.log(includesPython);

```

Output:
>false\
true

## indexOf()
The `indexOf()` method returns the first index at which a given element can be found in the array, or -1 if it is not present.
Say we want to find index of python then
```js
const indexOfPython = languages.indexOf('python');
console.log(indexOfPython);
```
Output:
>2

And that is it for this article. Thanks for reading.

thumbnail_js-array-methods.jpg

js-array-methods.jpg

In this article , we will see 10 important javascript array methods which almost needed everywhere in javascript projects. We will quickly take a look at each method with example.

Blog Articles

#begginers

📅 Master Javascript Dates In 2 Minutes

😬15 Very Important Javascript String Methods Every Developer Should Know

😬 10 Must Know Javascript Array Methods