In Obiettivo C, posso usare #pragma markper contrassegnare sezioni del mio codice nel navigatore dei simboli. Poiché si tratta di un comando preprocessore C, non è disponibile in Swift. C'è uno stand-in per questo in Swift o devo usare brutti commenti?

Puoi usare // MARK:

Si è anche discusso del fatto che l'uso liberale delle estensioni di classe potrebbe comunque essere una pratica migliore. Poiché le estensioni possono implementare protocolli, è possibile ad esempio mettere tutti i metodi delegati della vista tabella in un'estensione e raggruppare il codice a un livello più semantico di quello che #pragma markè in grado di fare.

Fino a Xcode 5 #pragma markesisteva la direttiva preprocessore .

Da Xcode 6 in poi, devi usare // MARK:

Queste funzionalità del preprocessore consentono di portare una struttura nella casella a discesa della funzione dell'editor del codice sorgente.

qualche esempio :

// MARK:

-> sarà preceduto da un divisore orizzontale

// MARK: your text goes here

-> mette "il tuo testo va qui" in grassetto nell'elenco a discesa

// MARK: - your text goes here

-> mette "il tuo testo va qui" in grassetto nell'elenco a discesa, preceduto da un divisore orizzontale

aggiornamento: aggiunto screenshot perché alcune persone sembrano avere ancora problemi con questo:

Per coloro che sono interessati all'utilizzo delle estensioni rispetto ai segni pragma (come menzionato nel primo commento), ecco come implementarlo da un ingegnere Swift:

import UIKit

class SwiftTableViewController: UITableViewController {

    init(coder aDecoder: NSCoder!) {
        super.init(coder: aDecoder)

    }

    override func viewDidLoad() {
        super.viewDidLoad()

    }
}

extension SwiftTableViewController {
    override func numberOfSectionsInTableView(tableView: UITableView?) -> Int {
        return 1
    }

    override func tableView(tableView: UITableView?, numberOfRowsInSection section: Int) -> Int {
        return 5
    }

    override func tableView(tableView: UITableView?, cellForRowAtIndexPath indexPath: NSIndexPath?) -> UITableViewCell? {
        let cell = tableView?.dequeueReusableCellWithIdentifier("myCell", forIndexPath: indexPath) as UITableViewCell;

        cell.textLabel.text = "Hello World"

        return cell
    }

}

Inoltre, non è necessariamente la migliore pratica, ma è così che lo fai se ti piace.

Pragma mark - [SOME TEXT HERE]è stato usato in Objective-C per raggruppare diverse funzioni per separazione delle righe.

In Swift puoi farlo usandoMARK, TODO OR FIXME

io. MARCHIO : //MARK: viewDidLoad

Questo creerà una linea orizzontale con funzioni raggruppate sotto viewDidLoad (mostrato nella schermata 1)

ii. FARE : //TODO: - viewDidLoad

Questo raggrupperà le funzioni in TODO: - categoria viewDidLoad (mostrato nella schermata 2)

iii. AGGIUSTAMI : //FIXME - viewDidLoad

Questo raggrupperà le funzioni in FIXME: - categoria viewDidLoad (mostrato nella schermata 3)

Controlla questa documentazione di Apple per i dettagli.

Documentazione ufficiale

Documento ufficiale di Apple sulla barra di salto Xcode: aggiungi annotazioni di codice alla barra di salto

Schermata Jump Bar per il codice di esempio

Comportamento in Xcode 10.1 e macOS 10.14.3 (Mojave)

Comportamento in Xcode 10.0 e macOS 10.13.4 (High Sierra)

Comportamento in Xcode 9.4.1 e macOS 10.13.0

Discussione

!!!:e a ???:volte non possono essere visualizzati.

Nel codice Objective-C Xcode rileva i commenti del tipo // MARK: - fooleggermente più portatile di #pragma. Ma anche questi non sembrano essere stati raccolti (ancora?).

Modifica: risolto in Xcode 6 beta 4.

Penso che Extensionssia un modo migliore invece di #pragma mark.

Il codice prima di utilizzare Extensions:

class ViewController: UIViewController, UICollectionViewDataSource, UICollectionViewDelegate {
    ...

    func collectionView(_ collectionView: UICollectionView, numberOfItemsInSection section: Int) -> Int {
        ...
    }

    func collectionView(_ collectionView: UICollectionView, cellForItemAt indexPath: IndexPath) -> UICollectionViewCell {
        ...
    }

    func collectionView(_ collectionView: UICollectionView, didSelectItemAt indexPath: IndexPath) {
        ...
    }
}

Il codice dopo aver usato Extensions:

class ViewController: UIViewController {
    ...
}

extension ViewController: UICollectionViewDataSource {
    func collectionView(_ collectionView: UICollectionView, numberOfItemsInSection section: Int) -> Int {
        ...
    }

    func collectionView(_ collectionView: UICollectionView, cellForItemAt indexPath: IndexPath) -> UICollectionViewCell {
        ...
    }
}

extension ViewController: UICollectionViewDelegate {
    func collectionView(_ collectionView: UICollectionView, didSelectItemAt indexPath: IndexPath) {
       ...
    }
}

Xcode 8 ora lo gestisce come seguito e si presenta così nel menu a discesa del metodo:

Confermato con un ingegnere Apple nel laboratorio Swift stamattina al WWDC che al momento non ci sono #pragma o equivalenti, lo considerano un bug e arriverà presto, quindi spero beta 2.

Comunque, sta arrivando.

Xcode ora supporta // MARK :, // TODO: e // FIXME landmarks per annotare il tuo codice ed elencarli nella barra di salto

Esistono tre opzioni da aggiungere #pragma_markin Swift:

1) // MARK: - your text here -

2) // TODO: - your text here -

3) // FIXME: - your text here -

Nota: utilizza -per aggiungere separatori

Uso

// MARK: SectionName

o

// MARK: - SectionName

Questo darà una linea sopra il segno del pragma, rendendolo più leggibile.

Per semplicità basta aggiungere

// MARK: - <#label#>

ai frammenti di codice.

Modo alternativo -

Usalo in questo modo

private typealias SectionName = ViewController
private extension SectionName  {
    // Your methods
}

Questo non solo aggiungerà mark (proprio come il pragma mark) ma segregherà bene anche il codice.

//# MARK: - Spinner Class Methods

Aggiungi una linea tra i due punti e la descrizione per inserire una linea di separazione. Questo aiuta a organizzare ancora di più il tuo codice. Il codice e lo screenshot sopra fanno uso del commento MARK con una riga inclusa.

1. // # MARK: - Metodi di testo (LINEA)
2. // # MARK: Metodi di testo (NO LINE)

Funziona solo con il commento MARK.

Potresti essere interessato anche alle direttive del compilatore Swift 4.2 / XCode 10 come

#warning("Some string to display")

e

#error("Some error to display")

Potrebbe essere utile quando davvero non vuoi perderti qualcosa.

Il programmatore professionista deve utilizzare questo tag per un buon codice. È anche buono per il lavoro di gruppo.

// MARK: example Web Service start here
// TODO: example 1
// FIXME: Please change BASE url before live 

È facile trovare un metodo come questo

In Xcode 11 hanno aggiunto la minimappa che può essere attivata Editor -> Minimap.

La minimappa mostrerà il testo di ogni segno per un rapido orientamento nel codice. Ogni segno è scritto come// MARK: Variables

//MARK:non sembra funzionare per me in Xcode 6.3.2. Tuttavia, questo è quello che ho fatto per farlo funzionare :

1) Codice:

import Cocoa

class MainWindowController: NSWindowController {

    //MARK: - My cool methods

    func fly() {
    }

    func turnInvisible() {

    }
}

2) Nel jump barnulla sembra cambiare quando si aggiunge il //MARK: commento. Tuttavia, se faccio clic sul nome più a destra nella barra di salto, nel mio caso si dice MainWindowController(with a leading C icon), verrà visualizzata una finestra popup che mostra gli effetti del // MARK: commento, vale a dire un'intestazione che dice "I miei metodi interessanti":

3) Noto anche che se faccio clic su uno dei metodi nel mio codice, il metodo diventa la voce più a destra nella barra di salto. Per MainWindowController(with a leading C icon)essere la voce più a destra nella barra di salto, devo fare clic sullo spazio bianco sopra i miei metodi.

Apple afferma nell'ultima versione di Building Cocoa Apps ,

Il compilatore Swift non include un preprocessore. Invece, sfrutta gli attributi in fase di compilazione, le configurazioni di compilazione e le funzionalità del linguaggio per ottenere la stessa funzionalità. Per questo motivo, le direttive del preprocessore non vengono importate in Swift.

Il personaggio # sembra essere ancora il modo in cui lavori con varie configurazioni di build e cose del genere, ma sembra che stiano cercando di ridurre la tua necessità di maggior preelaborazione nella vena del pragma e di inoltrarti ad altre funzionalità del linguaggio. Forse questo è di aiuto nel funzionamento dei Playgrounds e il REPL si comporta il più vicino possibile al codice completamente compilato.

Aggiungi un elemento da fare: inserisci un commento con il prefisso TODO :. Ad esempio: // TODO: [il tuo oggetto da fare].

Aggiungi un promemoria per la correzione di bug: inserisci un commento con il prefisso FIXME :. Ad esempio: // FIXME: [promemoria per la correzione di bug].

Aggiungi un'intestazione: inserisci un commento con il prefisso MARK :. Ad esempio: // MARK: [il titolo della tua sezione].

Aggiungi una linea di separazione: per aggiungere un separatore sopra un'annotazione, aggiungi un trattino (-) prima della parte di commento dell'annotazione. Ad esempio: // MARK: - [il tuo contenuto]. Per aggiungere un separatore sotto un'annotazione, aggiungi un trattino (-) dopo la parte di commento dell'annotazione. Ad esempio: // MARK: [il tuo contenuto] -.

Prova questo:

// MARK: Reload TableView

func reloadTableView(){

    tableView.reload()
}

Il marchio Pragma è un modo per migliorare la leggibilità del tuo codice. I commenti pragma apparirebbero come tag sulla barra di salto Xcode.

//MARK:  <Your comment goes here>

Esempio: nel codice,

//MARK: Properties

// MARK: View Life cycle

//MARK: Helper methods

Ecco come apparirebbe nella barra di salto di Xcode.