【iOS】copy&strong原理+深浅拷贝+完全拷贝

cheng_lin02012024-08-03 8:12

Copy&Strong原理

Copy探究

在回答copy的各种问题前，我们需要先了解我们为什么要使用copy。

    1. 拷贝的目的 ： 产生一个副本对象，跟源对象互不影响
    • 修改了源对象，不会影响副本对象
    • 修改了副本对象，不会影响源对象
    1. iOS提供了2个拷贝方法
      1. copy，不可变拷贝，产生不可变副本
      1. mutableCopy， 可变拷贝，产生可变副本
    1. 深拷贝和浅拷贝
      1. 深拷贝 ： 内容拷贝，产生新的对象
      1. 浅拷贝 ： 指针拷贝， 没有产生新的对象

下面是是6个test，分别是 可变/不可变 的 字符串/数组/字典 对应的 copy和mutableCopy操作。
复习的时候都不用看，直接看结论，想清楚都很简单

test1

对不可变字符串进行copy&mutableCopy操作

objc 复制代码 
void test1()
{
	NSString *str1 = [NSString stringWithFormat:@"test"];
	NSString *str2 = [str1 copy]; // 返回的是NSString
	NSMutableString *str3 = [str1 mutableCopy]; // 返回的是NSMutableString
	NSLog(@"%p %p %p", str1, str2, str3);
}

我们根据打印的地址可以看出不可变字符串在copy时是浅拷贝，只拷贝了指针没有拷贝对象；mutableCopy则是深拷贝，产生了新的对象

test2

对可变字符串进行copy&mutableCopy操作

objc 复制代码 
void test2()
{
	NSMutableString *str1 = [[NSMutableString alloc] initWithFormat:@"test"]; // 1
	NSString *str2 = [str1 copy]; // 深拷贝
	NSMutableString *str3 = [str1 mutableCopy]; // 深拷贝
	NSLog(@"%p %p %p", str1, str2, str3);
}

我们根据打印的地址可以看出对于可变字符串不论是copy还是mutableCopy都是深拷贝

test3

对不可变数组进行copy&mutableCopy操作

objc 复制代码 
void test3()
{
	NSArray *array1 = [[NSArray alloc] initWithObjects:@"a", @"b", nil];
	NSArray *array2 = [array1 copy]; // 浅拷贝
	NSMutableArray *array3 = [array1 mutableCopy]; // 深拷贝

	NSLog(@"%p %p %p", array1, array2, array3);
}

我们根据打印的地址可以看出不可变数组在copy时是浅拷贝，只拷贝了指针没有拷贝对象；mutableCopy则是深拷贝，产生了新的对象

test4

对可变数组进行copy&mutableCopy操作

objc 复制代码 
void test4()
{
	NSMutableArray *array1 = [[NSMutableArray alloc] initWithObjects:@"a", @"b", nil];
	NSArray *array2 = [array1 copy]; // 深拷贝
	NSMutableArray *array3 = [array1 mutableCopy]; // 深拷贝

	NSLog(@"%p %p %p", array1, array2, array3);
}

我们根据打印的地址可以看出对于可变数组不论是copy还是mutableCopy都是深拷贝

test5

对不可变字典进行copy&mutableCopy操作

objc 复制代码 
void test5()
{
	NSDictionary *dict1 = [[NSDictionary alloc] initWithObjectsAndKeys:@"jack", @"name", nil];
	NSDictionary *dict2 = [dict1 copy]; // 浅拷贝
	NSMutableDictionary *dict3 = [dict1 mutableCopy]; // 深拷贝

	NSLog(@"%p %p %p", dict1, dict2, dict3);
}

我们根据打印的地址可以看出不可变字典在copy时是浅拷贝，只拷贝了指针没有拷贝对象；mutableCopy则是深拷贝，产生了新的对象

test6

对可变字典进行copy&mutableCopy

objc 复制代码 
void test6()
{
	NSMutableDictionary *dict1 = [[NSMutableDictionary alloc] initWithObjectsAndKeys:@"jack", @"name", nil];
	NSDictionary *dict2 = [dict1 copy]; // 深拷贝
	NSMutableDictionary *dict3 = [dict1 mutableCopy]; // 深拷贝

	NSLog(@"%p %p %p", dict1, dict2, dict3);

}

结论

只要记住copy的目的是为了，修改拷贝后的数据不影响拷贝前的数据，修改拷贝前的数据不影响拷贝后的数据，结论都可以退出来

  1. 三个容器的结论都是一样的
  2. 只有不可变容器使用不可变拷贝（copy）时，才会浅拷贝。 因为只有这样，修改数据才不会相互影响
  3. 除了上述情况，其他情况都是深拷贝

让自己的类用 copy 修饰符

我们copy属性一般只对NSString NSArray NSDictionary NSSet等这些可用，假如我们要对我们的类对象进行copy实现，我们应该怎么做呢?

若想令自己所写的对象具有拷贝功能，则需实现 NSCopying 协议。如果自定义的对象分为可变版本与不可变版本，那么就要同时实现 NSCopying 与 NSMutableCopying 协议。

copy&strong实现原理

两者的区别

  • copy:用该修饰符进行修饰的属性,在调用该属性的set方法时,会进行一次copy操作,新开辟一块内存区域,所以原对象指针指向的内存区域值被修改不会造成影响.因为做了一次深拷贝.
  • strong:用该修饰符进行修饰的属性,引用计数+1,但仅仅拷贝了指针,实际跟原指针指向同一块内存区域,所以原指针指向的内存区域值被修改之后,新的对象值也会被修改.这里仅仅是浅拷贝.

copy内部做了什么处理

现在来看下到底copy到底是做了什么,才能保证值是不可变的.

这里我们通过clang的编译命令将oc文件编译成底层的c++源码一探究竟.通过命令xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc xxx.m将对应的.m文件编译成c++文件xxx.cpp,由于编译后会产生很多系统的代码,这里我们只贴上我们自己写的代码:

objc 复制代码 
  static void _I_ViewController_testStringCopy(ViewController * self, SEL _cmd) {

    NSMutableString *mut = ((NSMutableString * _Nonnull (*)(id, SEL, NSString * _Nonnull))(void *)objc_msgSend)((id)objc_getClass("NSMutableString"), sel_registerName("stringWithString:"), (NSString *)&__NSConstantStringImpl__var_folders_50__967f2m57k5dkqm4fm300hwr0000gn_T_ViewController_574830_mi_3);
    
    ((void (*)(id, SEL, NSString *))(void *)objc_msgSend)((id)self, sel_registerName("setCopyedStr:"), (NSString *)mut);
    ((void (*)(id, SEL, NSString *))(void *)objc_msgSend)((id)self, sel_registerName("setStrongStr:"), (NSString *)mut);
    
    ((void (*)(id, SEL, NSString * _Nonnull))(void *)objc_msgSend)((id)mut, sel_registerName("appendString:"), (NSString *)&__NSConstantStringImpl__var_folders_50__967f2m57k5dkqm4fm300hwr0000gn_T_ViewController_574830_mi_4);
    
    NSLog((NSString *)&__NSConstantStringImpl__var_folders_50__967f2m57k5dkqm4fm300hwr0000gn_T_ViewController_574830_mi_5, ((NSString *(*)(id, SEL))(void *)objc_msgSend)((id)self, sel_registerName("copyedStr")));
    NSLog((NSString *)&__NSConstantStringImpl__var_folders_50__967f2m57k5dkqm4fm300hwr0000gn_T_ViewController_574830_mi_6, ((NSString *(*)(id, SEL))(void *)objc_msgSend)((id)self, sel_registerName("strongStr")));

}

static NSString * _I_ViewController_copyedStr(ViewController * self, SEL _cmd) { return (*(NSString **)((char *)self + OBJC_IVAR_$_ViewController$_copyedStr)); }
extern "C" __declspec(dllimport) void objc_setProperty (id, SEL, long, id, bool, bool);

static void _I_ViewController_setCopyedStr_(ViewController * self, SEL _cmd, NSString *copyedStr) { objc_setProperty (self, _cmd, __OFFSETOFIVAR__(struct ViewController, _copyedStr), (id)copyedStr, 0, 1); }

static NSString * _I_ViewController_strongStr(ViewController * self, SEL _cmd) { return (*(NSString **)((char *)self + OBJC_IVAR_$_ViewController$_strongStr)); }
static void _I_ViewController_setStrongStr_(ViewController * self, SEL _cmd, NSString *strongStr) { (*(NSString **)((char *)self + OBJC_IVAR_$_ViewController$_strongStr)) = strongStr; }

这里注意下这两个属性的set方法的实现

objc 复制代码 
static void _I_ViewController_setCopyedStr_(ViewController * self, SEL _cmd, NSString *copyedStr) { objc_setProperty (self, _cmd, __OFFSETOFIVAR__(struct ViewController, _copyedStr), (id)copyedStr, 0, 1); }

static void _I_ViewController_setStrongStr_(ViewController * self, SEL _cmd, NSString *strongStr) { (*(NSString **)((char *)self + OBJC_IVAR_$_ViewController$_strongStr)) = strongStr; }

这里可以看出使用copy修饰的属性跟strong修饰的属性底层的set实现是不同的,strong的实现就是根据地址偏移找到对应的实例变量,然后直接赋值,所以当对象的指针指向的内存区域被修改之后,属性值也会同步被修改。

而使用copy修饰的其set方法内部调用了extern "C" __declspec(dllimport) void objc_setProperty (id, SEL, long, id, bool, bool);这个函数,第一个参数为属性的实例对象,第二个参数为SEL方法,第三个参数offset,是相对于self的偏移,用来找对应的成员变量的,第四个是新值,第五个是是否为原子性atomic,最后一个为是否需要进行copy操作。

通过clang编译出来的源码目前只能看到这个程度,我们需要去苹果OC源码地址(将oc的源码下载下来,打开工程去查看对应的函数实现)去查看objc_setProperty这个函数的具体实现才能知道内部做了什么操作。

通过查看源码,objc_setProperty具体实现如下

objc 复制代码 
   void objc_setProperty(id self, SEL _cmd, ptrdiff_t offset, id newValue, BOOL atomic, signed char shouldCopy) 
{
    bool copy = (shouldCopy && shouldCopy != MUTABLE_COPY);
    bool mutableCopy = (shouldCopy == MUTABLE_COPY);
    reallySetProperty(self, _cmd, newValue, offset, atomic, copy, mutableCopy);
}

在上面编译出来的c++源码中能看到系统调用这个函数的时候, shouldCopy设置的是1(最后一个参数)

objc 复制代码 
static void _I_ViewController_setCopyedStr_(ViewController * self, SEL _cmd, NSString *copyedStr) { objc_setProperty (self, _cmd, __OFFSETOFIVAR__(struct ViewController, _copyedStr), (id)copyedStr, 0, 1); }

所以这里告诉系统,这个对象需要进行拷贝。

objc 复制代码 
bool copy = (shouldCopy && shouldCopy != MUTABLE_COPY);
bool mutableCopy = (shouldCopy == MUTABLE_COPY);

这里是有两个copy标识的,当shouldCopy=1,并且不是mutable copy时需要copy操作,如果shouldCopy为mutable copy时,进行mutable copy操作(这里的MUTABLE_COPY就是个宏定义#define MUTABLE_COPY 2)。

接下来看实际内部真正实现的函数reallySetProperty:

objc 复制代码 
static inline void reallySetProperty(id self, SEL _cmd, id newValue, ptrdiff_t offset, bool atomic, bool copy, bool mutableCopy)
{
    if (offset == 0) {
        object_setClass(self, newValue);
        return;
    }

    id oldValue;
    id *slot = (id*) ((char*)self + offset);

    if (copy) {
        newValue = [newValue copyWithZone:nil];
    } else if (mutableCopy) {
        newValue = [newValue mutableCopyWithZone:nil];
    } else {
        if (*slot == newValue) return;
        newValue = objc_retain(newValue);
    }

    if (!atomic) {
        oldValue = *slot;
        *slot = newValue;
    } else {
        spinlock_t& slotlock = PropertyLocks[slot];
        slotlock.lock();
        oldValue = *slot;
        *slot = newValue;        
        slotlock.unlock();
    }

    objc_release(oldValue);
}

当copy或者mutableCopy为true时会调用copyWithZone/mutableCopyWithZone对属性进行一层深拷贝,这里就可以解释为什么用copy为什么原属性不会被修改,因为内存地址不是同一块了.而copy修饰的属性copy为true,mutableCopy为flase,所以只要是被copy修饰的属性,不管传入的值是否是可变的,最终赋值给属性后都是不可变的,因为这里调用了copyWithZone方法。

总结

所以具体NSString还有集合(NSArray、NSDictionary、NSSet)对象是否需要使用copy来修饰,完全可以根据情况来设置,如果这个值可以100%保证不会被修改的,那么使用strong即可,如果存在被修改的风险的则优先考虑使用copy来修饰。

使用copy修饰符会增加部分性能的消耗,从源码实现可以看出,copy修饰的对象底层实现的时候都需要进行判断,是否需要copy操作,如果项目过于庞大,copy修饰符使用过多也会造成性能消耗,所以如果这个值不存在被修改的风险,建议用strong优化性能。

容器的里面的内容的深浅拷贝

使用copy、mutableCopy对集合对象进行的深浅拷贝是针对集合对象本身的

使用 copy、mutableCopy 对集合对象（NSArray、NSDictionary、NSSet）进行的深浅拷贝是针对集合对象本身的，对集合中的对象执行的默认都是浅拷贝。也就是说只拷贝集合对象本身，而不复制其中的数据。主要原因是，集合内的对象未必都能拷贝，而且调用者也未必想在拷贝集合时一并拷贝其中的每个对象。

如果想要深拷贝集合对象本身的同时，对其元素也进行copy操作，可使用一下方法：

objc 复制代码 
NSArray* deepCopyArray = [[NSArray alloc] initWithArray: someArray copyItems: YES];

这样集合中的每一个对象都会收到copyWithZone:消息，需要注意的是集合中的对象都必须符合NSCopying 协议，否则会导致程序崩溃或中断

copyWithZone:是一个用于实现对象复制的方法，当被调用时，方法内部会先创建一个新实例，再将当前对象self的属性值复制到新实例中，最后返回新实例

注意：
initWithArray: copyItems: 方法不是所有情况下都深拷贝集合对象本身的。如果执行[[NSArray alloc] initWithArray: @[] copyItems: aBoolValue];，也就是原对象为不可变的空数组的话，对原对象本身执行的是浅拷贝，苹果对 @[] 使用了享元

享元是一种设计模式，详情见这篇博客：享元模式

那么如何实现真正的深拷贝（完全拷贝）呢？

先说结论：先归档后解档

从上面的叙述可知，如果集合中的对象的copy操作是浅拷贝，那么对于集合来说还不是真正意义上的拷贝。比如，现需要对一个NSArray<NSArray *>对象进行真正的深拷贝，那么内层数组及其内容元素也应该执行深拷贝，可以对该集合对象进行归档然后解档 ，只要集合中的对象都符合 NSCoding 协议。而且，使用这种方式，无论集合中存储的模型对象嵌套多少层，都可以实现深拷贝，但前提是嵌套的子模型也需要符合 NSCoding 协议才行，否则也会导致程序崩溃或中断

以下为真正的深拷贝：

objc 复制代码 
NSArray *trueDeepCopyArray = [NSKeyedUnarchiver unarchiveObjectWithData: [NSKeyedArchiver archivedDataWithRootObject: oldArray]];

在这段代码中，oldArray被传递给archivedDataWithRootObject:方法，并返回一个包含该oldArray对象及其关联数据的NSData对象，通过将前一步得到的NSData对象传递给unarchiveObjectWithData:方法，我们得到了一个解档后的对象，即trueDeepCopyArray

通过这个过程，我们实现了oldArray的深拷贝，得到了一个内容与原始数组相同的新数组trueDeepCopyArray，oldArray及其所有的元素必须符合 NSCoding 协议。如果其中的某个元素不支持归档，则可能会导致错误

就原对象和副本对象的可变性而言

使用initWithArray: copyItems: YES时，生成的副本集合中的对象（下一个级别）是不可变的，而更深层级的对象仍然保持其之前的可变性。换句话说，副本集合的第一级别是不可变的，但更深层级的对象仍然可以进行修改

来看这段代码

objc 复制代码 
NSArray* oldArray = @[@[].mutableCopy];
NSArray* deepCopyArray = [[NSArray alloc] initWithArray: oldArray copyItems: YES];
NSMutableArray* mArray = deepCopyArray[0]; // deepCopyArray[0] 已经被深拷贝为 NSArray （不可变）对象
[mArray addObject:@""];

首先创建了一个空的NSArray实例[]，并调用mutableCopy方法创建该数组的可变副本，即一个NSMutableArray实例，最后放进oldArray中。用此方法深拷贝后，deepCopyArray[0]已然不可变。因此给mArray添加对象时程序会报错

而归档解档集合的方式可以保留集合对象所有级别的可变性，就像在归档之前一样。通过归档解档，可以以完整的形式将可变集合对象存储到磁盘上，并在需要时重新加载，保留了集合对象层次结构及其可变性

实现对自定义对象的拷贝

实现对自定义对象的拷贝，需要遵守NSCopying 协议，并实现copyWithZone:方法。

  • 如果要浅拷贝，copyWithZone: 方法就返回当前对象：return self;
objc 复制代码 
- (id)copyWithZone:(NSZone *)zone {
    return self;
}

如果要深拷贝，copyWithZone: 方法中就创建新对象，并给希望拷贝的属性赋值，然后将其返回。如果有嵌套的子模型也需要深拷贝，那么子模型也需符合NSCopying 协议，且在属性赋值时调用子模型的copy方法，以此类推。

objc 复制代码 
@interface Dog : NSObject <NSCopying>
@property (nonatomic, copy) NSString *name;
@end

@implementation Dog
- (id)copyWithZone:(NSZone *)zone {
    Dog *copy = [[Dog alloc] init];
    copy.name = self.name;
    return copy;
}
@end

@interface Person : NSObject <NSCopying>
@property (nonatomic, copy) NSString *name;
@property (nonatomic, assign) NSInteger age;
@property (nonatomic, copy) Dog *dog;
@end

@implementation Person
- (id)copyWithZone:(NSZone *)zone {
    Person *copy = [[Person alloc] init];
    copy.name = self.name;
    copy.age = self.age;
    copy.dog = [self.dog copy]; //调用了嵌套子模型Dog的copy方法进行深拷贝
    return copy;
}
@end

如果自定义对象支持可变拷贝和不可变拷贝，那么还需要遵守NSMutableCopying 协议，并实现mutableCopyWithZone:方法，返回可变副本。而copyWithZone:方法返回不可变副本。我们可根据需要调用该对象的 copy 或 mutableCopy 方法来进行不可变拷贝或可变拷贝。

objc 复制代码 
@interface Person : NSObject <NSMutableCopying, NSCopying>
@property (nonatomic, copy) NSString *name;
@property (nonatomic, assign) NSInteger age;
@end

@implementation Person
- (id)mutableCopyWithZone:(NSZone *)zone {
    Person *copy = [[Person alloc] init];
    copy.name = [self.name mutableCopy]; //使用可变拷贝的方式来生成可变副本
    copy.age = self.age;
    return copy;
}

- (id)copyWithZone:(NSZone *)zone {
    Person *copy = [[Person alloc] init];
    copy.name = self.name; //使用不可变拷贝的方式来生成不可变副本
    copy.age = self.age;
    return copy;
}
@end

面试题

1. 请简单介绍一下iOS的浅拷贝和深拷贝？

答：

  • 浅拷贝：指针的拷贝，实际上拷贝了指向原来对象的指针，不会创建新的对象！
  • 深拷贝：拷贝对象的具体内容，创建新的对象。拷贝结束后，两个对象存的值是相同的，但是内存地址不一样！（至少有一层是深拷贝）

2. 请问NSString属性用什么修饰符修饰，为什么用这个修饰符修饰？

答：

开发中NSString属性用copy修饰符修饰。

之所以用copy来修饰NSString属性，是因为可以避免赋值来源是NSMutableString的时候，改变可变字符串的值会影响不可变字符串的值。之所以用copy后就不会影响其原有值，是因为用copy修饰不可变字符串，在赋值的时候，在setter方法中会对赋值来源执行一次copy操作，当对可变类型执行copy操作，返回新的不可变对象，即使改变了来源数据，也不会影响copy修饰的不可变属性！所以用copy修饰NSString属性，也可以保证数据安全，不受污染！

3. 你了解iOS中的完全拷贝吗？实现方法？

答：

完全拷贝的概念是相对于深拷贝来说的。在深拷贝的理解中有一种说法是至少是一层深拷贝，比如，我们对容器类型的对象执行一次mutableCopy操作时，就进行了深拷贝，但这次深拷贝是单层深拷贝，也就是说容器内存地址发生了变化，但容器内元素的内存地址没有发生变化，我们称它为单层深拷贝，并不是理论上的完全深拷贝！（容器类型的内容拷贝，仅限于对象本身，对象元素仍然是指针拷贝）

实现方法：

    1. 使用以下方法： 且集合中的对象都必须符合NSCopying 协议
      NSArray* deepCopyArray = [[NSArray alloc] initWithArray: someArray copyItems: YES];
    1. 先归档后解档

4.如何实现自定义类的深浅拷贝？

系统提供的一些类，比如NSString，NSArray，NSDictionry都遵循了NSCopying和NSMutableCopying协议，所以我们可以直接调用copy/mutableCopy方法。我们自定义的类也想要实现深浅拷贝的功能，我们自定义的类也需要遵循NSCopying和NSMutableCopying协议,并实现对应的协议方法！

自定义的类实现浅拷贝：遵循NSCopying协议，实现copyWithZone方法，方法内返回self！

自定义的类实现深拷贝：遵循NSMutableCopying协议，实现mutableCopyWithZone方法，方法内创建新对象，并把当前类的属性依次赋值给新对象的属性，最后返回这个新的对象！

实现自定义A类的深拷贝的时候，如果A类中嵌套B类，那么B类也要实现NSMutableCopying协议，现mutableCopyWithZone方法，方法内创建新对象，并把当前类的属性依次赋值给新对象的属性，最后返回这个新的B对象！并且，在A类的mutableCopyWithZone方法中， newA.b = [self.b mutableCopy] 。

这种实现方式只针对简单的单层的类！

上述是基本的实现方式！

下面介绍一种使用Runtime+KVC方式给新对象进行赋值！参考代码实现！（这只是浅拷贝，面试别说了）

objc 复制代码 
CustomModel *m1 = [CustomModel new];
m1.name = @"Shaw";
m1.age = 27;
CustomModel *m2 = [m1 copy];
m2.name = @"CTT";
m2.age = 28;
    
NSLog(@"%@&%@", m1.name, m2.name);
// 打印结果：Shaw&CTT
 
@interface CustomModel : NSObject <NSCopying>
@property (nonatomic, strong) NSString *name;
@property (nonatomic, assign) int age;
@end
 
@implementation CustomModel
 
- (id)copyWithZone:(NSZone *)zone {
    CustomModel *copy = [[[self class] alloc] init];
    unsigned int propertyCount = 0;
    objc_property_t *propertyList = class_copyPropertyList([self class], &propertyCount);
    for (int i = 0; i < propertyCount; i++ ) {
        objc_property_t thisProperty = propertyList[i];
        const char* propertyCName = property_getName(thisProperty);
        NSString *propertyName = [NSString stringWithCString:propertyCName encoding:NSUTF8StringEncoding];
        id value = [self valueForKey:propertyName];
        [copy setValue:value forKey:propertyName];
    }
    return copy;
}
// 注意此处需要实现这个函数，因为在通过Runtime获取属性列表时，会获取到一个名字为hash的属性名，这个是系统帮你生成的一个属性
- (void)setValue:(id)value forUndefinedKey:(NSString *)key {}

代码实现解释：

  • KVC：通过 valueForKey: 和 setValue:forKey: 轻松地获取和设置对象的属性值，而无需显式调用 getter 或 setter 方法。
  • Runtime：通过 class_copyPropertyList 动态获取对象的属性列表，使得 copyWithZone: 方法可以自动适应类中的所有属性，即使属性列表发生变化也不需要手动修改代码。
  • setValue:forUndefinedKey: 的空实现保证了 KVC 操作的安全性，避免未定义键导致的崩溃。

5.如果自定义的类有多层嵌套，有没有方法实现自定义类的深拷贝？

答：

解档和归档

  • 1 . 自定义类包括嵌套的类都要实现NSCoding协议，并实现encodeWithCoder/initWithCoder协议方法，
相关推荐
dr李四维2 小时前
iOS构建版本以及Hbuilder打iOS的ipa包全流程
前端·笔记·ios·产品运营·产品经理·xcode
️ 邪神2 小时前
【Android、IOS、Flutter、鸿蒙、ReactNative 】自定义View
flutter·ios·鸿蒙·reactnative·anroid
比格丽巴格丽抱14 小时前
flutter项目苹果编译运行打包上线
flutter·ios
网络安全-老纪15 小时前
iOS应用网络安全之HTTPS
web安全·ios·https
1024小神18 小时前
tauri2.0版本开发苹果ios和安卓android应用，环境搭建和最后编译为apk
android·ios·tauri
lzhdim19 小时前
iPhone 17 Air看点汇总：薄至6mm 刷新苹果轻薄纪录
ios·iphone
安和昂19 小时前
【iOS】知乎日报第四周总结
ios
麦田里的守望者江1 天前
KMP 中的 expect 和 actual 声明
android·ios·kotlin
_黎明1 天前
【Swift】字符串和字符
开发语言·ios·swift
ZVAyIVqt0UFji1 天前
iOS屏幕共享技术实践
macos·ios·objective-c·cocoa
热门推荐
01(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明02PyTorch机器学习实现液态神经网络03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04玄机平台应急响应—webshell查杀05Coze扣子平台完整体验和实践（附国内和国际版对比）06Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO07【目标跟踪】相机运动补偿08Unity中PICO实现 隔空取物 和 接触抓取物体09RAG 实践- Ollama+RagFlow 部署本地知识库10怎样让音频速度变慢？请跟随以下方法进行操作