如何从 otf 或 ttf 文件获取字体名称？

小开

最佳答案

Right click on the TTF -> Get Info

"Full Name" is what you're looking for.

That's what worked for me with TTFs.

Edit:

I just used a font that had a different name from the "Full Name" in Get Info.

For the compilation of this answer, If the quick check above doesn't work, run this code in your project:

for (NSString *fontFamilyName in [UIFont familyNames]) {
for (NSString *fontName in [UIFont fontNamesForFamilyName:fontFamilyName]) {
NSLog(@"Family: %@    Font: %@", fontFamilyName, fontName);
}
}

And search for the correct name of the font you want to use.

Swift 3.0 code:

for fontFamilyName in UIFont.familyNames{
for fontName in UIFont.fontNames(forFamilyName: fontFamilyName){
print("Family: \(fontFamilyName)     Font: \(fontName)")
}
}

小开

You want to know how to get name go for this :-

  NSArray *familyNames = [[NSArray alloc] initWithArray:[UIFont familyNames]];


for (NSInteger indFamily=0; indFamily<[familyNames count]; ++indFamily)
{
NSLog(@"Family name: %@", [familyNames objectAtIndex:indFamily]);


NSArray *fontNames = [[NSArray alloc] initWithArray:
[UIFont fontNamesForFamilyName:[familyNames objectAtIndex:indFamily]]];


for (NSInteger indFont=0; indFont<[fontNames count]; ++indFont)
{
NSLog(@"    Font name: %@", [fontNames objectAtIndex:indFont]);
}
}

hope it helps you...

小开

Log familyNames of font file and then access the fonts:

// You can log all font family names suing **fontNamesForFamilyName**


NSLog(@" font name %@", [UIFont fontNamesForFamilyName:@"the file name"]);

Hope it helps you.

小开

Follow these four easy steps to add and use a new font in your iOS app:

Add your_new_font.ttf or your_new_font.otf to your Xcode project
In your project's info.plist, add a new entry for your_new_font.ttf or your_new_font.otf to the UIAppFonts array (plain text for this one is 'Fonts provided by application')
At this point, I recommend adding this temporary chunk of debug code to dump all fonts that are accessible by your app, including your newly added your_new_font:

//Swift

    for family: String in UIFont.familyNames {
print("\(family)")
for names: String in UIFont.fontNames(forFamilyName: family) {
print("== \(names)")
}
}

//Objective-c

for(NSString *fontfamilyname in [UIFont familyNames]) {
NSLog(@"family:'%@'",fontfamilyname);
for(NSString *fontName in [UIFont fontNamesForFamilyName:fontfamilyname]) {
NSLog(@"\tfont:'%@'",fontName);
}
NSLog(@"-------------");
}

In the debug output, look for your new font's 'family' and 'font' name. Pass whatever is displayed as the 'font' name corresponding to your new font family (there could be more than one 'font' associated with your new font 'family') to UIFont *myNewFont = [UIFont fontWithName:@"font_name_from_debug_output" size:20] and you should be in business!

小开

After you've added your fonts to your project/app, add this code (probably just in app delegate didFinishLaunchingWithOptions method) in order to print out all the available fonts for your app. From with-in that list you should be able to identify the font you're after. Don't forget to remove the unnecessary code after.

for (NSString *fontFamilyName in [UIFont familyNames]) {
for (NSString *fontName in [UIFont fontNamesForFamilyName:fontFamilyName]) {
NSLog(@"Family: %@    Font: %@", fontFamilyName, fontName);
}
}

小开

You can also use otfinfo --info arial.ttf to get the name from command line. The postscript name is the one you need to pass to the UIFont constructor.

小开

Swift 1.2:

    for familyName in UIFont.familyNames() {
for fontName in UIFont.fontNamesForFamilyName(familyName as! String) {
println("\(familyName) : \(fontName)")
}
}

小开

Swift 3.0

for familyName in UIFont.familyNames {
for fontName in UIFont.fontNames(forFamilyName: familyName ) {
print("\(familyName) : \(fontName)")
}
}

小开

If you want to find the font name for a given font file programmatically:

import Foundation


func loadFontName(for file: URL) throws -> String {
let data = try Data(contentsOf: file)


guard let provider = CGDataProvider(data: data as CFData) else {
throw Error("Could not create data provider")
}


guard let font = CGFont(provider) else {
throw Error("Could not load font")
}


guard let name = font.postScriptName else {
throw Error("Could not get font name from font file")
}


return name as String
}

Replace with your own throwable Error objects as required.

小开

To use fonts in iOS, you have to load the font based on the font's FULL NAME (PostScript Name), which is sometimes (and usually is) different from the font's actual FILE NAME.

Imagine yourself renaming the Font file "Arial-regular.ttf" to be "foo.ttf". The font contained inside the font file you just renamed is still "Arial-regular".

There are some good programmatic ways to get the font name already on this thread, but I have a different approach using the command line.

If you are on a Mac or Linux, simply run this script from the command line in the directory where you have your custom fonts (uses the fc-scan utility from fontconfig which is probaly already installed, but if not you can install it via homebrew: brew install fontconfig):

for file in "$arg"*.{ttf,otf}; do fc-scan --format "%{postscriptname}\n" $file; done

Here is a screenshot of the above command running on my ~/Library/Fonts directory:

The script above will run through all the .ttf and .otf files in the current directory, then print out the PostScript Name for each font which you can use to reference the font file in XCode or elsewhere.

If you want to get fancy with some additional information (PostScriptName, Filename) and some color coding, you can run this alternative script:

for file in "$arg"*.{ttf,otf}; do
postscriptname=$(fc-scan --format "%{postscriptname}\n" $file);
printf "\033[36m PostScript Name:\033[0m %s \e[90m(%s)\033[0m\n" "$postscriptname" "$file";
done

This is a bit faster than copy-pasting code inside of your AppDelegate.m file to print out the names every time you want to add a new font file, which is the popular method, and it's also faster than opening the Font in FontBook to inspect the PostScript Name.

USEFUL TIP: If you alias the above script in your terminal so that all you need to do is type a single command to get all the PostScript font names for all the files in the current directory (my function is called fontnames so all I have to do is type fontnames at the terminal inside the directory with fonts in it, and the PostScript names will be printed automatically, then you will save time in your development workflow and have this handy script ready to use when you need it.

Hope this helps!

小开

Another "quick, practical" hack that doesn't involve scanning through all the default fonts that exist on either the emulator or device is to use the font for something in your storyboard. Then if you edit the storyboard with a text editor (open as source code), you can see the fonts used with "internal" names if you search for the "customFonts" tag:

<customFonts key="customFonts">
<array key="Linotype - AvenirNextLTPro-Bold.otf">
<string>AvenirNextLTPro-Bold</string>
</array>
<array key="Linotype - AvenirNextLTPro-Regular.otf">
<string>AvenirNextLTPro-Regular</string>
</array>
<array key="TradeGothicLTPro-BdCn20.otf">
<string>TradeGothicLTPro-BdCn20</string>
</array>
</customFonts>

小开

Install the font
Open Font Book app on your Mac
Select the font and click on 'info' button
The name you're looking for is PostScript name
- MacOS: View -> Show Font Info

小开

Swift 4.0 Supported

This is only one line code for print all font family and it's font's names

override func viewDidLoad() {
super.viewDidLoad()
//Main line of code
UIFont.familyNames.sorted().forEach({ print($0); UIFont.fontNames(forFamilyName: $0 as String).forEach({print($0)})})
}

小开

List font names and families for macOS with Swift 4.1:

NSFontManager.shared.availableFonts.map { print($0) }
NSFontManager.shared.availableFontFamilies.map { print($0) }

小开

Swift 4.0+ solution

    for fontFamilyName in UIFont.familyNames {
print("family: \(fontFamilyName)\n")


for fontName in UIFont.fontNames(forFamilyName: fontFamilyName) {
print("font: \(fontName)")
}
}

Will output:

family: Apple SD Gothic Neo

font: AppleSDGothicNeo-Thin

font: AppleSDGothicNeo-Light