Discussion :

[sylv20]

Bonjour,

Je voudrai renommer des fichiers de cette façon :
mesure_0.txt >> cycle_0.txt
mesure_1.txt >> cycle_10.txt
mesure_2.txt >> cycle_20.txt etc..

Voila mon code pour le moment mais je n'arrive pas à écrire la ligne de rename.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
 
#include <stdio.h>
#include <stdlib.h>
#include <dirent.h>
 
int main()
{
char directory[]="C:\\Users\\stellier\\Desktop\\ess code block\\fichier_a_renommer";
DIR *dir = opendir (directory);
int i = 0;
struct dirent *file;
char nbr_cycle=0;
 
if (dir != NULL){
 
    printf ("Dossier : '%s'\n", directory);
 
    while ((file = readdir (dir)) != NULL){
        if (strcmp (file->d_name, ".") != 0 && strcmp (file->d_name, "..") != 0){
            printf("%s\n", file->d_name);
            rename(file->d_name,nbr_cycle&&".txt");  // cette ligne là qui ne marche pas.
            printf("cycle_%d.txt\n", nbr_cycle);
            nbr_cycle+=10;
        }
 
    }
    closedir (dir);
 
 
}
}

Pouvez vous m'aider.

Merci

[Médinoc]

Tu dois utiliser un buffer et la fonction strcat() pour concaténer des chaînes (ou plutôt sprintf() -- snprintf() si ton EDI le supporte -- vu que tu emploies des nombres).

[plxpy]

Bonjour

des points de détails (encore que ...):

- gérer indépendamment tes numéros et ce qui t'arrive dans le readdir peut être casse-gueule. Nulle part dans la doc (sous Linux) que j'ai, il n'est dit que les structures dirent t'arrivent dans un ordre particulier (et encore moins celui qui t'arrange ...). Pratiquement, sous Windows, je ne sais pas, mais sous Linux, "ça le fait pas". Avec le code suivant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
#include <stdlib.h>
#include <dirent.h>
 
int main(int argc, char *argv[])
{
	DIR *dir = opendir(".");
	struct dirent *dirent;
 
	while (dirent = readdir(dir))
		printf("%s\n", dirent->d_name);
	closedir(dir);
}

j'obtiens :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
plx@satellite:~/TEST$ > mesure_0.txt
plx@satellite:~/TEST$ > mesure_1.txt
plx@satellite:~/TEST$ > mesure_2.txt
plx@satellite:~/TEST$ ../readdir 
mesure_0.txt
mesure_2.txt
..
.
mesure_1.txt

Il serait préférable de déterminer le no à partir du nom de fichier qui t'est retourné et de construire le nouveau nom du fichier en conséquence.

- tu évites les pièges "." et ".." mais, de plus en plus, nos répertoires sont truffés de fichiers et de réperoitres cachés (noms commençant par un point). Peut-être ferais-tu mieux de "passer" tout fichier dont le nom commence par '.'

- tu ramasses tous les fichiers avec ton code (mais peut-être que tous tes fichiers dans les répertoires que tu traites sont du style "mesure_<no>.txt"). Là, c'est toi qui sais.

[ternel]

Je sais qu'il existe une commande rename dans linux.
Tu peux aller voir dans ses sources, sachant que ca peut être du C ou du script Shell.

[plxpy]

Je sais qu'il existe une commande rename dans linux.

c'est la commande "mv"

Tu peux aller voir dans ses sources, sachant que ca peut être du C ou du script Shell.

C'est du C et, sous Linux/Unix, ça appellera, in fine, un appel système (section 2, et pas 3, du manuel Unix/Linux) qui est ... rename :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
[pascal:~] man 3 rename
No entry for rename in section 3 of the manual
[pascal:~] man 2 rename
 
RENAME(2)                   BSD System Calls Manual                  RENAME(2)
 
NAME
     rename -- change the name of a file
 
SYNOPSIS
     #include <stdio.h>
 
     int
     rename(const char *old, const char *new);
 
DESCRIPTION
     The rename() system call causes the link named old to be renamed as new.  If new exists, it is first removed.  Both old and new must be of the same
     type (that is, both must be either directories or non-directories) and must reside on the same file system.
 
     The rename() system call guarantees that an instance of new will always exist, even if the system should crash in the middle of the operation.
 
     If the final component of old is a symbolic link, the symbolic link is renamed, not the file or directory to which it points

La boucle est bouclée ...


Non, ici c'est un"bête" problème d'écriture dans une chaine de caractères, à mettre en paramètre de rename justement. Etudier le source de mv n'aidera pas.

[ternel]

En shell, j'utilise ce script, récupéré des tréfonds d'internet:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
#! /bin/bash
#
# original from:
# @(#) rename.ksh 1.1 94/05/10
# 90/06/01 John DuBois (spcecdt@armory.com)
# 91/02/25 Improved help info
# 92/06/07 remove quotes from around shell pattern as required by new ksh
# 94/05/10 Exit if no globbing chars given.
#
# conversion to bash v2 syntax by Chet Ramey
 
phelp()
{
echo "$usage
All files that match oldpattern will be renamed with the
filename components that match the constant parts of oldpattern
changed to the corresponding constant parts of newpattern.
The components of the filename that match variable parts of
oldpattern will be preserved.  Variable parts in oldpattern
must occur in the same order in newpattern.  Variables parts
can be '?' and '*'.
Example: 
rename \"/tmp/foo*.ba.?\" \"/tmp/new*x?\"
All files in /tmp that match foo*.ba.? will have the \"foo\" part
replaced by \"new\" and the \".ba.\" part replaced by \"x\"."
}
 
usage="usage: $name [-htv] oldpattern newpattern"
name=${0##/}
 
while getopts "htv" opt; do
    case "$opt" in
    t) tell=true;;
    v) verbose=true;;
    h) phelp; exit 0;;
    *) echo "$name: $usage" 1>&2; exit 2;;
    esac
done
shift $((OPTIND - 1))
 
if [ $# -lt 2 ]; then
    phelp
    exit 2
fi
 
oldpat=$1
newpat=$2
 
set -- $1
if [ ! -e "$1" ]; then
    echo "$name: no files match $oldpat."
    exit 1
fi
 
typeset -i i=1 j
 
# Example oldpat: foo*.a
# Example newpat: bar*.b
 
# Examples given for first iteration (in the example, the only interation)
while :; do
    case "$oldpat" in
    *[\*\?]*)	;;
    *)		break;;
    esac
 
    # Get leftmost globbing pattern in oldpat
    pat=${oldpat#*[\*\?]}	# pat=.a
    pat=${oldpat%%"$pat"}	# pat=foo*
    pat=${pat##*[!\?\*]}	# pat=*
    # Find parts before & after pattern
    oldpre[i]=${oldpat%%"$pat"*}	# oldpre[1]=foo
    oldsuf[i]=${oldpat#*"$pat"}		# oldsuf[1]=.a
    newpre[i]=${newpat%%"$pat"*}	# newpre[1]=bar
    # Get rid of processed part of patterns
    oldpat=${oldpat#${oldpre[i]}"$pat"}	# oldpat=.a
    newpat=${newpat#${newpre[i]}"$pat"}	# newpat=.b
    let i=i+1
done
 
if [ $i -eq 1 ]; then
    echo "No globbing chars in pattern." 1>&2
    exit 1
fi
 
oldpre[i]=${oldpat%%"$pat"*}	# oldpre[2]=.a
oldsuf[i]=${oldpat#*"$pat"}	# oldsuf[2]=.a
newpre[i]=${newpat%%"$pat"*}	# newpre[2]=.b
 
if [ -n "$verbose" ]; then
    j=1
    while let "j < i"; do
	echo \
"Old prefix: ${oldpre[j]}   Old suffix: ${oldsuf[j]}   New prefix: ${newpre[j]}"
	let j=j+1
    done
fi
 
# Example file: foox.a
 
for file; do
    j=1
    origname=$file	# origname=foox.a
    newfile=
    while let "j <= i"; do
	# Peel off a prefix	interation	1		2
	file=${file#${oldpre[j]}}		# file=x.a	file=
	# Save the part of this prefix that is to be retained
	const=${file%${oldsuf[j]}}		# const=x	const=
	newfile=$newfile${newpre[j]}$const	# newfile=barx	newfile=barx.b
	file=${file#$const}			# file=.a	file=.a
	let j=j+1
    done
    if [ -n "$tell" ]; then
	echo "Would move \"$origname\" to \"$newfile\"."
    else
	if [ -n "$verbose" ]; then
	    echo "Moving \"$origname\" to \"$newfile\"."
	fi
	mv $origname $newfile
    fi
done