J'ai une ficelle comme ça
var str = "@text1 this is good @text1"
Maintenant, remplacez text1
par une autre chaîne, dites t 1
. Je suis capable de remplacer le texte, mais je ne peux pas le mettre en gras. Je veux mettre en gras la nouvelle chaîne t 1
, de sorte que la sortie finale soit:
@t 1 c'est bon @t 1
Comment puis-je le faire?
Tous les exemples que je vois sont dans Objective-C, mais je veux le faire dans Swift.
Merci d'avance.
Voici un moyen astucieux de combiner des textes normaux et audacieux dans une seule étiquette.
Extension:
Swift 3.0
extension NSMutableAttributedString {
@discardableResult func bold(_ text:String) -> NSMutableAttributedString {
let attrs:[String:AnyObject] = [NSFontAttributeName: UIFont(name: "AvenirNext-Medium", size: 12)!]
let boldString = NSMutableAttributedString(string: text, attributes:attrs)
self.append(boldString)
return self
}
@discardableResult func normal(_ text:String)->NSMutableAttributedString {
let normal = NSAttributedString(string: text)
self.append(normal)
return self
}
}
Swift 4
extension NSMutableAttributedString {
@discardableResult func bold(_ text: String) -> NSMutableAttributedString {
let attrs: [NSAttributedStringKey: Any] = [.font: UIFont(name: "AvenirNext-Medium", size: 12)!]
let boldString = NSMutableAttributedString(string:text, attributes: attrs)
append(boldString)
return self
}
@discardableResult func normal(_ text: String) -> NSMutableAttributedString {
let normal = NSAttributedString(string: text)
append(normal)
return self
}
}
Utilisation:
let formattedString = NSMutableAttributedString()
formattedString
.bold("Bold Text")
.normal(" Normal Text ")
.bold("Bold Text")
let lbl = UILabel()
lbl.attributedText = formattedString
Résultat:
Texte en gras Texte normal Texte en gras
var normalText = "Hi am normal"
var boldText = "And I am BOLD!"
var attributedString = NSMutableAttributedString(string:normalText)
var attrs = [NSFontAttributeName : UIFont.boldSystemFont(ofSize: 15)]
var boldString = NSMutableAttributedString(string: boldText, attributes:attrs)
attributedString.append(boldString)
Lorsque vous souhaitez l'assigner à une étiquette:
yourLabel.attributedText = attributedString
edit/update: Xcode 8.3.2 • Swift 3.1
Si vous connaissez HTML et CSS, vous pouvez l'utiliser pour contrôler facilement le style de police, la couleur et la taille de la chaîne attribuée, comme suit:
extension String {
var html2AttStr: NSAttributedString? {
return try? NSAttributedString(data: Data(utf8), options: [NSDocumentTypeDocumentAttribute: NSHTMLTextDocumentType, NSCharacterEncodingDocumentAttribute: String.Encoding.utf8.rawValue], documentAttributes: nil)
}
}
"<style type=\"text/css\">#red{color:#F00}#green{color:#0F0}#blue{color: #00F; font-weight: Bold; font-size: 32}</style><span id=\"red\" >Red,</span><span id=\"green\" > Green </span><span id=\"blue\">and Blue</span>".html2AttStr
Si vous travaillez avec des chaînes localisées, vous ne pourrez peut-être pas compter sur une chaîne en gras se trouvant toujours à la fin de la phrase. Si tel est le cas, les éléments suivants fonctionnent bien:
par exemple. Requête "blah" ne correspond à aucun article
/* Create the search query part of the text, e.g. "blah".
The variable 'text' is just the value entered by the user. */
let searchQuery = "\"\(text)\""
/* Put the search text into the message */
let message = "Query \(searchQuery). does not match any items"
/* Find the position of the search string. Cast to NSString as we want
range to be of type NSRange, not Swift's Range<Index> */
let range = (message as NSString).rangeOfString(searchQuery)
/* Make the text at the given range bold. Rather than hard-coding a text size,
Use the text size configured in Interface Builder. */
let attributedString = NSMutableAttributedString(string: message)
attributedString.addAttribute(NSFontAttributeName, value: UIFont.boldSystemFontOfSize(label.font.pointSize), range: range)
/* Put the text in a label */
label.attributedText = attributedString
C’est la meilleure façon que j’ai trouvée. Ajoutez une fonction que vous pouvez appeler de n'importe où et ajoutez-la à un fichier sans classe comme Constants.Swift, puis vous pouvez enhardir les mots dans n'importe quelle chaîne, à de nombreuses reprises en appelant simplement ONE LINE de code:
Pour aller dans un fichier constants.Swift:
import Foundation
import UIKit
func addBoldText(fullString: NSString, boldPartOfString: NSString, font: UIFont!, boldFont: UIFont!) -> NSAttributedString {
let nonBoldFontAttribute = [NSFontAttributeName:font!]
let boldFontAttribute = [NSFontAttributeName:boldFont!]
let boldString = NSMutableAttributedString(string: fullString as String, attributes:nonBoldFontAttribute)
boldString.addAttributes(boldFontAttribute, range: fullString.rangeOfString(boldPartOfString as String))
return boldString
}
Ensuite, vous pouvez simplement appeler cette ligne de code pour n’importe quel UILabel:
self.UILabel.attributedText = addBoldText("Check again in 30 DAYS to find more friends", boldPartOfString: "30 DAYS", font: normalFont!, boldFont: boldSearchFont!)
//Mark: Albeit that you've had to define these somewhere:
let normalFont = UIFont(name: "INSERT FONT NAME", size: 15)
let boldFont = UIFont(name: "INSERT BOLD FONT", size: 15)
J'ai prolongé l'excellente réponse de David West afin que vous puissiez saisir une chaîne et lui dire toutes les chaînes que vous souhaitez enhardir:
func addBoldText(fullString: NSString, boldPartsOfString: Array<NSString>, font: UIFont!, boldFont: UIFont!) -> NSAttributedString {
let nonBoldFontAttribute = [NSFontAttributeName:font!]
let boldFontAttribute = [NSFontAttributeName:boldFont!]
let boldString = NSMutableAttributedString(string: fullString as String, attributes:nonBoldFontAttribute)
for i in 0 ..< boldPartsOfString.count {
boldString.addAttributes(boldFontAttribute, range: fullString.rangeOfString(boldPartsOfString[i] as String))
}
return boldString
}
Et puis appelez ça comme ça:
let normalFont = UIFont(name: "Dosis-Medium", size: 18)
let boldSearchFont = UIFont(name: "Dosis-Bold", size: 18)
self.UILabel.attributedText = addBoldText("Check again in 30 days to find more friends", boldPartsOfString: ["Check", "30 days", "find", "friends"], font: normalFont!, boldFont: boldSearchFont!)
Cela enhardira toutes les chaînes que vous voulez en gras dans votre chaîne donnée
S'appuyant sur les excellentes réponses de Jeremy Bader et David West, une extension Swift 3
extension String {
func withBoldText(boldPartsOfString: Array<NSString>, font: UIFont!, boldFont: UIFont!) -> NSAttributedString {
let nonBoldFontAttribute = [NSFontAttributeName:font!]
let boldFontAttribute = [NSFontAttributeName:boldFont!]
let boldString = NSMutableAttributedString(string: self as String, attributes:nonBoldFontAttribute)
for i in 0 ..< boldPartsOfString.count {
boldString.addAttributes(boldFontAttribute, range: (self as NSString).range(of: boldPartsOfString[i] as String))
}
return boldString
}
}
Usage:
let label = UILabel()
let font = UIFont(name: "AvenirNext-Italic", size: 24)!
let boldFont = UIFont(name: "AvenirNext-BoldItalic", size: 24)!
label.attributedText = "Make sure your face is\nbrightly and evenly lit".withBoldText(
boldPartsOfString: ["brightly", "evenly"], font: font, boldFont: boldFont)
usage....
let attrString = NSMutableAttributedString()
.appendWith(weight: .semibold, "almost bold")
.appendWith(color: .white, weight: .bold, " white and bold")
.appendWith(color: .black, ofSize: 18.0, " big black")
deux centimes...
extension NSMutableAttributedString {
@discardableResult func appendWith(color: UIColor = UIColor.darkText, weight: UIFont.Weight = .regular, ofSize: CGFloat = 12.0, _ text: String) -> NSMutableAttributedString{
let attrText = NSAttributedString.makeWith(color: color, weight: weight, ofSize:ofSize, text)
self.append(attrText)
return self
}
}
extension NSAttributedString {
public static func makeWith(color: UIColor = UIColor.darkText, weight: UIFont.Weight = .regular, ofSize: CGFloat = 12.0, _ text: String) -> NSMutableAttributedString {
let attrs = [NSAttributedStringKey.font: UIFont.systemFont(ofSize: ofSize, weight: weight), NSAttributedStringKey.foregroundColor: color]
return NSMutableAttributedString(string: text, attributes:attrs)
}
}
Cela pourrait être utile
class func createAttributedStringFrom (string1 : String ,strin2 : String, attributes1 : Dictionary<String, NSObject>, attributes2 : Dictionary<String, NSObject>) -> NSAttributedString{
let fullStringNormal = (string1 + strin2) as NSString
let attributedFullString = NSMutableAttributedString(string: fullStringNormal as String)
attributedFullString.addAttributes(attributes1, range: fullStringNormal.rangeOfString(string1))
attributedFullString.addAttributes(attributes2, range: fullStringNormal.rangeOfString(strin2))
return attributedFullString
}
Super moyen facile de faire cela.
let text = "This string is having multiple font"
let attributedText =
NSMutableAttributedString.getAttributedString(fromString: text)
attributedText.apply(font: UIFont.boldSystemFont(ofSize: 24), subString:
"This")
attributedText.apply(font: UIFont.boldSystemFont(ofSize: 24), onRange:
NSMakeRange(5, 6))
Pour plus de détails, cliquez ici: https://github.com/iOSTechHub/AttributedString
Acceptant comme valide la réponse de Prajeet Shrestha dans ce fil de discussion, je souhaiterais étendre sa solution à l’aide de l’étiquette si elle est connue et des caractéristiques de la police de caractères.
Swift 4
extension NSMutableAttributedString {
@discardableResult func normal(_ text: String) -> NSMutableAttributedString {
let normal = NSAttributedString(string: text)
append(normal)
return self
}
@discardableResult func bold(_ text: String, withLabel label: UILabel) -> NSMutableAttributedString {
//generate the bold font
var font: UIFont = UIFont(name: label.font.fontName , size: label.font.pointSize)!
font = UIFont(descriptor: font.fontDescriptor.withSymbolicTraits(.traitBold) ?? font.fontDescriptor, size: font.pointSize)
//generate attributes
let attrs: [NSAttributedStringKey: Any] = [NSAttributedStringKey.font: font]
let boldString = NSMutableAttributedString(string:text, attributes: attrs)
//append the attributed text
append(boldString)
return self
}
}
Swift 3.0
Convertissez le HTML en chaîne et changez de police selon vos besoins.
do {
let str = try NSAttributedString(data: ("I'm a normal text and <b>this is my bold part . </b>And I'm again in the normal text".data(using: String.Encoding.unicode, allowLossyConversion: true)!), options: [ NSDocumentTypeDocumentAttribute: NSHTMLTextDocumentType], documentAttributes: nil)
myLabel.attributedText = str
myLabel.font = MONTSERRAT_BOLD(23)
myLabel.textAlignment = NSTextAlignment.left
} catch {
print(error)
}
func MONTSERRAT_BOLD(_ size: CGFloat) -> UIFont
{
return UIFont(name: "MONTSERRAT-BOLD", size: size)!
}
Il suffit d'utiliser un code comme celui-ci:
let font = UIFont(name: "Your-Font-Name", size: 10.0)!
let attributedText = NSMutableAttributedString(attributedString: noteLabel.attributedText!)
let boldedRange = NSRange(attributedText.string.range(of: "Note:")!, in: attributedText.string)
attributedText.addAttributes([NSAttributedString.Key.font : font], range: boldedRange)
noteLabel.attributedText = attributedText
Vous pouvez le faire en utilisant une méthode personnalisée simple écrite ci-dessous. Vous avez donné la chaîne entière dans le premier paramètre et le texte en gras dans le second paramètre. J'espère que cela aidera.
func getAttributedBoldString(str : String, boldTxt : String) -> NSMutableAttributedString {
let attrStr = NSMutableAttributedString.init(string: str)
let boldedRange = NSRange(str.range(of: boldTxt)!, in: str)
attrStr.addAttributes([NSAttributedString.Key.font : UIFont.systemFont(ofSize: 17, weight: .bold)], range: boldedRange)
return attrStr
}
sage: initalString = Je suis un garçon
label.attributedText = getAttributedBoldString (str: initalString, boldTxt: "Boy")
chaîne résultante = je suis un garçon
Pour Swift 4 et plus, c’est un bon moyen:
let attributsBold = [NSAttributedString.Key.font : UIFont.systemFont(ofSize: 16, weight: .bold)]
let attributsNormal = [NSAttributedString.Key.font : UIFont.systemFont(ofSize: 16, weight: .regular)]
var attributedString = NSMutableAttributedString(string: "Hi ", attributes:attributsNormal)
let boldStringPart = NSMutableAttributedString(string: "John", attributes:attributsBold)
attributedString.append(boldStringPart)
yourLabel.attributedText = attributedString
Dans l'étiquette, le texte ressemble à: "Bonjour John"
Améliorer sur Prajeet Shrestha répondre: -
Vous pouvez créer une extension générique pour NSMutableAttributedString qui implique moins de code. Dans ce cas, j'ai choisi d'utiliser la police système mais vous pouvez l'adapter afin de pouvoir saisir le nom de la police en tant que paramètre.
extension NSMutableAttributedString {
func systemFontWith(text: String, size: CGFloat, weight: CGFloat) -> NSMutableAttributedString {
let attributes: [String: AnyObject] = [NSFontAttributeName: UIFont.systemFont(ofSize: size, weight: weight)]
let string = NSMutableAttributedString(string: text, attributes: attributes)
self.append(string)
return self
}
}