Comment définir le gras et l'italique sur UILabel de l'iPhone / iPad?

138

Comment définir le gras et l'italique sur UILabeliPhone / iPad? J'ai cherché sur le forum mais rien ne m'a aidé. Quelqu'un pourrait-il m'aider?

Edi
la source
Si vous utilisez une police personnalisée sans italique, vous pouvez [essayer cette méthode.] [1] [1]: stackoverflow.com/questions/21009957/…
Jakehao

Réponses:

132
sectionLabel.font = [UIFont fontWithName:@"TrebuchetMS-Bold" size:18];

Il existe une liste de noms de polices que vous pouvez définir à la place de l'attribut «fontWithName». Le lien est ici

Développeur mobile iOS Android
la source
5
La meilleure réponse est celle avec la méthode d'extension .withTraits () de @Maksymilian Wojakowski
No
monsieur monsieur comment définir le style de la zone de texte en gras sans déclarer l'objectif de taille c
Ramani Hitesh
3
Ceci est problématique car vous utilisez un nom de police fixe. Comme cela est sujet à changement, ce n'est pas une bonne solution. La réponse de Maksymilian Wojakowski est meilleure et beaucoup plus flexible.
Ray Wojciechowski
274

N'essayez pas de jouer avec les noms de polices. En utilisant le descripteur de police, vous n'avez besoin d'aucun nom:

UILabel * label = [[UILabel alloc] init]; // use your label object instead of this
UIFontDescriptor * fontD = [label.font.fontDescriptor
            fontDescriptorWithSymbolicTraits:UIFontDescriptorTraitBold
                            | UIFontDescriptorTraitItalic];
label.font = [UIFont fontWithDescriptor:fontD size:0];

size:0 signifie «garder la taille telle quelle»

Avec Swift, essayez l'extension suivante:

extension UIFont {

    func withTraits(traits:UIFontDescriptorSymbolicTraits...) -> UIFont {
        let descriptor = self.fontDescriptor()
            .fontDescriptorWithSymbolicTraits(UIFontDescriptorSymbolicTraits(traits))
        return UIFont(descriptor: descriptor, size: 0)
    }

    func boldItalic() -> UIFont {
        return withTraits(.TraitBold, .TraitItalic)
    }

}

Ensuite, vous pouvez l'utiliser de cette façon:

myLabel.font = myLabel.font.boldItalic()

ou même ajouter des traits supplémentaires comme Condensé:

myLabel.font = myLabel.font.withTraits(.TraitCondensed, .TraitBold, .TraitItalic)

Mise à jour pour Swift 4:

extension UIFont {
  var bold: UIFont {
    return with(traits: .traitBold)
  } // bold

  var italic: UIFont {
    return with(traits: .traitItalic)
  } // italic

  var boldItalic: UIFont {
    return with(traits: [.traitBold, .traitItalic])
  } // boldItalic


  func with(traits: UIFontDescriptorSymbolicTraits) -> UIFont {
    guard let descriptor = self.fontDescriptor.withSymbolicTraits(traits) else {
      return self
    } // guard

    return UIFont(descriptor: descriptor, size: 0)
  } // with(traits:)
} // extension

Utilisez-le comme suit:

myLabel.font = myLabel.font.bold

ou

myLabel.font = myLabel.font.italic

ou

myLabel.font = myLabel.font.with(traits: [ .traitBold, .traitCondensed ])

Mise à jour pour Swift 5

extension UIFont {
    var bold: UIFont {
        return with(.traitBold)
    }

    var italic: UIFont {
        return with(.traitItalic)
    }

    var boldItalic: UIFont {
        return with([.traitBold, .traitItalic])
    }



    func with(_ traits: UIFontDescriptor.SymbolicTraits...) -> UIFont {
        guard let descriptor = self.fontDescriptor.withSymbolicTraits(UIFontDescriptor.SymbolicTraits(traits).union(self.fontDescriptor.symbolicTraits)) else {
            return self
        }
        return UIFont(descriptor: descriptor, size: 0)
    }

    func without(_ traits: UIFontDescriptor.SymbolicTraits...) -> UIFont {
        guard let descriptor = self.fontDescriptor.withSymbolicTraits(self.fontDescriptor.symbolicTraits.subtracting(UIFontDescriptor.SymbolicTraits(traits))) else {
            return self
        }
        return UIFont(descriptor: descriptor, size: 0)
    }
}
Maksymilian Wojakowski
la source
5
Je ne sais pas pourquoi cela n'a pas reçu plus de votes! Pour les polices où vous n'avez pas de style gras ou italique, c'est génial!
Chris Prince
4
Ahhh. Je vois pourquoi ce n'est peut-être pas si populaire. Uniquement disponible dans iOS7 et au-dessus ...
Chris Prince
3
Je ne sais pas si cela devrait être considéré sous NDA, mais avec Xcode6 et iOS8 GM seed, je reçois un descripteur de police nul pour une police personnalisée alors qu'il n'était pas nul sous iOS7.
Chris Prince
@Maksymilian peut-on refuser cette méthode quelque part dans plusieurs libellés ie: uitableview
Majid Bashir
2
Juste une note rapide car cette réponse est très utile: return withTraits(.TraitBold, .TraitCondensed)devrait probablement return withTraits(.TraitBold, .TraitItalic)correspondre au nom de la fonction.
BreadicalMD
103

@Edinator jetez un œil à ce sujet.

myLabel.font = [UIFont boldSystemFontOfSize:16.0f]
myLabel.font = [UIFont italicSystemFontOfSize:16.0f];

utilisez l'un des éléments ci-dessus à l'heure que vous souhaitez

Sudhanshu
la source
1
Les deux styles ne fonctionnent pas. Dans ce cas, ce dernier prévaut dans le style italique. Merci pour votre réponse!
Edi le
@Edinator yups je sais que vous ne devez en utiliser qu'un à la fois ... j'avais aussi édité ma réponse!
Sudhanshu
8

Vous pouvez définir n'importe quel style de police, famille, taille pour l'étiquette, en cliquant sur la lettre «T» dans le champ Police .

Paramètres de police des étiquettes

ViliusK
la source
Mais voici la grande question, en plus d'utiliser fontWithName: @ "Arial-Light" comment spécifiez-vous les autres poids dans votre capture d'écran? Tout évoque boldSystemFontSize (sur: __) mais que faire si quelqu'un veut de la lumière ou de l'ultra-léger?
Dave G
6

J'ai le même problème qui doit appliquer à la fois gras et italique sur une étiquette et un bouton. Vous pouvez simplement utiliser le code suivant pour obtenir cet effet:

myLabel.font = [UIFont fontWithName:@"Arial-BoldItalic" size:30.0];
Même Cheng
la source
1
Je pense que vous vouliez dire "Arial", pas "Ariel" :)
MMMM
Pour Arial, cela ne fonctionne pas. Mais, cela fonctionne pour Helvetica-BoldOblique. Voir la documentation UIFont ici iphonedevwiki.net/index.php/UIFont
sudip
1
Vous voulez dire "HelveticaNeue", pas "Arial" :)
jpmartineau
et si nous ajoutions notre police personnalisée .. ??
Majid Bashir
6

Avec la police par défaut du système iOS 7, vous utiliserez helvetica neue bold si vous souhaitez conserver la police par défaut du système.

    [titleText setFont:[UIFont fontWithName:@"HelveticaNeue-Bold" size:16.0]];

Ou vous pouvez simplement l'appeler:

    [titleText setFont:[UIFont boldSystemFontOfSize:16.0]];
John Riselvato
la source
6

Swift 3

Audacieux:

let bondFont = UIFont.boldSystemFont(ofSize:UIFont.labelFontSize)

Italique:

let italicFont = UIFont.italicSystemFont(ofSize:UIFont.labelFontSize)

Vyacheslav
la source
3
 btn.titleLabel.font=[UIFont fontWithName:@"Helvetica neue" size:10];
 btn.titleLabel.font =  [UIFont boldSystemFontOfSize:btnPrev.titleLabel.font.pointSize+3];

vous pouvez faire une police d'étiquette / bouton en gras en utilisant également ceci

Jayesh Kavathiya
la source
3

J'ai fait une variation de la réponse de maksymilian wojakowski où vous pouvez ajouter ou supprimer un (des) trait (s)

extension UIFont {

    func withTraits(_ traits:UIFontDescriptorSymbolicTraits...) -> UIFont {
        let descriptor = self.fontDescriptor
            .withSymbolicTraits(UIFontDescriptorSymbolicTraits(traits).union(self.fontDescriptor.symbolicTraits))
        return UIFont(descriptor: descriptor!, size: 0)
    }
    func withoutTraits(_ traits:UIFontDescriptorSymbolicTraits...) -> UIFont {
        let descriptor = self.fontDescriptor
            .withSymbolicTraits(  self.fontDescriptor.symbolicTraits.subtracting(UIFontDescriptorSymbolicTraits(traits)))
        return UIFont(descriptor: descriptor!, size: 0)
    }
    func bold() -> UIFont {
        return withTraits( .traitBold)
    }

    func italic() -> UIFont {
        return withTraits(.traitItalic)
    }

    func noItalic() -> UIFont {
        return withoutTraits(.traitItalic)
    }
    func noBold() -> UIFont {
        return withoutTraits(.traitBold)
    }
}

exemple

label.font = label.font.italic().bold()

il est utile lors de la réutilisation d'une cellule et que vous souhaitez supprimer l'italique que vous avez mis sur une étiquette dans une cellule précédente

Tolbard
la source
2

J'ai récemment écrit un article de blog sur les restrictions de l'API UIFont et comment les résoudre. Vous pouvez le voir ici

Avec le code que je fournis là-bas, vous pouvez obtenir votre UIFont souhaité aussi facilement que:

UIFont *myFont = [FontResolver fontWithDescription:@"font-family: Helvetica; font-weight: bold; font-style: italic;"];

Et puis réglez-le sur votre UILabel (ou autre) avec: myLabel.font = myFont;

Jordi
la source
2

Comme cela a déjà été mentionné dans ces réponses, vous avez juste besoin du bon nom de police . Je trouve que iOSFonts.com est la ressource la plus utile pour savoir exactement quel nom utiliser.

Richard Venable
la source
Excellente ressource! Je l'ai parcouru dans mon appareil iOS et j'ai trouvé une belle police, puis j'ai utilisé "fontWithName" pour en obtenir une instance.
Markus Knappen Johansson
2

Exemple de texte en gras:

UILabel *titleBold = [[UILabel alloc] initWithFrame:CGRectMake(10, 10, 200, 30)];
UIFont* myBoldFont = [UIFont boldSystemFontOfSize:[UIFont systemFontSize]];
[titleBold setFont:myBoldFont];

Exemple de texte italique:

UILabel *subTitleItalic = [[UILabel alloc] initWithFrame:CGRectMake(10, 35, 200, 30)];
UIFont* myItalicFont = [UIFont italicSystemFontOfSize:[UIFont systemFontSize]];
[subTitleItalic setFont:myItalicFont];
Mer
la source
2

Bien que la réponse fournie par @tolbard soit incroyable et fonctionne bien!

Je pense que créer une extension pour quelque chose qui peut être réalisé en une seule ligne de code serait un sur-kill.

Vous pouvez obtenir un style gras et italique pour le même texte dans votre labelen configurant la propriété de police en utilisant UIFontDescriptorcomme indiqué ci-dessous dans l'exemple ci-dessous en utilisant Swift 4.0 :

label.font = UIFont(descriptor: UIFontDescriptor().withSymbolicTraits([.traitBold, .traitItalic])!, size: 12)

D'autres options incluent:

traitLooseLeading
traitTightLeading
traitUIOptimized
traitVertical
traitMonoSpace
traitCondensed
traitExpanded

Pour plus d'informations sur la signification de ces traits symboliques? visitez ici

iOSer
la source
2

Mise à jour de la réponse impressionnante de Maksymilian Wojakowski pour Swift 3

extension UIFont {
    func withTraits(traits:UIFontDescriptorSymbolicTraits...) -> UIFont? {
        guard let descriptorL = self.fontDescriptor.withSymbolicTraits(UIFontDescriptorSymbolicTraits(traits)) else{
            return nil
        }
        return UIFont(descriptor: descriptorL, size: 0)
    }

    func boldItalic() -> UIFont? {
        return withTraits(traits: .traitBold, .traitItalic)
    }
}
devjme
la source
1

C'est très simple. Voici le code.

[yourLabel setFont:[UIFont boldSystemFontOfSize:15.0];

Cela vous aidera.

Ashu
la source
Cela ne met pas en italique.
mattsson
Cela mettra en gras uniquement. Pour l'italique, vous pouvez utiliser par le constructeur d'interface.
Ashu
1

Je veux juste mentionner ça,

UIFont.systemFont(ofSize: 16, weight: UIFont.Weight.bold)
UIFont.boldSystemFont(ofSize: 16)

Ils ont des résultats différents ...

ysong4
la source
0

Plusieurs fois, le texte en gras est considéré d'une manière d'architecture d'information à un autre niveau et n'a donc pas gras et régulier sur une ligne, vous pouvez donc le diviser en deux étiquettes / textViews, une régulière et en italique gras. Et utilisez l'éditeur pour choisir les styles de police.

Patrik Rikama-Hinnenberg
la source
0

Avec Swift 5

Pour le style = BOLD

label.font = UIFont(name:"HelveticaNeue-Bold", size: 15.0)

Pour le style = Moyen

label.font = UIFont(name:"HelveticaNeue-Medium", size: 15.0)

Pour le style = mince

label.font = UIFont(name:"HelveticaNeue-Thin", size: 15.0)
swiftBoy
la source