दिलचस्प पोस्ट
सी ++ और जावा में "सामान्य" प्रकार के बीच अंतर क्या हैं? ASP.NET MVC Ajax.ActionLink छवि के साथ प्लगइन का निष्पादन जीवनचक्र कॉन्फ़िगरेशन द्वारा कवर नहीं किया गया (जेबोसास 7 ईएआर आदर्शरूप) क्या एसक्यूएल सर्वर में एक डबल का प्रतिनिधित्व करता है? पायथन में इवेंट सिस्टम मैं एक फाइल सूचक (फाइल * एफपी) को एक फ़ाइल डिस्क्रिप्टर (इंट एफडी) में कैसे रूपांतरित कर सकता / सकती हूं? एंड्रॉइड ब्राउज़र या वेबविवे के अंदर का पता लगाएं कुकी सेट करें और जावास्क्रिप्ट के साथ कुकी प्राप्त करें AFNetworking पोस्ट अनुरोध Idiomatically एक संख्या में मौजूद मानों की संख्या को खोजने के लिए एक सरणी में है जावास्क्रिप्ट के बिना एक HTML फार्म से एक सरणी पोस्ट करें atoi – कैसे शून्य और त्रुटि के बीच अंतर की पहचान करने के लिए? 1 वर्ष की अवधि शून्य? विधि पैरामीटर में अंतिम कीवर्ड शीर्षक से देशी टूलटिप स्टाइल = "टूलटिप पाठ"

एक "git निर्यात" (जैसे "svn निर्यात") करें?

मैं सोच रहा था कि क्या एक अच्छा "जीआईटी निर्यात" समाधान है जो कि .git रिपॉज़िटरी डायरेक्टरी के बिना एक पेड़ की प्रतिलिपि बनाता है। कम से कम तीन तरीकों से मुझे पता है:

  1. git clone .git रिपॉज़िटरी डायरेक्टरी को हटाकर।
  2. git checkout-index इस कार्यक्षमता को बताता है, लेकिन "बस वांछित ट्री को इंडेक्स में पढ़ें …" से शुरू होता है, जो मुझे पूरी तरह यकीन नहीं है कि कैसे करना है।
  3. git-export एक तीसरे पक्ष की स्क्रिप्ट है जो अनिवार्य रूप से एक अस्थायी स्थान में एक git clone करती है, उसके बाद rsync --exclude='.git' अंतिम गंतव्य में है।

इन समाधानों में से कोई भी मुझे संतोषजनक नहीं होने के रूप में हरा देता है। svn export करने के लिए सबसे निकटतम एक विकल्प 1 हो सकता है, क्योंकि दोनों को लक्ष्य निर्देशिका की आवश्यकता होती है पहले खाली होने के लिए। लेकिन विकल्प 2 भी बेहतर लगता है, मान लीजिए मुझे यह पता लग सकता है कि सूचकांक में एक पेड़ को पढ़ने का क्या मतलब है।

वेब के समाधान से एकत्रित समाधान "एक "git निर्यात" (जैसे "svn निर्यात") करें?"

शायद यह हासिल करने का सबसे आसान तरीका है git archive साथ यदि आपको वास्तव में विस्तारित पेड़ की ज़रूरत है तो आप ऐसा कुछ कर सकते हैं

 git archive master | tar -x -C /somewhere/else 

ज्यादातर समय जब मुझे git से कुछ 'निर्यात' करने की आवश्यकता होती है, तो मैं किसी भी मामले में एक संकुचित संग्रह चाहता हूं, इसलिए मैं ऐसा कुछ करता हूं।

 git archive master | bzip2 >source-tree.tar.bz2 

ज़िप संग्रह:

 git archive --format zip --output /full/path/to/zipfile.zip master 

अधिक जानकारी के लिए git help archive , यह काफी लचीला है


नोट: यदि आप सूचकांक निर्यात करने में रुचि रखते हैं, तो कमांड है

 git checkout-index -a -f --prefix=/destination/path/ 

(अधिक जानकारी के लिए ग्रेग के उत्तर देखें)

मुझे पता चला कि क्या विकल्प 2 का अर्थ है एक रिपॉजिटरी से, आप यह कर सकते हैं:

 git checkout-index -a -f --prefix=/destination/path/ 

पथ के अंत में स्लैश महत्वपूर्ण है, अन्यथा इसका परिणाम 'पथ' के उपसर्ग के साथ फाइल / गंतव्य में होगा।

चूंकि सामान्य स्थिति में सूचकांक में रिपॉजिटरी की सामग्री होती है, "इंडेक्स में वांछित वृक्ष को पढ़ने" के लिए विशेष कुछ नहीं है। यह पहले से ही वहां है

-a ध्वज को सूचकांक में सभी फाइलों को देखने की आवश्यकता है (मुझे यकीन नहीं है कि इस स्थिति में इस ध्वज को छोड़ने का क्या अर्थ है, क्योंकि यह मेरी इच्छानुसार नहीं है)। -f ध्वज बल आउटपुट में किसी भी मौजूदा फाइल को अधिलेखित करता है, जो कि यह कमांड सामान्य रूप से नहीं करता है।

ऐसा लगता है कि "जीआईटी निर्यात" की तरह मैं देख रहा था।

git archive भी दूरस्थ भंडार के साथ काम करता है

 git archive --format=tar \ --remote=ssh://remote_server/remote_repository master | tar -xf - 

विशेष रास्ते को निर्यात करने के लिए कई तरह के पथ जोड़ने के लिए, जैसा कि आप git के अंतिम तर्क के रूप में चाहते हैं, उदाहरण के लिए:

 git archive --format=tar \ --remote=ssh://remote_server/remote_repository master path1/ path2/ | tar -xv 

यहां छवि विवरण दर्ज करें

एक विशेष मामला उत्तर अगर रिपॉजिटरी की मेजबानी GitHub पर है

बस svn export उपयोग करें

जहाँ तक मुझे पता है कि archive --remote अनुमति नहीं देता – archive --remote यद्यपि GitHub svn संगत है और उनके पास सभी git repos svn सुलभ है, इसलिए आप केवल svn export उपयोग कर सकते हैं जैसे आप सामान्य रूप से अपने GitHub url के कुछ समायोजन के साथ।

उदाहरण के लिए एक संपूर्ण रिपॉजिटरी निर्यात करने के लिए, ध्यान दें कि यूआरएल में trunk कैसे बदलता है master (या जो भी प्रोजेक्ट की प्रमुख शाखा पर सेट है ):

 svn export https://github.com/username/repo-name/trunk/ 

और आप एक एकल फाइल या एक निश्चित पथ या फ़ोल्डर निर्यात कर सकते हैं:

 svn export https://github.com/username/repo-name/trunk/src/lib/folder 

JQuery जावास्क्रिप्ट पुस्तकालय के साथ उदाहरण

HEAD शाखा या मास्टर शाखा trunk का उपयोग करके उपलब्ध होगी:

 svn ls https://github.com/jquery/jquery/trunk 

गैर- HEAD शाखाएं /branches/ अंतर्गत पहुंच योग्य होगी:

 svn ls https://github.com/jquery/jquery/branches/2.1-stable 

उसी टैग के तहत /tags/ सभी टैग :

 svn ls https://github.com/jquery/jquery/tags/2.1.3 

गिट मैनुअल से :

जीआईटी-चेकआउट-इंडेक्स का उपयोग करके "एक संपूर्ण पेड़ निर्यात करें"

उपसर्ग की क्षमता मूल रूप से "वृक्ष के रूप में निर्यात" फ़ंक्शन के रूप में git-checkout-index का उपयोग करने के लिए तुच्छ बनाता है। बस वांछित पेड़ को इंडेक्स में पढ़ें, और करें:

$ git checkout-index --prefix=git-export-dir/ -a

मैंने git-checkout-index आसपास एक सरल आवरण लिखा है, जिसे आप इस तरह प्रयोग कर सकते हैं:

 git export ~/the/destination/dir 

यदि गंतव्य निर्देशिका पहले से मौजूद है, तो आपको -f या --force जोड़ना होगा।

स्थापना सरल है; बस अपने PATH में कहीं स्क्रिप्ट छोड़ दें, और सुनिश्चित करें कि यह निष्पादन योग्य है।

git-export लिए github रिपॉजिटरी

ऐसा लगता है कि यह एसआईएन की तुलना में Git के साथ एक समस्या से कम है। गिट केवल एक .git फोल्डर को रिपॉज़िटरी रूट में डालता है, जबकि SVN प्रत्येक उपनिर्देशिका में एक .svn फ़ोल्डर डालता है। इसलिए "svn निर्यात" रिकर्सिव कमांड-लाइन जादू से बचा जाता है, जबकि गिट रिकर्सन के साथ आवश्यक नहीं है।

के बराबर

 svn export . otherpath 

एक मौजूदा रेपो अंदर है

 git archive branchname | (cd otherpath; tar x) 

के बराबर

 svn export url otherpath 

है

 git archive --remote=url branchname | (cd otherpath; tar x) 

मैं git-submodules बड़े पैमाने पर उपयोग करते हैं यह मेरे लिए काम करता है:

 rsync -a ./FROM/ ./TO --exclude='.*' 

सही जवाब है "जीआईटी चेकआउट"

 mkdir /path/to/checkout/ git --git-dir=/path/to/repo/ --work-tree=/path/to/checkout/ checkout -f -q 

-f
जब सूचकांक से मार्गों की जाँच कर रहा हो, तो अनारगित प्रविष्टियों पर विफल न हो; इसके बजाय, अनारगित प्रविष्टियां उपेक्षा की जाती हैं।

-q
वर्बोस से बचें

इसके अतिरिक्त आप एसएवीएन में किसी भी शाखा या टैग या किसी विशिष्ट कमेट रिव्यूशन से प्राप्त कर सकते हैं, बस एसएचए 1 को जोड़कर (जीआईटी में एसएएचए 1 एसवीएन में संशोधन नंबर के समतुल्य है)

 mkdir /path/to/checkout/ git --git-dir=/path/to/repo/ --work-tree=/path/to/checkout/ checkout 2ef2e1f2de5f3d4f5e87df7d8 -f -q -- ./ 

/ Path / to / checkout / खाली होना चाहिए, Git किसी भी फाइल को नहीं हटाएगा, लेकिन किसी भी चेतावनी के बिना फाइलों को उसी नाम से अधिलेखित कर देगा

अद्यतन करें: शीर्षक, शाखाओं या एसएचए 1 के साथ निर्यात के लिए चेकआउट का उपयोग करते समय शिरोमण की समस्या से बचने के लिए या कार्यशील भंडार को छोड़ने के लिए, आपको जोड़ना होगा – ./ अंत में

डबल डैश – गिट को बताएं कि डैश के बाद सब कुछ पथ या फाइल हैं और इस मामले में भी जीआईटी चेकआउट को HEAD को न बदलने के लिए बताएं

उदाहरण:

यह कमांड सिर्फ लिब्स डायरेक्टरी और रीडमे। टीएटीटी फाइल को उसी प्रतिबद्धता से प्राप्त करेगा

 git --git-dir=/path/to/repo/ --work-tree=/path/to/checkout/ checkout fef2e1f2de5f3d4f5e87df7d8 -f -q -- ./libs ./docs/readme.txt 

यह (अतिलेखन) my_file_2_behind_HEAD.txt दो सिर HEAD ^ 2 के पीछे बना देगा

 git --git-dir=/path/to/repo/ --work-tree=/path/to/checkout/ checkout HEAD^2 -f -q -- ./my_file_2_behind_HEAD.txt 

किसी अन्य शाखा के निर्यात को प्राप्त करने के लिए

 git --git-dir=/path/to/repo/ --work-tree=/path/to/checkout/ checkout myotherbranch -f -q -- ./ 

ध्यान दें कि ./ रिपॉजिटरी की जड़ के सापेक्ष है

यह सभी सामग्रियों की प्रतिलिपि होगा,। मैं इसका इस्तेमाल गिट क्लोन प्रोजेक्ट को अपने वेब ऐप के जीआईटी रेपो में निर्यात करने के लिए करता हूं। जीआईटी सामान बिना।

सीपी-आर। / पाथ-टू -जीट-रिपो / पथ / टू / गंतव्य /

सादा पुराने बाश सिर्फ महान काम करता है 🙂

जीआईटी रिपॉजिटरी निर्यात करने के लिए एक मार्ग की तलाश करते समय मैंने इस पेज को अक्सर मारा है इस प्रश्न का मेरा उत्तर तीन गुणों को मानता है कि एसवीएन निर्यात जीआईटी की तुलना में डिज़ाइन के अनुसार है, क्योंकि एसवीएन एक केंद्रीयकृत रिपॉजिटरी दृष्टिकोण का अनुसरण करता है:

  • यह सभी संशोधनों को निर्यात नहीं करके किसी दूरस्थ रिपॉजिटरी स्थान पर यातायात को कम करता है
  • इसमें निर्यात निर्देशिका में मेटा जानकारी शामिल नहीं है
  • एसवीएन का उपयोग करके एक निश्चित शाखा का निर्यात करना उचित मार्ग निर्दिष्ट करके पूरा किया गया है

     git clone --depth 1 --branch master git://git.somewhere destination_path rm -rf destination_path/.git 

एक निश्चित रिहाई के निर्माण के दौरान, उदाहरण के लिए --branch stable या --branch release/0.9 रूप में एक स्थिर शाखा क्लोन करने के लिए उपयोगी है।

क्लोन के रूप में सरल रूप में .git फ़ोल्डर को हटाएं:

git clone url_of_your_repo path_to_export && rm -rf path_to_export/.git

मैं सिर्फ यह कहना चाहता हूं कि इस मामले में आप हैं

  1. रिपॉजिटरी के एक उप फ़ोल्डर का निर्यात (इस तरह मैं एसवीएन निर्यात सुविधा का उपयोग करने के लिए उपयोग किया था)
  2. उस फ़ोल्डर से तैनाती गंतव्य तक सब कुछ कॉपी करने के साथ ठीक है
  3. और क्योंकि आपके पास पहले से ही पूरे रिपॉजिटरी की एक प्रति है।

उसके बाद आप cp foo [destination] इस्तेमाल कर सकते हैं, जो कि git-archive master foo | -x -C [destination] बजाय git-archive master foo | -x -C [destination]

आप ज़िप फ़ाइल के रूप में किसी भी प्रतिबद्धता पर एक दूरस्थ रेपो संग्रह कर सकते हैं।

 git archive --format=zip --output=archive.zip --remote=USERNAME@HOSTNAME:PROJECTNAME.git HASHOFGITCOMMIT 

GitHub उपयोगकर्ताओं के लिए, git archive --remote विधि सीधे काम नहीं करेगा, क्योंकि निर्यात URL क्षणिक है आपको URL के लिए GitHub से पूछना होगा, फिर उस URL को डाउनलोड करना होगा curl इतना आसान बनाता है:

 curl -L https://api.github.com/repos/VENDOR/PROJECT/tarball | tar xzf - 

यह आपको एक स्थानीय निर्देशिका में निर्यात कोड देगा। उदाहरण:

 $ curl -L https://api.github.com/repos/jpic/bashworks/tarball | tar xzf - $ ls jpic-bashworks-34f4441/ break conf docs hack LICENSE mlog module mpd mtests os README.rst remote todo vcs vps wepcrack 

संपादित करें
यदि आप कोड को एक विशिष्ट, मौजूदा निर्देशिका (जीथूब से यादृच्छिक एक के बजाय) में रखना चाहते हैं:

 curl -L https://api.github.com/repos/VENDOR/PROJECT/tarball | \ tar xzC /path/you/want --strip 1 

जीआईटी-निर्यात के बैश-कार्यान्वयन

मैंने 'git-archive' कार्यान्वयन में उन्हें फिर से उपयोग करने के उद्देश्य से (बाद में पोस्ट किया जाएगा) अपने स्वयं के फ़ंक्शन पर .empty फ़ाइल निर्माण और हटाने की प्रक्रियाओं को विभाजित किया है।

मैंने लक्ष्य निर्यात फ़ोल्डर से अन-वांछित फ़ाइलों को हटाने के लिए प्रक्रिया में '.gitattributes' फ़ाइल भी जोड़ दी है I 'जीआईटी-एक्सपोर्ट' फंक्शन को और अधिक कुशल बनाने के दौरान प्रक्रिया के लिए शब्दशः शामिल है।

"। खाली" EMPTY_FILE =;

 function create_empty () { ## Processing path (target-dir): TRG_PATH="${1}"; ## Component(s): EXCLUDE_DIR=".git"; echo -en "\nAdding '${EMPTY_FILE}' files to empty folder(s): ..."; find ${TRG_PATH} -not -path "*/${EXCLUDE_DIR}/*" -type d -empty -exec touch {}/${EMPTY_FILE} \; #echo "done."; ## Purging SRC/TRG_DIRs variable(s): unset TRG_PATH EMPTY_FILE EXCLUDE_DIR; return 0; } declare -a GIT_EXCLUDE; function load_exclude () { SRC_PATH="${1}"; ITEMS=0; while read LINE; do # echo -e "Line [${ITEMS}]: '${LINE%%\ *}'"; GIT_EXCLUDE[((ITEMS++))]=${LINE%%\ *}; done < ${SRC_PATH}/.gitattributes; GIT_EXCLUDE[${ITEMS}]="${EMPTY_FILE}"; ## Purging variable(s): unset SRC_PATH ITEMS; return 0; } function purge_empty () { ## Processing path (Source/Target-dir): SRC_PATH="${1}"; TRG_PATH="${2}"; echo -e "\nPurging Git-Specific component(s): ... "; find ${SRC_PATH} -type f -name ${EMPTY_FILE} -exec /bin/rm '{}' \; for xRULE in ${GIT_EXCLUDE[@]}; do echo -en " '${TRG_PATH}/{${xRULE}}' files ... "; find ${TRG_PATH} -type f -name "${xRULE}" -exec /bin/rm -rf '{}' \; echo "done.'"; done; echo -e "done.\n" ## Purging SRC/TRG_PATHs variable(s): unset SRC_PATH; unset TRG_PATH; return 0; } function git-export () { TRG_DIR="${1}"; SRC_DIR="${2}"; if [ -z "${SRC_DIR}" ]; then SRC_DIR="${PWD}"; fi load_exclude "${SRC_DIR}"; ## Dynamically added '.empty' files to the Git-Structure: create_empty "${SRC_DIR}"; GIT_COMMIT="Including '${EMPTY_FILE}' files into Git-Index container."; #echo -e "\n${GIT_COMMIT}"; git add .; git commit --quiet --all --verbose --message "${GIT_COMMIT}"; if [ "${?}" -eq 0 ]; then echo " done."; fi /bin/rm -rf ${TRG_DIR} && mkdir -p "${TRG_DIR}"; echo -en "\nChecking-Out Index component(s): ... "; git checkout-index --prefix=${TRG_DIR}/ -q -f -a ## Reset: --mixed = reset HEAD and index: if [ "${?}" -eq 0 ]; then echo "done."; echo -en "Resetting HEAD and Index: ... "; git reset --soft HEAD^; if [ "${?}" -eq 0 ]; then echo "done."; ## Purging Git-specific components and '.empty' files from Target-Dir: purge_empty "${SRC_DIR}" "${TRG_DIR}" else echo "failed."; fi ## Archiving exported-content: echo -en "Archiving Checked-Out component(s): ... "; if [ -f "${TRG_DIR}.tgz" ]; then /bin/rm ${TRG_DIR}.tgz; fi cd ${TRG_DIR} && tar -czf ${TRG_DIR}.tgz ./; cd ${SRC_DIR} echo "done."; ## Listing *.tgz file attributes: ## Warning: Un-TAR this file to a specific directory: ls -al ${TRG_DIR}.tgz else echo "failed."; fi ## Purgin all references to Un-Staged File(s): git reset HEAD; ## Purging SRC/TRG_DIRs variable(s): unset SRC_DIR; unset TRG_DIR; echo ""; return 0; } 

आउटपुट:

$ git-export /tmp/rel-1.0.0

रिक्त फ़ोल्डर (रिकॉर्ड्स) में '.empty' फ़ाइलों को जोड़ना: … किया

चेकिंग आउट सूचकांक घटक (एस): … किया

हेड और इंडेक्स रीसेट करना: … किया

गिट-विशिष्ट घटकों को ख़त्म करना: …

'/tmp/rel-1.0.0/{.buildpath}' फ़ाइलें … पूर्ण हो गईं। '

'/tmp/rel-1.0.0/{.project}' फ़ाइलें … पूर्ण हो गईं। '

'/tmp/rel-1.0.0/{igitignore}' फ़ाइलें … पूर्ण हो गईं। '

'/tmp/rel-1.0.0/{.git}' फ़ाइलें … पूर्ण हो गईं। '

'/tmp/rel-1.0.0/{.gitattributes}' फ़ाइलें … पूर्ण हो गईं। '

'/tmp/rel-1.0.0/{*.mno}' फ़ाइलें … किया। '

'/tmp/rel-1.0.0/{*~}' फ़ाइलें … पूर्ण हो गईं। '

'/tmp/rel-1.0.0/{.*~}' फ़ाइलें … पूर्ण हो गईं। '

'/tmp/rel-1.0.0/{*.swp}' फ़ाइलें … पूर्ण हो गईं। '

'/tmp/rel-1.0.0/{*.swo}' फ़ाइलें … पूर्ण हो गईं। '

'/tmp/rel-1.0.0/{.DS_Store}' फ़ाइलें … पूर्ण हो गईं। '

'/tmp/rel-1.0.0/{.settings}' फ़ाइलें … पूर्ण हो गईं। '

'/tmp/rel-1.0.0/{.empty}' फ़ाइलें … पूर्ण हो गईं। '

किया हुआ।

संग्रहित आउट आउट घटक (एस): … किया

-आर-आर-आर-1-1 व्यवस्थापक व्हील 25445 901 3 नवम्बर 12:57 /tmp/rel-1.0.0.tgz

मैंने अब 'जीआईटी संग्रह' सुविधा को एकल प्रक्रिया में शामिल कर लिया है जो 'create_empty' फ़ंक्शन और अन्य विशेषताओं का उपयोग करता है।

 function git-archive () { PREFIX="${1}"; ## sudo mkdir -p ${PREFIX} REPO_PATH="`echo "${2}"|awk -F: '{print $1}'`"; RELEASE="`echo "${2}"|awk -F: '{print $2}'`"; USER_PATH="${PWD}"; echo "$PREFIX $REPO_PATH $RELEASE $USER_PATH"; ## Dynamically added '.empty' files to the Git-Structure: cd "${REPO_PATH}"; populate_empty .; echo -en "\n"; # git archive --prefix=git-1.4.0/ -o git-1.4.0.tar.gz v1.4.0 # eg: git-archive /var/www/htdocs /repos/domain.name/website:rel-1.0.0 --explode OUTPUT_FILE="${USER_PATH}/${RELEASE}.tar.gz"; git archive --verbose --prefix=${PREFIX}/ -o ${OUTPUT_FILE} ${RELEASE} cd "${USER_PATH}"; if [[ "${3}" =~ [--explode] ]]; then if [ -d "./${RELEASE}" ]; then /bin/rm -rf "./${RELEASE}"; fi mkdir -p ./${RELEASE}; tar -xzf "${OUTPUT_FILE}" -C ./${RELEASE} fi ## Purging SRC/TRG_DIRs variable(s): unset PREFIX REPO_PATH RELEASE USER_PATH OUTPUT_FILE; return 0; } 

यदि आप कुछ चाहते हैं जो submodules के साथ काम करता है तो यह एक जाने योग्य मूल्य हो सकता है

ध्यान दें:

  • MASTER_DIR = आपके सबडोम्यूल के साथ चेकआउट भी चेक आउट किया गया
  • DEST_DIR = जहां यह निर्यात समाप्त होगा
  • यदि आपके पास rsync है, तो मुझे लगता है कि आप भी कम बॉल दर्द के साथ ऐसा ही करने में सक्षम होंगे।

मान्यताओं:

  • आपको इसे MASTER_DIR की पैरेंट डायरेक्टरी से चलाने की आवश्यकता है (अर्थात MASTER_DIR सीडी .. से)
  • DEST_DIR बनाया गया है माना जाता है। यदि आप चाहें तो DEST_DIR के निर्माण में शामिल करने के लिए यह बहुत आसान है

सीडी MASTER_DIR और& tar-zcvf ../DEST_DIR/export.tar.gz –exclude = '। git *' && cd ../DEST_DIR/ && tar xvfz export.tar.gz && rm export.tar.gz

यह फ़ाइलों को सीमेंट की सीमाओं (सी टू जी) में एक टार फाइल में कॉपी करेगा नोट: यह केवल फाइल कमाने के लिए मिलेगी। संपूर्ण रिपॉजिटरी नहीं यहां से थोड़ा बदलाव किया गया

उदाहरण प्रतिबद्ध इतिहास

ए -> बी -> सी -> डी -> ई -> एफ -> जी -> एच -> आई

 git diff-tree -r --no-commit-id --name-only --diff-filter=ACMRT C~..G | xargs tar -rf myTarFile.tar 

git-diff-tree मैनुअल पृष्ठ

-आर -> उप-पेड़ों में अवशेष

–no-commit-id -> git diff-tree लागू होने पर प्रतिबद्ध आईडी के साथ एक पंक्ति का उत्पादन करता है। इस ध्वज ने प्रतिबद्ध आईडी आउटपुट को दबा दिया।

–name-only -> केवल परिवर्तित फाइलों के नाम दिखाएं।

–diff-filter = ACMRT -> केवल इन फ़ाइलों का चयन करें फाइलों की पूरी सूची के लिए यहां देखें

सी। जी -> कमेटी की इस श्रेणी में फ़ाइलें

सी ~ -> कमिट सी से फ़ाइलें शामिल करें। कमिट सी के बाद से सिर्फ फाइल नहीं।

| xargs tar -rf myTarFile -> टार के लिए आउटपुट

मेरी वरीयता वास्तव में आपके मेकफील (या अन्य बिल्ड सिस्टम) में एक जिला लक्ष्य होगा जो आपके कोड (.tar.bz2, .zip, .jar, या जो कुछ भी उपयुक्त है) के वितरित संग्रह को निर्यात करता है। यदि आप GNU autotools या पर्ल के MakeMaker सिस्टम का उपयोग करते हैं, तो मुझे लगता है कि यह आपके लिए स्वचालित रूप से मौजूद है यदि नहीं, तो मैं इसे जोड़ने की सिफारिश करता हूं

ईटीए (2012-09-06): वाह, कठोर डाउनवॉटें मैं अब भी विश्वास करता हूं कि अपने स्रोत कोड नियंत्रण उपकरण की बजाय आपके निर्माण उपकरण के साथ अपने वितरण का निर्माण करना बेहतर है। मैं निर्माण उपकरण के साथ कलाकृतियों का निर्माण करने में विश्वास करता हूं मेरी वर्तमान नौकरी में, हमारा मुख्य उत्पाद एक चींटी लक्ष्य के साथ बनाया गया है। हम स्रोत कोड नियंत्रण प्रणालियों को स्विच करने के बीच में हैं, और इस चींटी लक्ष्य की उपस्थिति से प्रवासन में एक कम परेशानी का मतलब है।

हां, यह संग्रह में कोई भी git शामिल किए बिना आपके कोड को संग्रहित करने के लिए एक स्वच्छ और सुव्यवस्थित कमांड है और किसी भी git कमिट इतिहास के बारे में चिंता किए बिना पारित करना अच्छा है।

 git archive --format zip --output /full/path/to/zipfile.zip master 

मुझे इस पर एक तैनाती स्क्रिप्ट के लिए आवश्यक था और मैं ऊपर दिए गए किसी भी दृष्टिकोण का उपयोग नहीं कर सका। इसके बजाय मैंने एक अलग समाधान का पता लगाया:

 #!/bin/sh [ $# -eq 2 ] || echo "USAGE $0 REPOSITORY DESTINATION" && exit 1 REPOSITORY=$1 DESTINATION=$2 TMPNAME="/tmp/$(basename $REPOSITORY).$$" git clone $REPOSITORY $TMPNAME rm -rf $TMPNAME/.git mkdir -p $DESTINATION cp -r $TMPNAME/* $DESTINATION rm -rf $TMPNAME 

इसे आसान तरीके से करना, यह .bash_profile के लिए एक फ़ंक्शन है, यह सीधे वर्तमान स्थान पर संग्रह को खोलता है, पहले अपने सामान्य [url: path] को कॉन्फ़िगर करें। नोट: इस फ़ंक्शन के साथ आप क्लोन ऑपरेशन से बचते हैं, यह दूरस्थ रीपो से सीधे हो जाता है

 gitss() { URL=[url:path] TMPFILE="`/bin/tempfile`" if [ "$1" = "" ]; then echo -e "Use: gitss repo [tree/commit]\n" return fi if [ "$2" = "" ]; then TREEISH="HEAD" else TREEISH="$2" fi echo "Getting $1/$TREEISH..." git archive --format=zip --remote=$URL/$1 $TREEISH > $TMPFILE && unzip $TMPFILE && echo -e "\nDone\n" rm $TMPFILE } 

.gitconfig के लिए उपनाम, वही कॉन्फ़िगरेशन की आवश्यकता है (गीले परियोजनाओं के अंदर कमांड निष्पादित करना), यह हमेशा बेस डियर पर कूदता है जैसा पहले कहा था , जब तक यह तय नहीं हो जाता है, मैं व्यक्तिगत रूप से फ़ंक्शन को पसंद करता हूं

 ss = !env GIT_TMPFILE="`/bin/tempfile`" sh -c 'git archive --format=zip --remote=[url:path]/$1 $2 \ > $GIT_TMPFILE && unzip $GIT_TMPFILE && rm $GIT_TMPFILE' - 

I think @Aredridel 's post was closest, but there's a bit more to that – so I will add this here; the thing is, in svn , if you're in a subfolder of a repo, and you do:

 /media/disk/repo_svn/subdir$ svn export . /media/disk2/repo_svn_B/subdir 

then svn will export all files that are under revision control (they could have also freshly Added; or Modified status) – and if you have other "junk" in that directory (and I'm not counting .svn subfolders here, but visible stuff like .o files), it will not be exported; only those files registered by the SVN repo will be exported. For me, one nice thing is that this export also includes files with local changes that have not been committed yet; and another nice thing is that the timestamps of the exported files are the same as the original ones. Or, as svn help export puts it:

  1. Exports a clean directory tree from the working copy specified by PATH1, at revision REV if it is given, otherwise at WORKING, into PATH2. … If REV is not specified, all local changes will be preserved. Files not under version control will not be copied.

To realize that git will not preserve the timestamps, compare the output of these commands (in a subfolder of a git repo of your choice):

 /media/disk/git_svn/subdir$ ls -la . 

… and:

 /media/disk/git_svn/subdir$ git archive --format=tar --prefix=junk/ HEAD | (tar -t -v --full-time -f -) 

… and I, in any case, notice that git archive causes all the timestamps of the archived file to be the same! git help archive says:

git archive behaves differently when given a tree ID versus when given a commit ID or tag ID. In the first case the current time is used as the modification time of each file in the archive. In the latter case the commit time as recorded in the referenced commit object is used instead.

… but apparently both cases set the "modification time of each file"; thereby not preserving the actual timestamps of those files!

So, in order to also preserve the timestamps, here is a bash script, which is actually a "one-liner", albeit somewhat complicated – so below it is posted in multiple lines:

 /media/disk/git_svn/subdir$ git archive --format=tar master | (tar tf -) | (\ DEST="/media/diskC/tmp/subdirB"; \ CWD="$PWD"; \ while read line; do \ DN=$(dirname "$line"); BN=$(basename "$line"); \ SRD="$CWD"; TGD="$DEST"; \ if [ "$DN" != "." ]; then \ SRD="$SRD/$DN" ; TGD="$TGD/$DN" ; \ if [ ! -d "$TGD" ] ; then \ CMD="mkdir \"$TGD\"; touch -r \"$SRD\" \"$TGD\""; \ echo "$CMD"; \ eval "$CMD"; \ fi; \ fi; \ CMD="cp -a \"$SRD/$BN\" \"$TGD/\""; \ echo "$CMD"; \ eval "$CMD"; \ done \ ) 

Note that it is assumed that you're exporting the contents in "current" directory (above, /media/disk/git_svn/subdir ) – and the destination you're exporting into is somewhat inconveniently placed, but it is in DEST environment variable. Note that with this script; you must create the DEST directory manually yourself, before running the above script.

After the script is ran, you should be able to compare:

 ls -la /media/disk/git_svn/subdir ls -la /media/diskC/tmp/subdirB # DEST 

… and hopefully see the same timestamps (for those files that were under version control).

Hope this helps someone,
चीयर्स!

By far the easiest way i've seen to do it (and works on windows as well) is git bundle :

git bundle create /some/bundle/path.bundle --all

See this answer for more details: How can I copy my git repository from my windows machine to a linux machine via usb drive?

If you need submodules as well, this should do the trick: https://github.com/meitar/git-archive-all.sh/wiki

i have the following utility function in my .bashrc file: it creates an archive of the current branch in a git repository.

 function garchive() { if [[ "x$1" == "xh" || "x$1" == "x" ]]; then cat <<EOF Usage: garchive <archive-name> create zip archive of the current branch into <archive-name> EOF else local oname=$1 set -x local bname=$(git branch | grep -F "*" | sed -e 's#^*##') git archive --format zip --output ${oname} ${bname} set +x fi } 

The option 1 sounds not too efficient. What if there is no space in the client to do a clone and then remove the .git folder?

Today I found myself trying to do this, where the client is a Raspberry Pi with almost no space left. Furthermore, I also want to exclude some heavy folder from the repository.

Option 2 and others answers here do not help in this scenario. Neither git archive (because require to commit a .gitattributes file, and I don't want to save this exclusion in the repository).

Here I share my solution, similar to option 3, but without the need of git clone :

 tmp=`mktemp` git ls-tree --name-only -r HEAD > $tmp rsync -avz --files-from=$tmp --exclude='fonts/*' . raspberry: 

Changing the rsync line for an equivalent line for compress will also work as a git archive but with a sort of exclusion option (as is asked here ).

This is my favorite solution:

 git diff <old-commit> <new-commit> --name-only | xargs tar -zcvf myTarFile.tar.gz 

This will compare two different commits and export changed files as a tar.gz file

चीयर्स!