Swift function can be called only once

Question

What is the simplest way to write a piece of code that can be executed only once?

I know a way but has a problem.

first, I write a Boolean variable that has negative value but can be set to positive and cannot change after that

 var hasTheFunctionCalled : Bool = false {
   didSet{
       hasTheFunctionCalled = true
   }
}

and then write the function and the code inside it:

func theFunction(){
   if !hasTheFunctionCalled{
      //do the thing
   }
   hasTheFunctionCalled = true
 }

but the problem is that the variable can be changed from somewhere else in the scope and this solution doesn't really look so simple and concrete.

I want to declare it inside a class but will call out from outside. I want to try Julien's answer. It seems brilliant. — Hamoonist, Feb 03 '18 at 21:28

Julien Perrenoud · Accepted Answer · 2018-02-05T21:12:25.440

27

A simple solution is to take advantage of lazy variables in the following way:

// Declare your "once-only" closure like this
private lazy var myFunction: Void = {
    // Do something once
}()

...

// Then to execute it, just call
_ = myFunction

This ensures that the code inside the myFunction closure is only executed the first time that the program runs _ = myFunction

Edit: Another approach is to use so called "dispatch once tokens". This comes from Objective-C and was available in Swift until Swift 3. It is still possible to make it work, however you will need to add a little bit of custom code. You can find more information on this post -> dispatch_once after the Swift 3 GCD API changes

Edit2: Should be _ = myFunction and not _ = myFunction(), as JohnMontgomery pointed out.

edited Feb 05 '18 at 21:12

answered Feb 02 '18 at 22:37

Julien Perrenoud

1,321
10
20

Correct me if I am wrong, but with this solution, you can't decide when the function is called though. – Sirmyself Feb 02 '18 at 22:39
1

Yes, you can. The function will be only be executed when the line `_ = myFunction()` is called. – Julien Perrenoud Feb 02 '18 at 22:40
ok, thank you. I though it would be a little bit like a static function – Sirmyself Feb 02 '18 at 22:41
I edited my post to add another approach, maybe you will prefer it. If my post helped you please upvote :) – Julien Perrenoud Feb 02 '18 at 22:44
3

Shouldn't it just be `_ = myFunction` without the `()`? – John Montgomery Feb 02 '18 at 23:55
1

@JohnMontgomery Yes I think you're correct. Thanks for pointing this out, I will edit my post. – Julien Perrenoud Feb 05 '18 at 21:11
Interesting. Found that ReactiveSwift uses exactly this approach for their `UIScheduler`: https://github.com/ReactiveCocoa/ReactiveSwift/blob/3c448a4432e17771cc2924328ccd1fd076f48a16/Sources/Scheduler.swift#L95 – Alexander Bekert Aug 24 '21 at 17:20

Andrea Mugnaini · Answer 2 · 2018-02-02T23:01:12.120

7

You might use a static bool inside a struct nested into the function itself doing so:

func theFunction(){
    struct Holder { static var called = false }

    if !Holder.called {
        Holder.called = true
        //do the thing
    }
}

edited Feb 02 '18 at 23:01

answered Feb 02 '18 at 22:40

Andrea Mugnaini

9,425
3
40
50

score 6 · Answer 3 · answered Feb 02 '18 at 22:47

One possible technique is to put the code into the initializer of a static type property, which is guaranteed to be lazily initialized only once (even when accessed across multiple threads simultaneously):

func theFunction() {
    struct Once {
        static let once = Once()
        init() {
            print("This should be executed only once during the lifetime of the program")
        }
    }
    _ = Once.once
}

(Compare Singleton in the "Using Swift with Cocoa and Objective-C" reference.)

Example:

print("Call #1")
theFunction()
print("Call #2")
theFunction()
print("Done")

Output:

Call #1
This should be executed only once during the lifetime of the program
Call #2
Done

score 2 · Answer 4 · answered Jul 03 '20 at 10:35

You can do smth like:

class Once {

  var already: Bool = false

  func run(@noescape block: () -> Void) {
    guard !already else { return }

    block()
    already = true
  }
}

and than use it like

class ViewController: UIViewController {
  let once = Once()

  override func viewDidAppear(animated: Bool) {
    super.viewDidAppear(animated)

    once.run {
      cameraMan.setup()
    }
  }
}

ref: https://dev.to/onmyway133/how-to-run-action-once-in-swift-3k7o

score 1 · Answer 5 · answered Feb 02 '18 at 22:38

1

Depending on what you are doing inside your method : you may check if the end result has already been accomplished :

e.g. if you instantiate a class, check if it is different from nil

answered Feb 02 '18 at 22:38

Sirmyself

1,392
1
11
25

score 1 · Answer 6 · answered Jan 13 '20 at 23:21

You can also use UserDefaults, and the knowledge that the default UserDefault Bool is false:

if !UserDefaults.standard.bool(forKey: "ExecuteOnce") {
    func()
    UserDefaults.standard.set(true, forKey: "ExecuteOnce")
}

This code will execute exactly once.

Swift function can be called only once

6 Answers6