Ios Swift游乐场无输出

我试图将斐波那契数放入一个数组中，并希望在游乐场控制台中看到数组输出，但由于某些原因，我没有看到任何输出。有人能帮助我理解我在程序中犯的错误吗

import UIKit

class FibonacciSequence {

    let includesZero: Bool
    let values: [Int]

    init(maxNumber: Int, includesZero: Bool) {
        self.includesZero = includesZero
        values = [0]
        var counter: Int
        if (includesZero == true) { counter = 0 }
        else { counter = 1 }
        for counter  <= maxNumber; {
            if ( counter == 0 ) {
                values.append(0)
                counter = 1
            }
            else {
                counter = counter + counter
                values.append(counter)
            }
        }
        println(values)

    }

    println(values)
    return values
}

let fibanocciSequence = FibonacciSequence(maxNumber:123, includesZero: true)

导入UIKit
类斐波那契序列{
让我们包括零：布尔
let值：[Int]
init（maxNumber:Int，includeZero:Bool）{
self.includesZero=includesZero
值=[0]
变量计数器：Int
如果（includesZero==true）{counter=0}
else{counter=1}
对于counter来说，您的问题是代码中有错误；如果代码中有错误，游戏场将不会运行它，您也不会得到任何输出


在计数器的
行中，您的问题是您的代码中有错误；如果代码中有错误，游戏场将不会运行它，您也不会得到任何输出


在计数器的
行中，您的问题是您的代码中有错误；如果代码中有错误，游戏场将不会运行它，您也不会得到任何输出


在计数器的
行中，您的问题是您的代码中有错误；如果代码中有错误，游戏场将不会运行它，您也不会得到任何输出


 
在“代码< >计数器> p> @ ABakerSmith已经给出了代码中的问题的一个很好的解决方法，但是您也可以考虑，而不是初始化一个数组成员变量的类，编写一个返回Fibonacci数：< /P>的<代码>序列号< /代码>。
struct FibonacciSequence: SequenceType {
    let maxNumber: Int
    let includesZero: Bool

    func generate() -> GeneratorOf<Int> {
        var (i, j) = includesZero ? (0,1) : (1,1)
        return GeneratorOf {
            (i, j) = (j, i+j)
            return (i < self.maxNumber) ? i : nil
        }
    }
}

let seq = FibonacciSequence(maxNumber: 20, includesZero: false)

// no arrays were harmed in the generation of this for loop
for num in seq {
    println(num)
}

// if you want it in array form:
let array = Array(seq)

struct FibonacciSequence:SequenceType{
让maxNumber:Int
让我们包括零：布尔
func generate（）->GeneratorOf{
var（i，j）=包括零？（0,1）：（1,1）
返回发生器{
（i，j）=（j，i+j）
返回值（i

如果你想在多个世代中提高性能，你当然可以记住这个序列。
 @ ABakerSmith已经给出了代码中的问题的一个很好的解决方法，但是你也可能想考虑，而不是初始化一个数组成员变量的类，编写一个返回Fibonacci NUMB的<代码>序列号> /代码>。呃:
struct FibonacciSequence: SequenceType {
    let maxNumber: Int
    let includesZero: Bool

    func generate() -> GeneratorOf<Int> {
        var (i, j) = includesZero ? (0,1) : (1,1)
        return GeneratorOf {
            (i, j) = (j, i+j)
            return (i < self.maxNumber) ? i : nil
        }
    }
}

let seq = FibonacciSequence(maxNumber: 20, includesZero: false)

// no arrays were harmed in the generation of this for loop
for num in seq {
    println(num)
}

// if you want it in array form:
let array = Array(seq)

struct FibonacciSequence:SequenceType{
让maxNumber:Int
让我们包括零：布尔
func generate（）->GeneratorOf{
var（i，j）=包括零？（0,1）：（1,1）
返回发生器{
（i，j）=（j，i+j）
返回值（i

如果你想在多个世代中提高性能，你当然可以记住这个序列。
 @ ABakerSmith已经给出了代码中的问题的一个很好的解决方法，但是你也可能想考虑，而不是初始化一个数组成员变量的类，编写一个返回Fibonacci NUMB的<代码>序列号> /代码>。呃:
struct FibonacciSequence: SequenceType {
    let maxNumber: Int
    let includesZero: Bool

    func generate() -> GeneratorOf<Int> {
        var (i, j) = includesZero ? (0,1) : (1,1)
        return GeneratorOf {
            (i, j) = (j, i+j)
            return (i < self.maxNumber) ? i : nil
        }
    }
}

let seq = FibonacciSequence(maxNumber: 20, includesZero: false)

// no arrays were harmed in the generation of this for loop
for num in seq {
    println(num)
}

// if you want it in array form:
let array = Array(seq)

struct FibonacciSequence:SequenceType{
让maxNumber:Int
让我们包括零：布尔
func generate（）->GeneratorOf{
var（i，j）=包括零？（0,1）：（1,1）
返回发生器{
（i，j）=（j，i+j）
返回值（i

如果你想在多个世代中提高性能，你当然可以记住这个序列。
 @ ABakerSmith已经给出了代码中的问题的一个很好的解决方法，但是你也可能想考虑，而不是初始化一个数组成员变量的类，编写一个返回Fibonacci NUMB的<代码>序列号> /代码>。呃:
struct FibonacciSequence: SequenceType {
    let maxNumber: Int
    let includesZero: Bool

    func generate() -> GeneratorOf<Int> {
        var (i, j) = includesZero ? (0,1) : (1,1)
        return GeneratorOf {
            (i, j) = (j, i+j)
            return (i < self.maxNumber) ? i : nil
        }
    }
}

let seq = FibonacciSequence(maxNumber: 20, includesZero: false)

// no arrays were harmed in the generation of this for loop
for num in seq {
    println(num)
}

// if you want it in array form:
let array = Array(seq)

struct FibonacciSequence:SequenceType{
让maxNumber:Int
让我们包括零：布尔
func generate（）->GeneratorOf{
var（i，j）=包括零？（0,1）：（1,1）
返回发生器{
（i，j）=（j，i+j）
返回值（i

当然，如果你想提高多代的性能，你可以记忆序列。
无需强制展开
最后一代
–可选项可以与非可选项进行比较。干杯，我已按答案进行了修改。无需强制展开
最后一代
–可选项可以与非可选项进行比较。干杯，我已按答案进行了修改。不需要强制展开
最后一个
–可选项可以与非可选项进行比较。干杯，我已按答案进行了修改。无需强制展开
最后一个
–可选项可以与非可选项进行比较。干杯，我已按答案进行了修改。