Je viens de creer un script qui produit exactement ce que je veux:
nom de l'image,hauteur,largeur
sips -g pixelHeight -g pixelWidth *.jpg > taille.txt
grep -i '.jpg' taille.txt | sed 's|.*/||' > nom
grep 'pixelHeight' taille.txt | sed 's/.*pixelHeight: //' > haut
grep 'pixelWidth' taille.txt | sed 's/.*pixelWidth: //' > large
paste -d',' nom haut large > taille.txt ; rm nom haut large
Le probleme, c'est que je dois creer (puis detruire) des fichiers
temporaires. Ne serait-il pas plus adulte d'utiliser des variables
plutot que des fichiers? Comment?
Le 21/02/04 10:29, dans , « Bertrille Ethrington » a écrit :
Je viens de creer un script qui produit exactement ce que je veux:
nom de l'image,hauteur,largeur
sips -g pixelHeight -g pixelWidth *.jpg > taille.txt grep -i '.jpg' taille.txt | sed 's|.*/||' > nom grep 'pixelHeight' taille.txt | sed 's/.*pixelHeight: //' > haut grep 'pixelWidth' taille.txt | sed 's/.*pixelWidth: //' > large paste -d',' nom haut large > taille.txt ; rm nom haut large
Le probleme, c'est que je dois creer (puis detruire) des fichiers temporaires. Ne serait-il pas plus adulte d'utiliser des variables plutot que des fichiers? Comment?
Au lieu de faire :
cmd args > fichier
Tu peux faire (en sh) :
var=`cmd args`
Et après tu utilises $var.
-- Éric Lévénez -- <http://www.levenez.com/> Unix is not only an OS, it's a way of life.
Le 21/02/04 10:29, dans <76ba41ea.0402210129.4ac07d9f@posting.google.com>,
« Bertrille Ethrington » <bertrille@bigfoot.com> a écrit :
Je viens de creer un script qui produit exactement ce que je veux:
nom de l'image,hauteur,largeur
sips -g pixelHeight -g pixelWidth *.jpg > taille.txt
grep -i '.jpg' taille.txt | sed 's|.*/||' > nom
grep 'pixelHeight' taille.txt | sed 's/.*pixelHeight: //' > haut
grep 'pixelWidth' taille.txt | sed 's/.*pixelWidth: //' > large
paste -d',' nom haut large > taille.txt ; rm nom haut large
Le probleme, c'est que je dois creer (puis detruire) des fichiers
temporaires. Ne serait-il pas plus adulte d'utiliser des variables
plutot que des fichiers? Comment?
Au lieu de faire :
cmd args > fichier
Tu peux faire (en sh) :
var=`cmd args`
Et après tu utilises $var.
--
Éric Lévénez -- <http://www.levenez.com/>
Unix is not only an OS, it's a way of life.
Le 21/02/04 10:29, dans , « Bertrille Ethrington » a écrit :
Je viens de creer un script qui produit exactement ce que je veux:
nom de l'image,hauteur,largeur
sips -g pixelHeight -g pixelWidth *.jpg > taille.txt grep -i '.jpg' taille.txt | sed 's|.*/||' > nom grep 'pixelHeight' taille.txt | sed 's/.*pixelHeight: //' > haut grep 'pixelWidth' taille.txt | sed 's/.*pixelWidth: //' > large paste -d',' nom haut large > taille.txt ; rm nom haut large
Le probleme, c'est que je dois creer (puis detruire) des fichiers temporaires. Ne serait-il pas plus adulte d'utiliser des variables plutot que des fichiers? Comment?
Au lieu de faire :
cmd args > fichier
Tu peux faire (en sh) :
var=`cmd args`
Et après tu utilises $var.
-- Éric Lévénez -- <http://www.levenez.com/> Unix is not only an OS, it's a way of life.
Pascal Bourguignon
Éric Lévénez writes:
Le 21/02/04 10:29, dans , « Bertrille Ethrington » a écrit :
Je viens de creer un script qui produit exactement ce que je veux:
nom de l'image,hauteur,largeur
sips -g pixelHeight -g pixelWidth *.jpg > taille.txt grep -i '.jpg' taille.txt | sed 's|.*/||' > nom grep 'pixelHeight' taille.txt | sed 's/.*pixelHeight: //' > haut grep 'pixelWidth' taille.txt | sed 's/.*pixelWidth: //' > large paste -d',' nom haut large > taille.txt ; rm nom haut large
Le probleme, c'est que je dois creer (puis detruire) des fichiers temporaires. Ne serait-il pas plus adulte d'utiliser des variables plutot que des fichiers? Comment?
haut=$( echo "$taille" | sed -n '/pixelHeight/s/.*pixelHeight: //p' )
Mais attention aux quotes:
$ x=$(echo '@c@' | tr '@' ' 12' ) $ echo $x ; echo $x|grep b a b c a b c $ echo "$x" ; echo "$x"|grep b a b c b
-- __Pascal_Bourguignon__ http://www.informatimago.com/ There is no worse tyranny than to force a man to pay for what he doesn't want merely because you think it would be good for him.--Robert Heinlein http://www.theadvocates.org/
Éric Lévénez <news@levenez.com> writes:
Le 21/02/04 10:29, dans <76ba41ea.0402210129.4ac07d9f@posting.google.com>,
« Bertrille Ethrington » <bertrille@bigfoot.com> a écrit :
Je viens de creer un script qui produit exactement ce que je veux:
nom de l'image,hauteur,largeur
sips -g pixelHeight -g pixelWidth *.jpg > taille.txt
grep -i '.jpg' taille.txt | sed 's|.*/||' > nom
grep 'pixelHeight' taille.txt | sed 's/.*pixelHeight: //' > haut
grep 'pixelWidth' taille.txt | sed 's/.*pixelWidth: //' > large
paste -d',' nom haut large > taille.txt ; rm nom haut large
Le probleme, c'est que je dois creer (puis detruire) des fichiers
temporaires. Ne serait-il pas plus adulte d'utiliser des variables
plutot que des fichiers? Comment?
haut=$( echo "$taille" | sed -n '/pixelHeight/s/.*pixelHeight: //p' )
Mais attention aux quotes:
$ x=$(echo 'a@b@c@' | tr '@' ' 12' )
$ echo $x ; echo $x|grep b
a b c
a b c
$ echo "$x" ; echo "$x"|grep b
a
b
c
b
--
__Pascal_Bourguignon__ http://www.informatimago.com/
There is no worse tyranny than to force a man to pay for what he doesn't
want merely because you think it would be good for him.--Robert Heinlein
http://www.theadvocates.org/
Le 21/02/04 10:29, dans , « Bertrille Ethrington » a écrit :
Je viens de creer un script qui produit exactement ce que je veux:
nom de l'image,hauteur,largeur
sips -g pixelHeight -g pixelWidth *.jpg > taille.txt grep -i '.jpg' taille.txt | sed 's|.*/||' > nom grep 'pixelHeight' taille.txt | sed 's/.*pixelHeight: //' > haut grep 'pixelWidth' taille.txt | sed 's/.*pixelWidth: //' > large paste -d',' nom haut large > taille.txt ; rm nom haut large
Le probleme, c'est que je dois creer (puis detruire) des fichiers temporaires. Ne serait-il pas plus adulte d'utiliser des variables plutot que des fichiers? Comment?
haut=$( echo "$taille" | sed -n '/pixelHeight/s/.*pixelHeight: //p' )
Mais attention aux quotes:
$ x=$(echo '@c@' | tr '@' ' 12' ) $ echo $x ; echo $x|grep b a b c a b c $ echo "$x" ; echo "$x"|grep b a b c b
-- __Pascal_Bourguignon__ http://www.informatimago.com/ There is no worse tyranny than to force a man to pay for what he doesn't want merely because you think it would be good for him.--Robert Heinlein http://www.theadvocates.org/
Éric Lévénez
Le 21/02/04 20:47, dans , « Pascal Bourguignon » a écrit :
Éric Lévénez writes:
Tu peux faire (en sh) :
var=`cmd args`
Ou mieux: var="$(cmd args)"
Ce n'est pas mieux, c'est juste une extension d'un shell. Je proposais une écriture standard en Bourne shell qui marche depuis des décennies. :-)
-- Éric Lévénez -- <http://www.levenez.com> Unix is not only an OS, it's a way of life.
Le 21/02/04 20:47, dans <87d6888ba6.fsf@thalassa.informatimago.com>,
« Pascal Bourguignon » <spam@thalassa.informatimago.com> a écrit :
Éric Lévénez <news@levenez.com> writes:
Tu peux faire (en sh) :
var=`cmd args`
Ou mieux: var="$(cmd args)"
Ce n'est pas mieux, c'est juste une extension d'un shell. Je proposais une
écriture standard en Bourne shell qui marche depuis des décennies. :-)
--
Éric Lévénez -- <http://www.levenez.com>
Unix is not only an OS, it's a way of life.
Le 21/02/04 20:47, dans , « Pascal Bourguignon » a écrit :
Éric Lévénez writes:
Tu peux faire (en sh) :
var=`cmd args`
Ou mieux: var="$(cmd args)"
Ce n'est pas mieux, c'est juste une extension d'un shell. Je proposais une écriture standard en Bourne shell qui marche depuis des décennies. :-)
-- Éric Lévénez -- <http://www.levenez.com> Unix is not only an OS, it's a way of life.
bertrille
Éric Lévénez wrote in message news:<BC5CF0AE.69F9D%...
Le 21/02/04 10:29, dans ,
Je viens de creer un script qui produit exactement ce que je veux:
nom de l'image,hauteur,largeur
sips -g pixelHeight -g pixelWidth *.jpg > taille.txt grep -i '.jpg' taille.txt | sed 's|.*/||' > nom grep 'pixelHeight' taille.txt | sed 's/.*pixelHeight: //' > haut grep 'pixelWidth' taille.txt | sed 's/.*pixelWidth: //' > large paste -d',' nom haut large > taille.txt ; rm nom haut large
Le probleme, c'est que je dois creer (puis detruire) des fichiers temporaires. Ne serait-il pas plus adulte d'utiliser des variables plutot que des fichiers? Comment?
Au lieu de faire :
cmd args > fichier
Tu peux faire (en sh) :
var=`cmd args`
Et après tu utilises $var.
D'une facon generale, quand je dois traiter des fichiers, je cree un grand fichier qui contient tout ce dont j'ai besoin puis j'en extrait d'autres fichiers que je vais traiter eux-memes pour produire les fichiers finaux.
Ca me semble etre le "Unix way".
Il me semble que le fait d'utiliser des variables plutot que des fichiers reduit le nombre des I/O et devrait accellerer le prossessus global.
Ai-je tord?
Éric Lévénez <news@levenez.com> wrote in message news:<BC5CF0AE.69F9D%news@levenez.com>...
Le 21/02/04 10:29, dans <76ba41ea.0402210129.4ac07d9f@posting.google.com>,
Je viens de creer un script qui produit exactement ce que je veux:
nom de l'image,hauteur,largeur
sips -g pixelHeight -g pixelWidth *.jpg > taille.txt
grep -i '.jpg' taille.txt | sed 's|.*/||' > nom
grep 'pixelHeight' taille.txt | sed 's/.*pixelHeight: //' > haut
grep 'pixelWidth' taille.txt | sed 's/.*pixelWidth: //' > large
paste -d',' nom haut large > taille.txt ; rm nom haut large
Le probleme, c'est que je dois creer (puis detruire) des fichiers
temporaires. Ne serait-il pas plus adulte d'utiliser des variables
plutot que des fichiers? Comment?
Au lieu de faire :
cmd args > fichier
Tu peux faire (en sh) :
var=`cmd args`
Et après tu utilises $var.
D'une facon generale, quand je dois traiter des fichiers, je cree un
grand fichier qui contient tout ce dont j'ai besoin puis j'en extrait
d'autres fichiers que je vais traiter eux-memes pour produire les
fichiers finaux.
Ca me semble etre le "Unix way".
Il me semble que le fait d'utiliser des variables plutot que des
fichiers reduit le nombre des I/O et devrait accellerer le prossessus
global.
Éric Lévénez wrote in message news:<BC5CF0AE.69F9D%...
Le 21/02/04 10:29, dans ,
Je viens de creer un script qui produit exactement ce que je veux:
nom de l'image,hauteur,largeur
sips -g pixelHeight -g pixelWidth *.jpg > taille.txt grep -i '.jpg' taille.txt | sed 's|.*/||' > nom grep 'pixelHeight' taille.txt | sed 's/.*pixelHeight: //' > haut grep 'pixelWidth' taille.txt | sed 's/.*pixelWidth: //' > large paste -d',' nom haut large > taille.txt ; rm nom haut large
Le probleme, c'est que je dois creer (puis detruire) des fichiers temporaires. Ne serait-il pas plus adulte d'utiliser des variables plutot que des fichiers? Comment?
Au lieu de faire :
cmd args > fichier
Tu peux faire (en sh) :
var=`cmd args`
Et après tu utilises $var.
D'une facon generale, quand je dois traiter des fichiers, je cree un grand fichier qui contient tout ce dont j'ai besoin puis j'en extrait d'autres fichiers que je vais traiter eux-memes pour produire les fichiers finaux.
Ca me semble etre le "Unix way".
Il me semble que le fait d'utiliser des variables plutot que des fichiers reduit le nombre des I/O et devrait accellerer le prossessus global.
Ai-je tord?
Éric Lévénez
Le 22/02/04 14:34, dans , « Bertrille Ethrington » a écrit :
D'une facon generale, quand je dois traiter des fichiers, je cree un grand fichier qui contient tout ce dont j'ai besoin puis j'en extrait d'autres fichiers que je vais traiter eux-memes pour produire les fichiers finaux.
Ca me semble etre le "Unix way".
Normalement sous unix, la façon de faire est d'utiliser les streams, c'est-à-dire de lancer une commande pipée dans une autre pipée dans une autre... et cela sans utiliser de variables ou de fichiers. Ce n'est pas toujours facile, ou possible, mais cette méthode de flux est la méthode unix.
Il me semble que le fait d'utiliser des variables plutot que des fichiers reduit le nombre des I/O et devrait accellerer le prossessus global.
Créer un ou plusieurs fichiers temporaire n'est pas toujours possible car le répertoire de traitement n'est pas toujours accessible en écriture. Il faut alors créer les fichiers temporaires sous /tmp en prenant soin de prévoir que l'on travaille en multi-utilisateur (il ne faut pas des noms fixes, et on utilise souvent $$ dans les noms). Il faut ensuite penser à effacer les fichiers dans tous les cas, et généralement on utilise la commande "trap" des shells pour effacer ces fichiers, même si le shell est arrêté en plein milieu.
Certains unix ont une gestion de /tmp particulière par l'utilisation d'un système de fichiers qui n'écrit pas beaucoup sur disque en gardant beaucoup de cache en ram. Cela permet d'accélérer les I/O pour les fichiers temporaires.
L'utilisation de variables dans un shell ne pénalise pas les perfs.
Je n'ai pas vraiment compris ton script car il suppose qu'il n'y a qu'un fichier jpeg. Enfin voici un exemple de code standard qui marche en sh sans utiliser de particularités liées à un shell :
for f in *.jpg ; do set `sips -g pixelHeight -g pixelWidth "$f" | tail -2` echo "$f,$2,$4" done
-- Éric Lévénez -- <http://www.levenez.com/> Unix is not only an OS, it's a way of life.
Le 22/02/04 14:34, dans <76ba41ea.0402220534.4516ed48@posting.google.com>,
« Bertrille Ethrington » <bertrille@bigfoot.com> a écrit :
D'une facon generale, quand je dois traiter des fichiers, je cree un
grand fichier qui contient tout ce dont j'ai besoin puis j'en extrait
d'autres fichiers que je vais traiter eux-memes pour produire les
fichiers finaux.
Ca me semble etre le "Unix way".
Normalement sous unix, la façon de faire est d'utiliser les streams,
c'est-à-dire de lancer une commande pipée dans une autre pipée dans une
autre... et cela sans utiliser de variables ou de fichiers. Ce n'est pas
toujours facile, ou possible, mais cette méthode de flux est la méthode
unix.
Il me semble que le fait d'utiliser des variables plutot que des
fichiers reduit le nombre des I/O et devrait accellerer le prossessus
global.
Créer un ou plusieurs fichiers temporaire n'est pas toujours possible car le
répertoire de traitement n'est pas toujours accessible en écriture. Il faut
alors créer les fichiers temporaires sous /tmp en prenant soin de prévoir
que l'on travaille en multi-utilisateur (il ne faut pas des noms fixes, et
on utilise souvent $$ dans les noms). Il faut ensuite penser à effacer les
fichiers dans tous les cas, et généralement on utilise la commande "trap"
des shells pour effacer ces fichiers, même si le shell est arrêté en plein
milieu.
Certains unix ont une gestion de /tmp particulière par l'utilisation d'un
système de fichiers qui n'écrit pas beaucoup sur disque en gardant beaucoup
de cache en ram. Cela permet d'accélérer les I/O pour les fichiers
temporaires.
L'utilisation de variables dans un shell ne pénalise pas les perfs.
Je n'ai pas vraiment compris ton script car il suppose qu'il n'y a qu'un
fichier jpeg. Enfin voici un exemple de code standard qui marche en sh sans
utiliser de particularités liées à un shell :
for f in *.jpg ; do
set `sips -g pixelHeight -g pixelWidth "$f" | tail -2`
echo "$f,$2,$4"
done
--
Éric Lévénez -- <http://www.levenez.com/>
Unix is not only an OS, it's a way of life.
Le 22/02/04 14:34, dans , « Bertrille Ethrington » a écrit :
D'une facon generale, quand je dois traiter des fichiers, je cree un grand fichier qui contient tout ce dont j'ai besoin puis j'en extrait d'autres fichiers que je vais traiter eux-memes pour produire les fichiers finaux.
Ca me semble etre le "Unix way".
Normalement sous unix, la façon de faire est d'utiliser les streams, c'est-à-dire de lancer une commande pipée dans une autre pipée dans une autre... et cela sans utiliser de variables ou de fichiers. Ce n'est pas toujours facile, ou possible, mais cette méthode de flux est la méthode unix.
Il me semble que le fait d'utiliser des variables plutot que des fichiers reduit le nombre des I/O et devrait accellerer le prossessus global.
Créer un ou plusieurs fichiers temporaire n'est pas toujours possible car le répertoire de traitement n'est pas toujours accessible en écriture. Il faut alors créer les fichiers temporaires sous /tmp en prenant soin de prévoir que l'on travaille en multi-utilisateur (il ne faut pas des noms fixes, et on utilise souvent $$ dans les noms). Il faut ensuite penser à effacer les fichiers dans tous les cas, et généralement on utilise la commande "trap" des shells pour effacer ces fichiers, même si le shell est arrêté en plein milieu.
Certains unix ont une gestion de /tmp particulière par l'utilisation d'un système de fichiers qui n'écrit pas beaucoup sur disque en gardant beaucoup de cache en ram. Cela permet d'accélérer les I/O pour les fichiers temporaires.
L'utilisation de variables dans un shell ne pénalise pas les perfs.
Je n'ai pas vraiment compris ton script car il suppose qu'il n'y a qu'un fichier jpeg. Enfin voici un exemple de code standard qui marche en sh sans utiliser de particularités liées à un shell :
for f in *.jpg ; do set `sips -g pixelHeight -g pixelWidth "$f" | tail -2` echo "$f,$2,$4" done
-- Éric Lévénez -- <http://www.levenez.com/> Unix is not only an OS, it's a way of life.
bertrille
Éric Lévénez wrote in message news:<BC5E7735.6A0C1%...
Le 22/02/04 14:34, dans ,
D'une facon generale, quand je dois traiter des fichiers, je cree un grand fichier qui contient tout ce dont j'ai besoin puis j'en extrait d'autres fichiers que je vais traiter eux-memes pour produire les fichiers finaux.
Ca me semble etre le "Unix way".
Normalement sous unix, la façon de faire est d'utiliser les streams, c'est-à-dire de lancer une commande pipée dans une autre pipée dans une autre... et cela sans utiliser de variables ou de fichiers. Ce n'est pas toujours facile, ou possible, mais cette méthode de flux est la méthode unix.
C'est tres clair, merci beaucoup!
Il me semble que le fait d'utiliser des variables plutot que des fichiers reduit le nombre des I/O et devrait accellerer le prossessus global.
Créer un ou plusieurs fichiers temporaire n'est pas toujours possible car le répertoire de traitement n'est pas toujours accessible en écriture. Il faut alors créer les fichiers temporaires sous /tmp en prenant soin de prévoir que l'on travaille en multi-utilisateur (il ne faut pas des noms fixes, et on utilise souvent $$ dans les noms). Il faut ensuite penser à effacer les fichiers dans tous les cas, et généralement on utilise la commande "trap" des shells pour effacer ces fichiers, même si le shell est arrêté en plein milieu.
Certains unix ont une gestion de /tmp particulière par l'utilisation d'un système de fichiers qui n'écrit pas beaucoup sur disque en gardant beaucoup de cache en ram. Cela permet d'accélérer les I/O pour les fichiers temporaires.
L'utilisation de variables dans un shell ne pénalise pas les perfs.
Je n'ai pas vraiment compris ton script car il suppose qu'il n'y a qu'un fichier jpeg.
Pourtant non. Il passe à travers les fichiers .jpg du dossier local. Tu m'a redendue incertaine, j'ai encore teste et ca fonctionne encore!
Enfin voici un exemple de code standard qui marche en sh sans utiliser de particularités liées à un shell :
for f in *.jpg ; do set `sips -g pixelHeight -g pixelWidth "$f" | tail -2` echo "$f,$2,$4" done
Ca aussi ca fonctionne en Bash! Où puis-je trouver plus d'information sur les variables?
Éric Lévénez <news@levenez.com> wrote in message news:<BC5E7735.6A0C1%news@levenez.com>...
Le 22/02/04 14:34, dans <76ba41ea.0402220534.4516ed48@posting.google.com>,
D'une facon generale, quand je dois traiter des fichiers, je cree un
grand fichier qui contient tout ce dont j'ai besoin puis j'en extrait
d'autres fichiers que je vais traiter eux-memes pour produire les
fichiers finaux.
Ca me semble etre le "Unix way".
Normalement sous unix, la façon de faire est d'utiliser les streams,
c'est-à-dire de lancer une commande pipée dans une autre pipée dans une
autre... et cela sans utiliser de variables ou de fichiers. Ce n'est pas
toujours facile, ou possible, mais cette méthode de flux est la méthode
unix.
C'est tres clair, merci beaucoup!
Il me semble que le fait d'utiliser des variables plutot que des
fichiers reduit le nombre des I/O et devrait accellerer le prossessus
global.
Créer un ou plusieurs fichiers temporaire n'est pas toujours possible car le
répertoire de traitement n'est pas toujours accessible en écriture. Il faut
alors créer les fichiers temporaires sous /tmp en prenant soin de prévoir
que l'on travaille en multi-utilisateur (il ne faut pas des noms fixes, et
on utilise souvent $$ dans les noms). Il faut ensuite penser à effacer les
fichiers dans tous les cas, et généralement on utilise la commande "trap"
des shells pour effacer ces fichiers, même si le shell est arrêté en plein
milieu.
Certains unix ont une gestion de /tmp particulière par l'utilisation d'un
système de fichiers qui n'écrit pas beaucoup sur disque en gardant beaucoup
de cache en ram. Cela permet d'accélérer les I/O pour les fichiers
temporaires.
L'utilisation de variables dans un shell ne pénalise pas les perfs.
Je n'ai pas vraiment compris ton script car il suppose qu'il n'y a qu'un
fichier jpeg.
Pourtant non. Il passe à travers les fichiers .jpg du dossier local.
Tu m'a redendue incertaine, j'ai encore teste et ca fonctionne encore!
Enfin voici un exemple de code standard qui marche en sh sans
utiliser de particularités liées à un shell :
for f in *.jpg ; do
set `sips -g pixelHeight -g pixelWidth "$f" | tail -2`
echo "$f,$2,$4"
done
Ca aussi ca fonctionne en Bash! Où puis-je trouver plus d'information
sur les variables?
Éric Lévénez wrote in message news:<BC5E7735.6A0C1%...
Le 22/02/04 14:34, dans ,
D'une facon generale, quand je dois traiter des fichiers, je cree un grand fichier qui contient tout ce dont j'ai besoin puis j'en extrait d'autres fichiers que je vais traiter eux-memes pour produire les fichiers finaux.
Ca me semble etre le "Unix way".
Normalement sous unix, la façon de faire est d'utiliser les streams, c'est-à-dire de lancer une commande pipée dans une autre pipée dans une autre... et cela sans utiliser de variables ou de fichiers. Ce n'est pas toujours facile, ou possible, mais cette méthode de flux est la méthode unix.
C'est tres clair, merci beaucoup!
Il me semble que le fait d'utiliser des variables plutot que des fichiers reduit le nombre des I/O et devrait accellerer le prossessus global.
Créer un ou plusieurs fichiers temporaire n'est pas toujours possible car le répertoire de traitement n'est pas toujours accessible en écriture. Il faut alors créer les fichiers temporaires sous /tmp en prenant soin de prévoir que l'on travaille en multi-utilisateur (il ne faut pas des noms fixes, et on utilise souvent $$ dans les noms). Il faut ensuite penser à effacer les fichiers dans tous les cas, et généralement on utilise la commande "trap" des shells pour effacer ces fichiers, même si le shell est arrêté en plein milieu.
Certains unix ont une gestion de /tmp particulière par l'utilisation d'un système de fichiers qui n'écrit pas beaucoup sur disque en gardant beaucoup de cache en ram. Cela permet d'accélérer les I/O pour les fichiers temporaires.
L'utilisation de variables dans un shell ne pénalise pas les perfs.
Je n'ai pas vraiment compris ton script car il suppose qu'il n'y a qu'un fichier jpeg.
Pourtant non. Il passe à travers les fichiers .jpg du dossier local. Tu m'a redendue incertaine, j'ai encore teste et ca fonctionne encore!
Enfin voici un exemple de code standard qui marche en sh sans utiliser de particularités liées à un shell :
for f in *.jpg ; do set `sips -g pixelHeight -g pixelWidth "$f" | tail -2` echo "$f,$2,$4" done
Ca aussi ca fonctionne en Bash! Où puis-je trouver plus d'information sur les variables?
Éric Lévénez
Le 23/02/04 3:22, dans , « Bertrille Ethrington » a écrit :
Enfin voici un exemple de code standard qui marche en sh sans utiliser de particularités liées à un shell :
for f in *.jpg ; do set `sips -g pixelHeight -g pixelWidth "$f" | tail -2` echo "$f,$2,$4" done
Ca aussi ca fonctionne en Bash!
Oui, sh est du Bourne shell qui date de 1971, et les shells type bash, ksh ou zsh sont des sur-ensembles. L'inverse n'étant pas vrai : un shell bash ou zsh peut ne pas marcher sous sh s'il utilise des particularités.
Où puis-je trouver plus d'information sur les variables?
Il y a d'abord les man des shells ("man bash"...), et il y a tous les cours sur les shells que l'on trouve sur internet (Google...).
-- Éric Lévénez -- <http://www.levenez.com/> Unix is not only an OS, it's a way of life.
Le 23/02/04 3:22, dans <76ba41ea.0402221822.640faac7@posting.google.com>,
« Bertrille Ethrington » <bertrille@bigfoot.com> a écrit :
Enfin voici un exemple de code standard qui marche en sh sans
utiliser de particularités liées à un shell :
for f in *.jpg ; do
set `sips -g pixelHeight -g pixelWidth "$f" | tail -2`
echo "$f,$2,$4"
done
Ca aussi ca fonctionne en Bash!
Oui, sh est du Bourne shell qui date de 1971, et les shells type bash, ksh
ou zsh sont des sur-ensembles. L'inverse n'étant pas vrai : un shell bash ou
zsh peut ne pas marcher sous sh s'il utilise des particularités.
Où puis-je trouver plus d'information
sur les variables?
Il y a d'abord les man des shells ("man bash"...), et il y a tous les cours
sur les shells que l'on trouve sur internet (Google...).
--
Éric Lévénez -- <http://www.levenez.com/>
Unix is not only an OS, it's a way of life.
Le 23/02/04 3:22, dans , « Bertrille Ethrington » a écrit :
Enfin voici un exemple de code standard qui marche en sh sans utiliser de particularités liées à un shell :
for f in *.jpg ; do set `sips -g pixelHeight -g pixelWidth "$f" | tail -2` echo "$f,$2,$4" done
Ca aussi ca fonctionne en Bash!
Oui, sh est du Bourne shell qui date de 1971, et les shells type bash, ksh ou zsh sont des sur-ensembles. L'inverse n'étant pas vrai : un shell bash ou zsh peut ne pas marcher sous sh s'il utilise des particularités.
Où puis-je trouver plus d'information sur les variables?
Il y a d'abord les man des shells ("man bash"...), et il y a tous les cours sur les shells que l'on trouve sur internet (Google...).
-- Éric Lévénez -- <http://www.levenez.com/> Unix is not only an OS, it's a way of life.
bertrille
Éric Lévénez wrote in message news:<BC5F6368.6A190%...
Le 23/02/04 3:22, dans ,
Enfin voici un exemple de code standard qui marche en sh sans utiliser de particularités liées à un shell :
for f in *.jpg ; do set `sips -g pixelHeight -g pixelWidth "$f" | tail -2` echo "$f,$2,$4" done
Ca aussi ca fonctionne en Bash!
Oui, sh est du Bourne shell qui date de 1971, et les shells type bash, ksh ou zsh sont des sur-ensembles. L'inverse n'étant pas vrai : un shell bash ou zsh peut ne pas marcher sous sh s'il utilise des particularités.
Où puis-je trouver plus d'information sur les variables?
Il y a d'abord les man des shells ("man bash"...), et il y a tous les cours sur les shells que l'on trouve sur internet (Google...).
Je n'ai que 2 problemes avec ces 2 facons de proceder.
Le premier est que, dans un cas comme dans l'autre, sips ne fonctionne pas avec des fichiers qui ont des nom contenant des caracteres accentues.
Le deuxieme est que si je precise que le dossier contenant les fichiers a des espaces blanc dans les noms de fichiers n'importe ou dans le path, le shell (serait-ce limite a bash?) refuse d'accepter que le dossier soit courrant.
C'est un peu genant intelectuellement car mac OS X est du Unix lui aussi et les gere tres bien.
Éric Lévénez <news@levenez.com> wrote in message news:<BC5F6368.6A190%news@levenez.com>...
Le 23/02/04 3:22, dans <76ba41ea.0402221822.640faac7@posting.google.com>,
Enfin voici un exemple de code standard qui marche en sh sans
utiliser de particularités liées à un shell :
for f in *.jpg ; do
set `sips -g pixelHeight -g pixelWidth "$f" | tail -2`
echo "$f,$2,$4"
done
Ca aussi ca fonctionne en Bash!
Oui, sh est du Bourne shell qui date de 1971, et les shells type bash, ksh
ou zsh sont des sur-ensembles. L'inverse n'étant pas vrai : un shell bash ou
zsh peut ne pas marcher sous sh s'il utilise des particularités.
Où puis-je trouver plus d'information
sur les variables?
Il y a d'abord les man des shells ("man bash"...), et il y a tous les cours
sur les shells que l'on trouve sur internet (Google...).
Je n'ai que 2 problemes avec ces 2 facons de proceder.
Le premier est que, dans un cas comme dans l'autre, sips ne fonctionne
pas avec des fichiers qui ont des nom contenant des caracteres
accentues.
Le deuxieme est que si je precise que le dossier contenant les
fichiers a des espaces blanc dans les noms de fichiers n'importe ou
dans le path, le shell (serait-ce limite a bash?) refuse d'accepter
que le dossier soit courrant.
C'est un peu genant intelectuellement car mac OS X est du Unix lui
aussi et les gere tres bien.
Éric Lévénez wrote in message news:<BC5F6368.6A190%...
Le 23/02/04 3:22, dans ,
Enfin voici un exemple de code standard qui marche en sh sans utiliser de particularités liées à un shell :
for f in *.jpg ; do set `sips -g pixelHeight -g pixelWidth "$f" | tail -2` echo "$f,$2,$4" done
Ca aussi ca fonctionne en Bash!
Oui, sh est du Bourne shell qui date de 1971, et les shells type bash, ksh ou zsh sont des sur-ensembles. L'inverse n'étant pas vrai : un shell bash ou zsh peut ne pas marcher sous sh s'il utilise des particularités.
Où puis-je trouver plus d'information sur les variables?
Il y a d'abord les man des shells ("man bash"...), et il y a tous les cours sur les shells que l'on trouve sur internet (Google...).
Je n'ai que 2 problemes avec ces 2 facons de proceder.
Le premier est que, dans un cas comme dans l'autre, sips ne fonctionne pas avec des fichiers qui ont des nom contenant des caracteres accentues.
Le deuxieme est que si je precise que le dossier contenant les fichiers a des espaces blanc dans les noms de fichiers n'importe ou dans le path, le shell (serait-ce limite a bash?) refuse d'accepter que le dossier soit courrant.
C'est un peu genant intelectuellement car mac OS X est du Unix lui aussi et les gere tres bien.
Éric Lévénez
Le 23/02/04 23:15, dans , « Bertrille Ethrington » a écrit :
Je n'ai que 2 problemes avec ces 2 facons de proceder.
Le premier est que, dans un cas comme dans l'autre, sips ne fonctionne pas avec des fichiers qui ont des nom contenant des caracteres accentues.
Le deuxieme est que si je precise que le dossier contenant les fichiers a des espaces blanc dans les noms de fichiers n'importe ou dans le path, le shell (serait-ce limite a bash?) refuse d'accepter que le dossier soit courrant.
Tout cela doit venir du shell et pas de la commande lancée. C'est pour cela que l'on met des guillemets autour des noms des variables shell.
-- Éric Lévénez -- <http://www.levenez.com/> Unix is not only an OS, it's a way of life.
Le 23/02/04 23:15, dans <76ba41ea.0402231415.18c0b9e8@posting.google.com>,
« Bertrille Ethrington » <bertrille@bigfoot.com> a écrit :
Je n'ai que 2 problemes avec ces 2 facons de proceder.
Le premier est que, dans un cas comme dans l'autre, sips ne fonctionne
pas avec des fichiers qui ont des nom contenant des caracteres
accentues.
Le deuxieme est que si je precise que le dossier contenant les
fichiers a des espaces blanc dans les noms de fichiers n'importe ou
dans le path, le shell (serait-ce limite a bash?) refuse d'accepter
que le dossier soit courrant.
Tout cela doit venir du shell et pas de la commande lancée. C'est pour cela
que l'on met des guillemets autour des noms des variables shell.
--
Éric Lévénez -- <http://www.levenez.com/>
Unix is not only an OS, it's a way of life.
Le 23/02/04 23:15, dans , « Bertrille Ethrington » a écrit :
Je n'ai que 2 problemes avec ces 2 facons de proceder.
Le premier est que, dans un cas comme dans l'autre, sips ne fonctionne pas avec des fichiers qui ont des nom contenant des caracteres accentues.
Le deuxieme est que si je precise que le dossier contenant les fichiers a des espaces blanc dans les noms de fichiers n'importe ou dans le path, le shell (serait-ce limite a bash?) refuse d'accepter que le dossier soit courrant.
Tout cela doit venir du shell et pas de la commande lancée. C'est pour cela que l'on met des guillemets autour des noms des variables shell.
-- Éric Lévénez -- <http://www.levenez.com/> Unix is not only an OS, it's a way of life.
blanc
Éric Lévénez wrote:
Je n'ai pas vraiment compris ton script car il suppose qu'il n'y a qu'un fichier jpeg. Enfin voici un exemple de code standard qui marche en sh sans utiliser de particularités liées à un shell :
for f in *.jpg ; do set `sips -g pixelHeight -g pixelWidth "$f" | tail -2` echo "$f,$2,$4" done
Pourquoi, chez moi, la commande "sips -g pixelHeight -g pixelWidth " me donne "Error: Error querying file" sur tous les fichiers jpg sur lesquels je l'essaye ? Qu'est-ce que j'ai donc pu rater ?...
JPaul.
-- /==/==- Jean-Paul BLANC / /--/--// quelque-part (somewhere) |/| L | en (in) /|| = ||| FRANCE
Éric Lévénez <news@levenez.com> wrote:
Je n'ai pas vraiment compris ton script car il suppose qu'il n'y a qu'un
fichier jpeg. Enfin voici un exemple de code standard qui marche en sh sans
utiliser de particularités liées à un shell :
for f in *.jpg ; do
set `sips -g pixelHeight -g pixelWidth "$f" | tail -2`
echo "$f,$2,$4"
done
Pourquoi, chez moi, la commande "sips -g pixelHeight -g pixelWidth "
me donne
"Error: Error querying file" sur tous les fichiers jpg sur lesquels je
l'essaye ?
Qu'est-ce que j'ai donc pu rater ?...
JPaul.
--
/==/==\- Jean-Paul BLANC
/ /--/--//\ quelque-part (somewhere)
|/| L |\ en (in)
/|| = |||\ FRANCE
Je n'ai pas vraiment compris ton script car il suppose qu'il n'y a qu'un fichier jpeg. Enfin voici un exemple de code standard qui marche en sh sans utiliser de particularités liées à un shell :
for f in *.jpg ; do set `sips -g pixelHeight -g pixelWidth "$f" | tail -2` echo "$f,$2,$4" done
Pourquoi, chez moi, la commande "sips -g pixelHeight -g pixelWidth " me donne "Error: Error querying file" sur tous les fichiers jpg sur lesquels je l'essaye ? Qu'est-ce que j'ai donc pu rater ?...
JPaul.
-- /==/==- Jean-Paul BLANC / /--/--// quelque-part (somewhere) |/| L | en (in) /|| = ||| FRANCE
