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

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?

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

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)
    }
}

@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

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 .

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];

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]];

Swift 3

Audacieux:

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

Italique:

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

 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

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

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;

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.

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];

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

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)
    }
}

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

[yourLabel setFont:[UIFont boldSystemFontOfSize:15.0];

Cela vous aidera.

Je veux juste mentionner ça,

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

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

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.

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)