Git ගබඩාවකට හිස් නාමාවලියක් එකතු කරන්නේ කෙසේද?

Git ගබඩාවකට හිස් නාමාවලියක් (ලිපිගොනු නොමැති) එකතු කරන්නේ කෙසේද?

ඩිරෙක්ටරියක් රැඳී සිටීමට තවත් ක්‍රමයක් (පාහේ) හිස් (නිධිය තුළ) .gitignoreමෙම පේළි හතර අඩංගු ගොනුවක් එම ඩිරෙක්ටරිය තුළ නිර්මාණය කිරීම :

# Ignore everything in this directory
*
# Except this file
!.gitignore

එවිට ඔබට m104 හි විසඳුමෙහි කළ යුතු ආකාරයට ඇණවුම ලබා ගත යුතු නොවේ .

ඔබ git තත්වයක් කරන විට එම නාමාවලියෙහි ඇති ගොනු "හඳුනා නොගත්" ලෙස නොපෙන්වන ප්‍රතිලාභයක්ද මෙය ලබා දෙයි.

කිරීම @GreenAsJade ගේ අදහස් දිගටම පවතින:

මෙම විසඳුම ප්‍රශ්නය ඇසූ දෙය හරියටම කරන බව සඳහන් කිරීම වටී යැයි මම සිතමි, නමුත් සමහර විට මෙම ප්‍රශ්නය දෙස බලන බොහෝ අය සොයන දේ නොවේ. මෙම විසඳුම ඩිරෙක්ටරිය හිස්ව පවතින බව සහතික කරයි. එහි සඳහන් වන්නේ “මට මෙහි කිසි විටෙකත් ලිපිගොනු පිරික්සීමට අවශ්‍ය නැත” යන්නයි. "මෙහි පිරික්සීමට මට කිසිදු ලිපිගොනු නොමැත, නමුත් මට මෙහි නාමාවලිය අවශ්‍යයි, ගොනු පසුව පැමිණෙනු ඇත".

ඔබට බැහැ. Git නිතර අසන පැන බලන්න .

වර්තමානයේ git දර්ශකයේ (වේදිකා ප්‍රදේශය) සැලසුම් කිරීම මඟින් ලිපිගොනු ලැයිස්තුගත කිරීමට පමණක් අවසර දී ඇති අතර හිස් නාමාවලි වලට ඉඩ දීම සඳහා වෙනසක් කිරීමට තරම් දක්ෂ කිසිවෙකු මෙම තත්වයට පිළියම් යෙදීමට ප්‍රමාණවත් සැලකිල්ලක් නොදක්වා ඇත.

නාමාවලි තුළ ගොනු එකතු කිරීමේදී ස්වයංක්‍රීයව එකතු වේ. එනම්, නාමාවලි කිසි විටෙකත් ගබඩාවට එක් කළ යුතු නැති අතර ඒවා තනිවම නිරීක්ෂණය නොකෙරේ.

ඔබට " git add <dir>" යැයි පැවසිය හැකි අතර එය එහි ගොනු එකතු කරනු ඇත.

පිටවීමේදී ඔබට සැබවින්ම නාමාවලියක් අවශ්‍ය නම් ඔබ එහි ගොනුවක් සෑදිය යුතුය. .ගිටිගෝර් මෙම කාර්යය සඳහා හොඳින් ක්‍රියා කරයි; ඔබට එය හිස්ව තැබිය හැකිය, නැතහොත් නාමාවලියෙහි පෙන්වීමට බලාපොරොත්තු වන ලිපිගොනු පුරවන්න.

.gitkeepනාමාවලියෙහි ඇති හිස් ගොනුවක් සාදන්න, එය එක් කරන්න.

ඔබට සෑම විටම README ගොනුවක් නාමාවලියෙහි තැබිය හැකිය, ඔබට මෙය අවශ්‍ය වන්නේ ඇයිද යන්න පැහැදිලි කිරීමක් සමඟ, නැතිනම් හිස්, නාමාවලිය ගබඩාවේ.

touch .keep

ලිනක්ස් හි මෙය හිස් ගොනුවක් නම් .keepකරයි. එය වටින දේ සඳහා, මෙම නම Git ට අ nost ෙයවාදියා වන අතර Git .gitkeepසඳහා විශේෂිත වේ. දෙවනුව, වෙනත් පරිශීලකයෙකු සඳහන් කළ පරිදි, .gitඋපසර්ගය සම්මුතිය Git විසින්ම භාවිතා කරන ලිපිගොනු සහ නාමාවලි සඳහා වෙන් කළ යුතුය.

විකල්පයක් ලෙස, වෙනත් පිළිතුරක සඳහන් කළ පරිදි , නාමාවලිය වෙනුවට විස්තරාත්මක READMEහෝ README.mdගොනුවක් අඩංගු විය හැකිය .

ඇත්ත වශයෙන්ම මේ සඳහා ගොනුව තිබීම ඔබගේ යෙදුම කැඩීමට හේතු නොවේ.

අපට හිස් අනුවාද ෆෝල්ඩර අවශ්‍ය වන්නේ ඇයි?

පළමු දේ පළමුව:

හිස් නාමාවලියක් Git අනුවාද ක්‍රමය යටතේ ගසක කොටසක් විය නොහැක .

එය හුදෙක් ලුහුබැඳ නොයනු ඇත. නමුත් හිස් නාමාවලි "අනුවාද කිරීම" අර්ථවත් විය හැකි අවස්ථා තිබේ, උදාහරණයක් ලෙස:

• පෙර සැකසූ ෆෝල්ඩර ව්‍යුහයක් පලංචියක් කිරීම , එය ගබඩාවේ සෑම පරිශීලකයෙකුටම / දායකයෙකුටම ලබා ගත හැකිය; හෝ, ඉහත විශේෂ specialized අවස්ථාවක් ලෙස , අපට ෆෝල්ඩරය සැපයීමට අවශ්‍ය නමුත් එහි අන්තර්ගතය වැනි තාවකාලික ලිපිගොනුcache/ හෝ logs/ඩිරෙක්ටරි වැනි ෆෝල්ඩරයක් නිර්මාණය කිරීම..gitignore
• ඉහත සඳහන් කරුණු වලට අදාළව, සමහර ව්‍යාපෘති සමහර ෆෝල්ඩර නොමැතිව ක්‍රියා නොකරනු ඇත (එය බොහෝ විට දුර්වල ලෙස සැලසුම් කරන ලද ව්‍යාපෘතියක ඉඟියක් වේ, නමුත් එය නිරන්තර තාත්වික ලෝක වාතාවරණයක් වන අතර සමහර විට ආමන්ත්‍රණය කිරීමට අවසර ගැටළු තිබිය හැකිය).

සමහරු යෝජනා කළ වැඩමුළු

බොහෝ පරිශීලකයින් යෝජනා කරන්නේ:

1. READMEනාමාවලිය හිස් නොවන බවට පත් කිරීම සඳහා කිසියම් අන්තර්ගතයක් සහිත ගොනුවක් හෝ වෙනත් ගොනුවක් තැබීම , හෝ
2. නිර්මානය .gitignore(සියලුම ගොනු අඩංගු කිරීමට එනම්) "ආපසු තර්ක" යම් වර්ගයක ගොනු වන, අවසානයේ දී, ප්රවේශය, # 1 එකම අරමුණ ද කටයුතු කරයි.

අතර විසඳුම් දෙකම නියත වශයෙන්ම වැඩ මම අනුවාද Git අර්ථවත් ප්රවේශය ඔවුන්ට නොගැලපෙන සොයා ගන්න.

• ඔබේ ව්‍යාපෘතියට ඔබට ඇත්තටම අවශ්‍ය නැති ව්‍යාජ ලිපිගොනු හෝ README දැමීමට ඔබ සිතන්නේ ඇයි?
• .gitignoreහැකි දෙයක් තිබුණත් ( ලිපිගොනු හැර ) එය කිරීමට අදහස් කරන දෙයට වඩා ප්‍රතිවිරුද්ධ දෙයක් ( ලිපිගොනු තබා ගැනීම ) භාවිතා කරන්නේ ඇයි ?

.ගිට්කිප් ප්‍රවේශය

අනුවාද පද්ධතියේ ෆෝල්ඩරය තිබීම බල කිරීම සඳහා කැඳවූ හිස් ගොනුවක් භාවිතා කරන්න .gitkeep.

එය එතරම් විශාල වෙනසක් නොවන බව පෙනෙන්නට තිබුණද:

• ෆෝල්ඩරය තබා ගැනීමේ එකම අරමුණ ඇති ගොනුවක් ඔබ භාවිතා කරයි . ඔබට තැබීමට අවශ්‍ය කිසිදු තොරතුරක් ඔබ එහි තබන්නේ නැත.

  උදාහරණයක් ලෙස, ඔබ ෆෝල්ඩරය තබා ගැනීමට නිදහසට කරුණක් ලෙස නොව ප්‍රයෝජනවත් තොරතුරු සහිත READMEs භාවිතා කළ යුතුය.

  උත්සුකයන් වෙන් කිරීම සැමවිටම හොඳ දෙයක් වන අතර .gitignoreඅනවශ්‍ය ලිපිගොනු නොසලකා හැරීමට ඔබට තවමත් එකතු කළ හැකිය .

• එය නම් කිරීම .gitkeepමඟින් මෙම ගොනුව ගොනුවේ නමෙන්ම (සහ අනෙකුත් සංවර්ධකයින්ට , හවුල් ව්‍යාපෘතියකට හොඳ සහ Git නිධියක මූලික අරමුණු වලින් එකක්) ඉතා පැහැදිලිව හා සරල කරයි.

  • කේතයට සම්බන්ධ නැති ගොනුවක් (ප්‍රමුඛ තිත සහ නම නිසා)
  • Git සමඟ පැහැදිලිවම සම්බන්ධ ගොනුවක්
  • එහි අරමුණ ( තබා ගැනීම ) පැහැදිලිව ප්‍රකාශ කර ඇති අතර නොසලකා හැරීමේ අර්ථයට අනුකූල වන අතර අර්ථාන්විතව විරුද්ධ වේ

දරුකමට හදා ගැනීම

Laravel , Angular-CLI.gitkeep වැනි ඉතා වැදගත් රාමු අනුගමනය කරන ප්‍රවේශය මම දැක ඇත්තෙමි .

වෙනත් පිළිතුරු වල විස්තර කර ඇති පරිදි, එහි වේදිකාවේ හිස් නාමාවලි නිරූපණය කිරීමට Git ට නොහැකි ය. ( Git FAQ බලන්න .) කෙසේ වෙතත්, ඔබේ අරමුණු සඳහා, නාමාවලියක් .gitignoreගොනුවක් පමණක් තිබේ නම් එය හිස් නම් , ඔබට .gitignoreහිස් ඩිරෙක්ටරිවල ගොනු සෑදිය හැක්කේ:

find . -type d -empty -exec touch {}/.gitignore \;

ඇන්ඩි ලෙස්ටර් හරි, නමුත් ඔබගේ බහලුම පමණක් හිස් විය යුතු අතර, නොඑසේ නම් හිස් හිස්, ඔබ හිස් කළ හැකි.gitignore වක් ලෙස එහි ගොනු.

අනෙක් අතට, මෙය ක්‍රියාත්මක කිරීමේ ගැටළුවක් මිස මූලික Git ගබඩා සැලසුම් ගැටළුවක් නොවේ. Git තැපැල් ලැයිස්තුවේ බොහෝ වාරයක් සඳහන් කර ඇති පරිදි, මෙය ක්‍රියාත්මක නොකිරීමට හේතුව, ඒ සඳහා පැච් එකක් ඉදිරිපත් කිරීමට තරම් කිසිවෙකු සැලකිලිමත් නොවීම මිස එය කළ නොහැකි හෝ නොකළ යුතු දේ නොවේ.

මෙම රේල් පීලි මත රූබි නිර්මාණය මාර්ගය ෆෝල්ඩරය ලොග්:

mkdir log && touch log/.gitkeep && git add log/.gitkeep

දැන් ලොග් නාමාවලිය ගසෙහි ඇතුළත් වේ. යෙදවීමේදී එය ඉතා ප්‍රයෝජනවත් වේ, එබැවින් ඔබට ලොග් නාමාවලි සෑදීම සඳහා පුරුද්දක් ලිවීමට අවශ්‍ය නොවේ.

නිකුත් කිරීමෙන් ලොග්ෆයිල් ඉවත් කළ හැකිය,

echo log/dev.log >> .gitignore

නමුත් ඔබ එය දැන සිටියා විය හැකිය.

Git හිස් නාමාවලි නිරීක්ෂණය නොකරයි. වැඩි විස්තර සඳහා Git FAQ බලන්න . යෝජිත කාර්යසාධනය වන්නේ .gitignoreගොනුවක් හිස් නාමාවලියෙහි තැබීමයි . මම ඒ විසඳුමට කැමති නැහැ.gitignore යුනික්ස් සම්මුතියෙන් "සැඟවී" ඇත. නාමාවලි හිස් වන්නේ ඇයිද යන්න පැහැදිලි කිරීමක් නොමැත.

නාමාවලිය හිස් වන්නේ ඇයි සහ එය Git හි ලුහුබැඳිය යුත්තේ ඇයිද යන්න පැහැදිලි කරමින් README ගොනුවක් හිස් ඩිරෙක්ටරියට දැමීමට මම යෝජනා කරමි. README ගොනුව ක්‍රියාත්මක වන විට, Git සම්බන්ධයෙන් ගත් කල, නාමාවලිය තවදුරටත් හිස් නොවේ.

ඇත්තම ප්‍රශ්නය නම් ඔබට හිස් නාමාවලිය git හි අවශ්‍ය වන්නේ ඇයි? සාමාන්‍යයෙන් ඔබ සතුව කිසියම් ආකාරයක බිල්ඩ් ස්ක්‍රිප්ට් එකක් ඇති අතර එය සම්පාදනය කිරීමට / ක්‍රියාත්මක කිරීමට පෙර හිස් නාමාවලිය නිර්මාණය කළ හැකිය. එසේ නොවේ නම් එකක් සාදන්න. හිස් නාමාවලි git තුළට දැමීමට වඩා එය වඩා හොඳ විසඳුමකි.

එබැවින් ඔබට git හි හිස් නාමාවලියක් අවශ්‍ය වීමට යම් හේතුවක් තිබේ. එම හේතුව README ගොනුවේ දමන්න. හිස් ඩිරෙක්ටරිය එහි තිබිය යුත්තේ මන්දැයි අනෙක් සංවර්ධකයින් (සහ අනාගතයේ ඔබ) දනී. හිස් නාමාවලිය අවශ්‍ය ගැටලුව විසඳූ විට ඔබට හිස් නාමාවලිය ඉවත් කළ හැකි බව ඔබ දැන ගනු ඇත.

සෑම හිස් නාමාවලියක්ම ලැයිස්තු ගත කිරීම සඳහා පහත විධානය භාවිතා කරන්න:

find -name .git -prune -o -type d -empty -print

සෑම හිස් නාමාවලියකම ස්ථානගත කිරීම් README නිර්මාණය කිරීම සඳහා:

find -name .git -prune -o -type d -empty -exec sh -c \
  "echo this directory needs to be empty because reasons > {}/README.emptydir" \;

README ගොනුව හැර ඩිරෙක්ටරියේ ඇති සියල්ල නොසලකා හැරීම සඳහා පහත දැක්වෙන පේළි ඔබේ .gitignore:

path/to/emptydir/*
!path/to/emptydir/README.emptydir
path/to/otheremptydir/*
!path/to/otheremptydir/README.emptydir

විකල්පයක් ලෙස, ඔබට සෑම README ගොනුවක්ම නොසලකා හැරිය හැක:

path/to/emptydir/*
path/to/otheremptydir/*
!README.emptydir

සෑම README එකක්ම දැනටමත් නිර්මාණය කිරීමෙන් පසුව ලැයිස්තුගත කිරීම සඳහා:

find -name README.emptydir

අවවාදයයි: මෙම වෙනස් කිරීම සැබවින්ම ක්‍රියාත්මක නොවේ. අපහසුතාවයට කනගාටුයි.

මුල් තනතුර පහතින්:

Git අභ්‍යන්තරයන් සමඟ සෙල්ලම් කරන අතරතුර මම විසඳුමක් සොයා ගත්තා!

1. ඔබ සිටින්නේ ඔබේ ගබඩාවේ යැයි සිතමු.

2. ඔබේ හිස් නාමාවලිය සාදන්න:

   $ mkdir path/to/empty-folder
   

3. ජලනල විධානයක් සහ හිස් ගසක් SHA-1 භාවිතයෙන් එය දර්ශකයට එක් කරන්න :

   $ git update-index --index-info
   040000 tree 4b825dc642cb6eb9a060e54bf8d69288fbee4904    path/to/empty-folder
   

   විධානය ටයිප් කර දෙවන පේළිය ඇතුළත් කරන්න. මාධ්ය Enterහා පසුව Ctrl+ Dඔබගේ ආදාන සේවයෙන් ඉවත් කිරීමට. සටහන: ආකෘතිය ප්‍රකාරය [SPACE] වර්ගය [SPACE] SHA-1hash [TAB] මාර්ගය (ටැබ් එක වැදගත්, පිළිතුරු හැඩතල ගැන්වීම එය ආරක්ෂා නොකරයි).

4. ඒක තමයි! ඔබගේ හිස් ෆෝල්ඩරය ඔබේ දර්ශකයේ ඇත. ඔබ කළ යුත්තේ කැපවීම පමණයි.

මෙම විසඳුම කෙටි වන අතර පෙනෙන ආකාරයට හොඳින් ක්‍රියාත්මක වේ ( සංස්කරණය බලන්න! ), නමුත් මතක තබා ගැනීම එතරම් පහසු නැත ...

හිස් ගස SHA-1 සොයාගත හැක්කේ හිස් හිස් ගස SHA-1 ප්‍රතිදානය කරන නව හිස් Git ගබඩාවක් cdතුළට සහ එය තුළට නිකුත් කිරීමෙනි git write-tree.

සංස්කරණය කරන්න:

මම මෙම විසඳුම සොයාගත් දා සිට භාවිතා කරමි. කිසිම තැනක මොඩියුලයක් නිර්වචනය කර ඇත්නම් හැර, එය උප මොඩියුලයක් නිර්මාණය කරන ආකාරයටම ක්‍රියා කරන බව පෙනේ. මෙය නිකුත් කිරීමේදී දෝෂ වලට තුඩු දෙයි git submodule init|update. ගැටළුව වන්නේ කොටස git update-indexනැවත ලිවීමයි040000 tree160000 commit .

එපමණක් නොව, එම මාර්ගය යටතේ තබා ඇති ඕනෑම ගොනුවක් Git විසින් කිසි විටෙකත් නොදකිනු ඇත, මන්ද ඒවා වෙනත් ගබඩාවකට අයත් යැයි සිතන බැවිනි. එය පහසුවෙන් නොසලකා හැරිය හැකි බැවින් මෙය නපුරු ය!

කෙසේ වෙතත්, ඔබ දැනටමත් ඔබේ ගබඩාවේ කිසිදු Git උප මොඩියුලයක් භාවිතා නොකරන්නේ නම් සහ "හිස්" ෆෝල්ඩරය හිස්ව පවතිනු ඇත හෝ Git එහි පැවැත්ම දැන ගැනීමට සහ එහි අන්තර්ගතය නොසලකා හැරීමට ඔබට අවශ්‍ය නම්, ඔබට යන්න පුළුවන් මෙම වෙනස් කිරීම. උප මොඩියුල සමඟ සුපුරුදු පරිදි ගමන් කිරීම මෙම වෙනස් කිරීම සඳහා තවත් පියවර ගනී.

ඔබට tmp නම් හිස් නාමාවලියක් අවශ්‍ය යැයි කියමු :

$ mkdir tmp
$ touch tmp/.gitignore
$ git add tmp
$ echo '*' > tmp/.gitignore
$ git commit -m 'Empty directory' tmp

වෙනත් වචන වලින් කිවහොත්, ඔබට එය නොසලකා හැරීමට Git ට පැවසීමට පෙර .gitignore ගොනුව දර්ශකයට එක් කළ යුතුය (සහ හිස් නාමාවලියෙහි ඇති සියල්ල).

සමහර විට හිස් ඩිරෙක්ටරියක් එක් කිරීම අවම වශයෙන් ප්‍රතිරෝධයේ මාවත වනු ඇති බව පෙනේ, මන්ද එම ඩිරෙක්ටරිය පවතිනු ඇතැයි අපේක්ෂා කරන ස්ක්‍රිප්ට් ඔබ සතුව ඇති හෙයිනි (සමහර විට එය ජනනය කරන ලද ද්විමය සඳහා ඉලක්කයක් විය හැකිය). තවත් ප්‍රවේශයක් වනුයේ අවශ්‍ය පරිදි නාමාවලිය නිර්මාණය කිරීම සඳහා ඔබේ ස්ක්‍රිප්ට් වෙනස් කිරීමයි .

mkdir --parents .generated/bin ## create a folder for storing generated binaries
mv myprogram1 myprogram2 .generated/bin ## populate the directory as needed

මෙම උදාහරණයේ දී, ඔබට ඩිරෙක්ටරියට (කැඩුණු) සංකේතාත්මක සබැඳියක් පරික්ෂා කළ හැකි අතර එවිට ඔබට ".ජෙනරේටඩ්" උපසර්ගය නොමැතිව ප්‍රවේශ විය හැකිය (නමුත් මෙය විකල්පයකි).

ln -sf .generated/bin bin
git add bin

ඔබේ ප්‍රභව ගස පිරිසිදු කිරීමට ඔබට අවශ්‍ය වූ විට ඔබට කළ හැක්කේ:

rm -rf .generated ## this should be in a "clean" script or in a makefile

හිස් හිස් ෆෝල්ඩරයක පරීක්ෂා කිරීම සඳහා ඔබ බොහෝ විට යෝජනා කළ ප්‍රවේශය නම්, ".gitignore" ගොනුව මකා නොදමමින් අන්තර්ගතය මකා දැමීමේ සුළු සංකීර්ණතාවයක් ඔබට ඇත.

ඔබගේ මූලයට පහත සඳහන් දෑ එකතු කිරීමෙන් ඔබට ජනනය කරන ලද සියලුම ගොනු නොසලකා හැරිය හැකිය .gitignore:

.generated

හිස් ඩිරෙක්ටරි සමඟද මම ගැටලුවට මුහුණ දී සිටිමි. ස්ථාන දරණ ලිපිගොනු භාවිතා කිරීමේ ගැටළුව නම්, ඒවා තවදුරටත් අවශ්‍ය නොවන්නේ නම් ඒවා නිර්මාණය කිරීම සහ මකා දැමීම අවශ්‍ය වේ (මන්දයත් පසුව උප ඩිරෙක්ටරි හෝ ලිපිගොනු එකතු කරන ලදි. විශාල මූලාශ්‍ර ගස් සමඟ මෙම ස්ථාන දරන්නාගේ ලිපිගොනු කළමනාකරණය කිරීම අවුල් සහගත විය හැකිය නැඹුරු.

එවැනි ස්ථානගත ලිපිගොනු ස්වයංක්‍රීයව නිර්මාණය කිරීම / මකා දැමීම කළමනාකරණය කළ හැකි විවෘත කේත මෙවලමක් ලිවීමට මා තීරණය කළේ මේ නිසා ය. එය .NET වේදිකාව සඳහා ලියා ඇති අතර එය මොනෝ (ලිනක්ස් සඳහා .NET) සහ වින්ඩෝස් යටතේ ක්‍රියාත්මක වේ.

බලන්න: http://code.google.com/p/markemptydirs

@ Artur79 සහ jmjs හි පිළිතුරු වලට මම කැමතියි, ඒ නිසා මම මේ දෙකේම එකතුවක් භාවිතා කර එය අපගේ ව්‍යාපෘති සඳහා ප්‍රමිතියක් බවට පත් කර ඇත්තෙමි.

find . -type d -empty -exec touch {}/.gitkeep \;

කෙසේ වෙතත්, අපගේ සංවර්ධකයින් අතළොස්සක් පමණක් මැක් හෝ ලිනක්ස් මත වැඩ කරයි. වින්ඩෝස් හි බොහෝ වැඩ සහ මට එය ඉටු කර ගැනීමට සමාන සරල ලයිනර් එකක් සොයා ගැනීමට නොහැකි විය. සමහරු සිග්වින් ලැබීමට තරම් වාසනාවන්ත වූහ වෙනත් හේතු නිසා ස්ථාපනය නමුත් සිග්වින්ට මේ සඳහා නියම .

වඩා හොඳ විසඳුමක් සඳහා සංස්කරණය කරන්න

එබැවින්, අපගේ බොහෝ සංවර්ධකයින් දැනටමත් කුහුඹුවන් ස්ථාපනය කර ඇති බැවින්, මම මුලින්ම සිතුවේ මෙය වේදිකාවෙන් ස්වාධීනව ඉටු කිරීම සඳහා කුහුඹුවන් තැනීමේ ගොනුවක් එක් කිරීමයි. මෙය තවමත් මෙහි සොයාගත හැකිය

කෙසේ වෙතත් , පසුව මෙය කුඩා උපයෝගිතා විධානයක් බවට පත් කිරීම වඩා හොඳ යැයි මම සිතුවෙමි, එබැවින් මම එය පයිතන් භාවිතයෙන් ප්‍රතිනිර්මාණය කර මෙහි PyPI වෙත ප්‍රකාශයට පත් කළෙමි . සරලව ධාවනය කිරීමෙන් ඔබට එය ස්ථාපනය කළ හැකිය:

pip3 install gitkeep2

එමඟින් ඔබට .gitkeepනැවත නැවත ලිපිගොනු නිර්මාණය කිරීමට සහ ඉවත් කිරීමට ඉඩ ලබා දෙන අතර, එම නාමාවලි වැදගත් වන්නේ ඇයිද යන්න ඔබේ සම වයසේ මිතුරන්ට අවබෝධ කර ගැනීම සඳහා ඒවාට පණිවිඩ එක් කිරීමටද එය ඉඩ දෙයි. මෙම අන්තිම බිට් ප්‍රසාද දීමනාවයි. .gitkeepලිපිගොනු ස්වයං ලේඛනගත කළ හැකි නම් හොඳයි කියා මම සිතුවෙමි .

$ gitkeep --help
Usage: gitkeep [OPTIONS] PATH

  Add a .gitkeep file to a directory in order to push them into a Git repo
  even if they're empty.

  Read more about why this is necessary at: https://git.wiki.kernel.org/inde
  x.php/Git_FAQ#Can_I_add_empty_directories.3F

Options:
  -r, --recursive     Add or remove the .gitkeep files recursively for all
                      sub-directories in the specified path.
  -l, --let-go        Remove the .gitkeep files from the specified path.
  -e, --empty         Create empty .gitkeep files. This will ignore any
                      message provided
  -m, --message TEXT  A message to be included in the .gitkeep file, ideally
                      used to explain why it's important to push the specified
                      directory to source control even if it's empty.
  -v, --verbose       Print out everything.
  --help              Show this message and exit.

මම හිතනවා ඔබට එය ප්‍රයෝජනවත් වේවි කියා.

ඔබට නොහැකි අතර අවාසනාවකට කිසි විටෙකත් එය කළ නොහැකි වනු ඇත. මෙය ලිනස් ටොවල්ඩ් විසින්ම ගත් තීරණයකි. ඔහු දන්නවා අපට හොඳ කුමක්ද කියා.

මම වරක් කියවූ කොහේ හරි තැනක කටහ is ක් තිබේ.

මට Re: හිස් නාමාවලි හමු විය .. , නමුත් සමහර විට තවත් එකක් තිබේ.

ඔබ වැඩ කළ යුතු දේ සමඟ ජීවත් විය යුතුයි ... අවාසනාවකට.

ඔබ .gitignoreගොනුවක් එකතු කරන විට, ඔබ එහි කිසියම් අන්තර්ගතයක් දැමීමට යන්නේ නම් (ඔබට Git නොසලකා හැරීමට අවශ්‍ය නම්) ඔබ *නොසලකා හරින ලද අන්තර්ගතය අහම්බෙන් එකතු නොකරන බවට වග බලා ගැනීම සඳහා ඔබට තරු ලකුණක් සමඟ තනි පේළියක් එක් කිරීමට අවශ්‍ය විය හැකිය. .

ඩිරෙක්ටරි ලුහුබැඳීමට Git ලබා ගැනීමට ක්‍රමයක් නොමැත, එබැවින් එකම විසඳුම වන්නේ ඔබට Git ලුහුබැඳීමට අවශ්‍ය නාමාවලිය තුළ ස්ථාන දරණ ගොනුවක් එක් කිරීමයි.

ගොනුව නම් කළ හැකි අතර ඔබට අවශ්‍ය ඕනෑම දෙයක් අඩංගු විය හැකිය, නමුත් බොහෝ අය නම් කරන ලද හිස් ගොනුවක් භාවිතා කරයි .gitkeep(සමහර අය VCS- අ nost ෙයවාදියාට කැමති වුවද.keep ).

උපසර්ගය .එය සැඟවුණු ගොනුවක් ලෙස සලකුණු කරයි.

තවත් අදහසක් වනුයේ READMEනාමාවලිය භාවිතා කරන්නේ කුමක් ද යන්න පැහැදිලි කරන ගොනුවක් එක් කිරීමයි .

සඳහන් කළ පරිදි හිස් ඩිරෙක්ටරි එකතු කළ නොහැක, නමුත් මෙහි එක් ඩයිනර් එකක් හිස් .gitignore ගොනු සියලුම ඩිරෙක්ටරි වලට එක් කරයි.

ruby -e 'require "fileutils" ; Dir.glob(["target_directory","target_directory/**"]).each { |f| FileUtils.touch(File.join(f, ".gitignore")) if File.directory?(f) }'

පහසු ප්‍රවේශයක් සඳහා මම මෙය රාක්ෆයිල් එකක සිර කර ඇත.

ජේමි ෆ්ලෝර්නෝයිගේ විසඳුම විශිෂ්ටයි. තබා ගැනීමට ටිකක් වැඩි දියුණු කළ අනුවාදයක් මෙන්න .htaccess:

# Ignore everything in this directory
*
# Except this file
!.gitignore
!.htaccess

මෙම විසඳුම සමඟ ඔබට හිස් ෆෝල්ඩරයක් කිරීමට හැකිය, උදාහරණයක් ලෙස /log, /tmpහෝ /cacheෆෝල්ඩරය හිස්ව පවතිනු ඇත.

මම සෑම විටම මගේ අපේක්ෂිත ෆෝල්ඩර ව්‍යුහය පරීක්ෂා කර එය ව්‍යාපෘතිය තුළ මා වෙනුවෙන් ගොඩනගා ගැනීමට ශ්‍රිතයක් ගොඩනඟමි. හිස් ෆෝල්ඩර ප්‍රොක්සි මගින් Git හි රඳවා ඇති බැවින් මෙය මෙම ගැටළුව මඟහරවා ගනී.

function check_page_custom_folder_structure () {
    if (!is_dir(TEMPLATEPATH."/page-customs"))
        mkdir(TEMPLATEPATH."/page-customs");    
    if (!is_dir(TEMPLATEPATH."/page-customs/css"))
        mkdir(TEMPLATEPATH."/page-customs/css");
    if (!is_dir(TEMPLATEPATH."/page-customs/js"))
        mkdir(TEMPLATEPATH."/page-customs/js");
}

මෙය PHP හි ඇත, නමුත් බොහෝ භාෂාවන් එකම ක්‍රියාකාරීත්වයට සහය දක්වන බව මට විශ්වාසයි. තවද, ෆෝල්ඩර සෑදීම යෙදුම විසින් බලා ගන්නා බැවින්, ෆෝල්ඩර සැමවිටම පවතී.

මෙන්න කඩුල්ලක්, නමුත් එය ක්‍රියාත්මක වීම විහිළුවක් (Git 2.2.1). E ටෙකා යෝජනා කළ දෙයට සමාන නමුත් මතක තබා ගැනීම පහසුය:

• ඕනෑම ගබඩාවකට උප මොඩියුලයක් එක් කරන්න ( git submodule add path_to_repo)
• මෙය ෆෝල්ඩරයක් සහ ගොනුවක් එක් කරනු ඇත .submodules. වෙනසක් කරන්න.
• .submodulesගොනුව මකා දමා වෙනස සිදු කරන්න.

දැන්, ඔබ සතුව ඩිරෙක්ටරියක් ඇති අතර එය කැපවීම පරීක්ෂා කළ විට නිර්මාණය වේ. සිත්ගන්නා කරුණක් නම්, මෙම ගොනුවේ ගස් වස්තුවේ අන්තර්ගතය දෙස බැලුවහොත් ඔබට ලැබෙනුයේ:

මාරාන්තික: වලංගු වස්තු නමක් නොවේ b64338b90b4209263b50244d18278c0999867193

Git හි අනාගත සංස්කරණ වල වැඩ කිරීම නවතා දැමිය හැකි බැවින් මම එය භාවිතා කිරීමට උනන්දු නොකරමි. එමඟින් ඔබේ ගබඩාව දූෂිත විය හැකිය.

බොහෝ දෙනෙක් දැනටමත් මෙම ප්රශ්නයට පිළිතුරු දී ඇත. පවර්ෂෙල් අනුවාදයක් මෙහි එක් කිරීම පමණි.

නාමාවලියෙහි ඇති සියලුම හිස් ෆෝල්ඩර සොයා ගන්න

හිස් .gitkeep ගොනුවක් එහි එක් කරන්න

Get-ChildItem 'Path to your Folder' -Recurse -Directory | Where-Object {[System.IO.Directory]::GetFileSystemEntries($_.FullName).Count -eq 0} | ForEach-Object { New-Item ($_.FullName + "\.gitkeep") -ItemType file}

බහුවිධ අර්ථකථන නාමාවලිවල අස්ථිර දත්ත විශාල ප්‍රමාණයක් අඩංගු ෆෝල්ඩරයක් එක් කිරීමට ඔබට අවශ්‍ය නම්, එක් ප්‍රවේශයක් නම් ඔබේ මූලයට මෙවැනි දෙයක් එකතු කිරීමයි .ගිටිග්නෝර් ...

/app/data/**/*.* !/app/data/**/*.md

එවිට ඔබට සෑම ඩිරෙක්ටරියක් තුළම විස්තරාත්මක README.md ගොනු (හෝ හිස් ලිපිගොනු, *.mdමෙම නඩුවේදී මෙන් අද්විතීය ලෙස ඉලක්ක කළ හැකි තාක් කල් ) වැදගත් වේ. ඩිරෙක්ටරි සියල්ලම repo හි කොටසක් ලෙස පවතින බව සහතික කිරීම සඳහා ගොනු (දිගු සමඟ) නොසලකා හරිනු ලැබේ. සීමාව: .නාමාවලි නාමවල ඉඩ නොදේ!

ඔබට මෙම ඩිරෙක්ටරි සියල්ලම xml / images ගොනු හෝ වෙනත් දේවලින් පුරවා ගත හැකි /app/data/අතර කාලයත් සමඟ තවත් ඩිරෙක්ටරි එකතු කළ හැකිය. හරියටම).

සෑම නව නාමාවලියකටම .gitignoreනව .gitignoreඑකක් නිර්මාණය කිරීමෙන් ඔබේ තවදුරටත් වෙනස් කිරීම හෝ විමධ්‍යගත කිරීම අවශ්‍ය නොවේ . බොහෝ විට බුද්ධිමත් විසඳුම නොව දැඩි ගිටිග්නෝර් නැණවත් වන අතර සෑම විටම මා වෙනුවෙන් ක්‍රියා කරයි. ලස්සන හා සරලයි! ;)

මෙය කිරීමට පහසු ක්‍රමයක් නම් .gitkeepඔබ (දැනට) හිස්ව තබා ගැනීමට කැමති නාමාවලියට ගොනුවක් එක් කිරීමයි .

වැඩිදුර තොරතුරු සඳහා මෙම SOF පිළිතුර බලන්න - සමහර අය .gitignore ගොනුවක් එක් කිරීමේ තරඟකාරී සම්මුතිය සොයා ගන්නේ මන්දැයි පැහැදිලි කරයි (මෙහි බොහෝ පිළිතුරු වල සඳහන් පරිදි) අවුල් සහගතය.

තවත් එක් විකල්පයක් සටනට එක් කිරීම.

ඒ සඳහා නාමාවලියක් එක් කිරීමට ඔබ කැමති යැයි උපකල්පනය gitකිරීම git, ඊට අදාළ සියලු අරමුණු සඳහා හිස්ව පැවතිය යුතු අතර එහි අන්තර්ගතය කිසි විටෙකත් සොයා නොගත යුතුය .gitignore.

සඳහන් කළ පරිදි ආකෘතිය:

*
!.gitignore

දැන්, විධාන රේඛාවේදී ඔබට මෙය කිරීමට ක්‍රමයක් අවශ්‍ය නම්, එකවරම වැටී ඇති අතර , ඔබට එකතු කිරීමට අවශ්‍ය නාමාවලිය තුළ , ඔබට ක්‍රියාත්මක කළ හැකිය:

$ echo "*" > .gitignore && echo '!.gitignore' >> .gitignore && git add .gitignore

මට මෙය කිරීමට ෂෙල් පිටපතක් තිබේ. ඔබ කැමති ඕනෑම දෙයක් ස්ක්‍රිප්ටයට නම් කරන්න, නැතහොත් එය ඔබගේ ඇතුළත් මාවතේ කොතැනක හෝ එක් කරන්න, නැතහොත් එය කෙලින්ම යොමු කරන්න:

#!/bin/bash

dir=''

if [ "$1" != "" ]; then
    dir="$1/"
fi

echo "*" > $dir.gitignore && \
echo '!.gitignore' >> $dir.gitignore && \
git add $dir.gitignore

මේ සමඟ, ඔබට එක් කිරීමට අවශ්‍ය නාමාවලිය තුළ සිට එය ක්‍රියාත්මක කළ හැකිය, නැතහොත් පළමු හා එකම පරාමිතිය ලෙස නාමාවලිය යොමු කරන්න:

$ ignore_dir ./some/directory

තවත් විකල්පයක් (@GreenAsJade විසින් අදහස් ප්රතිචාර), ඔබ හිස් ෆෝල්ඩරයකට නිරීක්ෂණය කිරීමට අවශ්ය නම්, මැයි අනාගතයේ දී දම්වැල් මත ධාවනය වන ගොනු අඩංගු වේ, නමුත් දැනට හිස් කරනු ඇත, ඔබ ommit හැකි *සිට .gitignoreගොනු, සහ පරීක්ෂා බව ය. මූලික වශයෙන්, සියලුම ගොනුව පවසන්නේ " මාව නොසලකා හරින්න එපා ", නමුත් එසේ නොමැති නම්, නාමාවලිය හිස් හා ලුහුබැඳ ඇත.

ඔබගේ .gitignoreගොනුව මෙසේ පෙනේ:

!.gitignore

එය එයයි, එය පරීක්ෂා කර බලන්න, ඔබට හිස්, නමුත් ලුහුබැඳ ඇති නාමාවලියක් ඇත, ඔබට පසුකාලීනව ලිපිගොනු නිරීක්ෂණය කළ හැකිය.

ගොනුවේ එක් පේළියක් තබා ගැනීමට මා යෝජනා කිරීමට හේතුව එය .gitignoreඅරමුණ ලබා දීමයි. එසේ නොමැතිනම්, එය ඉවත් කිරීමට සමහරු සිතිය හැකිය. ඔබ රේඛාවට ඉහළින් අදහස් දැක්වීමක් කළහොත් එය උදව් විය හැකිය.

සමහර විට ඔබට "සැබෑ" හිස් හා පවතින නාමාවලියක් අවශ්‍ය වන නරක ලිඛිත පුස්තකාල හෝ මෘදුකාංග සමඟ කටයුතු කිරීමට සිදුවේ. සරළව තැබීම .gitignoreහෝ .keepඒවා බිඳ දමා දෝෂයක් ඇතිවිය හැකිය. පහත දැක්වෙන කරුණු මෙම අවස්ථා වලදී උදව් විය හැකි නමුත් සහතිකයක් නොමැත ...

පළමුව අවශ්‍ය නාමාවලිය සාදන්න:

mkdir empty

ඉන්පසු ඔබ මෙම නාමාවලියට බිඳුණු සංකේතාත්මක සබැඳියක් එක් කරයි (නමුත් ඉහත විස්තර කර ඇති භාවිත නඩුව හැර වෙනත් ඕනෑම අවස්ථාවක කරුණාකර READMEපැහැදිලි කිරීමක් සහිතව භාවිතා කරන්න ):

ln -s .this.directory empty/.keep

මෙම නාමාවලියෙහි ඇති ගොනු නොසලකා හැරීමට, ඔබට එය ඔබේ මූලයට එක් කළ හැකිය .gitignore:

echo "/empty" >> .gitignore

නොසලකා හරින ලද ගොනුව එක් කිරීමට, එය බල කිරීම සඳහා පරාමිතියක් භාවිතා කරන්න:

git add -f empty/.keep

කැපවීමෙන් පසු ඔබේ දර්ශකයේ බිඳුණු සංකේතාත්මක සම්බන්ධතාවයක් ඇති අතර git නාමාවලිය නිර්මාණය කරයි. බිඳුණු සබැඳියට යම් වාසි ඇත, මන්ද එය සාමාන්‍ය ගොනුවක් නොවන අතර සාමාන්‍ය ගොනුවකට යොමු නොවේ. එබැවින් එය "(ලිපිගොනු කිසිවක් අඩංගු නොවේ)" යන ප්‍රශ්නයට පවා ගැලපේ, එය චේතනාවෙන් නොව අර්ථයෙන්, මම අනුමාන කරමි:

find empty -type f

මෙම නාමාවලියෙහි කිසිදු ලිපිගොනු නොමැති බැවින් මෙම විධානයන් හිස් ප්‍රති result ලයක් පෙන්වයි. එබැවින් ඩිරෙක්ටරියක් තුළ ඇති සියලුම ලිපිගොනු ලබා ගන්නා බොහෝ යෙදුම් සාමාන්‍යයෙන් මෙම සබැඳිය නොපෙනේ, අවම වශයෙන් ඒවා "ගොනුවක් තිබේ" හෝ "කියවිය හැකි" නම්. සමහර ස්ක්‍රිප්ට් වල පවා කිසිදු ලිපිගොනු සොයාගත නොහැක:

$ php -r "var_export(glob('empty/.*'));"
array (
  0 => 'empty/.',
  1 => 'empty/..',
)

නමුත් මෙම විසඳුම විශේෂ අවස්ථා වලදී පමණක් භාවිතා කිරීමට මම තරයේ නිර්දේශ කරමි, READMEහිස් නාමාවලියක ලියා ඇති හොඳ දේ සාමාන්‍යයෙන් වඩා හොඳ විසඳුමකි. (මෙය වින්ඩෝස් ගොනු පද්ධතියක් සමඟ ක්‍රියා කරන්නේ දැයි මම නොදනිමි ...)

කියවීම @ofavre ගේ හා @ stanislav-bashkyrtsev 'මෙම තාක්ෂණය නාමාවලි නිර්මාණය කිරීමට බිඳ GIT submodule යොමු භාවිතා විසඳුම්, මම කාටවත් මුළු දෙයක් සිහිකල්පනාව හා ආරක්ෂිත කිරීමට යෝජනා කර තිබේ තවමත් අදහසක් මෙම සරල සංශෝධනය පුදුමයට පත් කරනවා:

ඒ වෙනුවට වඩා GIT බවට ව්යාජ submodule අනවසරයෙන් ඇතුළුවී , හුදෙක් හිස් සැබෑ එකක් එකතු .

ඇතුලත් කරන්න: https://gitlab.com/empty-repo/empty.git

හරියටම එක් කැපවීමක් සහිත GIT ගබඩාවක්:

commit e84d7b81f0033399e325b8037ed2b801a5c994e0
Author: Nobody <none>
Date: Thu Jan 1 00:00:00 1970 +0000

පණිවිඩයක් නැත, කැපවූ ලිපිගොනු නොමැත.

භාවිතය

ඔබට හිස් ඩිරෙක්ටරියක් එක් කිරීමට GIT repo:

git submodule add https://gitlab.com/empty-repo/empty.git path/to/dir

පවතින සියලුම හිස් නාමාවලි උප මොඩියුල බවට පරිවර්තනය කිරීම සඳහා:

find . -type d -empty -delete -exec git submodule add -f https://gitlab.com/empty-repo/empty.git \{\} \;

උප මොඩියුලය යොමු කිරීමේදී Git නවතම කැපවීමේ හැෂ් ගබඩා කරයි, එබැවින් අනිෂ්ට ලිපිගොනු එන්නත් කිරීම සඳහා මෙය භාවිතා කිරීම ගැන මා (හෝ GitLab) ගැන කරදර විය යුතු නැත. අවාසනාවකට, පිටවීමේදී කුමන බැඳීම් හැඳුනුම්පතක් භාවිතා කිරීමට බල කිරීමට මට ක්‍රමයක් හමු වී නැත, එබැවින් යොමු යොමු හැඳුනුම්පත e84d7b81f0033399e325b8037ed2b801a5c994e0භාවිතා කරන්නේ දැයි ඔබ අතින් පරීක්ෂා කළ යුතුය.git submodule status repo එකතු කිරීමෙන් පසු .

නමුත් තවමත් ඒ දේශීය විසඳුමක්, නමුත් කවුරුහරි තමන්ගේ අත් ලබා ගැනීමෙන් තොරව අපි බොහෝ විට ඇති කරගත හැකි හොඳම ඇත්තටම , ඇත්තටම මේ තාක්ෂණය codebase දී අපිරිසිදු.

උපග්‍රන්ථය: මෙම කැපවීම නැවත ප්‍රතිනිර්මාණය කිරීම

(හිස් නාමාවලියක) භාවිතා කරමින් මෙම නිශ්චිත කැපවීම ප්‍රතිනිර්මාණය කිරීමට ඔබට හැකි විය යුතුය:

# Initialize new GIT repository
git init

# Set author data (don't set it as part of the `git commit` command or your default data will be stored as “commit author”)
git config --local user.name "Nobody"
git config --local user.email "none"

# Set both the commit and the author date to the start of the Unix epoch (this cannot be done using `git commit` directly)
export GIT_AUTHOR_DATE="Thu Jan 1 00:00:00 1970 +0000"
export GIT_COMMITTER_DATE="Thu Jan 1 00:00:00 1970 +0000"

# Add root commit
git commit --allow-empty --allow-empty-message --no-edit

ප්‍රජනනය කළ හැකි GIT කොමිෂන් නිර්මාණය කිරීම පුදුම සහගතය…

ඔබට බැහැ. මෙය Git නඩත්තුකරුවන්ගේ හිතාමතා සැලසුම් තීරණයක්. මූලික වශයෙන්, Git වැනි ප්‍රභව කේත කළමනාකරණ පද්ධතියක අරමුණ ප්‍රභව කේත කළමනාකරණය වන අතර හිස් නාමාවලි ප්‍රභව කේත නොවේ. Git බොහෝ විට අන්තර්ගත ලුහුබැඳීමක් ලෙස විස්තර කර ඇති අතර නැවතත් හිස් නාමාවලි අන්තර්ගත නොවේ (තරමක් ප්‍රතිවිරුද්ධ, ඇත්ත වශයෙන්ම), එබැවින් ඒවා නිරීක්ෂණය නොකෙරේ.

ඔබට මෙම කේතය create_readme.php ලෙස සුරැකිය හැකි අතර ඔබේ Git ව්‍යාපෘතියේ මූල නාමාවලියෙන් PHP කේතය ධාවනය කරන්න.

> php create_readme.php

එය හිස්ව ඇති සියලුම නාමාවලි වලට README ගොනු එකතු කරනු ඇති අතර එමඟින් එම නාමාවලි දර්ශකයට එකතු වේ.

<?php
    $path = realpath('.');
    $objects = new RecursiveIteratorIterator(new RecursiveDirectoryIterator($path),       RecursiveIteratorIterator::SELF_FIRST);
    foreach($objects as $name => $object){
        if ( is_dir($name) && ! is_empty_folder($name) ){
            echo "$name\n" ;
            exec("touch ".$name."/"."README");
        }
    }

    function is_empty_folder($folder) {
        $files = opendir($folder);
        while ($file = readdir($files)) {
            if ($file != '.' && $file != '..')
                return true; // Not empty
            }
        }
?>

එහෙනම් කරන්න

git commit -m "message"
git push