Answers:
ඔබට මෙය නිර්මාණය කළ හැකිය: -
Date.prototype.addDays = function(days) {
var date = new Date(this.valueOf());
date.setDate(date.getDate() + days);
return date;
}
var date = new Date();
alert(date.addDays(5));අවශ්ය නම් මාසය ස්වයංක්‍රීයව වැඩි කිරීමට මෙය සැලකිලිමත් වේ. උදාහරණයක් වශයෙන්:
8/31 + 1 දින 9/1 බවට පත්වේ .
setDateකෙලින්ම භාවිතා කිරීමේ ගැටළුව නම් එය විකෘතියක් වන අතර ඒ ආකාරයේ දේ වළක්වා ගත හැකිය. Dateවෙනස් කළ නොහැකි ව්‍යුහයකට වඩා විකෘති පංතියක් ලෙස සැලකීමට ECMA සුදුසු විය .
864E5කිසියම් හේතුවක් නිසා මම 24*60*60මගේ කේතයෙන් ලිවීමට කැමැත්තෙමි :)
නිවැරදි පිළිතුර :
function addDays(date, days) {
var result = new Date(date);
result.setDate(result.getDate() + days);
return result;
}වැරදි පිළිතුර :
මෙම පිළිතුර සමහර විට නිවැරදි ප්‍රති result ල ලබා දෙන නමුත් බොහෝ විට වැරදි වර්ෂය සහ මාසය ලබා දෙයි. මෙම පිළිතුර ක්‍රියාත්මක වන එකම අවස්ථාව වන්නේ ඔබ දින එකතු කරන දිනය වත්මන් වර්ෂය සහ මාසය ඇති වූ විට පමණි.
// Don't do it this way!
function addDaysWRONG(date, days) {
var result = new Date();
result.setDate(date.getDate() + days);
return result;
}සාධනය / උදාහරණය
var today = new Date();
var tomorrow = new Date();
tomorrow.setDate(today.getDate()+1);මෙය උපක්‍රමශීලී විය හැකි බැවින් ප්‍රවේශම් වන්න. "හෙට" සැකසීමේදී, එය ක්‍රියාත්මක වන්නේ එහි වර්තමාන වටිනාකම "අද" සඳහා වසර හා මාසයට ගැලපෙන බැවිනි. කෙසේ වෙතත්, සාමාන්‍යයෙන් "32" වැනි දින අංකයකට සැකසීම එය ඊළඟ මාසයට ගෙනයාමට තවමත් හොඳින් ක්‍රියා කරයි.
var d = new Date(); d.setDate( d.getDate() + 1 );?
getDate() ආපසු එවන්න . ඉන්පසු, ඇමතුම වත්මන් වර්ෂයේ දිනය නියම කරයි . ඒ නිසා එය නැති හොඳ සාමාන්ය විසඳුමක්. @ ඇන්තනි ඩබ්ලිව් ජෝන්ස්ගේ පිළිතුර ඇත්ත වශයෙන්ම නිවැරදිව ක්‍රියා කරයි. setDate
var d = new Date(2015,11,30);d.setDate(d.getDate() + 370)වසර 2 ක් ඉක්මවන 2017 ජනවාරි 3 ලබා දෙයි.
මගේ සරල විසඳුම:
nextday=new Date(oldDate.getFullYear(),oldDate.getMonth(),oldDate.getDate()+1);මෙම විසඳුමට දිවා ආලෝකය ඉතිරි කිරීමේ කාලය පිළිබඳ ගැටළුවක් නොමැත. එසේම, කෙනෙකුට වසර, මාස, දින ආදිය සඳහා ඕනෑම ඕෆ්සෙට් එකක් එකතු කළ හැකිය.
day=new Date(oldDate.getFullYear()-2,oldDate.getMonth()+22,oldDate.getDate()+61);නිවැරදි කේතය.
setDate.
මෙම පිළිතුරු මට ව්‍යාකූල බවක් පෙනේ, මම කැමතියි:
var ms = new Date().getTime() + 86400000;
var tomorrow = new Date(ms);getTime () අපට 1970 සිට මිලි තත්පර ලබා දෙන අතර 86400000 යනු දිනකට මිලි තත්පර ගණනයි. එබැවින්, අපේක්ෂිත දිනය සඳහා ms මිලි තත්පර අඩංගු වේ.
මිලි තත්පර ඉදිකිරීම්කරු භාවිතා කිරීමෙන් අපේක්ෂිත දින වස්තුව ලබා දෙයි.
new Date(new Date('11/4/2012').getTime() + 86400000)
උත්සාහ කරන්න
var someDate = new Date();
var duration = 2; //In Days
someDate.setTime(someDate.getTime() + (duration * 24 * 60 * 60 * 1000));ඔබගේ ගැටළුව විසඳන්නේ නැති දිනයක් එකතු කිරීමට setDate () භාවිතා කරමින්, පෙබරවාරි මාසයකට දින කිහිපයක් එකතු කිරීමට උත්සාහ කරන්න, ඔබ එයට නව දින එකතු කිරීමට උත්සාහ කරන්නේ නම්, එය ඔබ අපේක්ෂා කළ දෙයට ප්‍රති result ල නොලැබේ.
setDate()තිබේද? එය මෙයද: stackoverflow.com/questions/5497637/…
පහත දැක්වෙන ඊයම් උදාහරණ අනුගමනය කිරීමේදී එකතු නොකිරීමේ වසර සමඟ ගනුදෙනුව කුමක් දැයි සොයා බැලීමට අවුරුදු ගණනාවක් ගත කර ඇත.
ඔබට ඇති දිනට දින n ක් සරලව එකතු කිරීමට අවශ්ය නම් ඔබට යන්න වඩාත් සුදුසුය:
myDate.setDate (myDate.getDate () + n);
හෝ දිගුකාලීන අනුවාදය
var theDate = new Date(2013, 11, 15);
var myNewDate = new Date(theDate);
myNewDate.setDate(myNewDate.getDate() + 30);
console.log(myNewDate);මෙම අද / හෙට දේවල් අවුල් සහගතය. වත්මන් දිනය ඔබගේ නව දින විචල්‍යයට සැකසීමෙන් ඔබ වසරේ වටිනාකම අවුල් කරනු ඇත. ඔබ මුල් දිනයේ සිට වැඩ කරන්නේ නම් ඔබට එසේ නොවේ.
ඔබට හැකි නම්, moment.js භාවිතා කරන්න . ජාවාස්ක්‍රිප්ට්හි ඉතා හොඳ ස්වදේශීය දිනය / වේලාවන් නොමැත. පහත දැක්වෙන්නේ Moment හි වාක්‍ය ඛණ්ඩයයි:
var nextWeek = moment().add(7, 'days');
alert(nextWeek);<script src="https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.17.1/moment-with-locales.min.js"></script>int days = 1;
var newDate = new Date(Date.now() + days * 24*60*60*1000);var days = 2;
var newDate = new Date(Date.now() + days * 24*60*60*1000);
document.write('Today: <em>');
document.write(new Date());
document.write('</em><br/> New: <strong>');
document.write(newDate);මම ඊයේ රාත්‍රියේ මෙම දිගු නිර්මාණය කළෙමි:
ඔබට ධනාත්මක හෝ negative ණාත්මක අගයන් සමත් විය හැකිය;
උදාහරණයක්:
var someDate = new Date();
var expirationDate = someDate.addDays(10);
var previous = someDate.addDays(-5);
Date.prototype.addDays = function (num) {
var value = this.valueOf();
value += 86400000 * num;
return new Date(value);
}
Date.prototype.addSeconds = function (num) {
var value = this.valueOf();
value += 1000 * num;
return new Date(value);
}
Date.prototype.addMinutes = function (num) {
var value = this.valueOf();
value += 60000 * num;
return new Date(value);
}
Date.prototype.addHours = function (num) {
var value = this.valueOf();
value += 3600000 * num;
return new Date(value);
}
Date.prototype.addMonths = function (num) {
var value = new Date(this.valueOf());
var mo = this.getMonth();
var yr = this.getYear();
mo = (mo + num) % 12;
if (0 > mo) {
yr += (this.getMonth() + num - mo - 12) / 12;
mo += 12;
}
else
yr += ((this.getMonth() + num - mo) / 12);
value.setMonth(mo);
value.setYear(yr);
return value;
}දෙවන විචල්‍යය භාවිතා නොකර, ඔබේ ඊළඟ දින x සමඟ 7 ක් ආදේශ කළ හැකිය:
let d=new Date(new Date().getTime() + (7 * 24 * 60 * 60 * 1000));දින 30 ක භාවිතය ආදේශ කිරීමට (24h = 86400000ms)
new Date(+yourDate - 30 *86400000)නල මාර්ග ක්‍රියාකරු සඳහා නිර්මාණය කර ඇති විසඳුමක් :
const addDays = days => date => {
const result = new Date(date);
result.setDate(result.getDate() + days);
return result;
};භාවිතය:
// Without the pipeline operator...
addDays(7)(new Date());
// And with the pipeline operator...
new Date() |> addDays(7);ඔබට තවත් ක්‍රියාකාරීත්වයක් අවශ්ය නම්, දිනය-එෆ්එන්එස් පුස්තකාලය සොයා බැලීමට මම යෝජනා කරමි .
සරලම විසඳුම.
Date.prototype.addDays = function(days) {
this.setDate(this.getDate() + parseInt(days));
return this;
};
// and then call
var newDate = new Date().addDays(2); //+2 days
console.log(newDate);
// or
var newDate1 = new Date().addDays(-2); //-2 days
console.log(newDate1);සාදයට ප්‍රමාදයි, නමුත් ඔබ භාවිතා කරන්නේ මොහොත නමින් විශිෂ්ට ප්ලගිනයක් තිබේ:jQueryනම්
var myDateOfNowPlusThreeDays = moment().add(3, "days").toDate();http://momentjs.com/docs/#/manipulat/
එහි තවත් හොඳ දේවල් ගොඩක්!
සංස්කරණය කරන්න: අයිකෙරුගේ ප්‍රකාශයට ස්තූතියි jQuery යොමු කිරීම ඉවත් කරන ලදි
අපේක්ෂිත පරිදි ක්‍රියාත්මක වන ඔබගේ පිළිතුරට ස්තූතියි ජේසන්, මෙන්න ඔබේ කේතයෙන් සහ ඇන්තනි ඩබ්ලිව් ජෝන්ස්ගේ හැඩතලයෙන් මිශ්‍ර වීමකි:
Date.prototype.addDays = function(days){
var ms = new Date().getTime() + (86400000 * days);
var added = new Date(ms);
return added;
}පැරණි මම දනිමි, නමුත් සමහර විට මම මේකට කැමතියි:
function addDays(days) {
return new Date(Date.now() + 864e5 * days);
}Date.prototype.addDays = function(days) {return new Date(this.getTime() + (864e5 * days));};
යෝජිත විසඳුම සමඟ දිවා ආලෝකය ඉතිරි කිරීමේ කාලය පිළිබඳ ගැටළු මට තිබුණි.
ඒ වෙනුවට භාවිතා කිරීමෙන් getUTCDate/ setUTCDateමම මගේ ගැටලුව විසඳුවා.
// Curried, so that I can create helper functions like `add1Day`
const addDays = num => date => {
// Make a working copy so we don't mutate the supplied date.
const d = new Date(date);
d.setUTCDate(d.getUTCDate() + num);
return d;
}ඔබට JavaScript භාවිතා කළ හැකිය, jQuery අවශ්ය නොවේ:
var someDate = new Date();
var numberOfDaysToAdd = 6;
someDate.setDate(someDate.getDate() + numberOfDaysToAdd);
Formatting to dd/mm/yyyy :
var dd = someDate.getDate();
var mm = someDate.getMonth() + 1;
var y = someDate.getFullYear();
var someFormattedDate = dd + '/'+ mm + '/'+ y;විචල්යයන් නොමැති සාමාන්ය මූලාකෘතිය, එය පවත්නා දිනයක අගය මත අදාළ වේ:
Date.prototype.addDays = function (days) {
return new Date(this.valueOf() + days * 864e5);
}මේ තරම් සරලයි:
new Date((new Date()).getTime() + (60*60*24*1000));SetDate () සඳහා වන මොසිල්ලා ලියකියවිලි එය මාසය අවසානයේදී හැසිරවිය හැකි බව දක්වන්නේ නැත. බලන්නHttps://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Date
setDate ()
මට දින එකතු කිරීමට අවශ්ය වූ විට මම setTime () භාවිතා කරන්නේ එබැවිනි.
මම හිතන්නේ මමත් පිළිතුරක් දෙන්නම්:
පුද්ගලිකව, අනවශ්‍ය විචල්‍ය ප්‍රකාශයන්, ක්‍රම ඇමතුම් සහ ඉදිකිරීම්කරුවන්ගේ ඇමතුම් වළක්වා ගැනීමට උත්සාහ කිරීමට මම කැමතියි. (හේතුව අනුව, ඇත්ත වශයෙන්ම)
මම මෙය ඇන්තනි ඩබ්ලිව් ජෝන්ස් දුන් පිළිතුර යටතේ අදහස් දැක්වීමක් ලෙස තබමි.
// Prototype usage...
Date.prototype.addDays = Date.prototype.addDays || function( days ) {
return this.setTime( 864E5 * days + this.valueOf() ) && this;
};
// Namespace usage...
namespace.addDaysToDate = function( date, days ) {
return date.setTime( 864E5 * days + date.valueOf() ) && date;
};
// Basic Function declaration...
function addDaysToDate( date, days ) {
return date.setTime( 864E5 * days + date.valueOf() ) && date;
};ඉහත සඳහන් කරුණු DST ට ගරු කරනු ඇත. තේරුම ඔබ ඩීඑස්ටී තරණය කරන දින කිහිපයක් එකතු කළහොත්, එය පිළිබිඹු වන පරිදි දර්ශනය වන කාලය (පැය) වෙනස් වේ.
උදාහරණය:
2014 නොවැම්බර් 2 02:00 ඩීඑස්ටී හි අවසානය විය.
var dt = new Date( 2014, 10, 1, 10, 30, 0 );
console.log( dt ); // Sat Nov 01 2014 10:30:00
console.log( dt.addDays( 10 ) ); // Tue Nov 11 2014 09:30:00ඔබ DST හරහා කාලය රඳවා ගැනීමට බලාපොරොත්තු වන්නේ නම් (එබැවින් 10:30 තවමත් 10:30 වනු ඇත) ...
// Prototype usage...
Date.prototype.addDays = Date.prototype.addDays || function( days ) {
return this.setDate( this.getDate() + days ) && this;
};
// Namespace usage...
namespace.addDaysToDate = function( date, days ) {
return date.setDate( date.getDate() + days ) && date;
};
// Basic Function declaration...
function addDaysToDate( date, days ) {
return date.setDate( date.getDate() + days ) && date;
};ඉතින්, දැන් ඔබට ...
var dt = new Date( 2014, 10, 1, 10, 30, 0 );
console.log( dt ); // Sat Nov 01 2014 10:30:00
console.log( dt.addDays( 10 ) ); // Tue Nov 11 2014 10:30:00නැත, ජාවාස්ක්‍රිප්ට් තුළ කිසිදු ක්‍රියාකාරීත්වයක් නොමැත, නමුත් ඔබට සරල කේත රේඛාවක් භාවිතා කළ හැකිය
timeObject.setDate(timeObject.getDate() + countOfDays);මම මෙවැනි දෙයක් භාවිතා කරමි:
new Date(dateObject.getTime() + amountOfDays * 24 * 60 * 60 * 1000)දින ඉතිරි කිරීමේ කාලය සමඟ ක්‍රියා කරයි:
new Date(new Date(2014, 2, 29, 20, 0, 0).getTime() + 1 * 24 * 60 * 60 * 1000)නව වසර සමඟ වැඩ කරයි:
new Date(new Date(2014, 11, 31, 20, 0, 0).getTime() + 1 * 24 * 60 * 60 * 1000)එය පරාමිතිකරණය කළ හැකිය:
function DateAdd(source, amount, step) {
var factor = 1;
if (step == "day") factor = 24 * 60 * 60 * 1000;
else if (step == "hour") factor = 60 * 60 * 1000;
...
new Date(source.getTime() + amount * factor);
}ජාවාස්ක්‍රිප්ට් හි මූලාකෘති දීර් ing කිරීම හොඳ අදහසක් නොවනු ඇත , විශේෂයෙන් වෘත්තීය කේත පදනම් වල.
ඔබට කිරීමට අවශ්ය වන්නේ ස්වදේශීය Dateපන්තිය දීර් extend කිරීමයි :
class MyCustomDate extends Date {
addDays(days) {
const date = new MyCustomDate(this.valueOf());
date.setDate(date.getDate() + days);
return date;
}
}
const today = new MyCustomDate();
const nextWeek = today.addDays(7)
console.log(nextWeek)මේ ආකාරයෙන්, එක් දිනක් ජාවාස්ක්‍රිප්ට් ස්වදේශීය addDaysක්‍රමයක් ක්‍රියාත්මක කරන්නේ නම් , ඔබ කිසිවක් බිඳ නොදමනු ඇත.
මම පහත විසඳුම භාවිතා කරමි.
var msInDay = 86400000;
var daysToAdd = 5;
var now = new Date();
var milliseconds = now.getTime();
var newMillisecods = milliseconds + msInDay * daysToAdd;
var newDate = new Date(newMillisecods);
//or now.setTime(newMillisecods);දිනය සඳහා int එකක් පිළිගන්නා ඉදිකිරීම්කරුවෙකු ඇත. මෙම තර්කය 1970 ජනවාරි 1 ට පෙර / පසු මුළු මිලි තත්පර නියෝජනය කරයි. එයට නව කාල වස්තුවක් නිර්මාණය නොකර එයම කරන සෙට් ටයිම් ක්‍රමයක් ද ඇත.
අප මෙහි කරන්නේ දින මිලි තත්පර බවට පරිවර්තනය කර getTime විසින් සපයන ලද අගයට මෙම අගය එකතු කිරීමයි. අවසාන වශයෙන්, අපි ප්‍රති result ලය දිනය (මිලි තත්පර) ඉදිකිරීම්කරු හෝ සෙට් ටයිම් (මිලි තත්පර) ක්‍රමයට ලබා දෙමු.
now.setDate(now.getDate() + days);DST වෙනස්කම් ස්වයංක්‍රීයව හසුරුවයි. මම නිවැරදි කළ යුතුයි, පිම්ම තත්පර JS කාලරාමුවල නොසලකා හරිනු ලැබේ.
සංස්කරණය කරන්න:setTime() (හෝ setHours())
වෙනුවට ඔබට එය මේ ආකාරයෙන් කළ හැකිය:
Date.prototype.addDays= function(d){
this.setDate(this.getDate() + d);
return this;
};
var tomorrow = new Date().addDays(1);පැරණි:
භාවිතා කිරීම වෙනුවට setTime()ඔබට භාවිතා කළ හැකිය setHours():
Date.prototype.addDays= function(d){
this.setHours(this.getHours() + d * 24);
return this;
};
var tomorrow = new Date().addDays(1);JSFiddle බලන්න ...
d.setDate(d.getDate() + 1);
ජාවා ස්ක්‍රිප්ටයේ දින එකතු කිරීමට ඉතා සරල කේතයක්.
var d = new Date();
d.setDate(d.getDate() + prompt('how many days you want to add write here'));
alert(d);එය තියෙනවා setDate සහ getDate ඔයාට මේ වගේ දෙයක් කරන්න ඉඩ දෙන ක්රමය:
var newDate = aDate.setDate(aDate.getDate() + numberOfDays);ඔබට දින කිහිපයක්ම අඩු කර ඔබගේ දිනය මිනිස් කියවිය හැකි ආකෘතියකින් සංයුති කිරීමට අවශ්ය නම්, ඔබ DateHelperමේ ආකාරයට පෙනෙන අභිරුචි වස්තුවක් නිර්මාණය කිරීම ගැන සලකා බැලිය යුතුය :
var DateHelper = {
addDays : function(aDate, numberOfDays) {
aDate.setDate(aDate.getDate() + numberOfDays); // Add numberOfDays
return aDate; // Return the date
},
format : function format(date) {
return [
("0" + date.getDate()).slice(-2), // Get day and pad it with zeroes
("0" + (date.getMonth()+1)).slice(-2), // Get month and pad it with zeroes
date.getFullYear() // Get full year
].join('/'); // Glue the pieces together
}
}
// With this helper, you can now just use one line of readable code to :
// ---------------------------------------------------------------------
// 1. Get the current date
// 2. Add 20 days
// 3. Format it
// 4. Output it
// ---------------------------------------------------------------------
document.body.innerHTML = DateHelper.format(DateHelper.addDays(new Date(), 20));( මෙම ෆෙඩල් ද බලන්න )
Date.prototype.addDays=function(d){return new Date(this.valueOf()+864E5*d);};