在这里，我们将给大家分享关于Swift(UI)中的“some”关键字是什么？的知识，让您更了解swift关键字及作用的本质，同时也会涉及到如何更有效地AWESOMESWIFT-swift.libhun

在这里，我们将给大家分享关于Swift(UI) 中的“some”关键字是什么？的知识，让您更了解swift 关键字及作用的本质，同时也会涉及到如何更有效地AWESOME SWIFT-swift.libhunt.com-swift类库网站、C# 中的上下文关键字是什么？、C语言中的 auto 关键字是什么？、Go 语言中的 defer 关键字是什么？的内容。

• Swift(UI) 中的“some”关键字是什么？（swift 关键字及作用）
• AWESOME SWIFT-swift.libhunt.com-swift类库网站
• C# 中的上下文关键字是什么？
• C语言中的 auto 关键字是什么？
• Go 语言中的 defer 关键字是什么？

Swift(UI) 中的“some”关键字是什么？（swift 关键字及作用）

新的SwiftUI 教程有以下代码：

struct ContentView: View {    var body: some View {        Text("Hello World")    }}

第二行单词some, and 在他们的网站上突出显示，就好像它是一个关键字一样。

Swift 5.1 似乎没有some作为关键字，而且我看不出该词some在那里还能做什么，因为它位于类型通常所在的位置。是否有新的未发布版本的
Swift？它是以我不知道的方式在类型上使用的函数吗？

关键字some有什么作用？

答案1

some View是SE-0244引入的不透明结果类型，可在 Swift 5.1 和 Xcode 11
中使用。您可以将其视为“反向”通用占位符。

与调用者满意的常规通用占位符不同：

protocol P {}struct S1 : P {}struct S2 : P {}func foo<T : P>(_ x: T) {}foo(S1()) // Caller chooses T == S1.foo(S2()) // Caller chooses T == S2.

不透明的结果类型是 实现 满足的隐式通用占位符，因此您可以这样想：

func bar() -> some P {  return S1() // Implementation chooses S1 for the opaque result.}

看起来像这样：

func bar() -> <Output : P> Output {  return S1() // Implementation chooses Output == S1.}

事实上，这个特性的最终目标是允许反向泛型以这种更明确的形式出现，这也可以让你添加约束，例如-> <T : Collection> T whereT.Element == Int. 有关更多信息，请参阅此帖子。

主要的一点是，some P返回的函数是 返回 符合P. 尝试在函数中返回不同的符合类型会产生编译器错误：

// error: Function declares an opaque return type, but the return// statements in its body do not have matching underlying types.func bar(_ x: Int) -> some P {  if x > 10 {    return S1()  } else {    return S2()  }}

由于隐式通用占位符不能满足多种类型。

这与返回的函数形成对比，该函数P可用于表示 两者 S1，并且S2因为它表示任意P符合要求的值：

func baz(_ x: Int) -> P {  if x > 10 {    return S1()  } else {    return S2()  }}

好的，那么不透明的结果类型-> some P比协议返回类型有什么好处-> P？

1. 不透明的结果类型可以与 PAT 一起使用

当前协议的一个主要限制是
PAT（具有关联类型的协议）不能用作实际类型。尽管这一限制可能会在该语言的未来版本中取消，但由于不透明结果类型实际上只是通用占位符，它们现在可以与 PAT
一起使用。

这意味着您可以执行以下操作：

func giveMeACollection() -> some Collection {  return [1, 2, 3]}let collection = giveMeACollection()print(collection.count) // 3

2. 不透明的结果类型有标识

因为不透明结果类型强制返回单个具体类型，所以编译器知道对同一函数的两次调用必须返回相同类型的两个值。

这意味着您可以执行以下操作：

//   foo() -> <Output : Equatable> Output {func foo() -> some Equatable {   return 5 // The opaque result type is inferred to be Int.}let x = foo()let y = foo()print(x == y) // Legal both x and y have the return type of foo.

这是合法的，因为编译器知道两者x并且y具有相同的具体类型。这是一个重要的要求==，其中两个参数的类型Self。

protocol Equatable {  static func == (lhs: Self, rhs: Self) -> Bool}

这意味着它期望两个值都与具体的符合类型相同。即使Equatable可用作类型，您也无法将两个任意Equatable符合的值相互比较，例如：

func foo(_ x: Int) -> Equatable { // Assume this is legal.  if x > 10 {    return 0  } else {    return "hello world"        }}let x = foo(20)let y = foo(5)print(x == y) // Illegal.

由于编译器无法证明两个任意Equatable值具有相同的底层具体类型。

以类似的方式，如果我们引入另一个不透明类型的返回函数：

//   foo() -> <Output1 : Equatable> Output1 {func foo() -> some Equatable {   return 5 // The opaque result type is inferred to be Int.}//   bar() -> <Output2 : Equatable> Output2 {func bar() -> some Equatable {   return "" // The opaque result type is inferred to be String.}let x = foo()let y = bar()print(x == y) // Illegal, the return type of foo != return type of bar.

该示例变得非法，因为尽管foo和都bar返回someEquatable，但它们的“反向”通用占位符Output1可以满足Output2不同的类型。

3. 不透明的结果类型由通用占位符组成

与常规的协议类型值不同，不透明的结果类型与常规的通用占位符组合得很好，例如：

protocol P {  var i: Int { get }}struct S : P {  var i: Int}func makeP() -> some P { // Opaque result type inferred to be S.  return S(i: .random(in: 0 ..< 10))}func bar<T : P>(_ x: T, _ y: T) -> T {  return x.i < y.i ? x : y}let p1 = makeP()let p2 = makeP()print(bar(p1, p2)) // Legal, T is inferred to be the return type of makeP.

makeP如果刚刚返回，这将不起作用P，因为两个P值可能具有不同的底层具体类型，例如：

struct T : P {  var i: Int}func makeP() -> P {  if .random() { // 50:50 chance of picking each branch.    return S(i: 0)  } else {    return T(i: 1)  }}let p1 = makeP()let p2 = makeP()print(bar(p1, p2)) // Illegal.

为什么在具体类型上使用不透明的结果类型？

此时你可能会想，为什么不把代码写成：

func makeP() -> S {  return S(i: 0)}

好吧，不透明结果类型的使用允许您S通过仅公开由
提供的接口来使该类型成为实现细节P，从而使您可以灵活地在以后更改具体类型，而不会破坏任何依赖于该函数的代码。

例如，您可以替换：

func makeP() -> some P {  return S(i: 0)}

和：

func makeP() -> some P {   return T(i: 1)}

不破坏任何调用makeP().

有关此功能的更多信息，请参阅语言指南的不透明类型部分和Swift
进化提案。

AWESOME SWIFT-swift.libhunt.com-swift类库网站

C# 中的上下文关键字是什么？

在C#中，一些标识符在代码上下文中具有特殊含义，例如get和set被称为上下文关键字。

以下是显示上下文关键字的表格：

以上就是C# 中的上下文关键字是什么？的详细内容，更多请关注php中文网其它相关文章！

C语言中的 auto 关键字是什么？

在C语言中，每个函数的局部变量都被称为自动(auto)变量。在函数块内部声明的变量被称为局部变量。本地变量也被称为自动变量。在变量的数据类型前使用auto关键字是可选的。如果本地变量中没有存储任何值，那么它就由一个垃圾值组成。

Go 语言中的 defer 关键字是什么？

go 语言中的 defer 关键字是什么？

在编写程序时，我们经常需要在某个函数或方法执行完毕后，执行一些清理或资源释放工作。这个时候，Go 语言提供了一种方便的机制，通过使用 defer 关键字，可以将这些清理或资源释放工作推迟到函数或方法返回之前执行。

defer 关键字是一个编译时解析的语法糖，它通过将一个函数或方法的调用推迟到当前函数或方法返回之前执行，来实现在程序执行结束前，释放资源或执行清理工作的目的。defer 关键字可以出现在一个函数或方法中的任何位置，并且可以有多个 defer 语句，这些语句的执行顺序是倒序的。

defer func() {
// defer 延迟执行的代码
}()

示例中的 defer 语句将要执行的函数定义在匿名函数中，可以是任意的函数或方法调用。defer 后的左括号必须紧跟着 defer 关键字，右括号则在要执行的代码的末尾，这样才能确保正确的语法结构。

defer 关键字的使用场景不仅仅是在释放资源或执行清理工作方面。它还可以用来监控函数或方法的执行情况，使用defer 来记录函数或方法在调用前后的时间戳，可以轻松地记录函数或方法执行花费的时间。

func someFunction() {
start := time.Now() // 记录起始时间
defer func() {

", elapsed)
}()

// someFunction 的主要逻辑
}

在上面的示例中，someFunction 在执行返回后会输出执行花费的时间。这种监控函数或方法性能的方式非常实用，可以帮助我们更好地了解程序的性能瓶颈所在，并作出调整和改进。

defer 关键字也可以使用在 panic 和 recover 处理中，当程序发生 panic 时，可以通过 defer 语句中的 recover 语句把程序恢复到正常状态。

func someFunction() {
defer func() {

}()

// someFunction 的主要逻辑
}

在上面的示例中，someFunction 在发生 panic 时会输出 panic 的错误信息，这样我们可以及时处理程序的错误，并且让程序尽量保持正常运行状态。

总结来说，Go 语言中的 defer 关键字是用来推迟某个函数或方法的执行，处理资源释放或清理工作，监控函数或方法执行情况，处理 panic 和 recover 等方面的一个实用工具。它既能提高程序的效率和性能，也能提高程序的可靠性和健壮性，因此在编写程序时，使用 defer 关键字是一个非常好的选择。

以上就是Go 语言中的 defer 关键字是什么？的详细内容，更多请关注php中文网其它相关文章！

今天关于Swift(UI) 中的“some”关键字是什么？和swift 关键字及作用的讲解已经结束，谢谢您的阅读，如果想了解更多关于AWESOME SWIFT-swift.libhunt.com-swift类库网站、C# 中的上下文关键字是什么？、C语言中的 auto 关键字是什么？、Go 语言中的 defer 关键字是什么？的相关知识，请在本站搜索。