Como encontrar imagens não utilizadas em um projeto Xcode?

Alguém tem uma linha para localizar imagens não utilizadas em um projeto Xcode? (Supondo que todos os arquivos sejam referenciados por nome no código ou nos arquivos de projeto - nenhum nome de arquivo gerado por código.)

Esses arquivos tendem a se acumular ao longo da vida de um projeto e pode ser difícil dizer se é seguro excluir qualquer PNG.

Para arquivos que não estão incluídos no projeto, mas apenas perdidos na pasta, você pode pressionar

cmd ⌘+ alt ⌥+A

e eles não ficarão esmaecidos.

Para arquivos que não são referenciados nem no xib nem no código, algo assim pode funcionar:

#!/bin/sh
PROJ=`find . -name '*.xib' -o -name '*.[mh]'`

find . -iname '*.png' | while read png
do
    name=`basename $png`
    if ! grep -qhs "$name" "$PROJ"; then
        echo "$png is not referenced"
    fi
done

Esta é uma solução mais robusta - ela verifica qualquer referência ao nome de base em qualquer arquivo de texto. Observe as soluções acima que não incluem arquivos de storyboard (completamente compreensíveis, eles não existiam na época).

Ack torna isso muito rápido, mas há algumas otimizações óbvias a serem feitas se esse script for executado com frequência. Este código verifica cada nome de base duas vezes se você tiver ativos retina / não retina, por exemplo.

#!/bin/bash

for i in `find . -name "*.png" -o -name "*.jpg"`; do 
    file=`basename -s .jpg "$i" | xargs basename -s .png | xargs basename -s @2x`
    result=`ack -i "$file"`
    if [ -z "$result" ]; then
        echo "$i"
    fi
done

# Ex: to remove from git
# for i in `./script/unused_images.sh`; do git rm "$i"; done

Por favor, experimente LSUnusedResources .

É fortemente influenciado por jeffhodnett's Unused , mas honestamente Unused é muito lento e os resultados não são totalmente corretos. Então fiz algumas otimizações de desempenho, a velocidade de pesquisa é mais rápida do que não usada.

Tentei a solução de Roman e adicionei alguns ajustes para lidar com imagens de retina. Funciona bem, mas lembre-se de que os nomes das imagens podem ser gerados programaticamente no código, e esse script listaria incorretamente essas imagens como não referenciadas. Por exemplo, você pode ter

NSString *imageName = [NSString stringWithFormat:@"image_%d.png", 1];

Este script pensará incorretamente que image_1.pngnão é referenciado.

Aqui está o script modificado:

#!/bin/sh
PROJ=`find . -name '*.xib' -o -name '*.[mh]' -o -name '*.storyboard' -o -name '*.mm'`

for png in `find . -name '*.png'`
do
   name=`basename -s .png $png`
   name=`basename -s @2x $name`
   if ! grep -qhs "$name" "$PROJ"; then
        echo "$png"
   fi
done

Pode ser que você tente esbelto , faz um trabalho decente.

update: Com a ideia emcmanus, fui em frente e criei um pequeno utilitário sem ack apenas para evitar configuração adicional em uma máquina.

https://github.com/arun80/xcodeutils

Apenas este script está funcionando para mim, que está até mesmo controlando o espaço nos nomes dos arquivos:

Editar

Atualizado para suportar swiftarquivos e cocoapod. Por padrão, ele exclui o diretório de pods e verifica apenas os arquivos do projeto. Para executar a verificação da pasta Pods também, execute com o --podatributo:

/.finunusedimages.sh --pod

Aqui está o script real:

#!/bin/sh

#varables
baseCmd="find ." 
attrs="-name '*.xib' -o -name '*.[mh]' -o -name '*.storyboard' -o -name '*.mm' -o -name '*.swift'"
excudePodFiles="-not \( -path  */Pods/* -prune \)"
imgPathes="find . -iname '*.png' -print0"


#finalize commands
if [ "$1" != "--pod" ]; then
    echo "Pod files excluded"
    attrs="$excudePodFiles $attrs"
    imgPathes="find . $excudePodFiles -iname '*.png' -print0"
fi

#select project files to check
projFiles=`eval "$baseCmd $attrs"`
echo "Looking for in files: $projFiles"

#check images
eval "$imgPathes" | while read -d $'\0' png
do
   name=`basename -s .png "$png"`
   name=`basename -s @2x $name`
   name=`basename -s @3x $name`

   if grep -qhs "$name" $projFiles; then
        echo "(used - $png)"
   else
        echo "!!!UNUSED - $png"
   fi
done

Fiz uma pequena modificação na excelente resposta fornecida por @EdMcManus para lidar com projetos que utilizam catálogos de ativos.

#!/bin/bash

for i in `find . -name "*.imageset"`; do
    file=`basename -s .imageset "$i"`
    result=`ack -i "$file" --ignore-dir="*.xcassets"`
    if [ -z "$result" ]; then
        echo "$i"
    fi
done

Eu realmente não escrevo scripts bash, então se houver melhorias a serem feitas aqui (provavelmente), deixe-me saber nos comentários e eu irei atualizá-los.

Você pode fazer um script de shell que grepcontém o seu código-fonte e comparar as imagens encontradas com a pasta do seu projeto.

Aqui o (s) homem (s) para GREPeLS

Facilmente, você pode fazer um loop em todo o seu arquivo de origem, salvar imagens em array ou algo igual e usar

cat file.m | grep [-V] myImage.png

Com este truque, você pode pesquisar todas as imagens no código-fonte do seu projeto !!

espero que isto ajude!

Eu escrevi um roteiro lua, não tenho certeza se posso compartilhá-lo porque fiz isso no trabalho, mas funciona bem. Basicamente, ele faz isso:

Etapa um - referências de imagens estáticas (a parte fácil, coberta pelas outras respostas)

• olha recursivamente através de diretórios de imagens e extrai nomes de imagens
• remove os nomes de imagem de .png e @ 2x (não necessário / usado em imageNamed :)
• pesquisa textualmente por cada nome de imagem nos arquivos de origem (deve estar dentro de uma string literal)

Etapa dois - referências de imagens dinâmicas (a parte divertida)

• extrai uma lista de todos os literais de string na fonte contendo especificadores de formato (por exemplo,% @)
• substitui os especificadores de formato nestas strings por expressões regulares (por exemplo, "foo% dbar" torna-se "foo [0-9] * bar"
• pesquisa textualmente os nomes das imagens usando essas strings de regex

Em seguida, exclui tudo o que não encontrou em nenhuma das pesquisas.

O caso extremo é que os nomes das imagens que vêm de um servidor não são tratados. Para lidar com isso, incluímos o código do servidor nesta pesquisa.

Você pode experimentar o FauxPas App for Xcode . É muito bom descobrir as imagens que faltam e muitos outros problemas / violações relacionados ao projeto Xcode.

Usando as outras respostas, este é um bom exemplo de como ignorar imagens em dois diretórios e não pesquisar ocorrências das imagens nos arquivos pbxproj ou xcassets (cuidado com o ícone do aplicativo e as telas iniciais). Altere o * no --ignore-dir = *. Xcassets para corresponder ao seu diretório:

#!/bin/bash

for i in `find . -not \( -path ./Frameworks -prune \) -not \( -path ./Carthage -prune \) -not \( -path ./Pods -prune \) -name "*.png" -o -name "*.jpg"`; do 
    file=`basename -s .jpg "$i" | xargs basename -s .png | xargs basename -s @2x | xargs basename -s @3x`
    result=`ack -i --ignore-file=ext:pbxproj --ignore-dir=*.xcassets "$file"`
    if [ -z "$result" ]; then
        echo "$i"
    fi
done

Eu usei esta estrutura: -

http://jeffhodnett.github.io/Unused/

Funciona muito bem! Apenas 2 lugares onde vi problemas são quando os nomes das imagens são do servidor e quando o nome do recurso da imagem é diferente do nome da imagem dentro da pasta do recurso ...

Use http://jeffhodnett.github.io/Unused/ para encontrar as imagens não utilizadas.

Eu criei um script python para identificar as imagens não utilizadas: 'unused_assets.py' @ gist . Ele pode ser usado assim:

python3 unused_assets.py '/Users/DevK/MyProject' '/Users/DevK/MyProject/MyProject/Assets/Assets.xcassets'

Aqui estão algumas regras para usar o script:

• É importante passar o caminho da pasta do projeto como primeiro argumento, o caminho da pasta de ativos como segundo argumento
• Presume-se que todas as imagens são mantidas na pasta Assets.xcassets e são usadas em arquivos swift ou em storyboards

Limitações na primeira versão:

• Não funciona para arquivos c objetivos

Vou tentar melhorá-lo com o tempo, com base no feedback, mas a primeira versão deve ser boa para a maioria.

Encontre abaixo o código. O código deve ser autoexplicativo, pois adicionei comentários apropriados a cada etapa importante .

# Usage e.g.: python3 unused_assets.py '/Users/DevK/MyProject' '/Users/DevK/MyProject/MyProject/Assets/Assets.xcassets'
# It is important to pass project folder path as first argument, assets folder path as second argument
# It is assumed that all the images are maintained within Assets.xcassets folder and are used either within swift files or within storyboards

"""
@author = "Devarshi Kulshreshtha"
@copyright = "Copyright 2020, Devarshi Kulshreshtha"
@license = "GPL"
@version = "1.0.1"
@contact = "kulshreshtha.devarshi@gmail.com"
"""

import sys
import glob
from pathlib import Path
import mmap
import os
import time

# obtain start time
start = time.time()

arguments = sys.argv

# pass project folder path as argument 1
projectFolderPath = arguments[1].replace("\\", "") # replacing backslash with space
# pass assets folder path as argument 2
assetsPath = arguments[2].replace("\\", "") # replacing backslash with space

print(f"assetsPath: {assetsPath}")
print(f"projectFolderPath: {projectFolderPath}")

# obtain all assets / images 
# obtain paths for all assets

assetsSearchablePath = assetsPath + '/**/*.imageset'  #alternate way to append: fr"{assetsPath}/**/*.imageset"
print(f"assetsSearchablePath: {assetsSearchablePath}")

imagesNameCountDict = {} # empty dict to store image name as key and occurrence count
for imagesetPath in glob.glob(assetsSearchablePath, recursive=True):
    # storing the image name as encoded so that we save some time later during string search in file 
    encodedImageName = str.encode(Path(imagesetPath).stem)
    # initializing occurrence count as 0
    imagesNameCountDict[encodedImageName] = 0

print("Names of all assets obtained")

# search images in swift files
# obtain paths for all swift files

swiftFilesSearchablePath = projectFolderPath + '/**/*.swift' #alternate way to append: fr"{projectFolderPath}/**/*.swift"
print(f"swiftFilesSearchablePath: {swiftFilesSearchablePath}")

for swiftFilePath in glob.glob(swiftFilesSearchablePath, recursive=True):
    with open(swiftFilePath, 'rb', 0) as file, \
        mmap.mmap(file.fileno(), 0, access=mmap.ACCESS_READ) as s:
        # search all the assests within the swift file
        for encodedImageName in imagesNameCountDict:
            # file search
            if s.find(encodedImageName) != -1:
                # updating occurrence count, if found 
                imagesNameCountDict[encodedImageName] += 1

print("Images searched in all swift files!")

# search images in storyboards
# obtain path for all storyboards

storyboardsSearchablePath = projectFolderPath + '/**/*.storyboard' #alternate way to append: fr"{projectFolderPath}/**/*.storyboard"
print(f"storyboardsSearchablePath: {storyboardsSearchablePath}")
for storyboardPath in glob.glob(storyboardsSearchablePath, recursive=True):
    with open(storyboardPath, 'rb', 0) as file, \
        mmap.mmap(file.fileno(), 0, access=mmap.ACCESS_READ) as s:
        # search all the assests within the storyboard file
        for encodedImageName in imagesNameCountDict:
            # file search
            if s.find(encodedImageName) != -1:
                # updating occurrence count, if found
                imagesNameCountDict[encodedImageName] += 1

print("Images searched in all storyboard files!")
print("Here is the list of unused assets:")

# printing all image names, for which occurrence count is 0
print('\n'.join({encodedImageName.decode("utf-8", "strict") for encodedImageName, occurrenceCount in imagesNameCountDict.items() if occurrenceCount == 0}))

print(f"Done in {time.time() - start} seconds!")

Também recomendo experimentar o FengNiao .