AppleScript: Get dans le dossier des noms de fichiers sans extension

Question

Je peux obtenir les noms de tous les fichiers dans un dossier en faisant ceci:

tell application "Finder"
    set myFiles to name of every file of somePath
end tell

Comment puis-je changer les cordes en myFiles de sorte qu'ils ne comprennent pas l'extension de fichier?

Je pourrais par exemple get {"foo.mov", "bar.mov"}, mais je voudrais avoir {"foo", "bar"}.

---

Solution actuelle

Selon la réponse acceptée je suis venu avec le code ci-dessous. Faites-moi savoir si elle peut être en quelque sorte plus propre ou plus efficace.

-- Gets a list of filenames from the
on filenames from _folder

    -- Get filenames and extensions
    tell application "Finder"
        set _filenames to name of every file of _folder
        set _extensions to name extension of every file of _folder
    end tell

    -- Collect names (filename - dot and extension)
    set _names to {}
    repeat with n from 1 to count of _filenames

        set _filename to item n of _filenames
        set _extension to item n of _extensions

        if _extension is not "" then
            set _length to (count of _filename) - (count of _extension) - 1
            set end of _names to text 1 thru _length of _filename
        else
            set end of _names to _filename
        end if

    end repeat

    -- Done
    return _names
end filenames

-- Example usage
return filenames from (path to desktop)

Answer 1

Voici un script complet qui fait ce que vous vouliez. J'étais réticent à afficher à l'origine parce que je pensais qu'il y avait une simple-liner qui quelqu'un offrirait une solution. Espérons que cette solution n'est pas la façon Goldberg Rube de faire les choses.

Le dictionnaire Finder a une extension de nom propriété de sorte que vous pouvez faire quelque chose comme:

tell application "Finder"
   set myFiles to name extension of file 1 of (path to desktop)
end tell

Alors ce qui précède vous obtiendrez seulement l'extension du premier fichier sur le bureau de l'utilisateur. Il semble qu'il y aurait une fonction simple pour obtenir le (nom de base - extension). Mais je ne trouve pas un

Voici le script pour obtenir seulement les noms de fichiers sans extension pour chaque fichier dans un répertoire entier:

set filesFound to {}
set filesFound2 to {}
set nextItem to 1

tell application "Finder"
  set myFiles to name of every file of (path to desktop) --change path to whatever path you want   
end tell

--loop used for populating list filesFound with all filenames found (name + extension)
repeat with i in myFiles
  set end of filesFound to (item nextItem of myFiles)
  set nextItem to (nextItem + 1)
end repeat

set nextItem to 1 --reset counter to 1

--loop used for pulling each filename from list filesFound and then strip the extension   
--from filename and populate a new list called filesFound2
repeat with i in filesFound
  set myFile2 to item nextItem of filesFound
  set myFile3 to text 1 thru ((offset of "." in myFile2) - 1) of myFile2
  set end of filesFound2 to myFile3
  set nextItem to (nextItem + 1)
end repeat

return filesFound2

Bien que le script ci-dessus fonctionne si quelqu'un connaît un moyen plus simple de faire ce que l'OP voulait s'il vous plaît poster parce que je reçois toujours le sens qu'il devrait y avoir un moyen plus simple de le faire. Peut-être il y a un ajout de script qui facilite aussi. savoir Anyone?

Answer 2

De http://www.macosxautomation.com/applescript/sbrt/index.html :

on remove_extension(this_name)
  if this_name contains "." then
    set this_name to ¬
    (the reverse of every character of this_name) as string
    set x to the offset of "." in this_name
    set this_name to (text (x + 1) thru -1 of this_name)
    set this_name to (the reverse of every character of this_name) as string
  end if
  return this_name
end remove_extension

Answer 3

Voici une méthode applescriptish pour obtenir l'idée du Finder de ce que le nom de fichier est dépouillé:

set extension hidden of thisFile to true
set thisName to displayed name of thisFile
-- display dialog "hey"
set extension hidden of thisFile to false

Answer 4

chemin unifilaire de le faire, pas Finder, aucun événement système. Donc, plus efficace et plus rapide. Effet secondaire (pourrait être bon ou mauvais): un nom de fichier se terminant par « » aura ce caractère dépouillé. L'utilisation de « revers de chaque caractère » fait cela fonctionne si le nom plus d'une période.

set aName to text 1 thru ((aName's length) - (offset of "." in ¬
    (the reverse of every character of aName) as text)) of aName

La solution comme un gestionnaire pour traiter une liste de noms:

on RemoveNameExt(aList)
    set CleanedList to {}
    repeat with aName in aList
        set the end of CleanedList to text 1 thru ((aName's length) - (offset of ¬
            "." in (the reverse of every character of aName) as text)) of aName
    end repeat
    return CleanedList
end RemoveNameExt

Answer 5

Je ne sais pas comment supprimer les extensions lorsque vous utilisez le « tous les fichiers » syntaxe mais si cela ne vous dérange pas en boucle (boucle non représentée dans l'exemple) à travers chaque fichier, cela fonctionnera:

tell application "Finder"
  set myFile to name of file 1 of somePath
  set myFile2 to text 1 thru ((offset of "." in myFile) - 1) of myFile
end tell

Answer 6

Basé sur belle solution de Lauri Ranta, qui fonctionne pour les extensions que Finder ne connaît pas:

set delims to AppleScript's text item delimiters
set AppleScript's text item delimiters to "."
set myNames to {}
tell application "Finder"
    set myFiles to name of every file of (path to Desktop)
    repeat with myfile in myFiles
        set myname to name of file myfile
        if myname contains "." then set myname to (text items 1 thru -2 of myname) as text
        set end of myNames to myname
    end repeat
end tell
set AppleScript's text item delimiters to delims
return myNames

Answer 7

Dans un tell "Finder" bloquer ce nom de fichier recueille dépouillées de l'extension dans myNames:

repeat with f in myFiles
    set myNames's end to ¬
        (f's name as text)'s text 1 thru -(((f's name extension as text)'s length) + 2)
end repeat