Сделайте "экспорт git" (например, "экспорт svn")?

я узнал, что означает вариант 2. Из репозитория, вы можете сделать:

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

косая черта в конце пути важна, иначе это приведет к тому, что файлы будут в / destination с префиксом "path".

поскольку в нормальной ситуации индекс содержит содержимое репозитория, нет ничего особенного, чтобы "прочитать нужное дерево в индекс". Она уже там.

на -a флаг необходим, чтобы проверить все файлы в индекс (Я не уверен, что это означает, чтобы опустить этот флаг в этой ситуации, так как он не делает то, что я хочу). The -f флаг заставляет перезаписывать любые существующие файлы в выходных данных, что эта команда обычно не делает.

похоже, это своего рода "экспорт git", который я искал.

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.

насколько я знаю, Github не позволяет archive --remote. Хотя GitHub-это svn совместимость и у них есть все git repos svn доступно, поэтому вы можете просто использовать svn export как обычно, с несколькими настройками вашего url-адреса GitHub.

например, чтобы экспортировать весь репозиторий, обратите внимание, как trunk в URL заменяет master (или головная ветвь проекта установлена в):

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

и вы можете экспортировать в один файл или даже определенный путь или папку:

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

пример библиотека JavaScript 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:

использование git-checkout-index для "экспорта всего дерева"

способность префикса в основном делает тривиальным использование git-checkout-index в качестве функции "экспорт как дерево". Просто прочитайте нужное дерево в индексе и сделайте:

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

Я написал простую обертку вокруг git-checkout-index что вы можете использовать такой:

git export ~/the/destination/dir

если каталог назначения уже существует, вам необходимо добавить -f или --force.

установка проста; просто поместите скрипт где-нибудь в вашем PATH, и убедитесь, что это исполняемый файл.

репозиторий github для git-export

похоже, что это меньше Проблемы с Git, чем SVN. Git только ставит .папка git в корне репозитория, тогда как SVN помещает a .папка svn в каждом подкаталоге. Таким образом," SVN export " избегает рекурсивной магии командной строки, тогда как с Git рекурсия не нужна.

в эквиваленте

svn export . otherpath

внутри существующего РЕПО

git archive branchname | (cd otherpath; tar x)

в эквиваленте

svn export url otherpath

is

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

Я широко использую git-подмодули. Это работает для меня:

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

если вы не исключаете файлы с .gitattributes export-ignore попробуйте git checkout

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

- f
При проверке путей из индекса не допускайте сбоя при отключении записи; вместо этого не включенные записи игнорируются.

и

- q
Избегайте многословия

кроме того, вы можете получить любую ветку или тег или из определенной редакции фиксации, как в SVN, просто добавив SHA1 (SHA1 в Git эквивалентно номеру редакции в SVN)

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

на /path/to/checkout/ должен быть пустым, Git не будет удалять файлы, но перезапишет файлы с тем же именем без предупреждения

обновление: Чтобы избежать обезглавленной проблемы или оставить нетронутым рабочий репозиторий при использовании checkout for export с тегами, ветвями или SHA1, необходимо добавить -- ./ в конце

двойной тире -- говорит git, что все после тире являются путями или файлы, а также в этом случае рассказывает git checkout чтобы не менять HEAD

примеры:

эта команда получит только каталог libs, а также readme.txt файл из этого именно commit

git --git-dir=/path/to/repo/.git --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/.git --work-tree=/path/to/checkout/ checkout HEAD^2 -f -q -- ./my_file_2_behind_HEAD.txt

чтобы получить экспорт другой ветви

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

обратите внимание, что ./ относительно корня репозитория

Это скопирует все содержимое, за вычетом .Dot-файлов. Я использую это для экспорта git клонированных проектов в Git-РЕПО моего веб-приложения без .вещи ЖКТ.

cp-R ./path-to-git-repo/path/to/destination/

простой старый Баш работает просто отлично:)

Я часто попадал на эту страницу при поиске способа экспорта репозитория git. Мой ответ на этот вопрос рассматривает три свойства, которые SVN export имеет по дизайну по сравнению с git, поскольку svn следует централизованному подходу к репозиторию:

• он минимизирует трафик в удаленное хранилище, не экспортируя все версии
• он не включает метаинформацию в каталог экспорта

• экспорт определенной ветви с помощью svn выполняется путем указания соответствующего пути

  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. экспорт подпапки репозитория (именно так я использовал функцию экспорта SVN)
2. в порядке с копированием всего из этой папки в пункт назначения развертывания
3. и поскольку у вас уже есть копия всего репозитория на месте.

затем вы можете просто использовать cp foo [destination], вместо указанных git-archive master foo | -x -C [destination].

для пользователей GitHub,git archive --remote метод не будет работать напрямую, как URL экспорта эфемерен. Вы должны спросить GitHub для URL, а затем загрузить этот 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

редактировать
Если вы хотите, чтобы код был помещен в определенный,существующей каталог (а не случайный из github):

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

вы можете архивировать удаленное РЕПО при любой фиксации в виде zip-файла.

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

да этой - это чистая и аккуратная команда для архивирования кода без включения git в архив и хорошо передавать, не беспокоясь о какой-либо истории фиксации git.

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

Bash-реализация git-экспорта.

Я сегментирован .пустые процессы создания и удаления файлов по собственной функции с целью их повторного использования в реализации "git-archive" (будут опубликованы позже).

Я также добавил '.файл gitattributes к процессу для удаления нежелательных файлов из целевой папки экспорта. Включено многословие к процессу, делая функцию "git-export" более эффективный.

EMPTY_FILE=".пусто";

function create_empty () {
## Processing path (target-dir):
    TRG_PATH="";
## 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="";
    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="";
    TRG_PATH="";
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=""; SRC_DIR="";
    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

добавить '.пустые файлы в пустые папки: ... сделанный.

компонент (ы) индекса проверки:... сделанный.

сброс головки и индекса: ... сделанный.

продувать Git-специфические компонент (ы):...

'/tmp/rel-1.0.0 / {.файлы buildpath}'... сделанный.'

'/tmp/rel-1.0.0 / {.файл проекта. .. сделанный.'

'/tmp/rel-1.0.0 / {.файлы гитюдного}'... сделанный.'

'/tmp/rel-1.0.0 / {.git}' файлы ... сделанный.'

'/tmp/rel-1.0.0 / {.файлами gitattributes}'... сделанный.'

'/tmp/rel-1.0.0 / {*.мно}' файлы ... сделанный.'

'/tmp/ rel-1.0.0 / {*~} ' файлы ... сделанный.'

'/tmp/rel-1.0.0 / {.*~}' архив. .. сделанный.'

'/tmp/rel-1.0.0 / {*.ППВ}' файлы ... сделанный.'

'/tmp/rel-1.0.0 / {*.меча}' файлы ... сделанный.'

'/tmp/rel-1.0.0 / {.Файлы DS_Store}'... сделанный.'

'/tmp/rel-1.0.0 / {.файл настроек. .. сделанный.'

'/tmp/rel-1.0.0 / {.пустой файл. .. сделанный.'

сделано.

Архивация извлеченных компонентов:... сделанный.

- rw-r--r-- 1 колесо администратора 25445901 3 ноя 12:57 /tmp/rel-1.0.0.tgz

теперь я включил функциональность "git archive" в один процесс, который использует функцию "create_empty" и другие функции.

function git-archive () {
    PREFIX=""; ## sudo mkdir -p ${PREFIX}
    REPO_PATH="`echo ""|awk -F: '{print }'`";
    RELEASE="`echo ""|awk -F: '{print }'`";
    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
# e.g.: 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 [[ "" =~ [--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;
  }

Если вы хотите что-то, что работает с подмодулями, это может стоить того.

Примечание:

• MASTER_DIR = проверка с вашими подмодулями также проверена
• DEST_DIR = где этот экспорт закончится
• если у вас есть rsync, я думаю, вы сможете сделать то же самое с еще меньшей болью в шаре.

предположения:

• вам нужно запустить это из родительского каталога MASTER_DIR ( i.e от Компакт-диск MASTER_DIR .. )
• предполагается, что DEST_DIR был создан. Это довольно легко изменить, чтобы включить создание DEST_DIR, если вы хотите

cd MASTER_DIR & & tar-zcvf ../Печатает/экспорт.смола.gz --exclude='.мерзавец'* . && компакт. ./ Dest_dir / & & tar xvfz экспорт.смола.экспорт gz && rm.смола.gz

это скопирует файлы в диапазоне коммитов (C-G) в файл tar. Примечание: это будет только файлы совершено. Не все хранилище. Слегка изменено от здесь

Пример Фиксации Истории

A --> B -->C --> D --> E --> F --> G --> H --> I

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

страница руководства git-diff-tree

- r -- > рекурсия в под-деревья

--нет фиксации-идентификатор --> ГИТ дифф-дерево выдает строка с идентификатором фиксации, когда это применимо. Этот флаг подавил вывод идентификатора фиксации.

--name-only --> показывать только имена измененных файлов.

--diff-filter=ACMRT --> выберите только эти файлы. смотрите здесь полный список файлов

С..G --> файлы в этом диапазоне коммитов

C~ --> включить файлы из Commit C. Не только файлы, так как Commit C.

/ xargs tar-rf myTarFile -- > выходы в tar

мое предпочтение на самом деле было бы иметь р-н target в вашем Makefile (или другой системе сборки), которая экспортирует распространяемый архив вашего кода (.деготь.bz2,.промелькнуть. ,jar, или что-то подходящее). Если вы используете GNU autotools или системы MakeMaker Perl, я думаю, что это существует для вас автоматически. Если нет, я настоятельно рекомендую добавить его.

ETA (2012-09-06): Вау, суровые downvotes. Я по-прежнему считаю, что лучше строить свои дистрибутивы с помощью ваши инструменты сборки, а не инструмент управления исходным кодом. Я верю в создание артефактов с помощью инструментов сборки. В моей текущей работе наш основной продукт построен с целью муравья. Мы находимся в разгаре переключения систем управления исходным кодом, и наличие этой цели ant означает, что меньше хлопот в миграции.

мне это было нужно для сценария развертывания, и я не мог использовать ни один из вышеупомянутых подходов. Вместо этого я придумал другое решение:--2-->

#!/bin/sh
[ $# -eq 2 ] || echo "USAGE  REPOSITORY DESTINATION" && exit 1
REPOSITORY=
DESTINATION=
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 [ "" = "" ]; then
        echo -e "Use: gitss repo [tree/commit]\n"
        return
    fi
    if [ "" = "" ]; then
        TREEISH="HEAD"
    else
        TREEISH=""
    fi
    echo "Getting /$TREEISH..."
    git archive --format=zip --remote=$URL/ $TREEISH > $TMPFILE && unzip $TMPFILE && echo -e "\nDone\n"
    rm $TMPFILE
}

псевдоним .gitconfig, требуется та же конфигурация (позаботьтесь о выполнении команды внутри .git проекты, он всегда прыгает в базовый dir ранее как сказал Здесь, пока это не исправлено, я лично предпочитайте функцию

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

я думаю @Aredridelсообщение было ближе всего, но есть немного больше - поэтому я добавлю это здесь; дело в том, что в svn, если вы находитесь в подпапке РЕПО, и вы делаете:

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

затем svn будет экспортировать все файлы, которые находятся под контролем ревизии (они также могут быть недавно добавлены; или изменен статус) - и если у вас есть другой "мусор" в этом каталоге (и я не считаю .svn вложенные папки здесь, но видимые вещи, такие как .o файлы), it Уилл!--23-->не экспорт; будут экспортированы только те файлы, которые зарегистрированы в SVN РЕПО. Для меня хорошо, что этот экспорт также включает файлы с локальными изменениями, которые имеют не было зафиксировано; и еще одна хорошая вещь заключается в том, что временные метки экспортированных файлов такие же, как и оригинальные. Или, как svn help export пишет:

1. экспортирует чистое дерево каталогов из рабочей копии, указанной PATH1, при пересмотре REV, если в противном случае при работе она отдается ПУТЬ2. ... Если REV не указан, все локальные изменения будут сохранены. Файлы не под контролем версия не копировать.

чтобы понять, что git не будет сохранять временные метки, сравните выходные данные этих команд (в подпапке git репо по вашему выбору):

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

... и:

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

... и я, во всяком случае, замечаю, что git archive причины все метки времени архивированного файла должны быть одинаковыми! git help archive говорит:

архив git ведет себя по-разному, когда задан идентификатор дерева, а не когда задан идентификатор фиксации или идентификатор тега. В первом случае текущее время используется как время изменения каждого файла в архиве. В последнем случае фиксируется время совершения в ссылочном commit вместо этого используется объект.

... но, по-видимому, оба случая устанавливают " время модификации каждого файл"; тем самым не сохранение фактических временных меток этих файлов!

Итак, чтобы также сохранить временные метки, вот bash скрипт, который на самом деле является "однострочным", хотя и несколько сложным - поэтому ниже он размещен в нескольких строках:

/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 \
)

обратите внимание, что предполагается, что вы экспортируете содержимое в" текущий " каталог (выше,/media/disk/git_svn/subdir) - и пункт назначения, в который вы экспортируете, несколько неудобно расположен, но он в DEST переменные среды. Обратите внимание, что с помощью этого скрипта, вы должны создать вручную, перед запуском скрипта.

после запуска скрипта вы сможете сравнить:

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

... и, надеюсь, увидеть те же временные метки (для тех файлов, которые находились под контролем версий).

надеюсь, это кому-то поможет,
Ура!

На сегодняшний день самый простой способ я видел, чтобы сделать это (и работает на Windows, а) составляет git bundle:

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

см. этот ответ для получения более подробной информации:как я могу скопировать репозиторий git с моей машины windows на машину linux через usb-накопитель?

Если Вам также нужны подмодули, это должно сделать трюк:https://github.com/meitar/git-archive-all.sh/wiki

как я понимаю вопрос, это больше о загрузке только определенного состояния с сервера, без истории и без данных других ветвей, а не извлечении состояния из локального репозитория (как это делают многие anwsers здесь).

Это можно сделать так:

git clone -b someBranch --depth 1 --single-branch git://somewhere.com/repo.git \
&& rm -rf repo/.git/

• --single-branch доступен с Git 1.7.10 (апрель 2012).
• --depth есть (был?) неисправен, но в случае экспорта, упомянутое вопросы не должны иметь значения.

У меня есть следующая функция полезности в моем .файл bashrc: он создает архив текущей ветви в репозитории git.

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

Вариант 1 звучит не слишком эффективным. Что делать, если в клиенте нет места для клонирования и затем удалить .git папка?

сегодня я обнаружил, что пытаюсь сделать это, где клиент-Raspberry Pi почти без места. Кроме того, я также хочу исключить некоторую тяжелую папку из репозитория.

Вариант 2 и другие ответы здесь не помогают в этом сценарии. Ни git archive (потому что требуется совершить .gitattributes файл, и я не хотите сохранять это исключение в репозитории).

здесь я делюсь своим решением, похожий на Вариант 3, но без необходимости git clone:

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

изменение rsync строка для эквивалентной строки для сжатия также будет работать как git archive но с своего рода опцией исключения (как спрашивается здесь).

у меня есть другое решение, которое отлично работает, если у вас есть локальная копия репозитория на машине, где вы хотите создать экспорт. В этом случае перейдите в этот каталог репозитория и введите следующую команду:

GIT_WORK_TREE=outputdirectory git checkout -f

это особенно полезно, если вы управляете веб-сайтом с репозиторием git и хотите проверить чистую версию в /var/www/. В этом случае добавьте эту команду в .git/hooks/post-receive скрипт (hooks/post-receive на "голый" репозиторий, который больше подходит в этой ситуации)