Applescript: Get filenames in folder without extension

I can get the names of all files in a folder by doing this:

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

How can I change the strings in myFiles so that they do not include the file extension?

I could for example get {"foo.mov", "bar.mov"}, but would like to have {"foo", "bar"}.

Current solution

Based on the accepted answer I came up with the code below. Let me know if it can be made cleaner or more efficient somehow.

-- 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 o开发者_运维知识库f _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)

From 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

Single line way of doing it, no Finder, no System Events. So more efficient and faster. Side effect (could be good, or bad): a file name ending with "." will have this character stripped out. Using "reverse of every character" makes it works if the name as more than one period.

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

The solution as a handler to process a list of names:

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

Here's an applescriptish method to get Finder's idea of what the stripped filename is but please note it will only work if you have NOT enabled the option in Finder's preferences to "Show all filename extensions":

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

Here's a full script that does what you wanted. I was reluctant to post it originally because I figured there was some simple one-liner which someone would offer as a solution. Hopefully this solution is not a Rube Goldberg way of doing things.

The Finder dictionary does have a name extension property so you can do something like:

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

So the above will get you just the extension of the first file on the user's desktop. It seems like there would be a simple function for getting the (base name - extension) but I didn't find one.

Here's the script for getting just the filenames without extension for every file in an entire directory:

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

Though the above script does work if anyone knows a simpler way of doing what the OP wanted please post it cause I still get the sense that there should be a simpler way of doing it. Maybe there's a scripting addition which facilitates this as well. Anyone know?

Based on Lauri Ranta's nice solution, which works for extensions that Finder doesn't know about:

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

I don't know how to remove the extensions when you use the "every file" syntax but if you don't mind looping (loop not shown in example) through each file then this will work:

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

Within a tell "Finder" block this collects file names stripped of the extension in 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

For a single file I found the answer here, copied below.

set theFileName to "test.jpg"
set thePrefix to text 1 thru ((offset of "." in theFileName) - 1) of theFileName

This is a little more than you need, but it will handle more than one "." in a file name.

Assuming that a file alias is passed in to the method.

on Process(myFileAlias)

    set myFile to myFileAlias as string

    set AppleScript's text item delimiters to ":"
    set myItemCount to the number of text items in myFile
    set myFileName to the last text item of myFile
    set myFilePath to text items 1 through (myItemCount - 1) of myFile

    set AppleScript's text item delimiters to "."
    set myItemCount to the number of text items in myFileName
    set myExtension to the last text item of myFile

    // This line is the key.
    set myShortFilename to text items 1 through (myItemCount - 1) of myFileName as string

    log (myFileName)
    log (myShortFilename)
end