iOS项目开发中的知识点与问题收集整理②（Part 二）

2022-10-28 12:24:25

1、点击UIButton 无法产生触摸事件

如果在UIImageView中添加了一个按钮，你会发现在默认情况下这个按钮是无法被点击的，需要设置UIImageView的userInteractionEnabled为YES：

imageView.userInteractionEnabled = YES;
设置为YES后，UIImageView内部的按钮就可以被点击了

2、如何启动app时全屏显示Default.png（图片）？

大部分app在启动过程中全屏显示一张背景图片，比如新浪微博会显示这张：

要想在iOS中实现这种效果，毫无压力，非常地简单，把需要全屏显示的图片命名为Default.png即可，在iOS app启动时默认会去加载并全屏显示Default.png。

也可以用其他名称来命名图片，在Info.plist配置一下即可：

配置过后，app启动时就会去加载并全屏显示lufy.png

在默认情况下，app显示Default.png时并非真正的"全屏显示"，因为顶部的状态栏并没有被隐藏，比如下面的效果：

大部分情况下，我们都想隐藏状态栏，让Default.png真正全屏显示。

说到这里，可能有人马上就想到了一种办法：在AppDelegate的application:didFinishLaunchingWithOptions:方法中添加如下代码：

[UIApplication sharedApplication].statusBarHidden = YES;
我只能说你的思路是对的，但实际上达不到想要的效果，你会发现显示Default.png时状态栏还是存在的，等Default.png显示完毕后，状态栏才被隐藏。

我先解释下为什么这种方法不可行，其实原因很简单：

1> Default.png是在app启动过程中加载的，并不是在app启动完毕后再加载的

2> AppDelegate的application:didFinishLaunchingWithOptions:方法是在app启动完毕后才调用的

下面说一下解决方案，在Info.plist中增加一个配置即可：

这里的YES表示在app初始化(启动)的时候就隐藏状态栏。

当然，在Default.png显示完毕后状态栏还是隐藏的。如果想重新显示状态栏，补上下面代码即可：

[UIApplication sharedApplication].statusBarHidden = NO;

3、使用ASIHTTPRequest保存cookies

假如我的APP，第一次启动请求了登录接口并得到了Cookie，然后我把APP关了，下次启动APP，我不请求登录接口了，

那上次得到的Cookie就不存在了。如果需要，那么2种方法，下次启动app，自动登入，这样能得到服务器分配给你的cookier

（这一种是最好的，因为session也会过期），还有一种是你把上次登入的时候，拿到的cookier存起来，然后下次启动app的时候，

手动给请求（ASIHTTP）添加cookie。所以当第一次登录成功后，可以把cookie保存到CoreData，SQLite，UserDefault等，

等到下次网络请求时，读取：

  ASIFormDataRequest *request = [ASIFormDataRequest requestWithURL:UserInfoURL];

 [request setRequestMethod:@"POST"];

  [request addRequestHeader:@"Cookie" value:[NSString stringWithFormat:@"cookie=%@",[[NSUserDefaults standardUserDefaults] objectForKey:@"cookie"]]];

 //把cookie的值放进Header里，这个cookie的值是一串很长的字符串。

4、设置UITextField只有当有字符输入后，键盘右下角的搜索/返回/done/等等键才可以使用

TextField设置这个属性为YES就可以了，默认为NO

searchField.enablesReturnKeyAutomatically =YES;

5、类似QQ等IM软件，长度和高度不一的聊天气泡的图片是如何做的？拉伸？

其实是一个小气泡png，然后拉伸中间部分，四个角不拉动，就是局部拉伸。ios自带方法，四个角可以不拉伸的，如下：

6、UITableView中有多个UITextField时，被挡住的TextField如何实现自动向上弹起？

首先要实现TextField的delegate，在方法：

 - (void)textFieldDidBeginEditing:(UITextField *)textField {

     [self.tableView setContentOffset:CGPointMake(, ) animated:YES];

 }

这说明当开始输入时，tableview在原来的基础上向上抬起70个距离。多个UITextFiled可以通过判断来使用CGPoint的调整高度，我这写的是70.
tableview的scrollEnabled属性一定要是YES;要不然滚动不了了。
记得在return时复原tableview的位置：

 - (BOOL)textFieldShouldReturn:(UITextField *)sender {

     [self.tableView setContentOffset:CGPointMake(, ) animated:YES];

     return YES;

 }

7、ios如何在调试时，轻松找到程序在哪里崩溃？

我们给自己的工程添加一个全局的断点：

一步步按上面图完成操作。
再运行程序

自动就断点到这里来了，
log信息是:

-- ::19.635 GestureRecognizer[:c07] -[__NSCFNumber isEqualToString:]: unrecognized selector sent to instance 0x7a88df0

-- ::21.148 GestureRecognizer[:c07] *** Terminating app due to uncaught exception 'NSInvalidArgumentException',
 reason: '-[__NSCFNumber isEqualToString:]: unrecognized selector sent to instance 0x7a88df0'

这样很简单就能发现程序崩溃是因为value没有 isEqualToString方法。如果没加上面这个通用的断点，那程序会直接断点到main函数去。

8、UIImageView 如何实现windows 桌面类似的背景壁纸屏幕（很小的图片会显示N多个）？

从UImageView上找ContentMode或clipToBounds是都不管用的，正确的办法是，不用UImageView，使用UIView，然后设置backgroundColor属性为我们的图片，这样的话自动会以屏幕的方式显示。

 UIView *gridView = [[UIView alloc] initWithFrame:CGRectMake(, , , )];

 gridView.backgroundColor = [UIColor colorWithPatternImage:BUNDLE_IMAGE(@"blue_grid")];

 [self.view addSubview:gridView];

 [gridView release];

下图所示：（原图是一个6X6的方格）

9、UITableViewCell 的backgroundColor不起作用的问题？

在开发时，想要在tableview中的某一个Cell设置选中状态，并且Cell的背景颜色是一个自定义颜色。

  -(UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath{  

  <span style="white-space:pre">  </span>//省略....

      cell.textLabel.font = [UIFont systemFontOfSize:6.0];

      cell.textLabel.text = @"";  

      if (indexPath.row==) {

         [cell setBackgroundColor:[UIColor colorWithRed:100.0f/255.0f green:176.0f/255.0f blue:0.0f/255.0f alpha:1.0f]];

     }

     else{

         [cell setBackgroundColor:[UIColor whiteColor]];

     }  

     return cell;

 }

这样的话，第1行cell就应该是我们设置好的颜色，不过请注意，此方法在UITableViewStylePlain的风格下有效，在 UITableViewStyleGrouped的样式下是无效的！这个跟tableview的backgroundView和backgroundColor是没有关系的，个人猜想应该是在Grouped风格下，cell选中的颜色有系统的view遮罩，导致我们设置的无法显示出来。
【补充】如果想在reload或init时设置tableview的某一cell为 selected状态，千万不要使用cell setSelected:YESanimated:YES，使用tableview的方法：

 NSIndexPath *indexPath = [NSIndexPath indexPathForRow:i inSection:];

 terminalTableView selectRowAtIndexPath:indexPath animated:YES scrollPosition:UITableViewScrollPositionNone];

10、UITableViewCell选中时contentView中各组件的高亮状态

使用系统或简单自定义的UITableViewCell时，当选中某一行Cell后，除了背景颜色改变外，Cell上所有的组件（数据）比如UILabel，UIbutton等都被自动显示成了其

Highlighted（高亮）状态下的效果，（如果想显示出效果，你的那些自定义的组件必须要设置高亮状态，比如highlightedTextColor，UIControlStateHighlighted等），

所以这一点需要特别注意，如果不想要系统的这个自动特效，有两个解决办法：

1，组件不设置highlighted下的属性

2，如果自定义的Cell：

  - (void)setSelected:(BOOL)selected animated:(BOOL)animated

  {

      [super setSelected:selected animated:animated];

      if (selected) {

          //强制系统在UITableViewCell选中时SettingButton组件的高亮状态为NO

          [(UIButton *)[self.contentView.subviews objectAtIndex:] setHighlighted:NO];

          [settingBtn setImage:BUNDLE_IMAGE(@"accessory_sel") forState:UIControlStateNormal];

     }

     else{

         [settingBtn setImage:BUNDLE_IMAGE(@"accessory_nor") forState:UIControlStateNormal];

     }

 }

11、IOS atomic与nonatomic，assign,copy与retain的定义和区别

atomic和nonatomic用来决定编译器生成的getter和setter是否为原子操作。
        atomic
                设置成员变量的@property属性时，默认为atomic，提供多线程安全。
                在多线程环境下，原子操作是必要的，否则有可能引起错误的结果。加了atomic，setter函数会变成下面这样：
                        {lock}
                                if (property != newValue) {
                                        [property release];
                                        property = [newValue retain];
                                }
                        {unlock}
        nonatomic
        禁止多线程，变量保护，提高性能。
        atomic是Objc使用的一种线程保护技术，基本上来讲，是防止在写未完成的时候被另外一个线程读取，造成数据错误。而这种机制

是耗费系统资源的，所以在iPhone这种小型设备上，如果没有使用多线程间的通讯编程，那么nonatomic是一个非常好的选择。

指出访问器不是原子操作，而默认地，访问器是原子操作。这也就是说，在多线程环境下，解析的访问器提供一个对属性的安全访

问，从获取器得到的返回值或者通过设置器设置的值可以一次完成，即便是别的线程也正在对其进行访问。如果你不指定 nonato

mic，在自己管理内存的环境中，解析的访问器保留并自动释放返回的值，如果指定了 nonatomic ，那么访问器只是简单地返回

这个值。

assign
对基础数据类型（NSInteger，CGFloat）和C数据类型（int, float, double, char）等等。
此标记说明设置器直接进行赋值，这也是默认值。在使用垃圾收集的应用程序中，如果你要一个属性使用assign，且这个类符合

NSCopying协议，你就要明确指出这个标记，而不是简单地使用默认值，否则的话，你将得到一个编译警告。这再次向编译器

说明你确实需要赋值，即使它是可拷贝的。

retain
对其他NSObject和其子类对参数进行release旧值，再retain新值
指定retain会在赋值时唤醒传入值的retain消息。此属性只能用于Objective-C对象类型，而不能用于Core Foundation对象。

(原因很明显，retain会增加对象的引用计数，而基本数据类型或者Core Foundation对象都没有引用计数——译者注)。

注意: 把对象添加到数组中时，引用计数将增加对象的引用次数+1。

copy
对NSString 它指出，在赋值时使用传入值的一份拷贝。拷贝工作由copy方法执行，此属性只对那些实行了NSCopying协议

的对象类型有效。更深入的讨论，请参考“复制”部分。

copy与retain：
Copy其实是建立了一个相同的对象，而retain不是：
1.比如一个NSString 对象，地址为0×1111 ，内容为@”STR”，Copy 到另外一个NSString 之后，地址为0×2222 ，内容相同。
2.新的对象retain为1 ，旧有对象没有变化retain 到另外一个NSString 之后，地址相同（建立一个指针，指针拷贝），内容当然相同，

这个对象的retain值+1。
总结：retain 是指针拷贝，copy 是内容拷贝。

assign与retain：
1. 接触过C，那么假设你用malloc分配了一块内存，并且把它的地址赋值给了指针a，后来你希望指针b也共享这块内存，于是你又

把a赋值给（assign）了b。此时a和b指向同一块内存，请问当a不再需要这块内存，能否直接释放它？答案是否定的，因为a并不

知道b是否还在使用这块内存，如果a释放了，那么b在使用这块内存的时候会引起程序crash掉。

2. 了解到1中assign的问题，那么如何解决？最简单的一个方法就是使用引用计数（reference counting），还是上面的那个例子，

我们给那块内存设一个引用计数，当内存被分配并且赋值给a时，引用计数是1。当把a赋值给b时引用计数增加到2。这时如果a

不再使用这块内存，它只需要把引用计数减1，表明自己不再拥有这块内存。b不再使用这块内存时也把引用计数减1。当引用计数

变为0的时候，代表该内存不再被任何指针所引用，系统可以把它直接释放掉。

总结：

上面两点其实就是assign和retain的区别，assign就是直接赋值，从而可能引起1中的问题，当数据为int, float等原生类型时，

可以使用assign。retain就如2中所述，使用了引用计数，retain引起引用计数加1, release引起引用计数减1，当引用计数为

0时，dealloc函数被调用，内存被回收。

12、#pragma mark -#pragma mark Initialization含义

它们告诉Xcode编译器，要在编辑器窗格顶部的方法和函数弹出菜单中将代码分隔开;注意 #pragma mark – 的“-”后面不能有空格。如果你的标志没有

出现在弹出菜单中，比如没有分隔线出现，请在Xcode菜单 “Preferences..”中的 “Code Sense”选项取消选中”Sort listalphabetically”即可。

13、自定义delegate变量声明时使用assign还是retain？

我们通过发送消息给对象出发特定动作;对象发送某些变化的时候通过回调函数(callback)通知我们。对象在特定事件发生的时候，就会调用对应的回调函数，

触发业务逻辑。回调函数通过所谓的代理(Delegation)来实现.

delegate使用方法：

@property (assign) <id>xxxDelegate delegate;

正确的使用方法是使用assign属性而不是retain。之所以对于delegate这类对象使用assign而不是用retain是为了防止循环retain（retain loop）

14、给成员变量（属性）赋值时使不使用self？

使用@property和@synthesize声明一个成员变量，给其赋值是时要在前面加上"self."，以便调用成员变量的setmember方法。直接调用成员变量并且给其赋值：

member=[NSString stringWithFormat:@””];将不执行setmember 方法。
使用self调用成员变量并且给其赋值：self.member=[NSString stringWithFormat:@””];将执行setmember方法。

15、如何给UIbutton 同时设置图片（Image）和文字（Title）以及它们的各种状态？

 startRangeButton = [UIButton buttonWithType:UIButtonTypeCustom];

  startRangeButton.frame = CGRectMake(,componentOriginY, regionImage.size.width, );

 [startRangeButton setBackgroundImage:regionImage forState:UIControlStateNormal];

 //还可以设置其高亮状态startRangeButton setBackgroundImage:regionImage forState:UIControlStateHighlighted];

  startRangeButton.titleLabel.font = [UIFont systemFontOfSize:7.0];

 [startRangeButton setTitle:@"2013-08-01 07:00" forState:UIControlStateNormal];

 [startRangeButton setTitleColor:COLOR(, , , ) forState:UIControlStateNormal];

 [startRangeButton setTitleColor:[UIColor whiteColor] forState:UIControlStateHighlighted];

代码中我设置button背景图片为自己定义的一个regionImage，并设置了button的title = “2013-08-01 07:00”【注意，设置了背景图片后，title只能这样添加，以button.titleLabel.text方式添加会无法显示的】，并且设置了tiitle正常和高亮下文字颜色。
所以看到这里，应该明白button.setBackgroundImage 和 set Image 的区别了吧，前者是可以同时设置文字，后者是一旦设置了image，无法再显示文字。

普通：高亮：

16、如何将NSDate类型转化为距离1970/1/1的毫秒差?

[formatter setDateFormat:@"yyyy-MM-dd HH:mm"]; 这种格式得到的数值是精确到秒的，也就是说少1000，

但是尝试[formatter setDateFormat:@"yyyy-MM-dd HH:mm:ss"];或SS大写，或[formattersetDateFormat:@"yyyy-MM-dd HH:mm.ss.SSS"];都不起作用，最后才发现，

原来是这样

NSTimeInterval本身是个秒级别的double类型数值，小数点后面即毫秒数,*1000.0f即可得到毫秒级别的时间差

 //为了兼容java版本，事件是从1970/1/1开始

  -(NSDate *)getDateTimeFromMilliSeconds:(long long) miliSeconds

  {

      NSTimeInterval tempMilli = miliSeconds;

      NSTimeInterval seconds = tempMilli/1000.0;

     NSLog(@"seconds=%f",seconds);

     return [NSDate dateWithTimeIntervalSince1970:seconds];

 }

 //将NSDate类型的时间转换为NSInteger类型,从1970/1/1开始

 -(long long)getDateTimeTOMilliSeconds:(NSDate *)datetime

 {

     NSTimeInterval interval = [datetime timeIntervalSince1970];    

     NSLog(@"interval=%f",interval);

     long long totalMilliseconds = interval* ;

     NSLog(@"totalMilliseconds=%llu",totalMilliseconds);

     return totalMilliseconds;

 }

也就是说，计算结果再自己乘以1000就可以了

  NSDateFormatter *formatter = [[NSDateFormatter alloc] init];

  [formatter setDateFormat:@"yyyy-MM-dd HH:mm"];  

  NSDate *sDate  = [formatter dateFromString:startRangeButton.titleLabel.text];

  NSDate *eDate = [formatter dateFromString:endRangeButton.titleLabel.text];

  NSTimeInterval sinterval =  [sDate timeIntervalSince1970];

  long long start = sinterval*;

  NSTimeInterval einterval = [eDate timeIntervalSince1970];

  long long end = einterval*;

 [mConnectionHelper doTrack:mobile startTime:start endTime:end];

17、ios中的全局静态变量

Objective-C 支持全局变量
主要有两种实现方式：
（1）第一种和C/C++中的一样，使用"extern"关键词；
（2）另外一种就是使用单例实现。
（比如我们经常会把一个变量放在AppDelegate里面作为全局变量来访问，其中AppDelegate就是一个单例类）

在Objective-C中如何实现像C++中那样的静态成员变量呢？
你需要做的是在一个类A的implementation(.m或者.mm)文件中定义一个static变量，然后为A类定义静态成员函数（class method，也就是类方法）来操作该变量。

 //example.h

 @interface Example : NSObject {     

 }

 - (id)init;

 +(int)instanceCount;

 @end    

  //example.m

   #import "example.h"

  static int count;

  @implementation Example

  -(id)init{

      self = [super init];

      if(nil!=self){

          count+=;

      }

  return self;

 }

 +(int)instanceCount{

      return count;

 }

 @end

上面的例子中你就可以通过[Example instanceCount]对静态变量count进行访问，无须创建实例。
警告: static 写在interface外面编译是没有错误的，但是编译器会报警告，这么说这样的写法是不被编辑器认可的。
错误：static 写在interface里面会直接报错，显然这样的语法是不被认可的。

static关键字声明的变量必须放在implementation外面，或者方法中，如果不为它赋值默认为0，
它只在程序开机初始化一次。

18、如何使用 NSNotificationCenter 在viewcontroller之间进行传值？

简单点的来，两个界面间传值，直接上代码了：

sendViewcontroller.m

  //SettingViewController ：接受值的viewcontroller

  SettingViewController *setting = [[SettingViewController alloc] init];

  [[NSNotificationCenter defaultCenter] addObserver:setting selector:@selector(received:) name:@"msetting" object:nil];

  NSDictionary *dict = [[NSDictionary alloc] initWithObjectsAndKeys:@"user",@"type", nil];  

  [[NSNotificationCenter defaultCenter] postNotificationName:@"msetting" object:dict];

  [self.navigationController pushViewController:setting animated:YES];  

  [setting release];

 SettingViewController.m（接收值的viewcontroller）

 -(void)received:(NSNotification *)notification{  

     id data = [notification object];

     NSLog(@"received data: %@",data);

 }

这样就实现了基本的使用，跟delegate类似，注意 addObserver时，需要写目标viewcontroller的实例，而不是self。

19、Thread EXC_BAD_ACCESS : objc_retain, objc_getProperty 崩溃错误

如上图所示，遇到这个错误，从字面的意思我们大致能猜到，是有属性已经被release掉了，但是我们又使用它了，所以，一部一部排查把，一定有某个地方的属性

提前被release掉了，自己手动管理内存就会有这样的困恼，代码很多，不想去找，一定要有耐心，找的过程还可以学到很多知识。

如上图，这个就是我找到的原因所在，unarchiver release掉了，而我们在其它的类中想使用location的属性。

20、MAC 终端（bash）svn命令不识别 command not found

在mac os 10.8中，svn Command line tools是没有自动安装的，这样的话，svn 命令行就会失效，解决办法：
1.打开xcode偏好设置（comand+，）-->"Download" -->Components:

2.点击“Command line tools”下载，下载完成之后安装。

3.安装完成之后，打开终端，输入“svn help”，如果出现如下所示，说明命令行工具安装好了。

21、ios MapKit 判断坐标是否在MapView显示范围内

 CLLocationDegrees leftDegrees = mapView.region.center.longitude –(mapView.region.span.longitudeDelta / 2.0);

  CLLocationDegrees rightDegrees = mapView.region.center.longitude +(mapView.region.span.longitudeDelta / 2.0);

  CLLocationDegrees bottomDegrees = mapView.region.center.latitude –(mapView.region.span.latitudeDelta / 2.0);

  CLLocationDegrees topDegrees = self.region.center.latitude +(mapView.region.span.latitudeDelta / 2.0);

  if (leftDegrees > rightDegrees) { // Int'l Date Line in View

  leftDegrees = -180.0 - leftDegrees;

  if (coords.longitude > ) // coords to West of Date Line

  coords.longitude = -180.0 - coords.longitude;

  }

 If (leftDegrees <= coords.longitude && coords.longitude <= rightDegrees && bottomDegrees <= coords.latitude && coords.latitude <= topDegrees) {

 // 坐标在范围内

 }

22、在App图标上显示数字徽标

IOS7 ：

  UIApplication *app = [UIApplication sharedApplication];  

  // 应用程序右上角数字

  app.applicationIconBadgeNumber = ;

上面的代码可以搞定

IOS8:

iOS8中设置application badge value 会抛错：Attempting to badge the application icon but haven't received permission from the user to badge the

原因是因为在ios8中，设置应用的application badge value需要得到用户的许可。使用如下方法咨询用户是否许可应用设置application badge value

UIUserNotificationSettings *settings = [UIUserNotificationSettings settingsForTypes:UIUserNotificationTypeBadge categories:nil];

[[UIApplication sharedApplication] registerUserNotificationSettings:settings];

在这之前要判断系统是否为iOS8的系统，否则8之前的系统会报错。

  UIUserNotificationSettings *settings = [UIUserNotificationSettings settingsForTypes:UIUserNotificationTypeBadge categories:nil];  

  [[UIApplication sharedApplication] registerUserNotificationSettings:settings];  

  UIApplication *app = [UIApplication sharedApplication];

     // 应用程序右上角数字

     app.applicationIconBadgeNumber = ;

注意：清除数字请将数字设置为 0

1-2设置标签栏按钮显示数字图标

 UIViewController *second=[SecondViewController new];

 UITabBarItem *item=[[UITabBarItem alloc]initWithTitle:@"支付" image:[UIImage imageNamed:@""] selectedImage:[UIImage imageNamed:@""]];

     second.tabBarItem=item;

     item.badgeValue=@"";

效果如图

23、如何获取手机硬件信息？

通过使用UIDevice：

[[UIDevice currentDevice] systemName];
[[UIDevice currentDevice] systemVersion];//os version
[[UIDevice currentDevice] uniqueIdentifier];
[[UIDevice currentDevice] model];
[[UIDevice currentDevice] name];
真机上结果：
System Name: iPhone OS
System Version: 4.2.1
Unique ID: 9b5ded78d5fa0ac96250f8b4af0e46f40b96ea6d
Model: iPhone
Name: “wwk”的 iPhone
模拟器上结果：
System Name: iPhone OS
System Version: 4.2
Unique ID: 21FFE0FF-429B-5D0B-96D2-EADCA3203260
Model: iPhone Simulator
Name: iPhone Simulator
uniqueIdentifier：iPhone通过，向几个硬件标识符和设备序列号应用内部散列算法，而生成这一标识符。
http://blog.csdn.net/qiwancong/article/details/7914923 参考

24、设置隐藏头部状态栏（电池图标）

1-1 设置状态如图

1-2添加代码：

 //隐藏状态栏

 [[UIApplication sharedApplication]setStatusBarHidden:YES];

实现效果如图

25、根据App版本号来判断App开启时是否进入引导页

实现代码

 #define __kFirstVersion @"kFirstVersion"

  //根据App版本号来判断App开启时是否进入引导页

  - (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions { 

      //1.获取一个状态:是否已经进入过主界面

  //    BOOL b = [[[NSUserDefaults standardUserDefaults]valueForKey:__kFirst] boolValue];

      //获取到当前的版本

      NSString *key = (NSString *)kCFBundleVersionKey;

      NSString *version = [NSBundle mainBundle].infoDictionary[key]; 

     //获取到之前的版本

     NSString *lastVersion = [[NSUserDefaults standardUserDefaults]valueForKey:__kFirstVersion];

     //2.如果没有进入过主界面,则进入引导页

     //如果两个版本号相同,则进入主界面,否则进入引导页

     if (![lastVersion isEqualToString:version]) {

         ViewController *vc = [[ViewController alloc]init];

         [vc setCallback:^{

             [self startApp];

             [[NSUserDefaults standardUserDefaults]setValue:version forKey:__kFirstVersion];

             [[NSUserDefaults standardUserDefaults]synchronize];

         }];

         self.window.rootViewController = vc;

     }

     //3.如果已经进入过主界面,则直接进入主界面

     else

     {

         [self startApp];

     }

     return YES;

 }

 -(void)startApp

 {

     self.window.rootViewController = [[UINavigationController alloc]initWithRootViewController:[RootViewController new]];

 }

26、计算文本内容所占空间大小方法

1)对于单行文本数据的显示调用- (CGSize)sizeWithAttributes:(NSDictionary *)attrs;方法来得到文本宽度和高度。

例如：

  //根据文本内容取得文本占用空间大小

 CGSize textSize=[@"Hello World" sizeWithAttributes:@{NSFontAttributeName: [UIFont systemFontOfSize:]}];

2)对于多行文本数据的显示调用- (CGRect)boundingRectWithSize:(CGSize)size options:(NSStringDrawingOptions)options attributes:(NSDictionary *)attributes context:(NSStringDrawingContext *)context ;方法来得到文本宽度和高度；同时注意在此之前需要设置文本控件的numberOfLines属性为0。

例如：

 //计算多行文本所占空间大小

 CGSize textSize=[@"Hello WorldHello WorldHello WorldHello WorldHello WorldHello WorldHello World" boundingRectWithSize:CGSizeMake(, MAXFLOAT)

 options:NSStringDrawingUsesLineFragmentOrigin

 attributes:@{NSFontAttributeName: [UIFont systemFontOfSize:]} context:nil].size;

27、图解 imagView 的 UIContentMode的显示方式如下图

28、解决view的缩放的时候，layer.border.width（圆角边框）随着view的放大时会出现锯齿化的问题。

self.layer.allowsEdgeAntialiasing = YES;

29、Xcode 7中http通信出现如下错误：Application Transport Security has blocked a cleartext HTTP (http://)

resource load since it is insecure. Temporary exceptions can be configured via your app's Info.plist file.

原因：

在iOS9 中，苹果将原http协议改成了https协议，使用 TLS1.2 SSL加密请求数据。

解决方法：

编辑 Info.plist，加入如下设置：NSAppTransportSecurity ----> NSAllowsArbitraryLoads

如图：

30、报错： You must rebuild it with bitcode enabled (Xcode setting ENABLE_BITCODE)（解决方案）

解决方法有两种：

方法一：使用Enable Bitcode的第三方库

方法二：将工程中的Enable Bitcode设置为NO 如图：

31、Xcode SVN 报错 The server certificate failed to verify. 解决方法

打开终端（实用工具 -->终端），在终端中输入如下命令：
svn ls https://xxxxxxxx/svn/xxxxxx SVN的路径
然后直接输入 “ p ” 确认，再分别输入电脑密码、svn用户名以及密码;就可以重新连接了。

32、ios修改textField的placeholder的字体颜色、大小方法

 textField.placeholder = @"username is in here!";

 [textField setValue:[UIColor redColor]forKeyPath:@"_placeholderLabel.textColor"];

 [textField setValue:[UIFont boldSystemFontOfSize:]forKeyPath:@"_placeholderLabel.font"];

33、iOS获取当前根视图控制器并实现页面跳转的方法

  - (UIViewController*)topViewController

  {

      return [self topViewControllerWithRootViewController:self.window.rootViewController];

  }

  - (UIViewController*)topViewControllerWithRootViewController:(UIViewController*)rootViewController

  {

      if ([rootViewController isKindOfClass:[UITabBarController class]]) {

          UITabBarController *tabBarController = (UITabBarController *)rootViewController;

         return [self topViewControllerWithRootViewController:tabBarController.selectedViewController];

     } else if ([rootViewController isKindOfClass:[UINavigationController class]]) {

         UINavigationController* navigationController = (UINavigationController*)rootViewController;

         return [self topViewControllerWithRootViewController:navigationController.visibleViewController];

     } else if (rootViewController.presentedViewController) {

         UIViewController* presentedViewController = rootViewController.presentedViewController;

         return [self topViewControllerWithRootViewController:presentedViewController];

     } else {

         return rootViewController;

     }

 } 

 //调用

 [[self topViewController] presentViewController:[[TransViewController alloc] init] animated:YES completion:nil];

34、全局变量宏定义实现方法

 #define APPDELEGATE ((AppDelegate *)[UIApplication sharedApplication].delegate)

  //用法：在AppDelegate.h中定义变量 通过 APPDELEGATE对象实现全局调用

  //AppDelegate.h 代码

  #import <UIKit/UIKit.h>

  @interface AppDelegate : UIResponder <UIApplicationDelegate>

  @property (strong, nonatomic) UIWindow *window;

  @property (strong,nonatomic) NSString *systemName;

  @end

 //调用方法 (注意得引用头文件 AppDelegate.h)

  APPDELEGATE.systemName=@"KingKong";

35、解决MJExtension 转换字段为id(关键字)的问题处理

 #import "HGProductModel.h"

 #import "MJExtension.h"

 @implementation HGProductModel  

 //重写 replacedKeyFromPropertyName 方法将id替换为我们定义的字段名

 + (NSDictionary *)replacedKeyFromPropertyName

 {

     return @{@"productID" : @"id"};

 }

 @end

36、tableviewcell上按钮点击时确定当前所在行的方法

类似这种按钮：

 -(void)btnClicked:(id)sender event:(id)event

 {

 　　NSSet *touches =[event allTouches];

 　　UITouch *touch =[touches anyObject];

 　　CGPoint currentTouchPosition =[touch locationInView:self.tableView];

 　　NSIndexPath *indexPath =[self.tableView indexPathForRowAtPoint:currentTouchPosition];

    UITableViewCell *cell=[self tableView:tableView cellForRowAtIndexPath:indexPath];

 }

37、设置UItableViewCell 右侧小箭头

  cell.accessoryType=UITableViewCellAccessoryDisclosureIndicator;

38、UILabel 文字显示删除线方法如图：

aaarticlea/png;base64,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" alt="" width="638" height="81" />

 NSString *bottomStr=[NSString stringWithFormat:@"原价%@",model.standardPrice];

 NSMutableAttributedString *attrString=[[NSMutableAttributedString alloc]initWithString:bottomStr];

 [attrString addAttribute:NSStrikethroughStyleAttributeName value:[NSNumber numberWithInteger:NSUnderlinePatternSolid | NSUnderlineStyleSingle]

 range:NSMakeRange(, bottomStr.length)];

 self.bottomLb.attributedText=attrString;

39、xxx文件 is missing from working copy 解决方法

解决方案:
1.打开终端
2.cd 到警告所提示的文件夹下
3.执行命令svn rm --force 丢失文件的名称 4.回车

5. find . -type d -name .svn | xargs rm -rf //该命令为直接删除指定文件夹下所有SVN相关
6. sudo find /Users/KingKong/Desktop/Scitel_Project/iOS-BigEvent/ -name ".svn" -exec rm -r {} \;//红色字体为项目路径

40、解决 UITableView 等UI控件下移的问题

.//下方显示不全

_tableView.contentInset=UIEdgeInsetsMake(, , -, );   

、//其他UI控件下移复位处理

self.navigationController.navigationBar.translucent = NO;  

self.edgesForExtendedLayout = UIRectEdgeNone; 

self.automaticallyAdjustsScrollViewInsets = YES;

self.extendedLayoutIncludesOpaqueBars = YES;

41、UITableView 复用时实现修改FooterView背景色方法

- (void)tableView:(UITableView *)tableView willDisplayFooterView:(UIView *)view forSection:(NSInteger)section {

    view.tintColor = HGTableViewBackColor;

}

42、修改UIProgressView 高度的方法

CGAffineTransform transform = CGAffineTransformMakeScale(1.0f, 5.0f);

self.progressView.transform = transform;

需要导入CoreGraphics.framework包

43、根据index(下标)获取TableViewCell

 NSIndexPath *indexPath =  [NSIndexPath indexPathForItem:i inSection:];

 UITableViewCell *cell =  [self.tableView cellForRowAtIndexPath:indexPath];

44、iOS 中 _OBJC_CLASS_$_xxxx 问题解决方案

错误代码：

Undefined symbols for architecture x86_64:

"_OBJC_CLASS_$_QQApiInterface", referenced from: