无法检查泛型类型T: Equatable的值是否相等
泛型（Generics）是一种在编程中使用的技术，它允许我们编写可以适用于多种类型的代码。在泛型中，我们可以定义一个泛型类型T，并对其进行操作，但是在某些情况下，我们可能需要检查泛型类型T的值是否相等。
在Swift编程语言中，我们可以通过Equatable协议来实现泛型类型T的值的相等性检查。Equatable协议要求类型具有相等性运算符（==）的实现，以便比较两个值是否相等。
以下是一个示例代码，展示了如何检查泛型类型T: Equatable的值是否相等：
func checkEquality<T: Equatable>(value1: T, value2: T) -> Bool {
return value1 == value2
}
let result = checkEquality(value1: 5, value2: 5)
print(result) // 输出：true
let result2 = checkEquality(value1: "Hello", value2: "World")
print(result2) // 输出：false在上述示例中，我们定义了一个名为checkEquality的泛型函数，它接受两个参数value1和value2，这两个参数的类型都必须遵循Equatable协议。函数内部使用相等性运算符（==）来比较value1和value2的值是否相等，并返回比较结果。
对于这个问题，腾讯云提供了多个相关产品和服务，可以帮助开发者在云计算领域进行开发和部署。以下是一些相关产品和服务的介绍：
- 云服务器（ECS）：腾讯云提供的弹性云服务器，可满足各种计算需求。了解更多：云服务器产品介绍
- 云数据库MySQL版（CDB）：腾讯云提供的高性能、可扩展的云数据库服务，适用于各种应用场景。了解更多：云数据库MySQL版产品介绍
- 云原生容器服务（TKE）：腾讯云提供的容器化部署和管理服务，支持Kubernetes，帮助开发者快速构建和扩展应用。了解更多：云原生容器服务产品介绍
请注意，以上只是腾讯云提供的一些相关产品和服务的示例，更多产品和服务可以在腾讯云官网上找到。
相关·内容
3回答
我有一个叫做SomeProtocol的协议
我想创建一个函数，获取一个符合此协议的对象，并将其添加到一个数组中。
然后，我有另一个函数从这个数组中删除一个对象。
var allObjs = [SomeProtocol]()
func addObj<T: AnyObject where T: SomeProtocol>(obj: T) {
allObjs.append(obj)
}
func removeObj<T: AnyObject where T: SomeProtocol>(obj: T) {
for someObj in allObjs {
浏览 0提问于2015-07-02得票数 4
如何表示一个Swift泛型函数，该函数将T限制为Optional<Equatable>
我尝试了下面这样的方法，以及由此产生的错误。
func gen<T>(arg: T) where T : Optional<Equatable>
类型“T”受限于非协议类型“可选”
func gen<T>(arg: T) where T : OptionalProtocol<Equatable>
无法专门化非泛型类型“OptionalProtocol”
func gen<T, U>(arg: T) where T
浏览 3提问于2017-02-07得票数 6
回答已采纳
苹果的Swift 提供了以下使用泛型函数和类型参数的示例(在“行动中的类型约束”一节下)：
func findIndex<T: Equatable>(array: [T], valueToFind: T) -> Int? {
for (index, value) in enumerate(array) {
if value == valueToFind {
return index
}
}
return nil
}
这里有必要使用这两种方法吗？不是
func findIndex(array: [E
浏览 2提问于2014-10-24得票数 1
回答已采纳
我正在致力于在Swift中构建一个名为Node的灵活的数据结构，它本身并不与任何类型的内容相关联。但是，Node中的有效载荷数据被声明为符合平等协议的以下泛型元素结构：
public struct Element<T>: Equatable {
var data: T;
}
public func ==<T:Equatable>(lhs: Element<T>, rhs: Element<T>) -> Bool {
return lhs.data == rhs.data;
}
约束条件是，元素必须绑定到一个可等效的类类型。我遇
浏览 1提问于2016-02-25得票数 1
回答已采纳
我必须确定当前值是否等于给定的比较值。
public static func Is<TBaseValue, TComparingValue>(baseValue: TBaseValue, comparingValue: TComparingValue) -> Bool
{
return baseValue == comparingValue
}
我几乎要试一下这个
public static func Is<TBaseValue: Comparable, TComparingValue: Comparable>(baseValue: TBaseValue,
浏览 1提问于2015-07-17得票数 0
您可以从下面的图片中看到，我试图扩展Collection协议，以包括一个名为removingDuplicates的方法，它应该按照它所说的做。编译器显示的错误似乎与Equatable协议的定义直接矛盾。这是窃听器还是我误会了什么？
浏览 1提问于2018-03-31得票数 0
回答已采纳
import Foundation
struct NotEquable {}
struct Box<T> {
let id: Int
let value: T
}
extension Box: Equatable {
static func ==<T>(lhs: Box<T>, rhs: Box<T>) -> Bool {
return lhs.id == rhs.id
}
static func ==<T: Equatable>(lhs: Box<T>
浏览 2提问于2016-11-21得票数 3
回答已采纳
我正在尝试在Swift中创建一个泛型测试函数，用于测试一个可以改变其参数的函数。但是，我收到一个错误消息，我找不到解决的方法： public func testMutating<T: Comparable>(id: Int, input: T, output: T, testObj: (T) -> Any) {
var inputMutating = input // Make a mutable copy of input
_ = testObj(&inputMutating) // Compiler error: Argument type
浏览 15提问于2019-12-20得票数 1
回答已采纳
1回答
迅速泛型
、
我一直在使用泛型，并有这个函数，它接受一个数组并检查它是否包含给定的值.
func finder<T:Equatable>(array:[T], valueToFind:T) -> Int? {
for(index, value) in enumerate(array) {
if(value == valueToFind) {
return index
}
}
return nil
}
如果我在这个测试数组中使用它，它将完美地工作，并返回正确的索引。
var testArray = ["D
浏览 6提问于2014-08-03得票数 0
回答已采纳
我正在做exercism.io编程练习，我必须在代码上执行的测试有一个目标，那就是相互比较。练习的源代码可以在这里找到，。
据我所知，bridgeToObjectiveC是苹果内部的做事方法，因此它们被删除了。有了他们，我得到了'[S : T]' does not have a member named 'bridgeToObjectiveC'，这是非常可以理解的，如果他们已经删除它。
如果不使用仅使用AssertEquals调用中的params的方法，我将得到'[S : T]' does not conform to protocol
浏览 2提问于2014-09-29得票数 11
回答已采纳
假设我有两个变量，我不知道它们是什么类型(在运行之前也不可能知道它们是什么类型)：
var a: Any
var b: Any
如何使用Equatable协议测试它们是否相等？我不能只做a == b，因为这需要两个项都是相同的Equatable类型，而编译器不能证明这一点，因为它们可能是不同的类型(并且其中一个或两个都可能不是Equatable)。
那么，有没有可能告诉编译器检查它们是否具有相同的类型，如果该类型符合Equatable，则对它们使用==运算符并返回结果，否则返回false？
如果没有办法做到这一点，Swift是否有充分的理由阻止这一点，或者这是Swift当前的限制，可以在未来修
浏览 5提问于2016-01-20得票数 1
2回答
具有泛型枚举Result<T>
enum Result<T> {
case success(T)
case error
}
如何使其符合Swift第3版或更高版本中的Equatable协议？
我试过以下几种方法：
extension Result: Equatable {
static func ==<T: Equatable>(lhs: Result<T>, rhs: Result<T>) -> Bool {
switch (lhs, rhs) {
case let (
浏览 2提问于2017-07-08得票数 4
回答已采纳
1回答
我现在学得很快。当我学习的时候，我被仿制药困住了。我正在解决数组中指定元素的->返回索引这一简单问题
import UIKit
extension Array
{
func indexOfLetter<T:Equatable>(item:T) -> Int
{
var i = 0
for (index, value) in enumerate(self)
{
if value == item
{
return i
}
i++
}
retu
浏览 2提问于2015-06-25得票数 2
回答已采纳
非常奇怪，但是下面的代码不起作用，我收到了一条消息：“来自非协议、非类类型'String‘的继承”。也不适用于其他所有的基本类型，如Int、Bool等，但它适用于平等类型。我不明白有什么问题。
import Cocoa
import Foundation
class Foo<T: String> {}
浏览 2提问于2014-11-25得票数 1
回答已采纳
1回答
我有一个关于协议关联类型的问题。
这是密码..。
protocol TestProtocol {
associatedtype T: Equatable
}
struct Test {
let value: TestProtocol
}
它有一个错误。
struct Test<T: TestProtocol> {
let value: T
}
没什么大不了的。但我不想在struct中使用泛型。
所以我试了..。
protocol IntTestProtocol: TestProtocol where T == Int {
}
struct Test
浏览 1提问于2020-05-27得票数 0
回答已采纳
1回答
斯威夫特通用阵列等效浇铸
、、、
我有一个AAA类，它包含一个泛型数组。因为项目不能等同，所以我不把它编码为class AAA<Item: Equatable>。
我想在AAA类中添加一个remove函数，当项是相等的时，它是可用的。通过调用这个函数，它将在Array扩展中调用一个函数。
由于项在默认情况下是不可等价物的，所以以下代码无法编译。
class AAA<Item>
{
var items = [Item]()
func remove(item: Item)
{
items.remove(object: item)
}
}
exten
浏览 1提问于2017-06-09得票数 1
回答已采纳
我目前正在尝试一些基本的数据结构，比如LinkedList。我定义了一个泛型值的ListNode类，如下所示：
class ListNode<T> {
var nodeContent: T
var nextNode: ListNode<T>? = nil
init() {
// details omitted here
}
然后是链表。我想实现contains()方法，所以我有这样的东西：
func contains<T>(_ item: T) -> Bool {
var currNode = self.
浏览 2提问于2017-01-12得票数 1
回答已采纳
1回答
“！=”运算符的歧义用法
、、、
因此，我试图在使用CGPoint时，将gat、CGVector和CGSize很好地应用于自己。它们都是带有垂直和水平分量(向量)的结构。所以我制定了一个协议：VectorType
protocol VectorType {
init(x: CGFloat, y: CGFloat)
var x: CGFloat { get set }
var y: CGFloat { get set }
}
当然，我扩展了这3种结构以符合协议，并将x和y连接到每个结构的水平和垂直组件-- x返回dx表示CGVector (设置相同)，x返回width表示CGSize，而对于CGPoin
浏览 3提问于2016-06-14得票数 3
我正在尝试检测@State变量上的更改，以更新某些文本，但由于.onChange修饰符抛出了此错误，因此无法正常工作：
无法将“Double”类型的值转换为预期的参数类型“()”
struct CalcView: View {
@State private var width = 0.0
var body: some View {
VStack {
Button(action: {
width += 1.0
}, label: {
Text(
浏览 10提问于2022-07-17得票数 0
回答已采纳
2回答
任何类型和泛型之间的区别是什么？
任何类型的示例：
let swiftInt: Int = 1
let swiftString: String = "miao"
var array: [Any] = []
array.append(swiftInt)
array.append(swiftString)
泛型类型示例：
func duplicate<T>(item: T, numberOfTimes n: Int) -> [T] {
var buffer : [T] = []
for _ in 0 ..< n {
buffer.appen
浏览 1提问于2016-07-10得票数 1
回答已采纳
1回答
我试图在Swift中为array实现一个简单的扩展函数，它将“切换”元素--如果该值已经在Array中，则应该删除它，如果没有这样的值，则应该将其添加到数组中。
所以我想应该是这样的：
extension Array {
mutating func toggle(value: Element) {
if let index = indexOf(value) {
removeAtIndex(index)
} else {
append(value)
}
}
}
此代码不会生成这样的
浏览 7提问于2015-10-06得票数 3
回答已采纳
考虑这个例子
public interface Equatable<T> {
public boolean equal(T t1, T t2);
}
public class Square implements Equatable<Square> {
public boolean equal(Square t1, Square t2) {
return false;
}
}
接口Equatable是否有可能强制Square实现一个相等的函数，该函数接受两个Squar
浏览 0提问于2020-10-10得票数 1
当参数化类从符合Equatable的另一个类继承时，==调用超类的==。有人能解释一下为什么会发生这样的事情吗?或者我怎么会在这里做错事？我相信有一个例子最能说明我的问题：
public class Foo: Equatable {}
public func ==(lhs: Foo, rhs: Foo) -> Bool { return false }
//Parametrized
public class Bar<T: Equatable>: Foo {
public var bar: T?
public init(barIn: T?) {
self.ba
浏览 4提问于2015-12-07得票数 7
回答已采纳
当泛型参数具有可比性时，我需要对其进行比较，如下所示：
class MyClass<Item> {
var items: [[Items]]? {
didSet {
if Item is Equatable {
print(oldValue == items)
} else {
print(false)
}
}
}
}
我如何才能做到这一点？
我也尝试过：
extension TableV
浏览 0提问于2017-08-01得票数 0
这两种声明泛型超类的方法有什么区别？
func foo<T: SomeClass>(object: T) -> Array<T>
func foo<T>(object: T) -> Array<T> where T: SomeClass
浏览 5提问于2017-10-18得票数 17
回答已采纳
根据苹果发布的快速编程语言(SWIFT3.0.1) iBook，比较运算符也适用于元组，只要它们不包含布尔值。以下声明如下：
let t1 = (1, true)
let t2 = (1, true)
下面的句子按预期抛出一个错误
t1 <= t2
现在还没有
y1 == t2
计算结果为真，这似乎与上述说法相矛盾。有什么想法吗？
浏览 4提问于2017-01-19得票数 1
回答已采纳
2回答
因此，我想将两本相同类型的字典[AnyLanguage: SortedList<String>]等同起来。
AnyLanguage符合Hashable，因此也符合Equatable，所以这不是一个问题。另一方面，SortedList不符合Equatable，因为它在Element上是通用的，它没有任何限制：
public struct SortedList<Element> { ... }
现在，我已经为SortedList实现了相等操作符，当它的Elements符合Equatable时
public func ==<T: Equatable>(left:
浏览 7提问于2016-01-10得票数 0
回答已采纳
3回答
在C++中，有人可以编写以下代码：
#include <type_traits>
template <typename Type1, typename Type2>
bool TestArgumentTypesOnEquality(Type1 argument1, Type2 argument2)
{
return std::is_same<Type1, Type2>::value;
}
std::is_same类模板检查Type1和Type2 (这是TestArgumentTypesOnEquality函数模板参数的类型)是否相等。
是否有类似于
浏览 4提问于2016-06-08得票数 3
回答已采纳
2回答
我想介绍一个协议，它将强制我的枚举具有返回相同类型枚举的变量next。然后我希望能够调用方法来比较两个枚举。
protocol MySequenceProtocol {
associatedtype T
var next: T { get }
}
func compareNext<T: MySequenceProtocol>(input: T, target: T) {
if input.next == target {
print("match")
}
}
compareNext(input: Weekdays.m
浏览 5提问于2021-09-01得票数 1
问这个问题是为了澄清我对类型类和更高级类型的理解，我并不是在寻找Java中的变通方法。
在Haskell中，我可以这样写
class Negatable t where
negate :: t -> t
normalize :: (Negatable t) => t -> t
normalize x = negate (negate x)
然后假设Bool有一个Negatable的实例，
v :: Bool
v = normalize True
一切都很好。
在Java语言中，似乎不可能声明一个适当的Negatable接口。我们可以这样写：
interface
浏览 60提问于2018-08-08得票数 51
回答已采纳
为什么最后一条语句不能用错误进行编译：Binary operator '==' cannot be applied to two '[[Simple]]’ operands，是否有一种方法可以修改Simple结构或扩展==操作符，以便能够对嵌套数组(或字典)执行相等检查？
var i1: [Int] = [1]
var i2: [Int] = [1]
i1 == i2 // -> true
var i3: [[Int]] = [[1], [2]]
var i4: [[Int]] = [[1], [2]]
i3 == i4 // -> true
str
浏览 5提问于2015-10-27得票数 11
回答已采纳
1回答
我正在尝试创建一个很好的通用包装器，用于获取和处理数据。这样做的目的是，模型可以实现协议，因此可以与我的通用包装器兼容，但我在这样做时遇到了一些问题。
我已经注意到，Codable协议的行为方式与我希望的协议一样，它看起来就像继承Codable的对象数组被视为符合标准的数据类型。然而，对于我创建的协议来说，情况似乎并非如此。
以下是我想要达到的目标：
protocol MyProtocol {
static var name: String { get }
}
class MyService<T: MyProtocol> {
let otherService = MyOt
浏览 2提问于2019-12-30得票数 1
回答已采纳
我正在使用模板项目来尝试构建一个新的应用程序。当我运行模板项目时，我得到一个错误消息：'T没有名为'indexOf‘的成员。
Array+RemoveObject.swift文档中的现有代码是：
import Foundation
public func removeObject<T: Equatable>(object: T, inout fromArray array: [T])
{ let index = array.indexOf(object)
if let index = index {
array.removeAtIndex(i
浏览 3提问于2016-01-04得票数 0
5回答
func getIndex<T: Equatable>(valueToFind: T) -> Int? {...}
mutating func replaceObjectWithObject<T: Equatable>(obj1: T, obj2: T) {
if let index = self.getIndex(obj1) {
self.removeAtIndex(index)
self.insert(obj2, atIndex: index) // Error here: 'T'
浏览 0提问于2014-09-03得票数 5
2回答
这是我正在使用的协议，
public protocol PValidationCondition: Equatable {
associatedtype T
func isValid(value: T) -> Bool
func errorMessage() -> String
}
这是我使用的模型：
struct PValidationElementWithConditions<T: PValidationCondition> {
let validationElement: PValidationElement
var con
浏览 0提问于2018-08-10得票数 2
我需要得到一个库的通用类型的列表，以筛选它们的某些特性。我试图测试接口实现是否正确地实现了接口契约，并试图列出从该接口继承的所有类型，但是接口包含一个泛型参数。
我认为这种方法存在的问题是，如果测试/程序集不生成泛型类型的实例，它将不包含对该类型的引用。
我已经发现：
除非我知道类型：getting程序集中的所有类型都不包括泛型类型，我在下面做了一个测试用例证明了这一事实。
public class MyClass<T>
{
public T t { get; set; }
public MyClass(T t)
{
浏览 4提问于2020-08-26得票数 0
回答已采纳
4回答
我一直在关注一篇关于这个的扩展方法的文章
public static IEnumerable<T> Distinct<T,TKey>(this IEnumerable<T> list, Func<T,TKey> lookup) where TKey : struct {
return list.Distinct(new StructEqualityComparer<T, TKey>(lookup));
}
class StructEqualityComparer<T,TKey> : IEquali
浏览 0提问于2011-12-28得票数 2
回答已采纳
我有一个类似于这个类的泛型类：
class C<T: Equatable> {
let t: T
init(t: T) {
self.t = t
}
}
当我试图将Int?包装在里面时，我会得到以下错误：
// ERROR: Type "Int?" does not conform to protocol 'Equatable'
let c = C<Int?>(t: nil)
快速测试表明，Int?确实是Equatable
let a: Int? = 5
let b: Int? = 6
l
浏览 6提问于2016-02-29得票数 3
回答已采纳
我对用于协议的关联类型和泛型类型的语法之间的差异感到困惑。
例如，在Swift中，可以使用以下内容定义泛型类型
struct Stack<T> {
var items = [T]()
mutating func push(item: T) {
items.append(item)
}
mutating func pop() -> T {
return items.removeLast()
}
}
而使用下面的内容定义一个具有相关类型的协议
protocol Container {
associat
浏览 0提问于2014-10-25得票数 80
回答已采纳
2回答
下面是我在网上找到的堆栈实现
public struct Stack<T> {
fileprivate var array = [T]()
public var isEmpty: Bool {
return array.isEmpty
}
public var count: Int {
return array.count
}
public mutating func push(_ element: T) {
array.append(element)
}
public mutating func pop() ->
浏览 3提问于2018-03-20得票数 1
回答已采纳
1回答
我有许多不同的枚举，例如：
enum Fruit {
case apple, pear, banana, melon
}
enum Wood {
case oak, birch, mahogany
}
我想编写一个静态函数来比较两个指定的泛型枚举值是否相同。
funct myCmp<T>(a: T, b: T) -> Bool {
return a == b // cannot compare generic types
}
如何做到这一点？在Java中，这很容易做到，不需要任何额外的代码，这就是我感到困惑的原因。
浏览 0提问于2019-09-11得票数 0
2回答
我有一个Equatable课程
class Item: Equatable {
var value: AnyObject?
var title: String
init(title: String, value: AnyObject?) {
self.title = title
self.value = value
}
//Equatable
public static func ==(lhs: Item, rhs: Item) -> Bool {
return ((lhs.title ==
浏览 3提问于2017-08-31得票数 4
回答已采纳
2回答
考虑以下简化的代码片段：
class Foo<T: Equatable> {
var x: T
init(_ x: T, _ y: T) {
self.x = x
if (x == y) {
// do something
}
}
}
我希望这个类适用于所有类型的T，它们在某种程度上是可比较的。理想情况下，如果T是一个对象，它将比较身份，并直接比较符合Equatable的所有其他内容。
例如，上面的代码不适用于Array。如果我将Equatable更改为AnyObject，将==更改为=
浏览 0提问于2016-01-27得票数 2
1回答
我已经为不同的项编写了一个数组扩展
extension Array {
func distinct<T: Equatable>() -> [T]{
var unique = [T]()
for i in self{
if let item = i as? T {
if !unique.contains(item){
unique.append(item)
}
}
}
浏览 1提问于2016-02-09得票数 4
回答已采纳
我知道我无法在Java中抛出或捕获泛型类的实例，例如，以下代码编译错误：
public static <T extends Throwable> void test(Class<T> t){
try{
//do work
}
catch (T e){// ERROR--can't catch type variable
Logger.global.info(...)
}
}
有人能解释Java禁止抛出或捕获泛型类实例的确切原因吗？
浏览 2提问于2015-11-14得票数 5
回答已采纳
编辑:从目前为止添加的答案和评论来看，我还没有正确地解释我想要什么。下面是一个示例：
// type not supporting any type of comparison
[<NoEquality>]
[<NoComparison>]
type blah () =
member x.huha = 0
// make a map, turns out to work whether x supports equality or not
let inline tt x =
Map.ofList [1, x]
let test () =
浏览 2提问于2014-03-10得票数 4
回答已采纳
来自
SequenceEqual(IEnumerable，IEnumerable)方法并行枚举两个源序列，并使用默认的TSource ( Default )相等比较器比较相应的元素。默认相等比较器Default用于比较实现IEqualityComparer通用接口的类型的值。
( a)正如我所理解的，这意味着EqualityComparer<T>.Default用于比较实现IEqualityComparer<T>的类型的元素，而实际上Default用于返回调用IEquatable<T>.Equals (假设T可分配给IEquatable<T&g
浏览 8提问于2011-04-19得票数 3
回答已采纳
我在试着理解我做错了什么。
我创建的泛型类与下面的类似(不要注意代码的用途，它只是显示错误)
我需要定义'+‘对于A类的两个实例意味着什么。不幸的是，斯威夫特抱怨
无法将“A”类型的值转换为预期的参数类型“A<_>”
为
public static func +(lhs: A<T>, rhs: A<T>) -> A<T> {
return A.foobar(lhs: lhs, rhs: rhs, operation: +);
}
我也不知道为什么..。
下面是代码：
import Foundation
浏览 0提问于2018-04-23得票数 1
回答已采纳
我在试这个 struct Foo<T: Equatable> {
let object: T
}
extension Array where Element == Foo { // this lines give me error tried Foo<T> but didn't work
func updateElement(element: Element) {
// Do the stuff
}
} 它给了我一个错误：Reference to generic type 'Foo' require
浏览 27提问于2020-11-18得票数 0
回答已采纳
1回答
我想确定提供给泛型类的泛型类型。例如，假设我有一个联合类型，我想根据所使用的类型在构造函数中采取不同的操作：
type MyType = string | number;
class Foo<T extends MyType>{
private _something;
constructor(_bar?: SomeFunc<T>){
if(...)?
}
}
从中，我知道我可以确定函数的参数类型，但是我似乎找不到一种方法来检查提供给实际类的泛型的类型。试图以任何方式引用T都会导致“无法找到名称'T‘错误”(# t
浏览 4提问于2016-04-28得票数 1
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
实时音视频
即时通信 IM活动推荐
腾讯云开发者
