L'heure UNIX ou l'heure POSIX (eng. Heure Unix) est un moyen pratique d'encoder l'heure, adopté comme principal dans UNIX et d'autres systèmes d'exploitation compatibles POSIX.
Le temps lui-même est écrit en secondes écoulées depuis le début de l'époque Unix, qui a commencé à minuit (UTC) du 31 décembre 1969 au 1er janvier 1970. L'heure Unix est cohérente avec l'UTC, en particulier lors de la déclaration des secondes intercalaires UTC - les secondes correspondantes sont répétées.

Cette méthode de stockage est prise en charge par de nombreux systèmes et est très pratique, par exemple, les dates sont comparées à la seconde la plus proche, et le stockage est compact et facilement converti en n'importe quel format lisible. Bien sûr, il y a des inconvénients, par exemple, lors de l'accès fréquent aux éléments de date, tels que le numéro du mois, etc. Cependant, dans la plupart des cas, l'efficacité est obtenue en stockant la date sous la forme d'une valeur unique, au lieu d'un ensemble de champs.

Obtenir UnixTime dans un environnement "habitat" différent :

perle	temps
PHP	temps()
rubis	Time.now (ou Time.new). Pour sortir : Time.now.to_i
Python	importez d'abord l'heure, puis time.time()
Java	époque longue = System.currentTimeMillis()/1000 ;
Microsoft .NET C#	époque = (DateTime.Now.ToUniversalTime().Ticks - 621355968000000000) / 10000000 ;
VBScript/ASP	DiffDate("s", "01/01/1970 00:00:00", Maintenant())
Erlang	calendrier : datetime_to_gregorian_seconds(calendar :now_to_universal_time(now()))-719528*24*3600.
MySQL	SELECT unix_timestamp(maintenant())
PostgreSQLName	SELECT extrait(epoch FROM now());
serveur SQL	SELECT DATEIFF(s, "1970-01-01 00:00:00", GETUTCDATE())
Javascript	Math.round(new Date().getTime()/1000.0) getTime() renvoie l'heure en millisecondes.
Unix/Linux	date +%s
Autre système d'exploitation	Ligne de commande : perl -e "print time" (si Perl est installé sur votre système)

Comment convertir une date régulière en UnixTime ?

PHP	mktime( montre, minutes, secondes, mois, jour, année)
rubis	Heure.local( année, mois, jour, montre, minutes, secondes, usec) (ou Time.gm pour une sortie GMT/UTC). Pour sortir, ajoutez .to_i
Python	importez d'abord l'heure, puis int(time.mktime(time.strptime("2000-01-01 12:34:00", "%Y-%m-%d %H:%M:%S")))
Java	long epoch = new java.text.SimpleDateFormat("jj/MM/aaaa HH:mm:ss").parse("01/01/1970 01:00:00");
VBScript/ASP	DiffDate("s", "01/01/1970 00:00:00", champ date)
MySQL	SELECT unix_horodatage( temps) Format de l'heure : AAAA-MM-JJ HH:MM:SS ou AAMMJJ ou AAAAMMJJ
PostgreSQLName	SELECT extrait(epoch FROM date("2000-01-01 12:34")); Avec horodatage : SELECT EXTRACT(EPOCH FROM TIMESTAMP WITH TIME ZONE "2001-02-16 20:38:40-08"); Avec intervalle : SELECT EXTRACT(EPOCH FROM INTERVAL "5 jours 3 heures");
serveur SQL	SELECT DATEIFF(s, "1970-01-01 00:00:00", champ date)
Unix/Linux	date +%s -d"1er janvier 1980 00:00:01"

Reconvertissez les secondes UnixTime en une date lisible par l'homme :

PHP	date( Format, temps unix);
rubis	Heure.at( temps unix)
Python	importez d'abord l'heure, puis time.strftime("%a, %d %b %Y %H:%M:%S +0000", time.localtime( temps unix)) Remplacez time.localtime par time.gmtime pour la date GMT.
Java	Chaîne date = new java.text.SimpleDateFormat("jj/MM/aaaa HH:mm:ss").format(new java.util.Date ( temps unix*1000));
VBScript/ASP	DateAjoute("s", temps unix, "01/01/1970 00:00:00")
PostgreSQLName	SELECT TIMESTAMP WITH TIME ZONE "epoch" + temps unix* INTERVALLE "1 seconde" ;
MySQL	from_unixtime( temps unix, facultatif, format de sortie) Format de sortie standard AAAA-MM-JJ HH:MM:SS
serveur SQL	DATEADJ(s, temps unix, "1970-01-01 00:00:00")
Microsoft Excel	=(A1 / 86400) + 25569 Le résultat sera dans le fuseau horaire GMT. Pour les autres fuseaux horaires : =((A1 +/- différence de fuseau) / 86400) + 25569.
linux	date-j@1190000000
Autre système d'exploitation	Ligne de commande : perl -e "print scalar(localtime( temps unix))" (Si Perl est installé) Remplacez "localtime" par "gmtime" pour le fuseau horaire GMT/UTC.

La plupart des informations sont volées à :

Parce que il n'y a pas d'outils intégrés dans le carburant diesel, nous créons le script suivant : #!/bin/sh truss date 2>&1 |grep ^time |awk "(print $3;)" exit $? ou nawk "BEGIN(print srand())" ou en perl : perl -e "print time, "\n";" trouver la date de modification du fichier : truss -v lstat -t lstat ls -l file.txt 2>&1 1>/dev/null | grep "mt\=\" | awk "(imprimer $9;)"

Comment obtenir l'heure Unix dans...

perle	temps
PHP	temps()
rubis	Time.now (ou Time.new). Pour sortir : Time.now.to_i
Python	importez d'abord l'heure, puis time.time()
Java	époque longue = System.currentTimeMillis()/1000 ;
Microsoft .NET C#	époque = (DateTime.Now.ToUniversalTime().Ticks - 621355968000000000) / 10000000 ;
VBScript/ASP	DiffDate("s", "01/01/1970 00:00:00", Maintenant())
Erlang	calendrier : datetime_to_gregorian_seconds(calendar :now_to_universal_time(now()))-719528*24*3600.
MySQL	SELECT unix_timestamp(maintenant())
PostgreSQLName	SELECT extrait(epoch FROM now());
serveur SQL	SELECT DATEIFF(s, "1970-01-01 00:00:00", GETUTCDATE())
Javascript	Math.round(new Date().getTime()/1000.0) getTime() renvoie l'heure en millisecondes.
Unix/Linux	date+%s
Autre système d'exploitation	Ligne de commande : perl -e "print time" (si Perl est installé sur votre système)

Convertir la date en heure Unix en...

PHP	mktime( montre, minutes, secondes, mois, jour, année)
rubis	Heure.local( année, mois, jour, montre, minutes, secondes, usec) (ou Time.gm pour une sortie GMT/UTC). Pour sortir, ajoutez .to_i
Python	importez d'abord l'heure, puis int(time.mktime(time.strptime("2000-01-01 12:34:00", "%Y-%m-%d %H:%M:%S")))
Java	long epoch = new java.text.SimpleDateFormat("jj/MM/aaaa HH:mm:ss").parse("01/01/1970 01:00:00");
VBScript/ASP	DiffDate("s", "01/01/1970 00:00:00", champ date)
MySQL	SELECT unix_horodatage( temps) Format de l'heure : AAAA-MM-JJ HH:MM:SS ou AAMMJJ ou AAAAMMJJ
PostgreSQLName	SELECT extrait(epoch FROM date("2000-01-01 12:34")); Avec horodatage : SELECT EXTRACT(EPOCH FROM TIMESTAMP WITH TIME ZONE "2001-02-16 20:38:40-08"); Intervalle : SELECT EXTRACT(EPOCH FROM INTERVAL "5 days 3 hours");
serveur SQL	SELECT DATEIFF(s, "1970-01-01 00:00:00", champ date)
Unix/Linux	date +%s -d"1er janvier 1980 00:00:01"

Conversion de l'heure Unix en date lisible par l'homme...

PHP	date( Format, temps unix);
rubis	Heure.at( temps unix)
Python	importez d'abord l'heure, puis time.strftime("%a, %d %b %Y %H:%M:%S +0000", time.localtime( temps unix)) Remplacez time.localtime par time.gmtime pour la date GMT.
Java	Chaîne date = new java.text.SimpleDateFormat("jj/MM/aaaa HH:mm:ss").format(new java.util.Date ( temps unix*1000));
VBScript/ASP	DateAjoute("s", temps unix, "01/01/1970 00:00:00")
PostgreSQLName	SELECT TIMESTAMP WITH TIME ZONE "epoch" + temps unix* INTERVALLE "1 seconde" ;
MySQL	from_unixtime( temps unix, facultatif, format de sortie) Format de sortie standard AAAA-MM-JJ HH:MM:SS
serveur SQL	DATEADJ(s, temps unix, "1970-01-01 00:00:00")
Microsoft Excel	=(A1 / 86400) + 25569 Le résultat sera dans le fuseau horaire GMT. Pour les autres fuseaux horaires : =((A1 +/- différence de fuseau) / 86400) + 25569.
linux	date-j@1190000000
Autre système d'exploitation	Ligne de commande : perl -e "print scalar(localtime( temps unix))" (Si Perl est installé) Remplacez "localtime" par "gmtime" pour le fuseau horaire GMT/UTC.

Uniquement pour les lecteurs de Lifeexample, il est possible d'ouvrir une boutique en ligne sur Moguta.CMS avec une réduction de 15%

Heure Unix et horodatage Unix (MySQL, PHP, JavaScript)

Bonjour, chers lecteurs du blog, dans cet article, je veux vous parler de ce qui est Heure Unix Et Horodatage Unix. Souvent, les programmeurs combinent ces concepts en un seul, mais ce n'est pas tout à fait vrai. En outre, l'article contient de nombreuses notes utiles sur l'utilisation des horodatages Unix en PHP , MySQL et JavaScript.

Pourquoi l'heure Unix commence-t-elle le 1er janvier 1970 ?

Le fait est que le temps Unix commence à compter l'époque Unix, avec la sortie du premier système UNIX. Le premier système de ce genre a été créé en 1969, les développeurs ont donc pris la date du 1er janvier 1970 à minuit UTC ( UTC).

Comprenons à quoi servent l'heure Unix et l'horodatage Unix et donnons-leur des concepts clairs.

Horodatage Unixest un horodatage, qui est une séquence de caractères représentant le nombre de secondes écoulées depuis le 1er janvier 1970.

Je vais essayer de donner un exemple pour clarifier la différence entre ces deux concepts.

Au moment où j'écrivais ce post, Heure Unixétait égal 1346765877 .

Au moment de la lecture, par vous, de ces informations, un enregistrement de l'heure ( 1346765877 ) , est déjà une étiquette − Horodatage Unix! En convertissant cet horodatage en une forme lisible par l'homme, nous obtenons la date 09/04/2012 et l'heure 17:37:57 .

Franchement, il n'y a pas d'intérêt particulier à séparer les deux notions, à mon avis, mais il est quand même utile d'avoir une idée de ce que c'est Heure Unix, et il est également utile de comprendre que le nombre maximum de secondes possibles qui se sont écoulées depuis 1970 a une limite !

La fin de l'ère Unix arrivera en 2038

Fait: le nombre binaire maximal dans les systèmes 32 bits est le nombre 01111111 11111111 11111111 11111111 , en le convertissant en décimal, nous obtenons le nombre 2147483647.

19 janvier 2038à 03:14:08 viendra un moment où le nombre de secondes écoulées depuis le début de l'ère Unix dépassera le maximum disponible dans un système 32 bits, le nombre = 2147483647. Si le bit déborde, la date sera réinitialiser.

Il est très facile de tester cette théorie avec un exemple illustratif :

• Ouvrez la calculatrice Windows standard, appuyez sur ALT + 3, cela la traduira en une vue d'ingénierie;
• Définissez le mode 4 octets et le type d'entrée décimal ;
• Écrivez le numéro 2147483647 ;

• Faites attention à la représentation du nombre en binaire ;
• Ajoutez un au nombre ;

• Le résultat de l'addition est un nombre négatif !

Si nous continuons à en ajouter un, nous obtenons une fermeture cyclique.

C'est cette sonnerie de date qui interviendra à partir du 19 janvier 2038 sur tous les systèmes utilisant l'architecture 32 bits.

En fait, vous ne devriez pas être triste, car les développeurs de systèmes informatiques introduisent de plus en plus les architectures 64 bits dans une utilisation généralisée. Nous croirons qu'ils auront le temps d'ici 2038.

Parlons maintenant de l'utilisation de l'horodatage unix dans php, mysql et même dans javascript.

Travailler avec l'horodatage Unix

Un point très important lorsque vous travaillez avec des horodatages unix dans php ou mysql est la nécessité de bien comprendre les avantages et les inconvénients d'un tel format de date.

Par exemple, HORODATAGE ne peut pas être utilisé pour définir des événements historiques ou des événements d'un futur lointain. L'ensemble des dates est limité à la période de 1970 au début de 2038. Si vous définissez une date qui est en dehors de la portée de 2038, elle ne sera pas correctement interprétée par un système 32 bits.

Conscient de cette limitation, une question logique se pose : " Pourquoi s'embêter avec la représentation de la date en quelques secondes ?"

Quand utiliser l'horodatage Unix

Pour représenter le temps dans notre système de mesure habituel, 8 octets sont nécessaires, et pour l'horodatage unix la moitié - 4 octets.

La sauvegarde de la quantité de données est, à mon avis, le principal et indiscutable plus de l'utilisation d'Unix Time.

De plus, il existe un certain nombre de nuances utiles lorsque vous travaillez avec Horodatage UNIX dans mysql. Et puisque toutes les informations doivent être stockées sur le serveur de base de données, et qu'elles présentent à leur tour un certain nombre d'avantages lorsque l'on travaille avec des horodatages Unix, le choix vers l'horodatage Unix peut être correctement justifié par les dispositions suivantes.

MySQL fournit un type de données Timestamp correspondant pour fonctionner avec le format d'heure unix, en définissant ce que nous obtenons immédiatement un avantage utile par rapport aux formats standard DATE Et DATEHEURE. L'avantage est que lorsque vous ajoutez un nouvel enregistrement à une table, la colonne avec ce type de données est automatiquement remplie. Et cela signifie que nous pouvons économiser non seulement sur la quantité de données, mais aussi sur le temps CPU du serveur Web.

Pour renforcer les mots avec des actes, définissons la tâche suivante : lors de l'enregistrement d'un nouvel utilisateur dans le système, vous devez entrer la date de son ajout à la base de données.

Si le type du champ stockant la date dans la table est DATEHEURE, la requête du script PHP ressemblera à ceci :

L'avantage est évident !

Il y a aussi un moins: s'il y a plusieurs champs de type TIMESTAMP, seul le premier est mis à jour automatiquement.

Est-il judicieux d'utiliser INT au lieu de l'horodatage

De nombreux programmeurs, lorsqu'ils travaillent avec des horodatages Unix, utilisent le format entier int(11) . Ce n'est pas du tout une approche rationnelle de la question, car MySQL fournit de nombreuses fonctions utiles pour le type d'horodatage qui affectent la vitesse de travail avec lui. Par conséquent, en stockant l'horodatage en INT, nous nous priverons de tout support serveur pour ce format. C'est à peu près la même chose que de stocker l'identifiant dans le type varchar(11).

Cependant, il y a une justification pour garder horodatage unix en int. Lors du transfert d'une base de données entre différents SGBD, un conflit de type peut survenir, c'est-à-dire pour l'un des SGBD, le type d'horodatage peut être inconnu. Dans ce cas, l'utilisation de int sera prioritaire, car ce format est présent dans tous les SGBD.

Une brève description des types de calendrier MySQL

HORODATAGE- type de données pour stocker la date et l'heure. Les données sont stockées sous la forme du nombre de secondes qui se sont écoulées depuis le début de "l'époque Unix". Plage de valeurs : 1970-01-01 00:00:00 - 2038-12-31 00:00:00. Prend 4 octets.

DATE- type de données pour le stockage de la date. Plage de valeurs : 1000-01-01 - 9999-12-31. Prend 3 octets.

DATEHEURE- type de données pour stocker la date et l'heure. Plage de valeurs : 1000-01-01 00:00:00 - 9999-12-31 00:00:00. Il prend 8 octets et est stocké sous la forme AAAAMMJJHHMMSS./p>

ANNÉE- type de données pour stocker l'année. Plage de valeurs : 1901 - 2155. Occupe 1 octet.

TEMPS- type de données pour le stockage du temps. Plage de valeurs : -828:59:59 - 828:59:59. Prend 3 octets.

traduction de date sous unix

Il est temps de présenter quelques fonctions utiles pour convertir les dates en horodatage unix et retour de temps unixà une date lisible.

Comment obtenir l'heure UNIX actuelle

• PHP :

  temps();

• JavaScript :

  Math.round(new Date() .getTime() / 1000.0 ) ;

• MySQL :

  SELECT unix_timestamp(now()) ;

Époque Unix).

représentation entière

Chaque jour, le nombre représentant l'heure Unix est calculé de la manière décrite en UTC (00:00:00Z), et augmente d'exactement 1 par seconde, à partir de minuit. Par conséquent, 16-09-2004 17:55:43.54, 64543.54 secondes à partir de minuit, dans l'exemple ci-dessus, serait représenté en temps UNIX comme 1095292800 + 64543.54 = 1095357343.54. Pour les dates précédant le début du compte à rebours, le nombre augmente également, c'est-à-dire tend vers zéro avec le temps.

Le système d'entiers utilisé est pratique à utiliser pour comparer et stocker des dates (la date et l'heure dans ce format ne prend que 4 ou 8 octet). Si vous avez besoin de vous référer à des éléments de date (jour, mois, année), les secondes peuvent être converties dans n'importe quel format approprié (et vice versa).

Programmes pour stocker l'utilisation du temps UNIX type entier signé. Les nombres 32 bits signés peuvent faire référence aux heures du vendredi 13 décembre 1901 à 20 h 45 min 52 s au mardi 19 janvier 2038 à 03 h 14 min 07 s inclus.

Pour connaître l'heure UNIX actuelle sur la plupart des systèmes de type UNIX, vous pouvez utiliser la commande date+%s .

Significations du "jubilé"

Temps	Nombre de secondes
13 décembre 1901 , 20:45:52 UTC	Date minimale en notation signée 32 bits (0x80000000)
19 janvier 2038 , 03:14:07 UTC	Date maximale en notation signée 32 bits (0x7FFFFFFF)
9 septembre 2001 , 01:46:40 UTC	1 000 000 000 (1 gigaseconde)
10 janvier 2004 , 13:37:04 UTC	1 073 741 824 = 2 30 (1 gibiseconde)
18 mars 2005 , 01:58:31 UTC	1 111 111 111
6 septembre 2008 12:12:05 UTC	1 220 703 125 = 5 13
13 février 2009 , 23:31:30 UTC	1 234 567 890

Le problème de 2038

Le problème d'Apple iOS en tant que système UNIX

Pour 64 bits iOS Les appareils Apple ont un problème en tant que système UNIX. Si vous réglez l'heure sur un appareil avec un processeur 64 bits exécutant iOS sur une heure du matin le 1er janvier 1970 et redémarrez l'appareil, étant dans le fuseau horaire de UTC +1:30 ou plus, puis après le redémarrage de l'appareil il ne s'allumera pas, il brillera tout le temps "pomme blanche" Cela se produit en raison de la différence de fuseaux horaires, c'est-à-dire : si vous traduisez l'heure à 1h00 le 1er janvier 1970 dans le fuseau horaire UTC +1h30 ou plus, le compteur de temps UNIX devient négatif, car le compte à rebours est de l'heure UTC que le système n'est pas en mesure de comprendre, à la suite de quoi le compteur se fige. L'appareil n'est même pas restauré via DFU, mais le problème a trois solutions par d'autres moyens. La première façon: laissez simplement l'appareil allumé et attendez que le compteur de temps UNIX augmente (jusqu'à ce qu'il soit prouvé que cette méthode fonctionne). La deuxième façon : attendez que la batterie du téléphone soit complètement épuisée et que le compteur lui-même se remette à zéro. La troisième façon : démonter l'appareil et déconnecter la batterie pendant un moment, puis assembler l'appareil, le compteur se remettra également à zéro et l'appareil fonctionnera.

Le problème est finalement résolu dans iOS 9.3.1 - désormais disponible sur l'appareil pour définir la date à partir du 1er janvier 2001.

Conversion de logiciel

Un exemple d'implémentation dans le langage est donné. Xi fonctions de conversion entre l'heure UNIX et la représentation habituelle en date et heure du jour. L'exemple est donné au format standard signé 32 bits. Cependant, si vous commentez la définition de _XT_SIGNED, l'exemple sera compilé sous une forme non signée.

Fichier d'en-tête de conversion de l'heure

typedef court non signé u16_t ; typedef long non signé u32_t ; typedef signé court s16_t ; typedef signé long s32_t ; // DEF : format standard signé // UNDEF : format non standard non signé #define _XT_SIGNED #ifdef _XT_SIGNED typedef s32_t xtime_t; #else typedef u32_t xtime_t; #endif struct tm ( /* composants date et heure */ BYTE tm_sec; BYTE tm_min; BYTE tm_hour; BYTE tm_mday; BYTE tm_mon; u16_t tm_year; ); void xttotm(struct tm *t, xtime_t secs); xtime_t xtmtot(struct tm *t);

Conversion de temps

#include "xtime.h" #define _TBIAS_DAYS ((70 * (u32_t)365) + 17) #define _TBIAS_SECS (_TBIAS_DAYS * (xtime_t)86400) #define _TBIAS_YEAR 1900 #define MONTAB(année) ((((année) & 03) ||((année) == 0)) ?mos : lmos) const s16_t lmos = (0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335) ; const s16_t mos = (0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334); #define Daysto32(year, lun) (((year - 1) / 4) + MONTAB(year)) ////////////////////////// / ////////////////////////////////////////////// xtime_t xtmtot(struct tm *t ) ( /* convertir la structure temporelle en temps scalaire */ s32_t days; xtime_t secs; s32_t mon, year; /* Calculer le nombre de jours. */ mon = t->tm_mon - 1; year = t->tm_year - _TBIAS_YEAR; days = Daysto32(year, mon) - 1; days += 365 * year; days += t->tm_mday; days -= _TBIAS_DAYS; /* Calculer le nombre de secondes. */ secs = 3600 * t->tm_hour; secs += 60 * t->tm_min; secondes += t->tm_sec; secondes += (jours * (xtime_t)86400); retour (secondes); ) /////////////// //////////////////////////////////////////////// / //// void xttotm(struct tm *t, xtime_t secsarg) ( u32_t secs; s32_t days; s32_t mon; s32_t year; s32_t i; const s16_t* pm; #ifdef _XT_SIGNED if (secsarg >= 0) ( secs = ( u32_t)secsarg; days = _TBIAS_DAYS; ) else ( secs = (u32_t)secsarg + _TBIAS_SECS; days = 0; ) #else secs = secsarg; days = _TBIAS_DAYS; #endif /* jours, heure, min, sec */ jours + = secondes / 86400 ; secondes = secondes % 86400 ; t->tm_heure = secondes / 3600 ; secondes%= 3600 ; t->tm_min = s / 60 ; t->tm_sec = secondes % 60 ; /* déterminer l'année */ pour (année = jours / 365; jours< (i = Daysto32(year, 0) + 365*year);) { --year; } days -= i; t->tm_année = année + _TBIAS_YEAR ; /* déterminer le mois */ pm = MONTAB(année); pour (lun = 12; jours< pm[--mon];); t->tm_mon=mon+1 ; t->tm_mday = jours - pm + 1 ; )

Conversion de l'heure du format Excel au format Unix

double et; // date et heure au format Excel (également utilisé dans OpenOffice, Sierra Chart) time_t ut = round((et * 86400) - 2209161600); // date et heure au format Unix

Donnez votre avis sur l'article "Le temps UNIX"

Remarques

Liens externes

Un extrait caractérisant le temps UNIX

Chernyshev était assis avec un livre d'un roman français près de la fenêtre de la première pièce. Cette pièce était probablement autrefois une salle; il y avait encore un orgue, sur lequel étaient empilés des espèces de tapis, et dans un coin se dressait le lit pliant de l'adjudant Benigsen. Cet adjudant était ici. Lui, apparemment épuisé par un festin ou une affaire, s'est assis sur un lit plié et s'est assoupi. Deux portes partaient du hall : l'une directement dans l'ancien salon, l'autre à droite dans le bureau. Dès la première porte, des voix parlaient allemand et parfois français. Là, dans l'ancien salon, à la demande du souverain, non pas un conseil militaire était réuni (le souverain aimait l'incertitude), mais quelques personnes dont il voulait connaître l'avis sur les difficultés à venir. Ce n'était pas un conseil militaire, mais, pour ainsi dire, un conseil d'élus pour clarifier certaines questions personnellement pour le souverain. Ont été invités à ce demi-conseil : le général suédois Armfeld, l'adjudant général Wolzogen, Winzingerode, que Napoléon appelait un sujet français fugitif, Michaud, Tol, pas un militaire du tout - le comte Stein et, enfin, Pfuel lui-même, qui , comme le prince Andrei l'a entendu, était la cheville ouvrière [la base] de toute l'affaire. Le prince Andrei a eu l'occasion de bien l'examiner, puisque Pfuel est arrivé peu de temps après lui et est entré dans le salon, s'arrêtant une minute pour parler avec Chernyshev.
Pfuel à première vue, dans son uniforme mal taillé de général russe, qui était assis maladroitement, comme s'il était habillé, semblait familier au prince Andrei, bien qu'il ne l'ait jamais vu. Il comprenait Weyrother, et Mack, et Schmidt, et de nombreux autres théoriciens allemands des généraux, que le prince Andrei réussit à voir en 1805 ; mais il était plus typique que tous. Le prince Andrey n'avait jamais vu un tel théoricien allemand, qui réunissait en lui tout ce qu'il y avait chez ces Allemands.
Pful était petit, très mince, mais aux os larges, grossier, sain, avec un bassin large et des omoplates osseuses. Son visage était très ridé, avec des yeux enfoncés. Ses cheveux devant au niveau des tempes, évidemment, ont été lissés à la hâte avec une brosse, derrière des glands naïvement collés. Lui, regardant autour de lui avec inquiétude et colère, entra dans la pièce, comme s'il avait peur de tout dans la grande pièce dans laquelle il était entré. Tenant son épée d'un mouvement maladroit, il se tourna vers Chernyshev, demandant en allemand où était le souverain. Il voulait évidemment parcourir les salles au plus vite, achever les révérences et les salutations, et s'asseoir pour travailler devant la carte, où il se sentait à sa place. Il hocha rapidement la tête aux paroles de Chernyshev et sourit ironiquement, écoutant ses paroles selon lesquelles le souverain inspectait les fortifications que lui, Pfuel lui-même, avait posées selon sa théorie. Il était bassiste et cool, comme disent les Allemands sûrs d'eux-mêmes, marmonnant pour lui-même: Dummkopf ... ou: zu Grunde die ganze Geschichte ... ou: s "wird was gescheites d" raus werden ... [non-sens ... au diable le tout ... (allemand) ] Le prince Andrei n'a pas entendu et a voulu passer, mais Chernyshev a présenté le prince Andrei à Pful, notant que le prince Andrei était venu de Turquie, où la guerre s'était si bien terminée. Pfuel jeta presque un coup d'œil non pas tant au prince Andrei qu'à travers lui, et dit en riant : « Da muss ein schoner taktischcr Krieg gewesen sein. ["Cela devait être la bonne guerre tactique." (Allemand)] - Et, riant avec mépris, il entra dans la pièce d'où se firent entendre des voix.
Evidemment, Pfuel, toujours prêt à l'irritabilité ironique, était surtout agité aujourd'hui par le fait qu'on ait osé inspecter son camp sans lui et le juger. Le prince Andrei, de cette seule courte rencontre avec Pfuel, grâce à ses souvenirs d'Austerlitz, a dressé une claire caractérisation de cet homme. Pfuel faisait partie de ces personnes désespérément, invariablement, jusqu'au martyre, sûres d'elles-mêmes que seuls les Allemands sont, et précisément parce que seuls les Allemands ont confiance en eux sur la base d'une idée abstraite - la science, c'est-à-dire une connaissance imaginaire de vérité parfaite. Le Français a confiance en lui parce qu'il se considère personnellement, à la fois dans son esprit et dans son corps, irrésistiblement charmant pour les hommes et les femmes. Un Anglais a confiance en lui parce qu'il est citoyen de l'État le plus confortable du monde et, par conséquent, en tant qu'Anglais, il sait toujours ce qu'il doit faire et sait que tout ce qu'il fait en tant qu'Anglais est sans aucun doute bien. L'Italien a confiance en lui car il est agité et s'oublie facilement et oublie les autres. Le Russe a confiance en lui précisément parce qu'il ne sait rien et ne veut pas savoir, parce qu'il ne croit pas qu'il soit possible de tout savoir. L'Allemand est sûr de lui pire que tout le monde, et plus dur que tout le monde, et plus repoussant que tout le monde, parce qu'il s'imagine connaître la vérité, une science qu'il a lui-même inventée, mais qui pour lui est la vérité absolue. Tel était évidemment Pfuel. Il avait une science - la théorie du mouvement oblique, qu'il a tirée de l'histoire des guerres de Frédéric le Grand, et tout ce qu'il a rencontré dans l'histoire récente des guerres de Frédéric le Grand, et tout ce qu'il a rencontré dans les dernières l'histoire militaire, lui semblait un non-sens, une barbarie, un vilain affrontement, dans lequel tant d'erreurs avaient été commises de part et d'autre que ces guerres ne pouvaient être qualifiées de guerres : elles ne correspondaient pas à la théorie et ne pouvaient servir de sujet à la science.
En 1806, Pfuel fut l'un des rédacteurs du plan de guerre qui se termina à Iéna et Auerstet ; mais dans l'issue de cette guerre, il n'a pas vu la moindre preuve de l'inexactitude de sa théorie. Au contraire, les déviations faites à sa théorie, selon ses concepts, étaient la seule raison de tout l'échec, et il a dit avec son ironie joyeuse caractéristique: "Ich sagte ja, daji die ganze Geschichte zum Teufel gehen wird." [Après tout, j'ai dit que tout irait en enfer (allemand)] Pfuel était l'un de ces théoriciens qui aiment tellement leur théorie qu'ils en oublient le but de la théorie - son application à la pratique ; épris de théorie, il détestait toute pratique et ne voulait pas la connaître. Il se réjouit même de son échec, car l'échec, qui vient de l'écart de la pratique par rapport à la théorie, ne lui prouve que la validité de sa théorie.
Il a dit quelques mots au prince Andrei et Chernyshev sur une vraie guerre avec l'expression d'un homme qui sait d'avance que tout ira mal et qu'il n'en est même pas mécontent. Les mèches de cheveux non peignées qui ressortaient à l'arrière de la tête et les tempes lissées à la hâte le confirmaient avec une éloquence particulière.
Il est allé dans une autre pièce, et les sons graves et grommelants de sa voix ont été immédiatement entendus de là.

Avant que le prince Andrei ait eu le temps de suivre Pfuel des yeux, le comte Benigsen entra précipitamment dans la pièce et, faisant un signe de tête à Bolkonsky, sans s'arrêter, entra dans le bureau, donnant quelques ordres à son adjudant. Le souverain le suivit et Bennigsen se précipita pour préparer quelque chose et rencontrer le souverain à temps. Chernyshev et le prince Andrei sont sortis sur le porche. Le souverain à l'air fatigué descendit de son cheval. Le marquis Pauluchi dit quelque chose au souverain. Le souverain, inclinant la tête vers la gauche, écoutait d'un air malheureux Paulucci, qui parlait avec une ferveur particulière. L'empereur s'avança, voulant apparemment mettre fin à la conversation, mais l'Italien rouge et agité, oubliant la décence, le suivit, continuant à dire :
- Quant à celui qui a conseillé ce camp, le camp de Drissa, [Quant à celui qui a conseillé le camp de Drissa,] - dit Pauluchi, tandis que le souverain, entrant dans les marches et remarquant le prince Andrei, regarda un visage inconnu.