如何处理任务：询问选择和响应（引擎）

Question

答案！我用Arbitur修改的代码发布了一个答案。感谢Phillip以及引导我重定向我的搜索的关键建议。

TLDR：

有没有办法运行一个字符串的函数？像RunFunction（“myfunction_”+ number +“（）”），或者是像myfunction_ \ & number（）那样的硬编码方式？

我是贾斯汀，这是我的第一篇文章。我已经努力了过去2个月来不是问一个问题，但我终于坏了。我会尽量简短，但我非常罗嗦（这个长篇介绍并没有帮助）。提前感谢您的耐心。

基本上，我正在制作一个将简单的单词和短语转换为Swift代码的引擎;这样做的目标是快速制作文本游戏，教育应用程序和任何涉及非线性问题/答案的任何内容，这些问题/答案会根据您的反应而发生变化。

现在，我正在研究我认为的一个简单部分：存储标签和按钮的实际文本（我正在使用Xcode/iOS atm）。我决定像电影制作人/小说家那样对它进行建模：电影由由剪辑组成的场景组成。你也可以认为这是章/段

所以（不是实际的代码）：

App = (Scene 1 -> Scene 2 -> Scene 3, etc) 
Scene 1 = (Clip 1 -> Clip 2 -> Clip 3, etc) 
Scene 2 = Clip 2 -> Clip 5 -> Clip 1, based on responses       

....等等。

我认为（和程序）的方式，我倾向于尽可能地避免类，除了严格的数据或严格的功能结构。

所以，我的第一个解决方案是创建一个结构（或类）与嵌套函数：

struct SceneList { 

    //fScene calls, and passes the clip# from the button click 
    func fPlayClip(clipNUM: Int) 
    { 
     //Do logic stuff, then play the correct clip 
    } 

    //Called from button clicks on main screen; passes in clip# 
    func fScene1(play_clip clipNumber: Int){ 

     //sub functions(S1) 
     func fClip1(){ print("I'm scene 1, clip 1")} 
     func fClip2(){ print ("I'm scene 1, clip 2")} 

     fPlayClip(clipNumber) 
    } 

    func fScene2(play_clip clipNumber: Int){ 

     //sub functions(S2) 
     func fClip1(){ print("Yo, scene 2, clip 1")} 
     func fClip2(){ print ("Yo, scene 2, clip 2")} 

     fPlayClip(clipNumber) 
    } 
} 

不幸的是，这样的设计失败，因为没有办法，我打电话从fPlayClip子功能（） ，所以我采取另一种方法：

////////////////////////// 
/////SceneList.swift////// 
////////////////////////// 

struct Scene1{ 
    func fClip1(){ print("I'm scene 1, clip 1")} 
    func fClip2(){ print ("I'm scene 1, clip 2")}} 

struct Scene2{ 
    func fClip1(){ print("Yo, scene 2, clip 1")} 
    func fClip2(){ print ("Yo, scene 2, clip 2")}} 



    ////////////////////////// 
////////Main.swift//////// 
////////////////////////// 

// Implemention of the structs/clips. 
// (playScene is called in button click method.) 
func playScene(/*button prams go here*/){ 

    // Switch(){ case desired:   // Solve for X, 
     var oScenePlayer = SceneX()  // where X is the desired scene 

    // Switch(){ case desired:   // Solve for Z, 
     oScenePlayer.fClipZ()   // where Z is the desired clip 
} 

这再次失败，因为我不能只是一个对象使用，[oScenePlayer]，因为每个结构是不同的类型。

然后我绕了一段时间试图找出一种方法来销毁对象，然后重新创建它，但我无法做到这一点。然后，我环顾四周，将一个对象重新分配给另一个类的类型，但不能。然后，我看到了扩展，协议，泛型类型等等，试图找出一种扩展/固有的方式来实现它，但是失败了。所以现在，我最后的两个/工作/解决方案，就是在场景变化时创建一个新对象，然后等待ARC或其他任何东西来摧毁旧的对象;或者，让我回到第一个例子，并简单地嵌入[fPlayScene]到每一个功能：

//SOLUTION 1: 
struct SceneList { 

    func fScene1(play_clip clipNumber: Int){ 

     //sub functions(S1) 
     func fClip1(){ print("I'm scene 1, clip 1")} 
     func fClip2(){ print ("I'm scene 1, clip 2")} 

     //Do logic stuff below, solving for Y 
     case desired: 
     fClipY() 
    } 
} 

//SOLUTION 2: 
    ////////////////////////// 
/////SceneList.swift////// 
////////////////////////// 
struct Scene1{ 

    func fClip1(){ print("I'm scene 1, clip 1")} 
    func fClip2(){ print ("I'm scene 1, clip 2")}} 
} 

//And so on... 


    ////////////////////////// 
////////Main.swift//////// 
////////////////////////// 

////////////////////////// 
// Inside the globalish area: 
let oScene1: Scene1, 
    oScene2: Scene2 
    //And so on... 

var global_next_scene = 1 
var global_next_clip = 1 


///////////////////////////////// 
// Inside the button call method: 
func playScene(next_scene: Int, next_clip: Int){ 


    switch(next_scene){     //Find the scene 
     case 1: 
      oScene1 = Scene1() 

      switch(next_clip){   //Play the clip 
       case 1: 
        oScene1.fClip1() 
    } 
} 

基本上，我觉得我用太多的switch语句，并在方式太多的地方，（可能会有数百个场景和数千个剪辑），当像RunFunction("fClip" + next_clip + "()")这样简单的东西可以工作时，但我不知道任何'从字符串'函数执行快速命令：[，在那里我可以硬编码像fClip\&next_clip\()，我认为是可能的15年前，当我最后编程任何东西

我想出了一些其他疯狂的想法为了实现这一点，我甚至想到了OOP（不寒而栗）的嵌入类，并且让成员变量保存了子类的实例，但是用我当前的知识/资源，我找不到比最后2个片段更简单的方法。

所有的结构体，成员函数，开关语句等都将通过我的引擎自动生成 - 所以这并不是说我正在寻找一种更快的方式来实现这一点，它看起来像一个低效率/纳税的方式来做到这一点。

任何指导，将不胜感激。感谢很多提前了，我很惊讶，这是我花了这么长时间才需要在这里提出一个问题^ - ^（）

和平和祝福

Answer 1

Phillip的回答启发了我更多地关注数组和从函数中分离数据，事实上我正在寻找的是可用闭包 - 我不知道你可以简单地通过声明（展开）一个变量来调用闭包:)多么干净的语言！

这完美的作品，现在我不需要任何类或结构^ - ^（）（所有的更好！）

//initializer 
var clips_for_scene = [ 
    1: { print("initialized") } 
] 

//SceneList 
var scenes = [ 
    1: { clips_for_scene = [ 
     1: { print("scene 1, clip 1") }, 
     2: { print("s1, c2") }]}, 
    2: { clips_for_scene = [ 
     1: { print("scene 2, clip 1") }, 
     2: { print("s2, c2") }]}] 


func playClip(which_scene: Int, _ which_clip:Int){ 

    scenes[which_scene]?() 
    clips_for_scene[which_clip]?() 
} 


playClip(1, 1) 
playClip(1, 2) 
playClip(2, 1) 
playClip(2, 2) 

//output: 
//scene 1, clip 1 
//s1, c2 
//scene 2, clip 1 
//s2, c2 

由于Arbitur以及，因为他们在一个单独的答案问题： https://stackoverflow.com/a/30286375/6593818

Answer 2

在我看来，你什么混合自然数据输入你的代码。也就是说，你创建的函数知道他们负责哪个元素......这就是导致所有你想知道的重复的原因。

也许还有我不明白这个问题的部分，但为什么没有这样的结构：

class Clip { 
    func play() { 
     print("Playing \(self)") 
    } 
} 

class Scene { 
    var clips = [Clip]() 
    func play() { 
     print("Playing \(self)") 
     for aClip in clips { 
      aClip.play() 
     } 
    } 
    func playClip(number: Int) { 
     if number >= 0 && number < clips.count { 
      clips[number].play() 
     } 
    } 
} 

class SceneList { 
    var scenes = [Scene]() 
    func play() { 
     print("Playing \(self)") 
     for aScene in scenes { 
      aScene.play() 
     } 
    } 
    func playScene(number: Int) { 
     if number >= 0 && number < scenes.count { 
      scenes[number].play() 
     } 
    } 
} 

var list = SceneList() 
for _ in 0..<2 { 
    var scene = Scene() 
    list.scenes.append(scene) 
    for _ in 0..<3 { 
     scene.clips.append(Clip()) 
    } 
} 
list.play() 

添加任何你喜欢的其他特性和逻辑，但主要的一点是把这些编号用数据引用的函数转换为泛型函数。