एक निर्देशिका में कई फाइलें हैं, जो उपसर्ग के साथ शुरू होती हैं fgh, उदाहरण के लिए:
fghfilea
fghfileb
fghfilec
मैं उपसर्ग के साथ शुरू करने के लिए उन सभी का नाम बदलना चाहता हूं jkl। क्या प्रत्येक फ़ाइल को अलग-अलग नाम देने के बजाय ऐसा करने के लिए एक ही आदेश है?
जवाबों:
कई तरीके हैं, लेकिन उपयोग renameकरना शायद सबसे आसान होगा।
के एक संस्करण का उपयोग rename:
rename 's/^fgh/jkl/' fgh*
rename(के रूप में एक ही संस्करण का उपयोग कर Judy2K के उत्तर ):
rename fgh jkl fgh*
आपको अपने प्लेटफ़ॉर्म के मैन पेज की जाँच करनी चाहिए कि ऊपर कौन सा लागू होता है।
renameकर रहे हैं तब आप unixhelp.ed.ac.uk/CGI/man-cgi?rename के लिए वाक्यविन्यास दिखा रहे हैं , अन्य एक है
renameएक लिनक्स विशिष्ट स्क्रिप्ट या उपयोगिता लगती है। यदि आप पोर्टेबिलिटी के बारे में सभी का ध्यान रखते हैं, तो कृपया उपयोग जारी रखें sedऔर लूप या इनलाइन पर्ल स्क्रिप्ट का उपयोग करें।
brew install renameओएस एक्स पर :)
यह कैसे sedऔर mvनाम बदलने के लिए एक साथ इस्तेमाल किया जा सकता है:
for f in fgh*; do mv "$f" $(echo "$f" | sed 's/^fgh/jkl/g'); done
नीचे दी गई टिप्पणी के अनुसार, यदि फ़ाइल नामों में जगह है, तो उद्धरणों को उप-फ़ंक्शन को घेरने की आवश्यकता हो सकती है जो फ़ाइलों को स्थानांतरित करने के लिए नाम लौटाता है:
for f in fgh*; do mv "$f" "$(echo $f | sed 's/^fgh/jkl/g')"; done
for f in fgh*; do mv "$f" "$(echo $f | sed 's/^fgh/jkl/g')"; done
touch fghfilea fghfileb fghfilec fghfile\ d:। मैं कृपया @DaveNelson टिप्पणी को ध्यान में रखने का सुझाव देता हूं।
नाम हर प्रणाली में नहीं हो सकता है। इसलिए यदि आपके पास यह नहीं है, तो इस उदाहरण का उपयोग bash शेल में करें
for f in fgh*; do mv "$f" "${f/fgh/xxx}";done
sedकमांड की आवश्यकता नहीं है। यह @ नीक के उत्तर की तुलना में सरल है।
shया आमतौर पर अन्य शेल में मौजूद नहीं है ।
Mmv का उपयोग करना :
mmv "fgh*" "jkl#1"
;में लाएं #1। उदाहरण:mmv ";fgh*" "#1jkl#2"
इसे करने के कई तरीके हैं (इनमें से सभी सभी यूनिक्स सिस्टम पर काम नहीं करेंगे):
ls | cut -c4- | xargs -I§ mv fgh§ jkl§
The कुछ भी आप सुविधाजनक मिल द्वारा प्रतिस्थापित किया जा सकता है। आप ऐसा find -execभी कर सकते हैं, लेकिन यह कई प्रणालियों पर अलग-अलग व्यवहार करता है, इसलिए मैं आमतौर पर इससे बचता हूं
for f in fgh*; do mv "$f" "${f/fgh/jkl}";done
क्रूड लेकिन प्रभावी वे कहते हैं
rename 's/^fgh/jkl/' fgh*
असली सुंदर है, लेकिन नाम बीएसडी पर मौजूद नहीं है, जो कि सबसे आम यूनिक्स सिस्टम एफैक है।
rename fgh jkl fgh*
ls | perl -ne 'chomp; next unless -e; $o = $_; s/fgh/jkl/; next if -e; rename $o, $_';
यदि आप पर्ल का उपयोग करने पर जोर देते हैं, लेकिन आपके सिस्टम में कोई नाम नहीं है, तो आप इस राक्षस का उपयोग कर सकते हैं।
उनमें से कुछ थोड़ा जटिल हैं और सूची पूरी तरह से दूर है, लेकिन आप पाएंगे कि आप यहां बहुत सारे यूनिक्स सिस्टम के लिए क्या चाहते हैं।
rename fgh jkl fgh*
उपयोग करना find, xargsऔर sed:
find . -name "fgh*" -type f -print0 | xargs -0 -I {} sh -c 'mv "{}" "$(dirname "{}")/`echo $(basename "{}") | sed 's/^fgh/jkl/g'`"'
यह @ नीक के समाधान से अधिक जटिल है, लेकिन यह फ़ाइलों को पुन: नाम बदलने की अनुमति देता है। उदाहरण के लिए, संरचना,
.
├── fghdir
│ ├── fdhfilea
│ └── fghfilea
├── fghfile\ e
├── fghfilea
├── fghfileb
├── fghfilec
└── other
├── fghfile\ e
├── fghfilea
├── fghfileb
└── fghfilec
यह करने के लिए बदल जाएगा,
.
├── fghdir
│ ├── fdhfilea
│ └── jklfilea
├── jklfile\ e
├── jklfilea
├── jklfileb
├── jklfilec
└── other
├── jklfile\ e
├── jklfilea
├── jklfileb
└── jklfilec
इसके साथ काम करने की कुंजी यह xargsहै कि शेल को xargs से आह्वान किया जाए ।
पर्ल नाम स्क्रिप्ट स्थापित करने के लिए :
sudo cpan install File::Rename
Stephan202 के उत्तर में टिप्पणियों में उल्लिखित दो नाम हैं । डेबियन आधारित डिस्ट्रोस का पर्ल नाम है । Redhat / rpm डिस्ट्रोस का सी नाम है ।
OS X में डिफ़ॉल्ट रूप से (कम से कम 10.8 में) स्थापित नहीं है, न ही Windows / Cygwin।
यहाँ यह कमांड-लाइन ग्रूवी का उपयोग करने का एक तरीका है:
groovy -e 'new File(".").eachFileMatch(~/fgh.*/) {it.renameTo(it.name.replaceFirst("fgh", "jkl"))}'सोलारिस पर आप कोशिश कर सकते हैं:
for file in `find ./ -name "*TextForRename*"`; do
mv -f "$file" "${file/TextForRename/NewText}"
done
for file in $(find)मौलिक रूप से त्रुटिपूर्ण है और इसे उद्धरण के साथ ठीक नहीं किया जा सकता है। अगर findरिटर्न ./file name with spacesआप एक मिल जाएगा forपाश से अधिक ./file, name, with, और spacesऔर पाश अंदर के हवाले से मदद मिलेगी (या यहां तक आवश्यक हो) का कोई राशि।
इस स्क्रिप्ट ने मेरे लिए निर्देशिकाओं / फ़ाइल नामों के साथ फिर से नाम बदलने के लिए काम किया, जिसमें संभवतः सफेद-रिक्तियाँ थीं:
find . -type f -name "*\;*" | while read fname; do
dirname=`dirname "$fname"`
filename=`basename "$fname"`
newname=`echo "$filename" | sed -e "s/;/ /g"`
mv "${dirname}/$filename" "${dirname}/$newname"
done
सूचना sedअभिव्यक्ति जो इस उदाहरण में की सभी घटनाओं की जगह ;की जगह के साथ । यह निश्चित रूप से विशिष्ट आवश्यकताओं के अनुसार प्रतिस्थापित किया जाना चाहिए।
StringSolver टूल्स (विंडोज़ और लिनक्स बैश) का उपयोग करना, जो उदाहरणों द्वारा प्रक्रिया करते हैं:
filter fghfilea ok fghreport ok notfghfile notok; mv --all --filter fghfilea jklfilea
यह पहले उदाहरणों के आधार पर एक फिल्टर की गणना करता है , जहां इनपुट फ़ाइल नाम और आउटपुट (ठीक है और नोटोक, मनमाना तार) है। यदि इस विकल्प के बाद फ़िल्टर का विकल्प होता है --ऑटो या अकेले मंगाया जाता है, तो यह क्रमशः एक फ़ोल्डर okऔर एक फ़ोल्डर notokऔर फ़ाइलों को धक्का देगा।
फिर फ़िल्टर का उपयोग करते हुए, mvकमांड एक अर्ध-स्वचालित चाल है जो संशोधक - ऑटो के साथ स्वचालित हो जाती है। --फिल्टर के लिए पिछले फिल्टर का उपयोग करके, यह एक मानचित्रण पाता हैfghfilea करने के लिए jklfileaऔर उसके बाद फिल्टर किए गए सभी फाइलों पर यह लागू होता है।
अन्य एक लाइन समाधान
समान करने के अन्य समान तरीके (प्रत्येक पंक्ति समतुल्य है), इसलिए आप इसे करने के अपने पसंदीदा तरीके को चुन सकते हैं।
filter fghfilea ok fghreport ok notfghfile notok; mv --filter fghfilea jklfilea; mv
filter fghfilea ok fghreport ok notfghfile notok; auto --all --filter fghfilea "mv fghfilea jklfilea"
# Even better, automatically infers the file name
filter fghfilea ok fghreport ok notfghfile notok; auto --all --filter "mv fghfilea jklfilea"
बहु कदम समाधान
यह जानने के लिए कि क्या कमांड अच्छा प्रदर्शन कर रहे हैं, आप निम्न टाइप कर सकते हैं:
filter fghfilea ok
filter fghfileb ok
filter fghfileb notok
और जब आप आश्वस्त हों कि फ़िल्टर अच्छा है, तो पहली चाल प्रदर्शन करें:
mv fghfilea jklfilea
यदि आप पिछले फ़िल्टर का परीक्षण और उपयोग करना चाहते हैं, तो टाइप करें:
mv --test --filter
यदि परिवर्तन वह नहीं है जो आप चाहते थे (जैसे कि आपके साथ mv --explainयह देखने पर भी कि कुछ गड़बड़ है), आप mv --clearचलती फ़ाइलों को पुनः आरंभ करने के लिए टाइप कर सकते हैं , या अधिक उदाहरण जोड़ सकते हैंmv input1 input2 जहां input1 और input2 अन्य उदाहरण हैं
जब आप आश्वस्त हों, बस टाइप करें
mv --filter
और आवाज! सभी का नामकरण फ़िल्टर का उपयोग करके किया जाता है।
अस्वीकरण: मैं अकादमिक उद्देश्यों के लिए किए गए इस काम का सह-लेखक हूं। जल्द ही एक बैश-उत्पादक फीचर भी हो सकता है।
रूबी में ऐसा करना बहुत आसान था (मेरे मैक पर)। यहाँ 2 उदाहरण हैं:
# for your fgh example. renames all files from "fgh..." to "jkl..."
files = Dir['fgh*']
files.each do |f|
f2 = f.gsub('fgh', 'jkl')
system("mv #{f} #{f2}")
end
# renames all files in directory from "021roman.rb" to "021_roman.rb"
files = Dir['*rb'].select {|f| f =~ /^[0-9]{3}[a-zA-Z]+/}
files.each do |f|
f1 = f.clone
f2 = f.insert(3, '_')
system("mv #{f1} #{f2}")
end
मास फ़ाइलों का नाम बदलने का मेरा संस्करण:
for i in *; do
echo "mv $i $i"
done |
sed -e "s#from_pattern#to_pattern#g” > result1.sh
sh result1.sh
मैं अपनी खुद की स्क्रिप्ट का उपयोग करने की सलाह दूंगा, जो इस समस्या को हल करता है। इसमें फ़ाइल नामों के एन्कोडिंग को बदलने के लिए विकल्प भी हैं, और diacriticals के संयोजन को पहले से रखे गए वर्णों में बदलने के लिए, एक समस्या मुझे हमेशा होती है जब मैं अपने मैक से फ़ाइलों की प्रतिलिपि बनाता हूं।
#!/usr/bin/perl
# Copyright (c) 2014 André von Kugland
# Permission is hereby granted, free of charge, to any person obtaining a
# copy of this software and associated documentation files (the "Software"),
# to deal in the Software without restriction, including without limitation
# the rights to use, copy, modify, merge, publish, distribute, sublicense,
# and/or sell copies of the Software, and to permit persons to whom the
# Software is furnished to do so, subject to the following conditions:
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
# DEALINGS IN THE SOFTWARE.
$help_msg =
"rename.pl, a script to rename files in batches, using Perl
expressions to transform their names.
Usage:
rename.pl [options] FILE1 [FILE2 ...]
Where options can be:
-v Verbose.
-vv Very verbose.
--apply Really apply modifications.
-e PERLCODE Execute PERLCODE. (e.g. 's/a/b/g')
--from-charset=CS Source charset. (e.g. \"iso-8859-1\")
--to-charset=CS Destination charset. (e.g. \"utf-8\")
--unicode-normalize=NF Unicode normalization form. (e.g. \"KD\")
--basename Modifies only the last element of the path.
";
use Encode;
use Getopt::Long;
use Unicode::Normalize 'normalize';
use File::Basename;
use I18N::Langinfo qw(langinfo CODESET);
Getopt::Long::Configure ("bundling");
# ----------------------------------------------------------------------------------------------- #
# Our variables. #
# ----------------------------------------------------------------------------------------------- #
my $apply = 0;
my $verbose = 0;
my $help = 0;
my $debug = 0;
my $basename = 0;
my $unicode_normalize = "";
my @scripts;
my $from_charset = "";
my $to_charset = "";
my $codeset = "";
# ----------------------------------------------------------------------------------------------- #
# Get cmdline options. #
# ----------------------------------------------------------------------------------------------- #
$result = GetOptions ("apply" => \$apply,
"verbose|v+" => \$verbose,
"execute|e=s" => \@scripts,
"from-charset=s" => \$from_charset,
"to-charset=s" => \$to_charset,
"unicode-normalize=s" => \$unicode_normalize,
"basename" => \$basename,
"help|h|?" => \$help,
"debug" => \$debug);
# If not going to apply, then be verbose.
if (!$apply && $verbose == 0) {
$verbose = 1;
}
if ((($#scripts == -1)
&& (($from_charset eq "") || ($to_charset eq ""))
&& $unicode_normalize eq "")
|| ($#ARGV == -1) || ($help)) {
print $help_msg;
exit(0);
}
if (($to_charset ne "" && $from_charset eq "")
||($from_charset eq "" && $to_charset ne "")
||($to_charset eq "" && $from_charset eq "" && $unicode_normalize ne "")) {
$codeset = langinfo(CODESET);
$to_charset = $codeset if $from_charset ne "" && $to_charset eq "";
$from_charset = $codeset if $from_charset eq "" && $to_charset ne "";
}
# ----------------------------------------------------------------------------------------------- #
# Composes the filter function using the @scripts array and possibly other options. #
# ----------------------------------------------------------------------------------------------- #
$f = "sub filterfunc() {\n my \$s = shift;\n";
$f .= " my \$d = dirname(\$s);\n my \$s = basename(\$s);\n" if ($basename != 0);
$f .= " for (\$s) {\n";
$f .= " $_;\n" foreach (@scripts); # Get scripts from '-e' opt. #
# Handle charset translation and normalization.
if (($from_charset ne "") && ($to_charset ne "")) {
if ($unicode_normalize eq "") {
$f .= " \$_ = encode(\"$to_charset\", decode(\"$from_charset\", \$_));\n";
} else {
$f .= " \$_ = encode(\"$to_charset\", normalize(\"$unicode_normalize\", decode(\"$from_charset\", \$_)));\n"
}
} elsif (($from_charset ne "") || ($to_charset ne "")) {
die "You can't use `from-charset' nor `to-charset' alone";
} elsif ($unicode_normalize ne "") {
$f .= " \$_ = encode(\"$codeset\", normalize(\"$unicode_normalize\", decode(\"$codeset\", \$_)));\n"
}
$f .= " }\n";
$f .= " \$s = \$d . '/' . \$s;\n" if ($basename != 0);
$f .= " return \$s;\n}\n";
print "Generated function:\n\n$f" if ($debug);
# ----------------------------------------------------------------------------------------------- #
# Evaluates the filter function body, so to define it in our scope. #
# ----------------------------------------------------------------------------------------------- #
eval $f;
# ----------------------------------------------------------------------------------------------- #
# Main loop, which passes names through filters and renames files. #
# ----------------------------------------------------------------------------------------------- #
foreach (@ARGV) {
$old_name = $_;
$new_name = filterfunc($_);
if ($old_name ne $new_name) {
if (!$apply or (rename $old_name, $new_name)) {
print "`$old_name' => `$new_name'\n" if ($verbose);
} else {
print "Cannot rename `$old_name' to `$new_name'.\n";
}
} else {
print "`$old_name' unchanged.\n" if ($verbose > 1);
}
}
stale over time
इसने मेरे लिए regexp का उपयोग करके काम किया:
मैं चाहता था कि फ़ाइलों को इस तरह बदला जाए:
file0001.txt -> 1.txt
ofile0002.txt -> 2.txt
f_i_l_e0003.txt -> 3.txt
usig [az | _] + 0 * ([0-9] + ) regexp जहां ([99] + ) एक ग्रुप है जो रीनेम कमांड पर उपयोग करने के लिए एक समूह है ।
ls -1 | awk 'match($0, /[a-z|\_]+0*([0-9]+.*)/, arr) { print arr[0] " " arr[1] }'|xargs -l mv
पैदा करता है:
mv file0001.txt 1.txt
mv ofile0002.txt 2.txt
mv f_i_l_e0003.txt 3.txt
एक और उदाहरण:
file001abc.txt -> abc1.txt
ofile0002abcd.txt -> abcd2.txt
ls -1 | awk 'match($0, /[a-z|\_]+0*([0-9]+.*)([a-z]+)/, arr) { print arr[0] " " arr[2] arr[1] }'|xargs -l mv
पैदा करता है:
mv file001abc.txt abc1.txt
mv ofile0002abcd.txt abcd2.txt
चेतावनी, सावधान रहें।
मैंने यह स्क्रिप्ट सभी .mkv फ़ाइलों की खोज के लिए लिखी थी। पुनः प्राप्त की गई फ़ाइलों का नाम बदलकर .avi। आप इसे अपने neeeds को कस्टमाइज़ कर सकते हैं। मैंने फाइल डायरेक्टरी, एक्सटेंशन, फाइल नेम जैसे कुछ अन्य चीजों को जोड़ दिया है, बस आपको भविष्य में किसी चीज को संदर्भित करने की आवश्यकता है।
find . -type f -name "*.mkv" | while read fp; do
fd=$(dirname "${fp}");
fn=$(basename "${fp}");
ext="${fn##*.}";
f="${fn%.*}";
new_fp="${fd}/${f}.avi"
mv -v "$fp" "$new_fp"
done;
एक को चलाने के लिए एक सामान्य स्क्रिप्ट sedफ़ाइलों की एक सूची पर अभिव्यक्ति (जोड़ती sedसमाधान के साथ renameसमाधान ):
#!/bin/sh
e=$1
shift
for f in $*; do
fNew=$(echo "$f" | sed "$e")
mv "$f" "$fNew";
done
स्क्रिप्ट को एक sedअभिव्यक्ति और फिर फ़ाइलों की किसी भी सूची को पास करके लागू करें, बस एक संस्करण की तरह rename:
script.sh 's/^fgh/jkl/' fgh*
एक और संभावित पैरामीटर विस्तार :
for f in fgh*; do mv -- "$f" "jkl${f:3}"; done