Dates

Dönem
Yıl
Çeyrek
Ay
Hafta
Gün
Saat
Dakika
Saniye
Milisaniye
Mikrosaniye
Nanosaniye

Dönem türleri, zamanın kesikli, insana ait temsillerini temsil eder.

BileşikDönem

Bir BileşikDönem, daha küçük dönemlerin sabit bir katı olmayan zaman dilimlerini ifade etmek için yararlıdır. Örneğin, "bir yıl ve bir gün" sabit bir gün sayısı değildir, ancak bir BileşikDönem kullanılarak ifade edilebilir. Aslında, farklı dönem türlerinin toplanmasıyla otomatik olarak bir BileşikDönem üretilir; örneğin, Yıl(1) + Gün(1) bir BileşikDönem sonucu üretir.

Instant

Instant türleri, bir epoch'tan başlayarak sürekli zaman çizgileri olarak zamanın tam sayı tabanlı, makine temsillerini temsil eder.

UTInstant{T}

UTInstant, UT zamanına dayalı bir makine zaman çizelgesini temsil eder (1 gün = dünyanın bir devri). T, anın çözünürlüğünü veya hassasiyetini belirten bir Period parametresidir.

TimeType

TimeType türleri, makine anlarının insan temsillerini sağlamak için Instant makine örneklerini sarar. Time, DateTime ve Date, TimeType'ın alt türleridir.

DateTime

DateTime, proleptik Gregory takvimine göre bir zaman noktasını temsil eder. Zamanın en ince çözünürlüğü milisaniyedir (yani, mikro saniyeler veya nano saniyeler bu türle temsil edilemez). Bu tür, sabit nokta aritmetiğini destekler ve bu nedenle alt akma (veya üst akma) eğilimindedir. Önemli bir sonuç, bir Mikrosaniye veya Nanosaniye eklerken yuvarlamadır:

julia> dt = DateTime(2023, 8, 19, 17, 45, 32, 900)
2023-08-19T17:45:32.900

julia> dt + Millisecond(1)
2023-08-19T17:45:32.901

julia> dt + Microsecond(1000) # 1000us == 1ms
2023-08-19T17:45:32.901

julia> dt + Microsecond(999) # 999us 1000us'a yuvarlandı
2023-08-19T17:45:32.901

julia> dt + Microsecond(1499) # 1499 1000us'a yuvarlandı
2023-08-19T17:45:32.901

Tarih

Tarih, bir UTInstant{Gün} sarmalar ve onu proleptik Gregoryen takvimine göre yorumlar.

Zaman

Zaman, bir Nanosecond'ı sarar ve 24 saatlik bir günde belirli bir anı temsil eder.

Zaman Dilimi

Genellikle belirli bir konumdaki saati belirleyen boylam temelinde coğrafi bölge. Bazı zaman dilimleri yaz saati uygulamasını gözlemlemektedir (örneğin EST -> EDT). Uygulamalar ve daha fazla destek için TimeZones.jl paketine bakın.

UTC

UTC, veya Koordine Evrensel Zaman, tüm diğerlerinin ölçüldüğü TimeZone dir. 0° boylamındaki zamanla ilişkilidir. Yaz saati uygulaması için ayarlanmamıştır.

DateTime(y, [m, d, h, mi, s, ms]) -> DateTime

Parçalarla bir DateTime türü oluşturun. Argümanlar Int64 türüne dönüştürülebilir olmalıdır.

DateTime(periods::Period...) -> DateTime

Period türündeki parçalarla bir DateTime türü oluşturun. Argümanlar herhangi bir sırada olabilir. Sağlanmayan DateTime parçaları Dates.default(period) değerine varsayılan olarak ayarlanacaktır.

DateTime(f::Function, y[, m, d, h, mi, s]; step=Day(1), limit=10000) -> DateTime

Bir DateTime oluşturun, ayarlayıcı API'si aracılığıyla. Başlangıç noktası, sağlanan y, m, d... argümanlarından oluşturulacak ve f::Function true döndürene kadar ayarlanacaktır. Ayarlamada adım boyutu, step anahtar kelimesi aracılığıyla manuel olarak sağlanabilir. limit, ayarlama API'sinin bir hata fırlatmadan önce takip edeceği maksimum iterasyon sayısına bir sınır sağlar (eğer f::Function asla tatmin edilmezse).

Örnekler

julia> DateTime(dt -> second(dt) == 40, 2010, 10, 20, 10; step = Second(1))
2010-10-20T10:00:40

julia> DateTime(dt -> hour(dt) == 20, 2010, 10, 20, 10; step = Hour(1), limit = 5)
HATA: ArgumentError: Ayarlama limiti aşıldı: 5 iterasyon
Stacktrace:
[...]

DateTime(dt::Date) -> DateTime

Bir Date'i DateTime'e dönüştürür. Yeni DateTime'in saat, dakika, saniye ve milisaniye kısımlarının sıfır olduğu varsayılmaktadır.

DateTime(dt::AbstractString, format::AbstractString; locale="english") -> DateTime

dt tarih saat dizesini format dizesinde verilen desene göre ayrıştırarak bir DateTime oluşturur (sözdizimi için DateFormat bakınız).

Örnekler

julia> DateTime("2020-01-01", "yyyy-mm-dd")
2020-01-01T00:00:00

julia> a = ("2020-01-01", "2020-01-02");

julia> [DateTime(d, dateformat"yyyy-mm-dd") for d ∈ a] # tercih edilen
2-element Vector{DateTime}:
 2020-01-01T00:00:00
 2020-01-02T00:00:00

format(dt::TimeType, format::AbstractString; locale="türkçe") -> AbstractString

Bir TimeType nesnesi kullanarak ve sağlanan format'ı uygulayarak bir dize oluşturun. Aşağıdaki karakter kodları format dizesini oluşturmak için kullanılabilir:

Ardışık kod karakterlerinin sayısı, kodun genişliğini belirtir. yyyy-mm formatı, y kodunun dört genişliğe sahip olmasını, m kodunun ise iki genişliğe sahip olmasını belirtir. Sayısal rakamlar üreten kodların bir mod ile ilişkisi vardır: sabit genişlik veya minimum genişlik. Sabit genişlik modu, belirtilen genişlikten daha kısa olduğunda değeri sıfırlarla soldan doldurur ve daha uzun olduğunda değeri keser. Minimum genişlik modu, genişlikten daha uzun olan değerleri kesmeden sabit genişlik gibi çalışır.

Bir format oluştururken, ayırıcı olarak herhangi bir kod dışı karakter kullanabilirsiniz. Örneğin "1996-01-15T00:00:00" dizesini oluşturmak için format: "yyyy-mm-ddTHH:MM:SS" kullanabilirsiniz. Bir kod karakterini literal olarak kullanmanız gerektiğinde, kaçış karakteri ters eğik çizgi kullanabilirsiniz. "1996y01m" dizesi "yyyy\ymm\m" formatı ile üretilebilir.

DateFormat(format::AbstractString, locale="türkçe") -> DateFormat

Tarih dize'lerini ayrıştırmak veya bir tarih nesnesini dize olarak biçimlendirmek için kullanılabilecek bir tarih biçimlendirme nesnesi oluşturur. Aşağıdaki karakter kodları format dizesini oluşturmak için kullanılabilir:

Yukarıda listelenmeyen karakterler genellikle tarih ve saat dilimleri arasındaki ayırıcılar olarak kabul edilir. Örneğin, "1996-01-15T00:00:00.0" dizesinin format dizesi "y-m-dTH:M:S.s" gibi olacaktır. Bir kod karakterini ayırıcı olarak kullanmanız gerekiyorsa, onu ters eğik çizgi ile kaçırabilirsiniz. "1995y01m" tarihi "y\ym\m" formatına sahip olacaktır.

12:00AM'nin 00:00 (gece yarısı) ile, 12:00PM'nin 12:00 (öğle) ile eşleştiğini unutmayın. p belirteci ile bir zamanı ayrıştırırken, herhangi bir saat (ister H ister I) 12 saatlik saat olarak yorumlanır, bu nedenle I kodu esasen çıktı için faydalıdır.

Bir DateFormat nesnesi oluşturmak maliyetlidir. Mümkün olduğunda, bir kez oluşturun ve birçok kez kullanın veya dateformat"" dize makrosunu deneyin. Bu makro, DateFormat nesnesini makro genişletme zamanında bir kez oluşturur ve daha sonra yeniden kullanır. Ayrıca, daha sonra listelenen birkaç önceden tanımlı biçimlendirici vardır.

DateTime ve format ile bir DateFormat nesnesini tarih dizelerini ayrıştırmak ve yazmak için nasıl kullanacağınızı görün.

dateformat"Y-m-d H:M:S"

Bir DateFormat nesnesi oluşturun. DateFormat("Y-m-d H:M:S") ile benzer, ancak DateFormat nesnesini makro genişletme sırasında bir kez oluşturur.

Format belirteçleri hakkında daha fazla bilgi için DateFormat sayfasına bakın.

DateTime(dt::AbstractString, df::DateFormat=ISODateTimeFormat) -> DateTime

dt tarih saat dizesini DateFormat nesnesinde verilen desene göre ayrıştırarak bir DateTime oluşturur veya belirtilmezse dateformat"yyyy-mm-dd\THH:MM:SS.s" kullanır.

DateTime(::AbstractString, ::AbstractString) ile benzer, ancak önceden oluşturulmuş bir DateFormat nesnesi ile benzer biçimlendirilmiş tarih saat dizelerini tekrar tekrar ayrıştırırken daha verimlidir.

Date(y, [m, d]) -> Date

Parçalarla bir Date türü oluşturun. Argümanlar Int64 türüne dönüştürülebilir olmalıdır.

Date(period::Period...) -> Date

Period tür parçaları ile bir Date türü oluşturun. Argümanlar herhangi bir sırada olabilir. Sağlanmayan Date parçaları, Dates.default(period) değerine varsayılan olarak ayarlanacaktır.

Date(f::Function, y[, m, d]; step=Day(1), limit=10000) -> Date

Date'i ayarlayıcı API'si aracılığıyla oluşturun. Başlangıç noktası, sağlanan y, m, d argümanlarından oluşturulacak ve f::Function doğru döndüğü sürece ayarlanacaktır. Ayarlamada adım boyutu, step anahtar kelimesi aracılığıyla manuel olarak sağlanabilir. limit, ayarlama API'sinin bir hata fırlatmadan önce takip edeceği maksimum yineleme sayısına bir sınır sağlar (verilen f::Function asla tatmin edilmezse).

Örnekler

julia> Date(date -> week(date) == 20, 2010, 01, 01)
2010-05-17

julia> Date(date -> year(date) == 2010, 2000, 01, 01)
2010-01-01

julia> Date(date -> month(date) == 10, 2000, 01, 01; limit = 5)
HATA: ArgumentError: Ayarlama limiti aşıldı: 5 yineleme
Stacktrace:
[...]

Date(dt::DateTime) -> Date

Bir DateTime'ı Date'e dönüştürür. DateTime'ın saat, dakika, saniye ve milisaniye kısımları kesilir, bu nedenle yalnızca yıl, ay ve gün kısımları inşaatta kullanılır.

Date(d::AbstractString, format::AbstractString; locale="türkçe") -> Date

d tarih dizesini format dizesinde verilen desene göre ayrıştırarak bir Date oluşturur (sözdizimi için DateFormat bölümüne bakın).

Örnekler

julia> Date("2020-01-01", "yyyy-mm-dd")
2020-01-01

julia> a = ("2020-01-01", "2020-01-02");

julia> [Date(d, dateformat"yyyy-mm-dd") for d ∈ a] # tercih edilen
2-element Vector{Date}:
 2020-01-01
 2020-01-02

Date(d::AbstractString, df::DateFormat=ISODateFormat) -> Date

d tarih dizesini DateFormat nesnesinde belirtilen desene göre ayrıştırarak bir Date oluşturur veya belirtilmezse tarihformat"yyyy-mm-dd" kullanır.

Date(::AbstractString, ::AbstractString) ile benzer, ancak önceden oluşturulmuş bir DateFormat nesnesi ile benzer biçimlendirilmiş tarih dizelerini tekrar tekrar ayrıştırırken daha verimlidir.

Zaman(h, [dk, s, ms, us, ns]) -> Zaman

Parçalar halinde bir Zaman türü oluşturun. Argümanlar Int64 türüne dönüştürülebilir olmalıdır.

Time(period::TimePeriod...) -> Time

Period türündeki parçalarla bir Time türü oluşturun. Argümanlar herhangi bir sırada olabilir. Sağlanmayan Time parçaları Dates.default(period) değerine varsayılan olarak ayarlanacaktır.

Time(f::Function, h, mi=0; step::Period=Second(1), limit::Int=10000)
Time(f::Function, h, mi, s; step::Period=Millisecond(1), limit::Int=10000)
Time(f::Function, h, mi, s, ms; step::Period=Microsecond(1), limit::Int=10000)
Time(f::Function, h, mi, s, ms, us; step::Period=Nanosecond(1), limit::Int=10000)

h, mi, s, ms, us argümanlarından sağlanan başlangıç noktası ile adjuster API aracılığıyla bir Time oluşturun ve f::Function true döndürene kadar ayarlayın. Ayarlama için adım boyutu, step anahtar kelimesi aracılığıyla manuel olarak sağlanabilir. limit, ayarlama API'sinin bir hata fırlatmadan önce takip edeceği maksimum iterasyon sayısına bir sınır sağlar (eğer f::Function asla tatmin edilmezse). Verilen argümanlar için daha büyük hassasiyet sağlamak üzere varsayılan adımın ayarlanacağını unutmayın; yani, saat, dakika ve saniye argümanları sağlandığında, varsayılan adım Second(1) yerine Millisecond(1) olacaktır.

Örnekler

julia> Time(t -> minute(t) == 30, 20)
20:30:00

julia> Time(t -> minute(t) == 0, 20)
20:00:00

julia> Time(t -> hour(t) == 10, 3; limit = 5)
HATA: ArgumentError: Ayarlama limiti aşıldı: 5 iterasyon
Stacktrace:
[...]

Time(dt::DateTime) -> Time

Bir DateTime'i Time'a dönüştürür. DateTime'ın saat, dakika, saniye ve milisaniye kısımları yeni Time'ı oluşturmak için kullanılır. Mikrosaniye ve nanosaniyeler varsayılan olarak sıfırdır.

Time(t::AbstractString, format::AbstractString; locale="türkçe") -> Time

format dizesinde belirtilen desene göre t zaman dizesini ayrıştırarak bir Time oluşturur (sözdizimi için DateFormat bölümüne bakın).

Örnekler

julia> Time("12:34pm", "HH:MMp")
12:34:00

julia> a = ("12:34pm", "2:34am");

julia> [Time(d, dateformat"HH:MMp") for d ∈ a] # tercih edilen
2-element Vector{Time}:
 12:34:00
 02:34:00

Time(t::AbstractString, df::DateFormat=ISOTimeFormat) -> Time

Time nesnesini, belirtilen DateFormat nesnesinde verilen deseni izleyerek t tarih saat dizesini ayrıştırarak oluşturur veya belirtilmezse tarihformat"HH:MM:SS.s" kullanır.

Time(::AbstractString, ::AbstractString) ile benzer, ancak önceden oluşturulmuş bir DateFormat nesnesi ile benzer biçimlendirilmiş zaman dizelerini tekrar tekrar ayrıştırırken daha verimlidir.

now() -> DateTime

Kullanıcının sistem saatine ve sistem saat dilimi yerel ayarına karşılık gelen bir DateTime döndürür.

now(::Type{UTC}) -> DateTime

Kullanıcının sistem saatine karşılık gelen bir DateTime döndürür, UTC/GMT olarak. Diğer saat dilimleri için TimeZones.jl paketine bakın.

Örnekler

julia> now(UTC)
2023-01-04T10:52:24.864

eps(::Type{DateTime}) -> Millisaniye
eps(::Type{Date}) -> Gün
eps(::Type{Time}) -> Nan saniye
eps(::TimeType) -> Periyot

TimeType tarafından desteklenen en küçük birim değerini döndürür.

Örnekler

julia> eps(DateTime)
1 millisaniye

julia> eps(Date)
1 gün

julia> eps(Time)
1 nan saniye

year(dt::TimeType) -> Int64

Bir Date veya DateTime'ın Int64 olarak yılı.

month(dt::TimeType) -> Int64

Bir Date veya DateTime'ın Int64 olarak ayı.

week(dt::TimeType) -> Int64

Bir Date veya DateTime'ın ISO hafta tarihi olarak bir Int64 döndürür. Bir yılın ilk haftası, yılın ilk Perşembe'sini içeren haftadır; bu, 4 Ocak'tan önceki tarihlerinin bir önceki yılın son haftasında olmasına neden olabilir. Örneğin, week(Date(2005, 1, 1)) 2004'ün 53. haftasıdır.

Örnekler

julia> week(Date(1989, 6, 22))
25

julia> week(Date(2005, 1, 1))
53

julia> week(Date(2004, 12, 31))
53

day(dt::TimeType) -> Int64

Bir Date veya DateTime'ın ayın günü olarak bir Int64 döner.

hour(dt::DateTime) -> Int64

Bir DateTime'in günündeki saatini Int64 olarak döndürür.

hour(t::Time) -> Int64

Bir Time'ın saatini Int64 olarak döndürür.

minute(dt::DateTime) -> Int64

Bir DateTime'in dakikasını Int64 olarak döndürür.

minute(t::Time) -> Int64

Bir Time'ın dakikası Int64 olarak.

second(dt::DateTime) -> Int64

Bir DateTime'in saniyesi Int64 olarak.

second(t::Time) -> Int64

Bir Time'ın Int64 olarak saniyesi.

millisecond(dt::DateTime) -> Int64

Bir DateTime'in milisaniyesi Int64 olarak.

millisecond(t::Time) -> Int64

Bir Time'ın milisaniyesi Int64 olarak.

mikrosaniye(t::Time) -> Int64

Bir Time nesnesinin mikrosaniyesi Int64 olarak.

nanosecond(t::Time) -> Int64

Bir Time nesnesinin nanosekundası Int64 olarak.

Year(v)

Verilen v değeri ile bir Year nesnesi oluşturun. Girdi, Int64 türüne kayıpsız bir şekilde dönüştürülebilir olmalıdır.

Month(v)

Verilen v değeri ile bir Month nesnesi oluşturun. Girdi, Int64 türüne kayıpsız bir şekilde dönüştürülebilir olmalıdır.

Week(v)

Verilen v değeri ile bir Week nesnesi oluşturun. Girdi, kayıpsız bir şekilde Int64 türüne dönüştürülebilir olmalıdır.

Day(v)

Verilen v değeri ile bir Day nesnesi oluşturun. Girdi, Int64 türüne kayıpsız bir şekilde dönüştürülebilir olmalıdır.

Hour(dt::DateTime) -> Hour

Bir DateTime'in saat kısmı Hour olarak.

Minute(dt::DateTime) -> Minute

Bir DateTime'ın dakika kısmı Minute olarak.

Second(dt::DateTime) -> Second

Bir DateTime'ın ikinci kısmı Second olarak.

Millisecond(dt::DateTime) -> Millisecond

Bir DateTime nesnesinin milisaniye kısmı Millisecond olarak.

Microsecond(dt::Time) -> Microsecond

Bir Zamanın mikro saniye kısmı Microsecond olarak.

Nanosecond(dt::Time) -> Nanosecond

Bir Zamanın nanosecond kısmı Nanosecond olarak.

yearmonth(dt::TimeType) -> (Int64, Int64)

Bir Date veya DateTime'ın yıl ve ay kısımlarını aynı anda döndürür.

monthday(dt::TimeType) -> (Int64, Int64)

Bir Date veya DateTime'ın ay ve gün kısımlarını aynı anda döndürür.

yearmonthday(dt::TimeType) -> (Int64, Int64, Int64)

Bir Date veya DateTime'ın yıl, ay ve gün kısımlarını aynı anda döndürür.

dayname(dt::TimeType; locale="türkçe") -> String
dayname(day::Integer; locale="türkçe") -> String

Verilen locale'deki haftanın gününe karşılık gelen tam gün adını döndürür. Ayrıca Integer da kabul eder.

Örnekler

julia> dayname(Date("2000-01-01"))
"Cumartesi"

julia> dayname(4)
"Perşembe"

dayabbr(dt::TimeType; locale="türkçe") -> String
dayabbr(day::Integer; locale="türkçe") -> String

Verilen locale'deki haftanın gününe karşılık gelen kısaltılmış ismi döndürür. Ayrıca Integer da kabul eder.

Örnekler

julia> dayabbr(Date("2000-01-01"))
"Cum"

julia> dayabbr(3)
"Çar"

dayofweek(dt::TimeType) -> Int64

Haftanın gününü Int64 olarak döndürür; 1 = Pazartesi, 2 = Salı, vb..

Örnekler

julia> dayofweek(Date("2000-01-01"))
6

dayofmonth(dt::TimeType) -> Int64

Bir Date veya DateTime'ın ay içindeki günü Int64 olarak döndürür.

dayofweekofmonth(dt::TimeType) -> Int

dt'nin haftanın günü için, dt'nin ayındaki hangi numara olduğunu döndür. Yani, eğer dt'nin haftanın günü Pazartesi ise, o zaman 1 = Ayın İlk Pazartesi'si, 2 = Ayın İkinci Pazartesi'si, vb. 1:5 aralığında.

Örnekler

julia> dayofweekofmonth(Date("2000-02-01"))
1

julia> dayofweekofmonth(Date("2000-02-08"))
2

julia> dayofweekofmonth(Date("2000-02-15"))
3

daysofweekinmonth(dt::TimeType) -> Int

dt'nin haftanın günü için, dt'nin ayındaki o haftanın günlerinin toplam sayısını döndürür. 4 veya 5 döner. Bir ay içindeki haftanın son gününü belirtmek için dayofweekofmonth(dt) == daysofweekinmonth(dt) ifadesini ayarlayıcı fonksiyona dahil ederek zamansal ifadelerde kullanışlıdır.

Örnekler

julia> daysofweekinmonth(Date("2005-01-01"))
5

julia> daysofweekinmonth(Date("2005-01-04"))
4

monthname(dt::TimeType; locale="türkçe") -> String
monthname(month::Integer, locale="türkçe") -> String

Verilen locale'deki Date veya DateTime veya Integer'ın ayının tam adını döndürür.

Örnekler

julia> monthname(Date("2005-01-04"))
"Ocak"

julia> monthname(2)
"Şubat"

monthabbr(dt::TimeType; locale="türkçe") -> String
monthabbr(month::Integer, locale="türkçe") -> String

Verilen locale'deki Date veya DateTime veya Integer'ın kısaltılmış ay adını döndürür.

Örnekler

julia> monthabbr(Date("2005-01-04"))
"Jan"

julia> monthabbr(2)
"Feb"

daysinmonth(dt::TimeType) -> Int

dt'nin ayındaki gün sayısını döndürür. Değer 28, 29, 30 veya 31 olacaktır.

Örnekler

julia> daysinmonth(Date("2000-01"))
31

julia> daysinmonth(Date("2001-02"))
28

julia> daysinmonth(Date("2000-02"))
29

isleapyear(dt::TimeType) -> Bool

dt'nin yılı bir artık yıl ise true döner.

Örnekler

julia> isleapyear(Date("2004"))
true

julia> isleapyear(Date("2005"))
false

dayofyear(dt::TimeType) -> Int

dt için yılın gününü döndürür; 1 Ocak 1. gün olarak kabul edilir.

daysinyear(dt::TimeType) -> Int

dt yılının artık yıl olması durumunda 366, aksi takdirde 365 döndürün.

Örnekler

julia> daysinyear(1999)
365

julia> daysinyear(2000)
366

quarterofyear(dt::TimeType) -> Int

dt'nin bulunduğu çeyreği döndürür. Değer aralığı 1:4'tür.

dayofquarter(dt::TimeType) -> Int

dt'nin mevcut çeyreğindeki günü döndürür. Değer aralığı 1:92'dir.

trunc(dt::TimeType, ::Type{Period}) -> TimeType

dt değerini sağlanan Period türüne göre keser.

Örnekler

julia> trunc(DateTime("1996-01-01T12:30:00"), Day)
1996-01-01T00:00:00

firstdayofweek(dt::TimeType) -> TimeType

dt'yi haftasının Pazartesi gününe ayarlar.

Örnekler

julia> firstdayofweek(DateTime("1996-01-05T12:30:00"))
1996-01-01T00:00:00

lastdayofweek(dt::TimeType) -> TimeType

dt'yi haftasının Pazar gününe ayarlar.

Örnekler

julia> lastdayofweek(DateTime("1996-01-05T12:30:00"))
1996-01-07T00:00:00

firstdayofmonth(dt::TimeType) -> TimeType

dt'yi ayının ilk gününe ayarlar.

Örnekler

julia> firstdayofmonth(DateTime("1996-05-20"))
1996-05-01T00:00:00

lastdayofmonth(dt::TimeType) -> TimeType

dt'yi ayının son gününe ayarlar.

Örnekler

julia> lastdayofmonth(DateTime("1996-05-20"))
1996-05-31T00:00:00

firstdayofyear(dt::TimeType) -> TimeType

dt'yi yılının ilk gününe ayarlar.

Örnekler

julia> firstdayofyear(DateTime("1996-05-20"))
1996-01-01T00:00:00

lastdayofyear(dt::TimeType) -> TimeType

dt'yi yılının son gününe ayarlar.

Örnekler

julia> lastdayofyear(DateTime("1996-05-20"))
1996-12-31T00:00:00

firstdayofquarter(dt::TimeType) -> TimeType

dt'yi çeyreğinin ilk gününe ayarlar.

Örnekler

julia> firstdayofquarter(DateTime("1996-05-20"))
1996-04-01T00:00:00

julia> firstdayofquarter(DateTime("1996-08-20"))
1996-07-01T00:00:00

lastdayofquarter(dt::TimeType) -> TimeType

dt'yi çeyreğinin son gününe ayarlar.

Örnekler

julia> lastdayofquarter(DateTime("1996-05-20"))
1996-06-30T00:00:00

julia> lastdayofquarter(DateTime("1996-08-20"))
1996-09-30T00:00:00

tonext(dt::TimeType, dow::Int; same::Bool=false) -> TimeType

dt'yi dow ile ilgili olan bir sonraki haftanın gününe ayarlar; burada 1 = Pazartesi, 2 = Salı, vb. same=true olarak ayarlandığında, mevcut dt'nin bir sonraki dow olarak kabul edilmesine izin verir ve ayarlama yapılmaz.

toprev(dt::TimeType, dow::Int; same::Bool=false) -> TimeType

dt'yi dow ile ilgili önceki haftanın gününe ayarlar; burada 1 = Pazartesi, 2 = Salı, vb. same=true olarak ayarlandığında, mevcut dt önceki dow olarak kabul edilir ve ayarlama yapılmaz.

tofirst(dt::TimeType, dow::Int; of=Month) -> TimeType

dt'yi ayının ilk dow'una ayarlar. Alternatif olarak, of=Year ayarlanırsa, yılın ilk dow'una ayarlanır.

tolast(dt::TimeType, dow::Int; of=Month) -> TimeType

dt'yi ayının son dow'una ayarlar. Alternatif olarak, of=Year ayarlanırsa, yılın son dow'una ayarlanır.

tonext(func::Function, dt::TimeType; step=Day(1), limit=10000, same=false) -> TimeType

dt'yi, func true döndürene kadar en fazla limit iterasyon ile step artışları yaparak ayarlar. func, tek bir TimeType argümanı almalı ve bir Bool döndürmelidir. same, dt'nin func'u tatmin etmede dikkate alınmasına izin verir.

toprev(func::Function, dt::TimeType; step=Day(-1), limit=10000, same=false) -> TimeType

dt'yi, func true döndürene kadar en fazla limit iterasyon ile step artışları yaparak ayarlar. func, tek bir TimeType argümanı almalı ve bir Bool döndürmelidir. same, dt'nin func'u tatmin etmede dikkate alınmasına izin verir.

Yıl(v)
Çeyrek(v)
Ay(v)
Hafta(v)
Gün(v)
Saat(v)
Dakika(v)
Saniye(v)
Milisaniye(v)
Mikrosaniye(v)
Nanisaniye(v)

Verilen v değeri ile bir Period türü oluşturun. Girdi, Int64 türüne kayıpsız bir şekilde dönüştürülebilir olmalıdır.

CompoundPeriod(periods) -> CompoundPeriod

Bir Period'lerin Vector'ından bir CompoundPeriod oluşturur. Aynı türdeki tüm Period'ler bir araya getirilecektir.

Örnekler

julia> Dates.CompoundPeriod(Dates.Hour(12), Dates.Hour(13))
25 saat

julia> Dates.CompoundPeriod(Dates.Hour(-1), Dates.Minute(1))
-1 saat, 1 dakika

julia> Dates.CompoundPeriod(Dates.Month(1), Dates.Week(-2))
1 ay, -2 hafta

julia> Dates.CompoundPeriod(Dates.Minute(50000))
50000 dakika

canonicalize(::CompoundPeriod) -> CompoundPeriod

CompoundPeriod'ı aşağıdaki kuralları uygulayarak kanonik formuna indirger:

• Yeterince büyük olan herhangi bir Period, daha kaba bir Period tarafından kısmen temsil edilebiliyorsa, birden fazla Period'a bölünecektir (örneğin, Hour(30) Day(1) + Hour(6) haline gelir)
• Zıt işaretlere sahip Period'lar mümkün olduğunda birleştirilecektir (örneğin, Hour(1) - Day(1) -Hour(23) haline gelir)

Örnekler

julia> canonicalize(Dates.CompoundPeriod(Dates.Hour(12), Dates.Hour(13)))
1 gün, 1 saat

julia> canonicalize(Dates.CompoundPeriod(Dates.Hour(-1), Dates.Minute(1)))
-59 dakika

julia> canonicalize(Dates.CompoundPeriod(Dates.Month(1), Dates.Week(-2)))
1 ay, -2 hafta

julia> canonicalize(Dates.CompoundPeriod(Dates.Minute(50000)))
4 hafta, 6 gün, 17 saat, 20 dakika

Dates.value(x::Period) -> Int64

Verilen bir dönem için, o döneme karşılık gelen değeri döndürür. Örneğin, value(Millisecond(10)) 10'u bir tamsayı olarak döndürür.

default(p::Period) -> Period

Girdi Periyodu için mantıklı bir "varsayılan" değer döndürmek için Yıl, Ay ve Gün için T(1) ve Saat, Dakika, Saniye ve Milisaniye için T(0) döndürün.

Dates.periods(::CompoundPeriod) -> Vector{Period}

Verilen CompoundPeriod'i oluşturan Periodlerin Vector'ını döndürür.

floor(dt::TimeType, p::Period) -> TimeType

dt'ye p çözünürlüğünde eşit veya daha küçük en yakın Date veya DateTime değerini döndürür.

Kolaylık olması açısından, p bir değer yerine bir tür de olabilir: floor(dt, Dates.Hour) ifadesi floor(dt, Dates.Hour(1)) için bir kısayoldur.

julia> floor(Date(1985, 8, 16), Month)
1985-08-01

julia> floor(DateTime(2013, 2, 13, 0, 31, 20), Minute(15))
2013-02-13T00:30:00

julia> floor(DateTime(2016, 8, 6, 12, 0, 0), Day)
2016-08-06T00:00:00

ceil(dt::TimeType, p::Period) -> TimeType

dt'ye en yakın Date veya DateTime'ı p çözünürlüğünde büyük veya eşit olarak döndürür.

Kolaylık olması açısından, p bir değer yerine bir tür olabilir: ceil(dt, Dates.Hour) ifadesi ceil(dt, Dates.Hour(1)) için bir kısayoldur.

julia> ceil(Date(1985, 8, 16), Month)
1985-09-01

julia> ceil(DateTime(2013, 2, 13, 0, 31, 20), Minute(15))
2013-02-13T00:45:00

julia> ceil(DateTime(2016, 8, 6, 12, 0, 0), Day)
2016-08-07T00:00:00

round(dt::TimeType, p::Period, [r::RoundingMode]) -> TimeType

dt'ye en yakın Date veya DateTime'ı p çözünürlüğünde döndürür. Varsayılan olarak (RoundNearestTiesUp), bağlar (örneğin, 9:30'u en yakın saate yuvarlama) yukarı yuvarlanacaktır.

Kolaylık olması açısından, p bir değer yerine bir tür olabilir: round(dt, Dates.Hour) ifadesi round(dt, Dates.Hour(1)) için bir kısayoldur.

julia> round(Date(1985, 8, 16), Month)
1985-08-01

julia> round(DateTime(2013, 2, 13, 0, 31, 20), Minute(15))
2013-02-13T00:30:00

julia> round(DateTime(2016, 8, 6, 12, 0, 0), Day)
2016-08-07T00:00:00

round(::TimeType, ::Period, ::RoundingMode) için geçerli yuvarlama modları RoundNearestTiesUp (varsayılan), RoundDown (floor) ve RoundUp (ceil)'dir.

floor(x::Period, precision::T) where T <: Union{TimePeriod, Week, Day} -> T

x'i precision'ın en yakın katına yuvarlayın. Eğer x ve precision farklı Period alt türleri ise, dönen değer precision ile aynı türde olacaktır.

Kolaylık olması açısından, precision bir değer yerine bir tür olabilir: floor(x, Dates.Hour) ifadesi floor(x, Dates.Hour(1)) için bir kısayoldur.

julia> floor(Day(16), Week)
2 weeks

julia> floor(Minute(44), Minute(15))
30 minutes

julia> floor(Hour(36), Day)
1 day

Month veya Year gibi bir precision'a yuvarlama desteklenmemektedir, çünkü bu Period'ler tutarsız uzunluktadır.

ceil(x::Period, precision::T) where T <: Union{TimePeriod, Week, Day} -> T

x'i precision'ın en yakın katına yuvarlayın. Eğer x ve precision farklı Period alt türleri ise, dönen değer precision ile aynı türde olacaktır.

Kolaylık olması açısından, precision bir değer yerine bir tür olabilir: ceil(x, Dates.Hour) ifadesi ceil(x, Dates.Hour(1)) için bir kısayoldur.

julia> ceil(Day(16), Week)
3 weeks

julia> ceil(Minute(44), Minute(15))
45 minutes

julia> ceil(Hour(36), Day)
2 days

Month veya Year'ler için bir precision ile yuvarlama desteklenmemektedir, çünkü bu Period'ler tutarsız uzunluktadır.

round(x::Period, precision::T, [r::RoundingMode]) where T <: Union{TimePeriod, Week, Day} -> T

x'i precision'a en yakın katına yuvarlayın. Eğer x ve precision farklı Period alt türleri ise, dönen değer precision ile aynı türde olacaktır. Varsayılan olarak (RoundNearestTiesUp), bağlar (örneğin, 90 dakikayı en yakın saate yuvarlamak) yukarı yuvarlanacaktır.

Kolaylık olması açısından, precision bir değer yerine bir tür olabilir: round(x, Dates.Hour) ifadesi round(x, Dates.Hour(1)) için bir kısayoldur.

julia> round(Day(16), Week)
2 weeks

julia> round(Minute(44), Minute(15))
45 minutes

julia> round(Hour(36), Day)
2 days

round(::Period, ::T, ::RoundingMode) için geçerli yuvarlama modları RoundNearestTiesUp (varsayılan), RoundDown (floor) ve RoundUp (ceil)'dir.

Month veya Year'lar için bir precision'a yuvarlama desteklenmemektedir, çünkü bu Period'ler tutarsız uzunluktadır.

floorceil(dt::TimeType, p::Period) -> (TimeType, TimeType)

Bir Date veya DateTime'in p çözünürlüğündeki floor ve ceil değerlerini aynı anda döndürür. Hem floor hem de ceil'i ayrı ayrı çağırmaktan daha verimlidir.

floorceil(x::Period, precision::T) where T <: Union{TimePeriod, Week, Day} -> (T, T)

Aynı anda Period'ün p çözünürlüğündeki floor ve ceil değerlerini döndürür. Hem floor hem de ceil'i ayrı ayrı çağırmaktan daha verimlidir.

epochdays2date(günler) -> Tarih

Rounding epoch'tan (0000-01-01T00:00:00) itibaren geçen gün sayısını alır ve karşılık gelen Tarih'i döner.

epochms2datetime(milisaniye) -> TarihZaman

Rounding epoch'tan ( 0000-01-01T00:00:00 ) itibaren geçen milisaniye sayısını alır ve karşılık gelen TarihZaman'ı döner.

date2epochdays(dt::Date) -> Int64

Verilen Date'i alır ve yuvarlama epoch'undan (0000-01-01T00:00:00) itibaren geçen gün sayısını bir Int64 olarak döner.

datetime2epochms(dt::DateTime) -> Int64

Verilen DateTime'ı alır ve yuvarlama epoch'undan (0000-01-01T00:00:00) itibaren geçen milisaniye sayısını Int64 olarak döner.

today() -> Date

now()'un tarih kısmını döndürür.

unix2datetime(x) -> DateTime

Unix epoch 1970-01-01T00:00:00'dan itibaren geçen saniye sayısını alır ve karşılık gelen DateTime'a dönüştürür.

datetime2unix(dt::DateTime) -> Float64

Verilen DateTime'ı alır ve unix epoch'u 1970-01-01T00:00:00'dan itibaren geçen saniye sayısını Float64 olarak döner.

julian2datetime(julian_days) -> DateTime

Julian takviminden epoch -4713-11-24T12:00:00'dan itibaren geçen gün sayısını alır ve karşılık gelen DateTime'ı döner.

datetime2julian(dt::DateTime) -> Float64

Verilen DateTime'ı alır ve Julian epoch -4713-11-24T12:00:00'dan bu yana geçen Julian takvim günlerinin sayısını Float64 olarak döner.

rata2datetime(günler) -> DateTime

Epoch 0000-12-31T00:00:00'dan itibaren geçen Rata Die gün sayısını alır ve karşılık gelen DateTime'ı döndürür.

datetime2rata(dt::TimeType) -> Int64

Verilen Date veya DateTime'dan itibaren epoch'tan beri geçen Rata Die günlerinin sayısını döndürür.

Dates.ISODateTimeFormat

Tarih ve saat için ISO8601 formatlamasını açıklar. Bu, bir DateTime'ın Dates.format için varsayılan değerdir.

Örnekler

julia> Dates.format(DateTime(2018, 8, 8, 12, 0, 43, 1), ISODateTimeFormat)
"2018-08-08T12:00:43.001"

Dates.ISODateFormat

Bir tarihin ISO8601 formatlamasını açıklar. Bu, bir Date için Dates.format'ın varsayılan değeridir.

Örnekler

julia> Dates.format(Date(2018, 8, 8), ISODateFormat)
"2018-08-08"

Dates.ISOTimeFormat

Zaman için ISO8601 formatlamasını açıklar. Bu, bir Time'ın Dates.format için varsayılan değeridir.

Örnekler

julia> Dates.format(Time(12, 0, 43, 1), ISOTimeFormat)
"12:00:43.001"

Dates.RFC1123Format

Tarih ve saat için RFC1123 formatlamasını açıklar.

Örnekler

julia> Dates.format(DateTime(2018, 8, 8, 12, 0, 43, 1), RFC1123Format)
"Çar, 08 Ağu 2018 12:00:43"