让所有的东西！

Swift让我们声明常量（ let ）或变量（ var ）。这是一种宣传价值是否会在受影响后发生变化的简单易行的方法。

简而言之，Swift是声明性的；我们应该用它来编写清晰的代码！

这里的两个要点是声明和情感。

一个常见的误解是，使用let的声明需要紧随其后。
通常，这会导致var与if或switch这样的控制流一起使用。

  var变量：任何 
  如果布尔值{ 
 变量= foo 
  } 其他 { 
 变量=条 
  } //不再更改变量variable 
 打印（变量） 
  返回

但是，如果每个代码路径只有一种影响， let可以-而且应该这样做！ – 使用：

  让常数：任何 
  如果布尔值{ 
 常数= foo 
  } 其他 { 
 常数= bar 
  } //再也不会改变 change️ 
 打印（恒定） 
 常量= foobar //编译器错误 🤗 
  返回

在switch也有效：

  让常数：任何 
  切换布尔值{ 
 正确的情况 ：常量= foo 
 错误的情况 ：常数=条 
  } //再也不会改变 change️

该一般想法可以应用于许多用例，例如：

摆脱可选项目；
展平厄运金字塔；
为每个代码路径调用一个闭包；
简化循环。

摆脱可选

  class Less { var b：B？  init（string：String）{ 
  切换字符串{ 
  情况 “ foo”：b = .foo 
  情况 “栏”：b = .bar 
  默认值 ：b = nil 
  } b？.make（） 
  如果 让 someB = b { 
 使用（someB） 
  } 
  } 
  }

变成：

  类 Y { 让 b：B init（string：String） 抛出 { 
  切换字符串{ 
  情况 “ foo”：b = .foo 
  情况 “栏”：b = .bar 
  默认值 ：抛出错误 
  } b.make（） 
  use（b） //再见可选链和if- lets👋 
  } 
  }

展平厄运金字塔

更准确地说， let隐含使用常数的每个代码路径的单一影响。这有助于使用do-try-catch处理抛出函数：

  func function（）{ 
  做 { 
  让 foo = 尝试 compute（“富”） 
 使用（foo） 
  做 { 
  让酒吧= 尝试计算（“酒吧”） 
 使用（栏） 
  } { 
 打印（错误） 
  返回 
  } 
  } { 
 打印（错误） 
  返回 
  } 

 东西（） 
  } func compute（string：String） 抛出 -> C

变成：

  func f（）{ let foo：任何 
  让吧：任何 
  做 { 
  foo = 试试 compute（“ foo”） 
  bar = 试试 compute（“ bar”） 
  } { 
 打印（错误） 
  返回 
  } ///至此，设置了foo和bar 
  ///或f（）从catch语句[foo，bar]返回。forEach {use（$ 0）} stuff（） 
  }

容易理解得多！

调用闭包；每次

  func collectAB（completion：（String，String，ComparisonResult）->（））{ let a = getA（） 
  让 b：字符串 
  令 c： 如果 a ==“ A” { 
  b = getB（） 
  如果 b == a { 
  c = .orderedSame 
 完成度（a，b，c） 
  返回 
  } c = compare（a，b） 
  } 其他 { 
  b = getOtherB（） 
  c = a。比较（b） 
 完成度（a，b，c） 
  } 
  }

gatherAB()有点笨。但是，很容易想到会导致编写类似条件膨胀代码的各种逻辑，从而容易忘记对completion的调用。像这里b != a 。

预先声明意图（这里获取a和b以及它们如何进行比较）可以帮助编写完整而坚固的代码：

  func collectAB（completion：（String，String，ComparisonResult）->（））{ 
  让一个：字符串 
  让 b：字符串 
  令 c：比较结果 
  如果 a ==“ A” {，则延迟 {complete（a，b，c）} a = getA（） 
  b = getB（） 
  如果 b == a { 
  c = .orderedSame; 
  返回 
  } 
  c =比较（a，b） 
  } 其他 { 
  b = getOtherB（） 
  c = a。比较（b） 
  } 
  }

在这里，这可能是矫kill过正。但是现在可以确保在所有代码路径中调用completion函数，并且如果忘记设置a ， b或c ，则会出现编译器错误。

可能不是生产代码，而是调试工具或重构步骤。

简化循环

如果您仍在阅读此书，也许是因为您想要摆脱尽可能多的var🤗
最后一个可以做到的地方是使用循环。通常：

  var accumulator =“” 
  for （[[a]，“ b”，“ c”，“ d”]中的s）{ 
 累加器+ = s 
  } 
  print（累加器） //再也不会更改 😥

在这里，使用let是不正确的，因为accumulator被多次突变（每个循环运行一次）。但是循环之后， accumulator将保持不变。与开头的if和switch示例一样，该循环是常量的唯一影响。

因此，可能可以提取一个函数以返回所需的值……希望，功能Swift可以涵盖这种情况：

  //甚至不再需要本地累加器 👌 
  print（[“ a”，“ b”，“ c”，“ d”]。reduce（“”，+））

这里reduce但显然有很多可能性，例如map和其他。

在那里，您可以找到：摆脱var新工具，更重要的是，使您的代码更具自记录性和坚固性！

你喜欢吗？

让所有的东西！

摆脱可选

展平厄运金字塔

调用闭包； 每次

简化循环

调用闭包；每次