strftime
v1.1.0
Temps de travail rapide pour Go
f , err := strftime . New ( `.... pattern ...` )
if err := f . Format ( buf , time . Now ()); err != nil {
log . Println ( err . Error ())
}Les objectifs de cette bibliothèque sont
Prend le modèle et l'heure, et le formate. Cette fonction est une fonction utilitaire qui recompile le modèle à chaque fois que la fonction est appelée. Si vous savez à l'avance que vous formaterez le même modèle plusieurs fois, envisagez d'utiliser New pour créer un objet Strftime et le réutiliser.
Prend le modèle et crée un nouvel objet Strftime .
Renvoie la chaîne de modèle utilisée pour créer cet objet Strftime
Formate l'heure selon le modèle précompilé et écrit le résultat dans le io.Writer spécifié
Formate l'heure selon le modèle précompilé et renvoie la chaîne de résultat.
| modèle | description |
|---|---|
| %UN | représentation nationale du nom complet du jour de la semaine |
| %un | représentation nationale du jour de semaine abrégé |
| %B | représentation nationale du nom complet du mois |
| %b | représentation nationale du nom du mois abrégé |
| %C | (année / 100) sous forme de nombre décimal ; les chiffres simples sont précédés d'un zéro |
| %c | représentation nationale de l'heure et de la date |
| %D | équivalent à %m/%d/%y |
| %d | jour du mois sous forme de nombre décimal (01-31) |
| %e | le jour du mois sous forme de nombre décimal (1-31) ; les chiffres simples sont précédés d'un espace |
| %F | équivalent à %Y-%m-%d |
| %H | l'heure (horloge de 24 heures) sous forme de nombre décimal (00-23) |
| %h | identique à %b |
| %JE | l'heure (horloge de 12 heures) sous forme de nombre décimal (01-12) |
| %j | le jour de l'année sous forme de nombre décimal (001-366) |
| %k | l'heure (horloge de 24 heures) sous forme de nombre décimal (0-23) ; les chiffres simples sont précédés d'un espace |
| %l | l'heure (horloge de 12 heures) sous forme de nombre décimal (1-12) ; les chiffres simples sont précédés d'un espace |
| %M | la minute sous forme de nombre décimal (00-59) |
| %m | le mois sous forme de nombre décimal (01-12) |
| %n | une nouvelle ligne |
| %p | représentation nationale soit « ante meridiem » (am) soit « post meridiem » (pm), selon le cas. |
| %R | équivalent à %H:%M |
| %r | équivalent à %I:%M:%S %p |
| %S | la seconde sous forme de nombre décimal (00-60) |
| %T | équivalent à %H:%M:%S |
| %t | un onglet |
| %U | le numéro de semaine de l'année (dimanche comme premier jour de la semaine) sous forme de nombre décimal (00-53) |
| %u | le jour de la semaine (lundi comme premier jour de la semaine) sous forme de nombre décimal (1-7) |
| %V | le numéro de semaine de l'année (lundi comme premier jour de la semaine) sous forme de nombre décimal (01-53) |
| % v | équivalent à %e-%b-%Y |
| %W | le numéro de semaine de l'année (lundi comme premier jour de la semaine) sous forme de nombre décimal (00-53) |
| %w | le jour de la semaine (dimanche comme premier jour de la semaine) sous forme de nombre décimal (0-6) |
| %X | représentation nationale de l'époque |
| %x | représentation nationale de la date |
| %Y | l'année avec le siècle comme nombre décimal |
| %y | l'année sans siècle sous forme de nombre décimal (00-99) |
| %Z | le nom du fuseau horaire |
| %z | le fuseau horaire décalé par rapport à UTC |
| %% | un '%' |
Cette bibliothèque essaie en général d'être conforme à POSIX, mais parfois vous avez juste besoin d'une ou deux spécifications supplémentaires qui sont relativement largement utilisées mais qui ne sont pas incluses dans la spécification POSIX.
Par exemple, POSIX ne précise pas comment imprimer les millisecondes, mais les implémentations courantes permettent à %f ou %L d'y parvenir.
Pour ces instances, strftime.Strftime peut être configuré pour utiliser un ensemble personnalisé de spécifications :
ss := strftime.NewSpecificationSet()
ss.Set('L', ...) // provide implementation for `%L`
// pass this new specification set to the strftime instance
p, err := strftime.New(`%L`, strftime.WithSpecificationSet(ss))
p.Format(..., time.Now())
L'implémentation doit implémenter l'interface Appender , qui est
type Appender interface {
Append([]byte, time.Time) []byte
}
Pour les extensions couramment utilisées telles que l'exemple milliseconde et l'horodatage Unix, nous fournissons une implémentation par défaut afin que l'utilisateur puisse effectuer l'une des opérations suivantes :
// (1) Pass a specification byte and the Appender
// This allows you to pass arbitrary Appenders
p, err := strftime.New(
`%L`,
strftime.WithSpecification('L', strftime.Milliseconds),
)
// (2) Pass an option that knows to use strftime.Milliseconds
p, err := strftime.New(
`%L`,
strftime.WithMilliseconds('L'),
)
De même pour l'horodatage Unix :
// (1) Pass a specification byte and the Appender
// This allows you to pass arbitrary Appenders
p, err := strftime.New(
`%s`,
strftime.WithSpecification('s', strftime.UnixSeconds),
)
// (2) Pass an option that knows to use strftime.UnixSeconds
p, err := strftime.New(
`%s`,
strftime.WithUnixSeconds('s'),
)
Si une spécification commune manque, n'hésitez pas à soumettre un PR (mais assurez-vous de pouvoir défendre à quel point elle est "commune")
Milliseconds (option associée : WithMilliseconds );
Microseconds (option associée : WithMicroseconds ) ;
UnixSeconds (option associée : WithUnixSeconds ).
Les tests suivants ont été exécutés séparément car certaines bibliothèques utilisaient cgo sur des plates-formes spécifiques (notamment la version fastly)
// On my OS X 10.14.6, 2.3 GHz Intel Core i5, 16GB memory.
// go version go1.13.4 darwin/amd64
hummingbird% go test -tags bench -benchmem -bench .
<snip>
BenchmarkTebeka-4 297471 3905 ns/op 257 B/op 20 allocs/op
BenchmarkJehiah-4 818444 1773 ns/op 256 B/op 17 allocs/op
BenchmarkFastly-4 2330794 550 ns/op 80 B/op 5 allocs/op
BenchmarkLestrrat-4 916365 1458 ns/op 80 B/op 2 allocs/op
BenchmarkLestrratCachedString-4 2527428 546 ns/op 128 B/op 2 allocs/op
BenchmarkLestrratCachedWriter-4 537422 2155 ns/op 192 B/op 3 allocs/op
PASS
ok github.com/lestrrat-go/strftime 25.618s
// On a host on Google Cloud Platform, machine-type: f1-micro (vCPU x 1, memory: 0.6GB)
// (Yes, I was being skimpy)
// Linux <snip> 4.9.0-11-amd64 #1 SMP Debian 4.9.189-3+deb9u1 (2019-09-20) x86_64 GNU/Linux
// go version go1.13.4 linux/amd64
hummingbird% go test -tags bench -benchmem -bench .
<snip>
BenchmarkTebeka 254997 4726 ns/op 256 B/op 20 allocs/op
BenchmarkJehiah 659289 1882 ns/op 256 B/op 17 allocs/op
BenchmarkFastly 389150 3044 ns/op 224 B/op 13 allocs/op
BenchmarkLestrrat 699069 1780 ns/op 80 B/op 2 allocs/op
BenchmarkLestrratCachedString 2081594 589 ns/op 128 B/op 2 allocs/op
BenchmarkLestrratCachedWriter 825763 1480 ns/op 192 B/op 3 allocs/op
PASS
ok github.com/lestrrat-go/strftime 11.355s
Cette bibliothèque est beaucoup plus rapide que les autres bibliothèques SI vous pouvez réutiliser le modèle de format.
Voici la liste annotée des résultats du benchmark. Vous voyez clairement que (ré)utiliser un objet Strftime et produire une chaîne est le plus rapide. Écrire sur un io.Writer semble un peu lent, mais comme celui qui produit la chaîne fait presque exactement la même chose, nous pensons qu'il s'agit simplement de la surcharge liée à l'écriture sur un io.Writer
| Chemin d'importation | Score | Note |
|---|---|---|
| github.com/lestrat-go/strftime | 3000000 | Utilisation FormatString() (mis en cache) |
| github.com/fastly/go-utils/strftime | 2000000 | Version pure go sur OS X |
| github.com/lestrat-go/strftime | 1000000 | Utilisation Format() (NON mis en cache) |
| github.com/jehiah/go-strftime | 1000000 | |
| github.com/fastly/go-utils/strftime | 1000000 | version cgo sous Linux |
| github.com/lestrat-go/strftime | 500000 | Utilisation Format() (mis en cache) |
| github.com/tebeka/strftime | 300000 |
Toutefois, selon votre schéma, cette vitesse peut varier. Si vous trouvez un modèle particulier qui semble lent, veuillez envoyer des correctifs ou des tests.
Veuillez également noter que ce test utilise uniquement le sous-ensemble de spécifications de conversion prises en charge par TOUTES les bibliothèques comparées.
Éléments à prendre en compte lors des comparaisons de performances à l'avenir :
%specification gère-t-il ?
