import Foundation
//变量声明使用

//使用 let 来声明常量,使用 var 来声明变量 常量只能为它赋值一次
let name="cuiyw";
var age:Int=20;
//声明时类型是可选的,声明的同时 赋值的话,编译器会自动推断类型
var money:Double=200.0;
//有一种更简单的把值转换成字符串的方法:把值写到括号中,并且在括号之前写一个反斜杠
let infto=name+String(age)+"\(money)";
PRintln(infto);

//函数
//func  函数名（ 参数变量：类型 ，参数变量：类型...）｛｝
//说明:
//1: func 是函数关键字
//2：｛｝ 函数体
//3: 参数变量是默认常量类型，不能在函数函数体里面直接修改
//即 func A (value:String)  与 func A (let value:String)写法是相同的，即value 是常量。参数不能修改


//a.无参数无返回值
func functest()
{
    println("functest");
}

//b.有参数无返回值  可以设置默认值
func functest(name:String,age:Int=23)
{
    println(name+"\(age)")
}
functest("cyw");

//c该方法与b方法一起调用时 都调用b方法
//func functest(var name:String)->String
//{
//    name="a1变量参数cyw";
//    println(name);
//    return name;
//}
//functest("cyw");


//func 函数名( var  参数变量 : 类型,... ） ｛｝
//说明
//1: func 函数关键字
//2: var 参数变量 ：类型   表示参数变量是可变变量，不是常量，可以任意修改

//d该方法与b方法比较 时各自输出
//方法也可以添加一个外部参数名
func functest( var personName name:String)
{
    name="a变量参数cyw";
    println(name);
    //        return name;
}
functest("cyw");



//e.有参数有多个返回值
func functest()->(String,Int)
{
    return("cuiyw",23);
    
}
// f 输入输出函数 inout声明就不能用 var let 声明 同时参数也不能是let声明的
func hello( inout sayhello say:String )
{
    say="hello";
}
var hello="say hello";
hello(sayhello: &hello);
println(hello)


//g 内部函数
func func1()
{
    func func2()
    {
        println("fuc2");
    }
    func2();
    
}
func1();

//h 返回函数类型的函数
func add(num:Int)->Int
{
    return num+1;
}

func sub(num:Int)->Int
{
    return num-1;
}

func func3(num:Bool)->(Int)->Int
{
    return num ? add:sub;
}
var num=9;
var fun:(Int)->Int=func3(num>10);
num=fun(num);
println(num);


//支持可变参数长度的函数
func sumOf(numbers: Int...) -> Int {
    var sum = 0
    for number in numbers {
        sum += number
    }
    return sum
}
println(sumOf(22,22))
println(sumOf(42, 597, 12))