Pogrubianie tekstu za pomocą przypisanego ciągu w szybkim tempie

100

Mam taki sznurek

var str = "@text1 this is good @text1"

text1Powiedzmy, że teraz zastąp innym ciągiem t 1. Mogę zamienić tekst, ale nie mogę go pogrubić. Chcę pogrubić nowy ciąg t 1, aby ostateczny wynik był następujący:

@t 1 to jest dobre @t 1

Jak mogę to zrobić?

Wszystkie przykłady, które widzę, są w Objective-C, ale chcę to zrobić w Swift.

Z góry dziękuję.

user2413621
źródło
1
Musisz rozłożyć swój problem: Dowiedz się, jak „pogrubić”: stackoverflow.com/questions/25199580/… Dowiedz się, jak zamienić tekst.
Larme
1
Użyj tej biblioteki, to drobiazgowo proste. github.com/iOSTechHub/AttributedString
Ashish Chauhan

Odpowiedzi:

237

Stosowanie:

let label = UILabel()
label.attributedText =
    NSMutableAttributedString()
        .bold("Address: ")
        .normal(" Kathmandu, Nepal\n\n")
        .orangeHighlight(" Email: ")
        .blackHighlight(" [email protected] ")
        .bold("\n\nCopyright: ")
        .underlined(" All rights reserved. 2020.")

Wynik:

wprowadź opis obrazu tutaj

Oto zgrabny sposób na połączenie pogrubionych i normalnych tekstów na jednej etykiecie oraz kilka innych dodatkowych metod.

Rozszerzenie: Swift 5. *

extension NSMutableAttributedString {
    var fontSize:CGFloat { return 14 }
    var boldFont:UIFont { return UIFont(name: "AvenirNext-Bold", size: fontSize) ?? UIFont.boldSystemFont(ofSize: fontSize) }
    var normalFont:UIFont { return UIFont(name: "AvenirNext-Regular", size: fontSize) ?? UIFont.systemFont(ofSize: fontSize)}

    func bold(_ value:String) -> NSMutableAttributedString {

        let attributes:[NSAttributedString.Key : Any] = [
            .font : boldFont
        ]

        self.append(NSAttributedString(string: value, attributes:attributes))
        return self
    }

    func normal(_ value:String) -> NSMutableAttributedString {

        let attributes:[NSAttributedString.Key : Any] = [
            .font : normalFont,
        ]

        self.append(NSAttributedString(string: value, attributes:attributes))
        return self
    }
    /* Other styling methods */
    func orangeHighlight(_ value:String) -> NSMutableAttributedString {

        let attributes:[NSAttributedString.Key : Any] = [
            .font :  normalFont,
            .foregroundColor : UIColor.white,
            .backgroundColor : UIColor.orange
        ]

        self.append(NSAttributedString(string: value, attributes:attributes))
        return self
    }

    func blackHighlight(_ value:String) -> NSMutableAttributedString {

        let attributes:[NSAttributedString.Key : Any] = [
            .font :  normalFont,
            .foregroundColor : UIColor.white,
            .backgroundColor : UIColor.black

        ]

        self.append(NSAttributedString(string: value, attributes:attributes))
        return self
    }

    func underlined(_ value:String) -> NSMutableAttributedString {

        let attributes:[NSAttributedString.Key : Any] = [
            .font :  normalFont,
            .underlineStyle : NSUnderlineStyle.single.rawValue

        ]

        self.append(NSAttributedString(string: value, attributes:attributes))
        return self
    }
}
Prajeet Shrestha
źródło
czy to nie jest dla swift 2?
remy boys
2
Niewielki dodatek: func bold(_ text:String, _ size:CGFloat). Dodałem rozmiar do pogrubienia, aby móc kontrolować go z zewnątrz. Poza tym brakowało mi AvenirNext-Mediumczcionki w tej funkcji, więc zrozumienie, dlaczego nie widzę mojej czcionki, zajęło mi kilka minut. Heads-up.
Gal
uratowałeś mi dzień, stary!
oskarko
Dzięki! Zadziałało jak urok :)
Sharad Chauhan
1
Ballay ballay sarkaaar: D
Mohsin Khubaib Ahmed
102
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)

Jeśli chcesz przypisać go do etykiety:

yourLabel.attributedText = attributedString
Dejan Skledar
źródło
Świetna odpowiedź! Dzięki!
hacker_1989
uwaga: nazwa appendAttributedString została zmieniona na .append ()
Andrea Leganza
28

edycja / aktualizacja: Xcode 8.3.2 • Swift 3.1

Jeśli znasz HTML i CSS, możesz go użyć do łatwej kontroli stylu czcionki, koloru i rozmiaru przypisanego ciągu w następujący sposób:

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
Leo Dabus
źródło
Próbuję zaimplementować to w Swift 2 Xcode, ale czcionka nie jest stosowana. Oto ciąg <link href=\"https://fonts.googleapis.com/css?family=Frank+Ruhl+Libre\" rel=\"stylesheet\"> <span style=\"font-family: 'Frank Ruhl Libre', sans-serif;\">שלום</span>
znaków
Jeśli styl używa WebKit do analizowania ciągów HTML w NSAttributedString, ostrożnie używaj go w wątku w tle ...
FouZ
Jakie są zalety korzystania z tego podejścia zamiast @prajeet answer?
Emre Önder
17

Jeśli pracujesz ze zlokalizowanymi ciągami znaków, możesz nie być w stanie polegać na tym, że pogrubiony ciąg zawsze znajduje się na końcu zdania. W takim przypadku dobrze działa następujące rozwiązanie:

np. zapytanie „bla” nie pasuje do żadnych elementów

/* 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
Ian
źródło
2
Po wielu godzinach poszukiwań to jedyna odpowiedź, która znalazła rozwiązanie mojego problemu. +1
Super_Simon
9

Rozszerzyłem świetną odpowiedź Davida Westa, abyś mógł wprowadzić ciąg i powiedzieć mu wszystkie podciągi, które chcesz ośmielić:

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
}

A potem nazwij to tak:

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

To ośmieli wszystkie podciągi, które chcesz pogrubić w danym ciągu

Jeremy Bader
źródło
Czy można pogrubić to samo słowo w dwóch różnych miejscach? Np .: „Sprawdź ponownie za 30 dni, aby znaleźć 30 znajomych”. Jak pogrubić oba „30”? Z góry dziękuję.
Dian
8

To najlepszy sposób, na jaki wpadłem. Dodaj funkcję, którą możesz wywołać z dowolnego miejsca i dodaj ją do pliku bez klasy, takiej jak Constants.swift, a następnie możesz ośmielić słowa w dowolnym ciągu, wielokrotnie, wywołując tylko JEDNĄ LINIĘ kodu:

Aby przejść do pliku 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
}

Następnie możesz po prostu wywołać tę jedną linię kodu dla dowolnego 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)
David West
źródło
8

Opierając się na doskonałych odpowiedziach Jeremy'ego Badera i Davida Westa, rozszerzenie 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
    }
}

Stosowanie:

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)
Daniel McLean
źródło
5

stosowanie....

let attrString = NSMutableAttributedString()
            .appendWith(weight: .semibold, "almost bold")
            .appendWith(color: .white, weight: .bold, " white and bold")
            .appendWith(color: .black, ofSize: 18.0, " big black")

dwa centy...

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)
    }
}
Samuel
źródło
1
iOS 11 lub nowszy (ze względu na użycie UIFont.Weight).
Andrea Leganza
4

Przyjmując jako poprawną odpowiedź Prajeeta Shrestha w tym wątku, chciałbym rozszerzyć jego rozwiązanie o etykietę, jeśli jest znana, oraz cechy czcionki.

Szybki 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
    }
}
JSR - Silicornio
źródło
4

Swift 4 i wyżej

Dla Swift 4 i nowszych to dobry sposób:

    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

W etykiecie tekst wygląda tak: „Cześć John

Jonas Deichelmann
źródło
3

Super łatwy sposób na zrobienie tego.

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

Aby uzyskać więcej informacji, kliknij tutaj: https://github.com/iOSTechHub/AttributedString

Ashish Chauhan
źródło
A może pół odważny?
Houman
To powinna być akceptowana odpowiedź. @Houman użyj powyższej biblioteki i użyj applymetody z wybraną czcionką
Zack Shapiro,
2

To może być przydatne

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
}
Martin Jacob
źródło
2

Swift 3.0

Konwertuj HTML na ciąg i zmianę czcionki zgodnie z wymaganiami.

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)!
}
Mitul Marsoniya
źródło
Powinieneś przekonwertować swój ciąg na dane za pomocą utf8. Zwróć uwagę, że dane są zgodne z kolekcją w Swift 3, więc możesz zainicjować Data za pomocą widoku kolekcji ciągów utf8 Data("I'm a normal text and <b>this is my bold part . </b>And I'm again in the normal text".utf8)i ustawić kodowanie znaków w opcjach[NSDocumentTypeDocumentAttribute: NSHTMLTextDocumentType, NSCharacterEncodingDocumentAttribute: String.Encoding.utf8.rawValue]
Leo Dabus
0

Po prostu użyj kodu podobnego do tego:

 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
Michał Ziobro
źródło
0

dwie wkładki w swift 4:

            button.setAttributedTitle(.init(string: "My text", attributes: [.font: UIFont.systemFont(ofSize: 20, weight: .bold)]), for: .selected)
            button.setAttributedTitle(.init(string: "My text", attributes: [.font: UIFont.systemFont(ofSize: 20, weight: .regular)]), for: .normal)
Antzi
źródło
0

Swift 5,1 używać NSAttributedString.KeyzamiastNSAttributedStringKey

let test1Attributes:[NSAttributedString.Key: Any] = [.font : UIFont(name: "CircularStd-Book", size: 14)!]
let test2Attributes:[NSAttributedString.Key: Any] = [.font : UIFont(name: "CircularStd-Bold", size: 16)!]

let test1 = NSAttributedString(string: "\(greeting!) ", attributes:test1Attributes)
let test2 = NSAttributedString(string: firstName!, attributes:test2Attributes)
let text = NSMutableAttributedString()

text.append(test1)
text.append(test2)
return text
Yodagama
źródło
0

Dla -> Wyszukaj telewizję według rozmiaru

Jednokierunkowe przy użyciu NString i jego zakresu

let query = "Television"
let headerTitle = "size"
let message = "Search \(query) by \(headerTitle)"
let range = (message as NSString).range(of: query)
let attributedString = NSMutableAttributedString(string: message)
attributedString.addAttribute(NSAttributedString.Key.font, value: UIFont.boldSystemFont(ofSize: label1.font.pointSize), range: range)
label1.attributedText = attributedString

inny bez użycia NString i jego Range

let query = "Television"
let headerTitle = "size"
let (searchText, byText) = ("Search ", " by \(headerTitle)")
let attributedString = NSMutableAttributedString(string: searchText)
let byTextAttributedString = NSMutableAttributedString(string: byText)
let attrs = [NSAttributedString.Key.font : UIFont.boldSystemFont(ofSize: label1.font.pointSize)]
let boldString = NSMutableAttributedString(string: query, attributes:attrs)
attributedString.append(boldString)
attributedString.append(byTextAttributedString)
label1.attributedText = attributedString

swift5

Vinoth Anandan
źródło
-1

Poprawa odpowiedzi Prajeeta Shrestha: -

Możesz utworzyć ogólne rozszerzenie dla NSMutableAttributedString, które obejmuje mniej kodu. W tym przypadku zdecydowałem się użyć czcionki systemowej, ale możesz ją dostosować, aby wprowadzić nazwę czcionki jako parametr.

    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
        }
    }
Edward
źródło
-1

Możesz to zrobić za pomocą prostej niestandardowej metody opisanej poniżej. Musisz podać cały ciąg w pierwszym parametrze i tekst, który ma być pogrubiony w drugim parametrze. Mam nadzieję, że to pomoże.

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
    }

użycie: initalString = Jestem chłopcem

label.attributedText = getAttributedBoldString (str: initalString, boldTxt: "Boy")

wynikowy ciąg = Jestem chłopcem

Muhammad Haroon Iqbal
źródło