Swift Tutorial - Enumerations & Structures | Everything You Need to Know
Swift-Enumerations Structures Tutorial ACTE

Swift Tutorial – Enumerations & Structures | Everything You Need to Know

Last updated on 09th Feb 2022, Blog, Tutorials

About author

Manish Pandey (IT DevOps Cloud Senior Engineer )

Manish Pandey is an IT DevOps Cloud Senior Engineer. He has expertise in trending domains like Data Science, Artificial Intelligence, Machine Learning, Blockchain, etc. His articles help the learners get insights into the domain.

(5.0) | 17596 Ratings 1303
    • Introduction to Swift-Enumerations & Structures
    • What is fast enumeration in Swift?
    • Enumerations and Structures
    • Difference between Associated Values and Raw Values
    • Raw Values
    • Swift Enumeration with Switch Statement
    • Swift Enumeration with Associated Values
    • Swift Enumeration with Raw Values
    • Advantages of Swift-Enumerations & Structures
    • Conclusion

    Subscribe For Free Demo

      Introduction to Swift-Enumerations & Structures:

    • In swift, enumeration is an information type that comprises a bunch of Associated qualities and it permits us to involve those characterized values in our code in a sort safe way.

    • The qualities anything, we characterized in swift enumeration can be a string or a person or a worth of whole number or float. We can make different sort of enumeration models in swift like an assortment of shadings, cards, creatures, and so on

    • The swift enumeration is strong when we contrast other programming dialects like Objective-C and so because enumeration imparts their functionalities to constructions and class. A enumeration in swift is a client characterized so it contains techniques, convention, and properties.

    • What is enumeration utilized for in Swift?

      An enumeration a typical kind for a gathering of Associated qualities and empowers you to work with those values in a sort of safe way inside your code. Enumeration in Swift are top-notch types by their own doing.

      What is the contrast among enum and struct in Swift?

      One distinction between the two is that structs can be started up where Enums can’t. So in many situations where you simply need to utilize constants, it’s most likely best to utilize Enums to stay away from disarray.

      How would I utilize enum in Swift 5?

      The linguistic structure for lists is very basic: You utilize the enum watchword to announce a list, for example, enum name {body}, similar to pronouncing classes. In the enum body, you can incorporate various cases with the case watchword. An Enum’s cases are the various qualities that it has, for example, the above-frozen yogurt flavors.

      What is fast enumeration in Swift?

      The swift enumeration is a language include that permits you to effectively and securely identify the substance of an assortment utilizing a compact linguistic structure.

      Enumeration Functionality:

      Enumeration in Swift 4 additionally takes after the construction of C and Objective C.

    • It is pronounced in a class and its qualities are gotten to through the occurrence of that class.
    • Introductory part esteem is characterized by utilizing enum initializers.
    • Its usefulness is likewise reached out by guaranteeing standard convention usefulness.

    • Enumerations and Structures:

      An enumeration portrays a typical sort for a Associated worth gathering and permits you to work with those values inside your code in a kind safe way.

      1. Assuming you’re familiar with C, you’ll comprehend that a bunch of number qualities is relegated by C enumeration. Swift enumeration s is significantly more adaptable and don’t need to offer a benefit for every enumeration case. If a worth (known as a Raw worth) is accommodated in every enumeration case, the worth might be a string, a person, or any sort of number or drifting point esteem.

      2. Then again, enumeration occasions might demonstrate Associated upsides of any kind to be put away along with every individual case esteem, similarly as in different dialects. As a feature of a solitary identification, you can distinguish a typical arrangement of Associated occasions, every one of which has a particular arrangement of values associated with reasonable sorts.

      3. Swift enumeration s are first-rate class types. They embrace various features commonly supported unmistakably by classes, for instance, we get some more data on enumeration’s present worth, and strategies to control values addressed by enumeration s. The initializers can be likewise characterized in enumeration s to instate enumeration case values. Identification’s usefulness can be extended past their underlying execution and can stick to conventions to give typical usefulness.

      The enum watchword presents enumerations and spots their whole definition in two or three supports.


      • enum enumname {
      • // enumeration values are portrayed here
      • }
      • For instance, for heading you can characterize a enumeration as follows.
      • enumCompassPoint {
      • case north
      • casesouth
      • caseeast
      • casewest
      • }

      Why Even Use a Class?

    • Given the above drawbacks, you could ask why you could at any point need to utilize a class. First off, they permit you to take on mature and fight tried structures like Cocoa and Cocoa Touch.

    • Also, classes really do have more significant employments. For instance, an enormous memory-hoarding, costly to-duplicate article is a decent contender for enveloping by a class. Classes can show a personality well.

    • You might have what is going on in which many perspectives are showing a similar article. Assuming that item is adjusted, every one of the perspectives additionally reflect changes in the model. With a worth kind, synchronizing updates can turn into an issue.

    • To put it plainly, classes are useful whenever reference versus esteem semantics become an integral factor. Look at this two-section instructional exercise regarding the matter: Reference versus Esteem Types in Swift.

    • Implementing Computed Properties

    • All named model sorts let you make custom setters and getters that don’t really relate to a put away property.
    • Assume you need to add a distance across getter and setter to your Circle model. It’s not difficult to execute it as far as the current span property.

    • Retroactive Modeling and Type Constraining

    • One of the extraordinary highlights of Swift is retroactive displaying. It allows you to broaden the conduct of a model kind regardless of whether you have the source code for it.
    • Here is a utilization case: Suppose you’re a client of the SVG code and you need to add a region and edge to Rectangle very much like Circle.
    • This utilizations lessen to compute the amount of borders. You can get familiar with how it functions in An Introduction to Functional Programming.

    • Where to Go From Here?

    • In this instructional exercise, you found out about enum, struct and class – the named model kinds of Swift. Each of the three have key likenesses: They give exemplification, can have initializer techniques, can have processed properties, can embrace conventions, and can be displayed retroactively.

    • I want to believe that you have partaken in this tornado visit through the named model sorts in Swift. On the off chance that you’re searching for a test, consider building a more complete rendition of the SVG delivering library. You’re looking great so far!

    • The qualities characterized in a enumeration (like north, south, east, and west) are its identification cases. You utilize the case catchphrase to present new identification cases.Consider beneath the model for greater lucidity.

      Course Curriculum

      Develop Your Skills with Swift Certification Training

      Weekday / Weekend BatchesSee Batch Details
      • enum names {
      • case Hello
      • case World
      • }
      • var lang = names.World
      • lang =.World
      • switch lang {
      • case.Hello:
      • print(“Welcome to Hello”)
      • case.World:
      • print(“Welcome to World”)
      • default:
      • print(“Introduction”)
      • }

      An enumeration can be additionally arranged into Associated qualities and Raw qualities.

      Difference between Associated Values and Raw Values:

    • Data Types are different Ex: enum {15,1.8,”World”}
    • Datatypes same Ex: enum {Jan, Feb, Mar}
    • The constant or variable decides value.
    • It has always prepopulated values
    • Each time it is stated, it varies.
    • Member value is identical

    • Associated Values:

      1. The models in the past area show how the instances of identification are characterized (and composed) esteem by their own doing. You can set a steady or variable to Planet. earth, and check for this esteem later. In any case, it’s occasionally helpful to have the option to store upsides of different sorts close by these case values. This extra data is called a Associated worth, and it fluctuates each time you utilize that case as a worth in your code.

      2. You can characterize Swift lists to store Associated upsides of some random kid, and the worth sorts can be different for each instance of the list if necessary.

      3. Enumeration like these are known as segregated associations, labeled associations, or variations in other programming dialects. For instance, assume a stock global positioning framework needs to follow items by two distinct kinds of scanner tag. A few items are marked with 1D standardized enumeration in UPC design, which utilizes the numbers 0 to 9.

      4. Each standardized tag has a number framework digit, trailed by five producer code digits and five-item code digits. These are trailed by an take a look at the digit to confirm that the code has been examined accurately:

      5. Different items are marked with 2D standardized tags in QR code design, which can utilize any ISO 8859-1 person and can encode a string up to 2,953 characters in length:

      It’s advantageous for a stock global positioning framework to store UPC scanner tags as a tuple of four numbers, and QR code standardized tags as a line of any length. In Swift, a enumeration to characterize item standardized tags of either type may resemble this:

      1. enum Barcode {

      2. case UPC(Int, Int, Int, Int)

      3. case QrCode(String)

      4. }

      This can be perused as:

      “Characterize a enumeration type called Barcode, which can take either a worth of UPC with a Associated worth of type (Int, Int, Int, Int) or a worth of qrCode with a Associated worth of type String.”

      This definition doesn’t give any real Int or String values-it simply enumeration the kind of Associated qualities that Barcode constants and factors can store when they’re equivalent to Barcode.UPC or Barcode.qrCode. You can then make new standardized enumeration utilizing either type:

      var productBarcode = Barcode.upc(8, 85909, 51226, 3)

      This model makes another variable called product barcode and allots it worth of Barcode. up with a Associated tuple worth of (8, 85909, 51226, 3). You can appoint a similar item an alternate kind of standardized tag:

      productBarcode = .qrCode(“ABCDEFGHIJKLMNOP”)

      Now, the first Barcode.UPC and its number of qualities are supplanted by the new Barcode.QrCode and its string esteem. Constants and factors of type Barcode can store either a .upc or a .qrCode (along with their Associated qualities), however, they can store just one of them at some random time. You can check the different standardized tag types utilizing a switch proclamation, like the model in Matching Enumeration Values with a Switch Statement. This time, be that as it may, the Associated qualities are removed as a feature of the switch proclamation. You separate each Associated worth as a steady (with the let prefix) or a variable (with the var prefix) for use inside the switch case’s body:

      Course Curriculum

      Get JOB Oriented Swift Training for Beginners By MNC Experts

      • Instructor-led Sessions
      • Real-life Case Studies
      • Assignments
      Explore Curriculum

      Raw Values:

      The standardized identification model in Associated Values shows how instances of a enumeration can announce that they store-Associated upsides of various sorts. As an option in contrast to Associated qualities, identification cases can come prepopulated with default values (called Raw qualities), which are the entirety of a similar sort. Here is a model that stores Raw ASCII values close by named enumeration cases:

      1. enum ASCIIControlCharacter: Character {

      2. case tab = “\t”

      3. case lineFeed = “\n”

      4. case carriageReturn = “\r”

      5. }

      Here, the Raw qualities for a enumeration called ASCIIControlCharacter are characterized to be of type Character and are set to a portion of the more normal ASCII control characters. Character values are depicted in Strings and Characters. Raw qualities can be strings, characters, or any of the whole number or drifting point number sorts. Every Raw worth should be remarkable inside its enumeration statement.

      Swift Enumeration with Switch Statement:

    • For the most part in the swift enumeration, we use case watchword to characterize enumeration values and swiftly permit us to proclaim individual qualities rely on which design we will continue in our code.
    • In swift, we can utilize identification with a Switch proclamation to match individual list values.
    • Following is the case of utilizing swift identification with a Switch explanation.
    • Assuming you see the above model, we characterized the list “Zoo” and checked variable with change case articulation to perform required proclamations in light of variable worth.
    • At the point when we run the above program in the swift jungle gym, we will obtain an outcome like as displayed beneath.

    • It’s a Lion

      This is how we can utilize a swift list with change case explanations to perform required proclamations because of the characterized conditions in the swift programming language.

      Swift Enumeration with Associated Values:

      a) In swift enumerations, we can store Associated upsides of any kind alongside the case values. The Associated qualities will assist us with putting away extra custom data alongside the case values in swift lists.

      b) In swift enumeration s, we can store any sort of Associated qualities yet the worth kinds can be not quite the same as each instance of the list in light of our prerequisites.

      c) For instance, to store signs of understudies alongside their names in the student list then by utilizing Associated qualities we can store effortlessly founded on our prerequisites.

      d) Presently we will perceive how to involve Associated qualities with a enumeration in a swift programming language.

      e) If you see the above model we characterized Associated upsides of understudy alongside case explanations in the swift programming language.

      f) Whenever we run the above program in swift jungle gym we will come by an outcome like as displayed underneath

      Understudy Name: Suresh Dasari

      Understudy Marks: 50, 70, 85

      a) This is how we can involve Associated qualities with lists in a swift programming language because of our prerequisites.

      Swift Enumeration with Raw Values:

      As we talked about in swift enumeration Associated qualities are utilized to store upsides of any kind alongside the case values. As an option in contrast to Associated qualities, identification cases can accompany pre-populated default esteems that are called Raw qualities.

      In swift enumeration, Raw qualities can be int, string, character, and so forth and the Raw worth will be similar sort for every one of the individuals in the enumeration. The Raw incentive for every part of the list should be interesting.


    • Swift is publicly released and simple to learn.
    • Swift is swift, protected, and expressive.
    • Swift is receptive and recognizable (C and C++ code can be added by Swift software engineers into Swift applications.)
    • Swift is the eventual fate of Apple’s advancement.
    • Swift is venture prepared.

    • Disadvantages:

    • The language is still very youthful and the ability pool is restricted.
    • Swift is thought of as a “moving objective” as it is another dialect and the number of swift developers is not many.
    • Helpless interoperability with outsider devices and IDEs
    • Absence of help for prior iOS variants

    • IOS Sample Resumes! Download & Edit, Get Noticed by Top Employers! Download


      In this article, we looked into how to make enumeration s in Python. The functionalities are mostly accomplished by exploiting making a subclass of the Enum class that is in the enum module. Here is a fast recap of the central issues.

    • Dissimilar to customary classes, properties of the Enum class will be viewed as autonomous individuals from the class.
    • These individuals have names and values, which can be whole numbers (they’re the default ones), strings, or different information types.
    • Strategies can be announced with the identification class, which permits us to make extra activities for simpler treatment of the individuals.
    • We can emphasize every one of the individuals from the class, which is iterable itself. We can likewise make a rundown of these individuals by exploiting the class being iterable.
    • As an adaptable element, we can utilize utilitarian APIs to make an identification class during runtime. Moreover, we can utilize monkey fixing to add extra strategies to the class.

    Are you looking training with Right Jobs?

    Contact Us
    Get Training Quote for Free