time – Le langage de programmation Go

time – Le langage de programmation Go

Rate this post


Sommaire

Vue d'ensemble ▹

Vue d'ensemble ▾

Le temps de paquet fournit une fonctionnalité pour mesurer et afficher le temps.

Les calculs calendaires supposent toujours un calendrier grégorien, avec
pas de secondes intercalaires.

Horloges Monotoniques

Les systèmes d’exploitation fournissent à la fois une «horloge murale», soumise à
changements pour la synchronisation d'horloge, et une "horloge monotone", qui est
ne pas. La règle générale est que l'horloge murale sert à indiquer l'heure et
l'horloge monotone sert à mesurer le temps. Plutôt que de scinder l'API,
dans ce paquet, le temps renvoyé par time.Now contient à la fois un mur
lecture d'horloge et une lecture d'horloge monotone; plus tard
les opérations utilisent la lecture de l'horloge murale, mais plus tard, la mesure du temps
opérations, en particulier les comparaisons et les soustractions, utilisent le
lecture d'horloge monotone.

Par exemple, ce code calcule toujours un temps écoulé positif de
environ 20 millisecondes, même si l'horloge murale est changée pendant
l'opération étant chronométrée:

start: = time.Now ()
... opération qui prend 20 millisecondes ...
t: = heure.Maintenant ()
écoulé: = t.Sub (début)

Autres expressions idiomatiques, telles que time.Since (début), time.Un (délai) et
time.Now (). Before (date limite), sont également robustes contre l’horloge murale
réinitialise.

Le reste de cette section donne les détails précis de la façon dont les opérations
utilisez des horloges monotones, mais il n'est pas nécessaire de comprendre ces détails
utiliser ce paquet.

L'heure renvoyée par time.Now contient une lecture d'horloge monotone.
Si Time t affiche une horloge monotone, t.Add ajoute la même durée à
les lectures de l'horloge murale et de l'horloge monotone pour calculer le résultat.
Parce que t.AddDate (y, m, d), t.Round (d) et t.Truncate (d) sont des temps de mur
calculs, ils enlèvent toujours toute lecture d’horloge monotone de leurs résultats.
Parce que t.In, t.Local et t.UTC sont utilisés pour leur effet sur l'interprétation
du temps du mur, ils suppriment également toute horloge monotone de leurs résultats.
Le moyen canonique de supprimer une lecture d'horloge monotone est d'utiliser t = t.Round (0).

Si les temps t et u contiennent tous deux des lectures d’horloge monotones, les opérations
t.Après (u), t.Avant (u), t.Equal (u), et t.Sub (u) sont effectués
en utilisant uniquement les lectures de l'horloge monotone, en ignorant l'horloge murale
lectures. Si t ou u ne contient aucune horloge monotone, ceux-ci
les opérations reposent sur l'utilisation des relevés de l'horloge murale.

Sur certains systèmes, l'horloge monotone s'arrête si l'ordinateur se met en veille.
Sur un tel système, t.Sub (u) peut ne pas refléter avec exactitude la
le temps qui s'est passé entre t et u.

Parce que la lecture d'horloge monotone n'a pas de sens en dehors
le processus en cours, les formulaires sérialisés générés par t.GobEncode,
t.MarshalBinary, t.MarshalJSON et t.MarshalText omettent le monotone
la lecture de l'horloge, et t.Format ne fournit aucun format pour cela. De même, le
constructeurs time.Date, time.Parse, time.ParseInLocation et time.Unix,
ainsi que les unmarshalers t.GobDecode, t.UnmarshalBinary.
t.UnmarshalJSON et t.UnmarshalText créent toujours des temps avec
pas de lecture d'horloge monotone.

Notez que l’opérateur Go == compare non seulement l’instant, mais
aussi l'emplacement et la lecture monotone de l'horloge. Voir le
documentation pour le type de temps pour une discussion de l'égalité
tester les valeurs de temps.

Pour le débogage, le résultat de t.String inclut le monotone
lecture d'horloge si présente. Si t! = U en raison de lectures différentes de l’horloge monotone,
cette différence sera visible lors de l'impression de t.String () et de u.String ().

Index

Index

Constantes
func Après (Durée) <-chan Temps
func Sleep (d Durée)
func Tick (Durée) <-chan Temps
type Durée
func ParseDuration (chaîne de caractères) (Durée, erreur)
func Depuis (t Time) Durée
func jusqu'à ce que (t Time) Durée
func (d Durée) Heures () float64
func (d Durée) Minutes () float64
func (d duration) nanosecondes () int64
func (d Durée) Tour (m Durée) Durée
func (d Durée) Secondes () float64
func (d Duration) Chaîne () chaîne
func (d Duration) Truncate (m Duration) Durée
type Lieu
func FixedZone (chaîne de nom, offset int) * Emplacement
func LoadLocation (chaîne de nom) (* emplacement, erreur)
func LoadLocationFromTZData (chaîne de nom, données []octet) (* Lieu, erreur)
func (l * Location) Chaîne () chaîne
tapez le mois
func (m Month) String () chaîne
type ParseError
func (e * ParseError) Error () chaîne
type ticker
func NewTicker (d Duration) * Téléscripteur
func (t * Ticker) Stop ()
tapez Time
func Date (année int, mois mois, jour, heure, min, sec, nsec int, loc * Lieu) Heure
func Now () Time
func Parse (layout, chaîne de valeur) (Time, error)
func ParseInLocation (layout, chaîne de valeur, loc * Location) (Time, error)
func Unix (sec int64, nsec int64) Heure
func (t Time) Ajouter (d Duration) Time
func (t Time) AddDate (années int, mois int, jours int) Heure
func (t Time) Après (u Time) bool
func (t Time) AppendFormat (b []octet, chaîne de présentation) []octet
func (t Time) Avant (u Time) bool
func (t Time) Horloge () (heure, minute, seconde)
func (t Time) Date () (année int, mois mois, jour int)
func (t Time) Jour () int
func (t Time) égal à (u Time) bool
func (t Time) Format (chaîne de mise en forme) chaîne
func (t * Time) GobDecode (données []octet) erreur
func (t Time) GobEncode () ([]octet, erreur)
func (t Time) Heure () int
func (t Time) ISOWeek () (année, semaine int)
func (t Time) In (loc * Location) Time
func (t Time) IsZero () bool
func (t Time) Heure locale ()
func (t Time) Lieu () * Lieu
func (t Time) MarshalBinary () ([]octet, erreur)
func (t Time) MarshalJSON () ([]octet, erreur)
func (t Time) MarshalText () ([]octet, erreur)
func (t Time) Minute () int
func (t Time) Mois () Mois
func (t Time) Nanosecond () int
func (t Time) Round (d Durée) Time
func (t Time) Second () int
func (t Time) String () chaîne
func (t Time) Sous (u Time) Durée
func (t Time) Truncate (d Durée) Time
func (t Time) UTC () Time
func (t Time) Unix () int64
func (t Time) UnixNano () int64
func (t * Time) UnmarshalBinary (données []octet) erreur
func (t * Time) UnmarshalJSON (données []octet) erreur
func (t * Time) UnmarshalText (données []octet) erreur
func (t Time) Jour de la semaine () Jour de la semaine
func (t Time) Année () int
func (t Time) YearDay () int
func (t Time) Zone () (nom de la chaîne, offset int)
type minuterie
func AfterFunc (d Durée, f func ()) * Minuterie
func NewTimer (d Durée) * Minuterie
func (t * Timer) Réinitialiser (d Durée) bool
func (t * Timer) Stop () bool
type jour de semaine
func (d Weekday) String () chaîne

Fichiers de package

format.go

dormir.go

sys_unix.go

tick.go

temps.go

zoneinfo.go

zoneinfo_read.go

zoneinfo_unix.go

Constantes

Ce sont des dispositions prédéfinies à utiliser dans Time.Format et time.Parse.
L'heure de référence utilisée dans les mises en page est l'heure spécifique:

Lun 2 jan 15:04:05 HNE 2006

qui est le temps Unix 1136239445. Puisque MST est GMT-0700,
le temps de référence peut être considéré comme

01/02 15:04:05 PM '06 -0700

Pour définir votre propre format, écrivez à quoi ressemblerait le temps de référence
comme formaté à votre façon; voir les valeurs de constantes comme ANSIC,
StampMicro ou Kitchen pour des exemples. Le modèle consiste à démontrer ce que le
le temps de référence ressemble à ce que les méthodes Format et Parse puissent s'appliquer
la même transformation en une valeur de temps générale.

Certaines dispositions valides sont des valeurs de temps non valides pour time.Parse, en raison des formats
tels que _ pour le remplissage d'espace et Z pour les informations de zone.

Dans la chaîne de format, un trait de soulignement _ représente un espace qui peut être
remplacé par un chiffre si le nombre suivant (un jour) a deux chiffres; pour
compatibilité avec les formats de temps Unix à largeur fixe.

Un point décimal suivi d'un ou de plusieurs zéros représente une fraction
deuxièmement, imprimé avec le nombre donné de décimales. Un point décimal
suivi d'un ou plusieurs neuf représente une fraction de seconde, imprimée
le nombre donné de décimales, avec les zéros de fin supprimés.
Lors de l'analyse (uniquement), l'entrée peut contenir une fraction de seconde
champ immédiatement après le champ des secondes, même si la mise en page ne
signifier sa présence. Dans ce cas, un point décimal suivi d’un maximum
la série de chiffres est analysée comme une fraction de seconde.

Les décalages numériques de fuseau horaire se présentent comme suit:

-0700 ± hhmm
-07: 00 ± hh: mm
-07 ± hh

Remplacer le signe au format par un déclencheur Z
le comportement ISO 8601 de l'impression Z au lieu d'un
décalage pour la zone UTC. Ainsi:

Z0700 Z ou ± hhmm
Z07: 00 Z ou ± hh: mm
Z07 Z ou ± hh

Les formats de jour de la semaine reconnus sont "lundi" et "lundi".
Les formats de mois reconnus sont "Jan" et "Janvier".

Texte dans la chaîne de format qui n'est pas reconnue comme faisant partie de la référence
le temps est répété mot à mot pendant le format et devrait apparaître mot à mot
dans l'entrée à analyser.

L’exemple exécutable de Time.Format illustre le fonctionnement de
de la chaîne de mise en page en détail et est une bonne référence.

Notez que les formats RFC822, RFC850 et RFC1123 doivent être appliqués
seulement aux heures locales. Les appliquer aux heures UTC utilisera "UTC" comme
l’abréviation de fuseau horaire, alors que, à proprement parler, ces RFC nécessitent
utilisation de "GMT" dans ce cas.
En général, RFC1123Z doit être utilisé à la place de RFC1123 pour les serveurs
qui insistent sur ce format, et RFC3339 devrait être préféré pour les nouveaux protocoles.
Les RFC3339, RFC822, RFC822Z, RFC1123 et RFC1123Z sont utiles pour le formatage;
lorsqu'ils sont utilisés avec time.Parse, ils n'acceptent pas tous les formats d'heure
permis par les RFC.
Le format RFC3339Nano supprime les zéros de fin du champ des secondes
et peut donc ne pas trier correctement une fois formaté.

const (
        ANSIC       = "Lun. Jan _2 15:04:05 2006"
        UnixDate    = "Lun. Janv. _ 15:04:05 HNR 2006"
        RubyDate    = "Lundi 2 janvier 15:04:05 - 0700 2006"
        RFC822      = "02 janvier 06 15h04 HNT"
        RFC822Z     = "02 janvier 06 15:04 -0700" 
        RFC850      = "Lundi, 02-Jan-06 15:04:05 HNT"
        RFC1123     = "Lun., 02 janv. 2006 15:04:05 HNT"
        RFC1123Z    = "Lun., 02 janv. 2006 15:04:05 -0700" 
        RFC3339     = "2006-01-02T15: 04: 05Z07: 00"
        RFC3339Nano = "2006-01-02T15: 04: 05.999999999Z07: 00"
        Cuisine     = "15h04"
        
        Timbre      = "Jan _2 15:04:05"
        StampMilli = "Jan _2 15: 04: 05.000"
        StampMicro = "Jan _2 15: 04: 05.000000"
        StampNano  = "Jan _2 15: 04: 05.000000000"
)

Durées communes. Il n'y a pas de définition pour les unités de jour ou supérieures
pour éviter toute confusion entre les transitions de fuseaux horaires.

Pour compter le nombre d'unités dans une durée, divisez:

seconde: = time.Second
fmt.Print (int64 (seconde / time.Millisecond)) // imprime 1 000

Pour convertir un nombre entier d'unités en une durée, multipliez:

secondes: = 10
fmt.Print (time.Duration (seconds) * time.Second) // affiche 10 secondes
const (
        Nanoseconde  Durée = 1
        Microseconde          = 1000 * nanoseconde
        Milliseconde          = 1000 * microseconde
        Seconde               = 1000 * Milliseconde
        Minute               = 60 * seconde
        Heure                 = 60 * minute
)
func Après (Durée) <-chan Temps

Après attend que la durée s'écoule, puis envoie l'heure actuelle
sur le canal de retour.
C'est l'équivalent de NewTimer (d) .C.
Le minuteur sous-jacent n'est pas récupéré par le ramasse-miettes
jusqu'à ce que la minuterie se déclenche. Si l'efficacité est un problème, utilisez NewTimer
à la place, appelez Timer.Stop si la minuterie n’est plus nécessaire.

Exemple

func Sleep (d Durée)

Sleep met en pause le goroutine actuel pendant au moins la durée d.
Une durée négative ou nulle entraîne le retour immédiat du sommeil.

Exemple

func Tick (Durée) <-chan Temps

Tick ​​est un wrapper de commodité pour NewTicker donnant accès au ticking
canal uniquement. Alors que Tick est utile pour les clients qui n'ont pas besoin de fermer
le ticker, sachez que sans un moyen de le fermer, le sous-jacent
Le téléscripteur ne peut pas être récupéré par le ramasse-miettes; il "fuit".
Contrairement à NewTicker, Tick retournera nil si d <= 0.

Exemple

Une durée représente le temps écoulé entre deux instants
en tant que compte int64 nanosecondes. La représentation limite la
la plus longue durée représentable à environ 290 ans.

type Durée int64

Exemple

func ParseDuration

func ParseDuration (chaîne de caractères) (Durée, erreur)

ParseDuration analyse une chaîne de durée.
Une chaîne de durée est une séquence éventuellement signée de
nombres décimaux, chacun avec une fraction optionnelle et un suffixe d'unité,
tels que "300ms", "-1.5h" ou "2h45m".
Les unités de temps valides sont "ns", "us" (ou "µs"), "ms", "s", "m", "h".

Exemple

10h0m0s
1h10m10s
il y a 4210 secondes dans 1h10m10s

func depuis

func Depuis (t Time) Durée

Depuis renvoie le temps écoulé depuis t.
C'est un raccourci pour time.Now (). Sub (t).

func jusqu'à

1.8

func jusqu'à ce que (t Time) Durée

Until renvoie la durée jusqu'à t.
C'est un raccourci pour t.Sub (time.Now ()).

func (Durée) Heures

func (d Durée) Heures () float64

Heures renvoie la durée sous forme de nombre d'heures en virgule flottante.

Exemple

Il me reste 4,5 heures de travail.

func (Durée) Minutes

func (d Durée) Minutes () float64

Minutes renvoie la durée sous forme de nombre à virgule flottante.

Exemple

Le film dure 90 minutes.

func (Durée) Nanosecondes

func (d duration) nanosecondes () int64

Nanosecondes renvoie la durée sous forme de nombre entier nanosecondes.

Exemple

une microseconde a 1000 nanosecondes.

func (Durée) Ronde

1,9

func (d Durée) Tour (m Durée) Durée

Round renvoie le résultat de l'arrondi d au multiple de m le plus proche.
Le comportement d'arrondi pour les valeurs à mi-chemin consiste à arrondir à zéro.
Si le résultat dépasse le maximum (ou le minimum)
valeur pouvant être stockée dans une durée,
Round renvoie la durée maximale (ou minimale).
Si m <= 0, Round renvoie d inchangé.

Exemple

d.Round (1ns) = 1h15m30.918273645s
d.Round (1µs) = 1h15m30.918274s
d.Round (1ms) = 1h15m30.918s
d.Round (1s) = 1h15m31s
d.Round (2s) = 1h15m30s
d.round (1m0s) = 1h16m0s
d.Round (10m0s) = 1h20m0s
d.Round (1h0m0s) = 1h0m0s

func (Durée) Secondes

func (d Durée) Secondes () float64

Seconds renvoie la durée sous forme de nombre à virgule flottante de secondes.

Exemple

décoller dans t-90 secondes.

func (Durée) String

func (d Duration) Chaîne () chaîne

String renvoie une chaîne représentant la durée sous la forme "72h3m0.5s".
Les unités zéro en tête sont omises. Comme cas particulier, les durées inférieures à un
deuxième format, utilisez une unité plus petite (millièmes, micro ou nanosecondes) pour assurer
que le chiffre de départ est différent de zéro. La durée zéro se présente sous forme de 0.

Exemple

func (durée) tronqué

1,9

func (d Duration) Truncate (m Duration) Durée

Troncature renvoie le résultat de l'arrondi d vers zéro à un multiple de m.
Si m <= 0, Truncate renvoie d inchangé.

Exemple

d.Truncate (1ns) = 1h15m30.918273645s
d.Truncate (1µs) = 1h15m30.918273s
d.Truncate (1ms) = 1h15m30.918s
d.Truncate (1s) = 1h15m30s
d.Truncate (2s) = 1h15m30s
d.Truncate (1m0s) = 1h15m0s
d.Truncate (10m0s) = 1h10m0s
d.Truncate (1h0m0s) = 1h0m0s

Un lieu mappe les instants de temps sur la zone utilisée à ce moment-là.
En général, l'emplacement représente la collection de décalages horaires
utilisé dans une zone géographique telle que CEST et CET pour l’Europe centrale.

type Location struct {
        
}

Local représente le fuseau horaire local du système.

var Local * Emplacement = & localLoc

UTC représente le temps universel coordonné (UTC).

var UTC * Emplacement = & utcLoc

Exemple

func FixedZone

func FixedZone (chaîne de nom, offset int) * Emplacement

FixedZone renvoie un emplacement qui utilise toujours
le nom de la zone donnée et son décalage (secondes à l'est de l'UTC).

Exemple

L'heure est: 10 Nov 09 23:00 UTC-8

func LoadLocation

func LoadLocation (chaîne de nom) (* emplacement, erreur)

LoadLocation renvoie l'emplacement avec le nom donné.

Si le nom est "" ou "UTC", LoadLocation renvoie UTC.
Si le nom est "Local", LoadLocation renvoie Local.

Sinon, le nom est considéré comme un nom d’emplacement correspondant à un fichier.
dans la base de données de fuseaux horaires IANA, tels que "America / New_York".

La base de données de fuseau horaire requise par LoadLocation peut ne pas être
présent sur tous les systèmes, en particulier les systèmes non-Unix.
LoadLocation cherche dans le répertoire ou le fichier zip non compressé
nommé par la variable d’environnement ZONEINFO, le cas échéant, recherche ensuite
emplacements d'installation connus sur les systèmes Unix,
et regarde enfin dans $ GOROOT / lib / time / zoneinfo.zip.

Exemple

2018-08-30 05:00:00 -0700 PDT

func LoadLocationFromTZData

1.10

func LoadLocationFromTZData (chaîne de nom, données []octet) (* Lieu, erreur)

LoadLocationFromTZData renvoie un emplacement avec le nom donné
initialisé à partir des données au format base de données IANA Time Zone.
Les données doivent être au format d'un fichier de fuseau horaire IANA standard
(par exemple, le contenu de / etc / localtime sur les systèmes Unix).

func (* Location) String

func (l * Location) Chaîne () chaîne

String renvoie un nom descriptif pour les informations de fuseau horaire.
correspondant à l'argument de nom à LoadLocation ou FixedZone.

Un mois spécifie un mois de l'année (janvier = 1, …).

tapez Month int
const (
        janvier Mois = 1 + iota
        février
        Mars
        avril
        Peut
        juin
        juillet
        août
        septembre
        octobre
        novembre
        décembre
)

Exemple

func (Month) String

func (m Month) String () chaîne

String renvoie le nom anglais du mois ("janvier", "février", …).

ParseError décrit un problème d'analyse d'une chaîne temporelle.

type ParseError struct {
        Chaîne de mise en page
        Chaîne de valeur
        LayoutElem chaîne
        Chaîne ValueElem
        Chaîne de message
}

func (* ParseError) Erreur

func (e * ParseError) Error () chaîne

Error renvoie la représentation sous forme de chaîne d'une erreur ParseError.

Un ticker détient un canal qui émet des "ticks" d'une horloge
à intervalles.

type Ticker struct {
        C <-chan Time
        
}

func NewTicker

func NewTicker (d Duration) * Téléscripteur

NewTicker renvoie un nouveau ticker contenant un canal qui enverra le message
heure avec une période spécifiée par l'argument de durée.
Il ajuste les intervalles ou les pertes de temps pour compenser les récepteurs lents.
La durée d doit être supérieure à zéro; sinon, NewTicker paniquera.
Arrêtez le ticker pour libérer les ressources associées.

Exemple

func (* Ticker) Stop

func (t * Ticker) Stop ()

Stop éteint un ticker. Après Stop, plus aucune tick ne sera envoyée.
Stop ne ferme pas le canal, pour empêcher un goroutine simultané
lecture du canal de voir une "tique" erronée.

Une heure représente un instant dans le temps avec une précision à la nanoseconde.

Les programmes utilisant des temps doivent généralement les stocker et les transmettre en tant que valeurs,
pas des pointeurs. Autrement dit, les variables de temps et les champs de struct doivent être de
tapez time.Time, pas * time.Time.

Une valeur de temps peut être utilisée par plusieurs goroutines simultanément sauf
que les méthodes GobDecode, UnmarshalBinary, UnmarshalJSON et
UnmarshalText ne sont pas sécurisés contre la concurrence.

Les instants de temps peuvent être comparés en utilisant les méthodes Avant, Après et Equal.
La méthode Sub soustrait deux instants, produisant une Duration.
La méthode Add ajoute une heure et une durée, produisant une heure.

La valeur zéro du type Heure est le 1er janvier de l’année 1, 00: 00: 00: 00.000000000 UTC.
Comme il est peu probable que ce temps s’apparaisse dans la pratique, la méthode IsZero donne
un moyen simple de détecter une heure qui n’a pas été initialisée explicitement.

A chaque heure est associée une localisation, consultée lors du calcul de la
forme de présentation de l’heure, comme dans les méthodes Format, Heure et Année.
Les méthodes Local, UTC et In In return une heure avec un emplacement spécifique.
Changer le lieu de cette manière ne change que la présentation; ce ne est pas
changer l'instant dans le temps étant noté et donc n'affecte pas la
calculs décrits dans les paragraphes précédents.

Représentations d'une valeur de temps enregistrée par le GobEncode, MarshalBinary,
Les méthodes MarshalJSON et MarshalText stockent le décalage de Time.Location, mais pas
le nom de l'emplacement. Ils perdent donc des informations sur l'heure d'été.

En plus de la lecture «horloge murale» requise, une heure peut contenir une option
lecture de l'horloge monotone du processus en cours, pour une précision supplémentaire
pour comparaison ou soustraction.
Voir la section «Horloges monotoniques» dans la documentation du paquet pour plus de détails.

Notez que l’opérateur Go == compare non seulement l’instant, mais également le
Emplacement et la lecture monotone de l'horloge. Par conséquent, les valeurs de temps ne doivent pas
être utilisés comme clés de carte ou de base de données sans garantir au préalable que
un emplacement identique a été défini pour toutes les valeurs, ce qui peut être obtenu
grâce à l’utilisation de la méthode UTC ou locale, et que la lecture de l’horloge monotone
a été supprimée en définissant t = t.Round (0). En général, préférez t.Equal (u)
à t == u, car t.Equal utilise la comparaison la plus précise disponible et
gère correctement le cas où un seul de ses arguments a un monotone
lecture d'horloge.

tapez Time struct {
        
}

func Date

func Date (année int, mois mois, jour, heure, min, sec, nsec int, loc * Lieu) Heure

Date renvoie l'heure correspondant à

aaaa-mm-jj hh: mm: ss + nsec nanosecondes

dans la zone appropriée pour cette heure à l'endroit indiqué.

Les valeurs de mois, jour, heure, minute, seconde et nsec peuvent être en dehors
leurs gammes habituelles et seront normalisées lors de la conversion.
Par exemple, le 32 octobre est converti au 1 er novembre.

Une transition à l'heure d'été évite ou répète les heures.
Par exemple, aux États-Unis, le 13 mars 2011 à 2 h 15 ne s'est jamais produit,
tandis que le 6 novembre 2011 à 1 h 15 s'est produite deux fois. Dans de tels cas, le
le choix du fuseau horaire, et donc l'heure, n'est pas bien défini.
Date renvoie une heure correcte dans l'une des deux zones concernées
dans la transition, mais cela ne garantit pas.

Date panique si loc est nul.

Exemple

Go lancé au 2009-11-10 15:00:00 -0800 PST

func maintenant

func Now () Time

Retourne maintenant l'heure locale actuelle.

func Parse

func Parse (layout, chaîne de valeur) (Time, error)

Parse analyse une chaîne formatée et renvoie la valeur de temps qu’elle représente.
La mise en page définit le format en montrant comment l’heure de référence,
défini pour être

Lun 2 jan 15:04:05 -0700 HNR 2006

serait interprété s'il s'agissait de la valeur; il sert d'exemple de
le format d'entrée. La même interprétation sera alors faite à la
chaîne d'entrée.

Les schémas prédéfinis ANSIC, UnixDate, RFC3339 et autres décrivent les normes
et des représentations pratiques du temps de référence. Pour plus d'informations
sur les formats et la définition du temps de référence, voir le
documentation pour ANSIC et les autres constantes définies par ce paquet.
En outre, l’exemple exécutable de Time.Format illustre le fonctionnement de
de la chaîne de mise en page en détail et est une bonne référence.

Les éléments omis de la valeur sont supposés être zéro ou, quand
zéro est impossible, un, donc l'analyse de "15h04" renvoie l'heure
correspondant au 1 janvier, année 0, 15:04:00 UTC (notez que, comme l'année est
0, cette heure est avant l'heure zéro).
Les années doivent être comprises entre 0000 et 9999. Le jour de la semaine est vérifié
pour la syntaxe mais il est par ailleurs ignoré.

En l'absence d'indicateur de fuseau horaire, Parse renvoie une heure au format UTC.

Lors de l'analyse d'une heure avec un décalage de zone tel que -0700, si le décalage correspond
fuseau horaire utilisé par l’emplacement actuel (Local), puis Parse utilise ce
emplacement et zone dans l'heure retournée. Sinon, il enregistre l'heure comme
être dans un emplacement fabriqué avec le temps fixé au décalage de zone donné.

Lors de l'analyse d'une heure avec une abréviation de zone comme MST, si l'abréviation de zone
a un décalage défini à l’emplacement actuel, puis ce décalage est utilisé.
L'abréviation de zone "UTC" est reconnue comme UTC quel que soit l'emplacement.
Si l’abréviation de la zone est inconnue, Parse enregistre le temps comme étant
dans un emplacement fabriqué avec l'abréviation de zone donnée et un décalage d'origine.
Ce choix signifie qu’une telle heure peut être analysée et reformatée avec la
même disposition sans perte, mais l’instant exact utilisé dans la représentation sera
différer par le décalage de zone réel. Pour éviter de tels problèmes, préférez les dispositions de temps
qui utilisent un décalage de zone numérique ou utilisent ParseInLocation.

Exemple

2013-02-03 19:54:00 -0800 PST
2013-02-03 00:00:00 +0000 UTC
2006-01-02 15:04:05 +0000 UTC
2006-01-02 15:04:05 +0700 +0700
erreur d’analyse "2006-01-02T15: 04: 05Z07: 00": texte supplémentaire: 07:00

func ParseInLocation

1.1

func ParseInLocation (layout, chaîne de valeur, loc * Location) (Time, error)

ParseInLocation est semblable à Parse mais diffère de deux manières importantes.
Premièrement, en l'absence d'informations de fuseau horaire, Parse interprète une heure comme UTC;
ParseInLocation interprète l'heure comme dans l'emplacement indiqué.
Deuxièmement, quand une zone ou une abréviation est donnée, Parse essaie de la faire correspondre
contre l'emplacement local; ParseInLocation utilise l'emplacement indiqué.

Exemple

2012-07-09 05:02:00 +0200 CEST
2012-07-09 00:00:00 +0200 CEST

func Unix

func Unix (sec int64, nsec int64) Heure

Unix retourne l'heure locale correspondant à l'heure Unix donnée,
sec secondes et nsec nanosecondes depuis le 1er janvier 1970 UTC.
Il est valide de passer nsec en dehors de la plage [0, 999999999].
Toutes les valeurs en secondes n'ont pas de valeur de temps correspondante. Un tel
la valeur est 1 << 63-1 (la plus grande valeur int64).

func (Time) Ajouter

func (t Time) Ajouter (d Duration) Time

Ajouter renvoie le temps t + d.

Exemple

start = 2009-01-01 12:00:00 +0000 UTC
start.Add (time.Second * 10) = 2009-01-01 12:00:10 +0000 UTC
start.Add (time.Minute * 10) = 2009-01-01 12:10:00 +0000 UTC
start.Add (time.Hour * 10) = 2009-01-01 22:00:00 +0000 UTC
start.Add (time.Hour * 24 * 10) = 2009-01-11 12:00:00 +0000 UTC

func (Time) AddDate

func (t Time) AddDate (années int, mois int, jours int) Heure

AddDate renvoie l'heure correspondant à l'ajout du
étant donné le nombre d'années, de mois et de jours à t.
Par exemple, AddDate (-1, 2, 3) appliqué au 1er janvier 2011
retourne le 4 mars 2010.

AddDate normalise son résultat de la même manière que Date,
donc, par exemple, en ajoutant un mois aux rendements du 31 octobre
1er décembre, la forme normalisée pour le 31 novembre.

Exemple

oneDayLater: start.AddDate (0, 0, 1) = 2009-01-02 00:00:00 +0000 UTC
oneMonthLater: start.AddDate (0, 1, 0) = 2009-02-01 00:00:00 +0000 UTC
oneYearLater: start.AddDate(1, 0, 0) = 2010-01-01 00:00:00 +0000 UTC

func (Time) After

func (t Time) After(u Time) bool

After reports whether the time instant t is after u.

Exemple

year3000.After(year2000) = true
year2000.After(year3000) = false

func (Time) AppendFormat

1,5

func (t Time) AppendFormat(b []byte, layout string) []octet

AppendFormat is like Format but appends the textual
representation to b and returns the extended buffer.

Exemple

func (Time) Before

func (t Time) Before(u Time) bool

Before reports whether the time instant t is before u.

Exemple

year2000.Before(year3000) = true
year3000.Before(year2000) = false

func (Time) Clock

func (t Time) Clock() (hour, min, sec int)

Clock returns the hour, minute, and second within the day specified by t.

func (Time) Date

func (t Time) Date() (year int, month Month, day int)

Date returns the year, month, and day in which t occurs.

Exemple

year = 2000
month = February
day = 1

func (Time) Day

func (t Time) Day() int

Day returns the day of the month specified by t.

Exemple

func (Time) Equal

func (t Time) Equal(u Time) bool

Equal reports whether t and u represent the same time instant.
Two times can be equal even if they are in different locations.
For example, 6:00 +0200 CEST and 4:00 UTC are Equal.
See the documentation on the Time type for the pitfalls of using == with
Time values; most code should use Equal instead.

Exemple

datesEqualUsingEqualOperator = false
datesEqualUsingFunction = true

func (Time) Format

func (t Time) Format(layout string) string

Format returns a textual representation of the time value formatted
according to layout, which defines the format by showing how the reference
time, defined to be

Mon Jan 2 15:04:05 -0700 MST 2006

would be displayed if it were the value; it serves as an example of the
desired output. The same display rules will then be applied to the time
valeur.

A fractional second is represented by adding a period and zeros
to the end of the seconds section of layout string, as in "15:04:05.000"
to format a time stamp with millisecond precision.

Predefined layouts ANSIC, UnixDate, RFC3339 and others describe standard
and convenient representations of the reference time. Pour plus d'informations
about the formats and the definition of the reference time, see the
documentation for ANSIC and the other constants defined by this package.

Exemple

default format: 2015-03-07 11:06:39 -0800 PST
Unix format: Sat Mar  7 11:06:39 PST 2015
Same, in UTC: Sat Mar  7 19:06:39 UTC 2015

Formats:

Basic           "Mon Jan 2 15:04:05 MST 2006" gives "Sat Mar 7 11:06:39 PST 2015"
No pad          "<2>" gives "<7>"
Spaces          "<_2>" gives "< 7>"
Zeros           "<02>" gives "<07>"
Suppressed pad  "04:05" gives "06:39"
Unix            "Mon Jan _2 15:04:05 MST 2006" gives "Sat Mar  7 11:06:39 PST 2015"
AM/PM           "3PM==3pm==15h" gives "11AM==11am==11h"
No fraction     "Mon Jan _2 15:04:05 MST 2006" gives "Sat Mar  7 11:06:39 PST 2015"
0s for fraction "15:04:05.00000" gives "11:06:39.12340"
9s for fraction "15:04:05.99999999" gives "11:06:39.1234"

func (*Time) GobDecode

func (t *Time) GobDecode(data []byte) error

GobDecode implements the gob.GobDecoder interface.

func (Time) GobEncode

func (t Time) GobEncode() ([]byte, error)

GobEncode implements the gob.GobEncoder interface.

func (Time) Hour

func (t Time) Hour() int

Hour returns the hour within the day specified by t, in the range [0, 23].

func (Time) ISOWeek

func (t Time) ISOWeek() (year, week int)

ISOWeek returns the ISO 8601 year and week number in which t occurs.
Week ranges from 1 to 53. Jan 01 to Jan 03 of year n might belong to
week 52 or 53 of year n-1, and Dec 29 to Dec 31 might belong to week 1
of year n+1.

func (Time) In

func (t Time) In(loc *Location) Time

In returns a copy of t representing the same time instant, but
with the copy's location information set to loc for display
purposes.

In panics if loc is nil.

func (Time) IsZero

func (t Time) IsZero() bool

IsZero reports whether t represents the zero time instant,
January 1, year 1, 00:00:00 UTC.

func (Time) Local

func (t Time) Local() Time

Local returns t with the location set to local time.

func (Time) Location

func (t Time) Location() *Location

Location returns the time zone information associated with t.

func (Time) MarshalBinary

1.2

func (t Time) MarshalBinary() ([]byte, error)

MarshalBinary implements the encoding.BinaryMarshaler interface.

func (Time) MarshalJSON

func (t Time) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaler interface.
The time is a quoted string in RFC 3339 format, with sub-second precision added if present.

func (Time) MarshalText

1.2

func (t Time) MarshalText() ([]byte, error)

MarshalText implements the encoding.TextMarshaler interface.
The time is formatted in RFC 3339 format, with sub-second precision added if present.

func (Time) Minute

func (t Time) Minute() int

Minute returns the minute offset within the hour specified by t, in the range [0, 59].

func (Time) Month

func (t Time) Month() Month

Month returns the month of the year specified by t.

func (Time) Nanosecond

func (t Time) Nanosecond() int

Nanosecond returns the nanosecond offset within the second specified by t,
in the range [0, 999999999].

func (Time) Round

1.1

func (t Time) Round(d Duration) Time

Round returns the result of rounding t to the nearest multiple of d (since the zero time).
The rounding behavior for halfway values is to round up.
If d <= 0, Round returns t stripped of any monotonic clock reading but otherwise unchanged.

Round operates on the time as an absolute duration since the
zero time; it does not operate on the presentation form of the
time. Thus, Round(Hour) may return a time with a non-zero
minute, depending on the time's Location.

Exemple

t.Round(   1ns) = 12:15:30.918273645
t.Round(   1µs) = 12:15:30.918274
t.Round(   1ms) = 12:15:30.918
t.Round(    1s) = 12:15:31
t.Round(    2s) = 12:15:30
t.Round(  1m0s) = 12:16:00
t.Round( 10m0s) = 12:20:00
t.Round(1h0m0s) = 12:00:00

func (Time) Second

func (t Time) Second() int

Second returns the second offset within the minute specified by t, in the range [0, 59].

func (Time) String

func (t Time) String() string

String returns the time formatted using the format string

"2006-01-02 15:04:05.999999999 -0700 MST"

If the time has a monotonic clock reading, the returned string
includes a final field "m=±", where value is the monotonic
clock reading formatted as a decimal number of seconds.

The returned string is meant for debugging; for a stable serialized
representation, use t.MarshalText, t.MarshalBinary, or t.Format
with an explicit format string.

Exemple

withNanoseconds = 2000-02-01 12:13:14.000000015 +0000 UTC
withoutNanoseconds = 2000-02-01 12:13:14 +0000 UTC

func (Time) Sub

func (t Time) Sub(u Time) Duration

Sub returns the duration t-u. If the result exceeds the maximum (or minimum)
value that can be stored in a Duration, the maximum (or minimum) duration
will be returned.
To compute t-d for a duration d, use t.Add(-d).

Exemple

func (Time) Truncate

1.1

func (t Time) Truncate(d Duration) Time

Truncate returns the result of rounding t down to a multiple of d (since the zero time).
If d <= 0, Truncate returns t stripped of any monotonic clock reading but otherwise unchanged.

Truncate operates on the time as an absolute duration since the
zero time; it does not operate on the presentation form of the
time. Thus, Truncate(Hour) may return a time with a non-zero
minute, depending on the time's Location.

Exemple

t.Truncate(  1ns) = 12:15:30.918273645
t.Truncate(  1µs) = 12:15:30.918273
t.Truncate(  1ms) = 12:15:30.918
t.Truncate(   1s) = 12:15:30
t.Truncate(   2s) = 12:15:30
t.Truncate( 1m0s) = 12:15:00
t.Truncate(10m0s) = 12:10:00

func (Time) UTC

func (t Time) UTC() Time

UTC returns t with the location set to UTC.

func (Time) Unix

func (t Time) Unix() int64

Unix returns t as a Unix time, the number of seconds elapsed
since January 1, 1970 UTC. The result does not depend on the
location associated with t.

Exemple

2001-09-09 01:46:40 +0000 UTC
2001-09-09 01:46:40 +0000 UTC
2001-09-09 01:46:40 +0000 UTC
1000000000
1000000000000000000

func (Time) UnixNano

func (t Time) UnixNano() int64

UnixNano returns t as a Unix time, the number of nanoseconds elapsed
since January 1, 1970 UTC. The result is undefined if the Unix time
in nanoseconds cannot be represented by an int64 (a date before the year
1678 or after 2262). Note that this means the result of calling UnixNano
on the zero Time is undefined. The result does not depend on the
location associated with t.

func (*Time) UnmarshalBinary

1.2

func (t *Time) UnmarshalBinary(data []byte) error

UnmarshalBinary implements the encoding.BinaryUnmarshaler interface.

func (*Time) UnmarshalJSON

func (t *Time) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaler interface.
The time is expected to be a quoted string in RFC 3339 format.

func (*Time) UnmarshalText

1.2

func (t *Time) UnmarshalText(data []byte) error

UnmarshalText implements the encoding.TextUnmarshaler interface.
The time is expected to be in RFC 3339 format.

func (Time) Weekday

func (t Time) Weekday() Weekday

Weekday returns the day of the week specified by t.

func (Time) Year

func (t Time) Year() int

Year returns the year in which t occurs.

func (Time) YearDay

1.1

func (t Time) YearDay() int

YearDay returns the day of the year specified by t, in the range [1,365] for non-leap years,
et [1,366] in leap years.

func (Time) Zone

func (t Time) Zone() (name string, offset int)

Zone computes the time zone in effect at time t, returning the abbreviated
name of the zone (such as "CET") and its offset in seconds east of UTC.

The Timer type represents a single event.
When the Timer expires, the current time will be sent on C,
unless the Timer was created by AfterFunc.
A Timer must be created with NewTimer or AfterFunc.

type Timer struct {
        C <-chan Time
        
}

func AfterFunc

func AfterFunc(d Duration, f func()) *Timer

AfterFunc waits for the duration to elapse and then calls f
in its own goroutine. It returns a Timer that can
be used to cancel the call using its Stop method.

func NewTimer

func NewTimer(d Duration) *Timer

NewTimer creates a new Timer that will send
the current time on its channel after at least duration d.

func (*Timer) Reset

1.1

func (t *Timer) Reset(d Duration) bool

Reset changes the timer to expire after duration d.
It returns true if the timer had been active, false if the timer had
expired or been stopped.

Resetting a timer must take care not to race with the send into t.C
that happens when the current timer expires.
If a program has already received a value from t.C, the timer is known
to have expired, and t.Reset can be used directly.
If a program has not yet received a value from t.C, however,
the timer must be stopped and—if Stop reports that the timer expired
before being stopped—the channel explicitly drained:

if !t.Stop() {
	<-t.C
}
t.Reset(d)

This should not be done concurrent to other receives from the Timer's
canal.

Note that it is not possible to use Reset's return value correctly, as there
is a race condition between draining the channel and the new timer expiring.
Reset should always be invoked on stopped or expired channels, as described above.
The return value exists to preserve compatibility with existing programs.

func (*Timer) Stop

func (t *Timer) Stop() bool

Stop prevents the Timer from firing.
It returns true if the call stops the timer, false if the timer has already
expired or been stopped.
Stop does not close the channel, to prevent a read from the channel succeeding
incorrectly.

To prevent a timer created with NewTimer from firing after a call to Stop,
check the return value and drain the channel.
For example, assuming the program has not received from t.C already:

if !t.Stop() {
	<-t.C
}

This cannot be done concurrent to other receives from the Timer's
canal.

For a timer created with AfterFunc(d, f), if t.Stop returns false, then the timer
has already expired and the function f has been started in its own goroutine;
Stop does not wait for f to complete before returning.
If the caller needs to know whether f is completed, it must coordinate
with f explicitly.

A Weekday specifies a day of the week (Sunday = 0, …).

type Weekday int
const (
        Sunday Weekday = iota
        Lundi
        Mardi
        Mercredi
        Jeudi
        Vendredi
        samedi
)

func (Weekday) String

func (d Weekday) String() string

String returns the English name of the day ("Sunday", "Monday", …).


Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *