简介： 所谓动静热修补就是把可能导致app 解体的重大bug，提交新版本到appstore 审核速度太慢影响用户应用，这时候就能够利用 JSPatch 能够让你用 JavaScript 书写原生 iOS APP。

所谓动静热修补就是把可能导致app 解体的重大bug，提交新版本到appstore 审核速度太慢影响用户应用，这时候就能够利用

JSPatch 能够让你用 JavaScript 书写原生 iOS APP。只需在我的项目引入极小的引擎，就能够应用 JavaScript 调用任何 Objective-C 的原生接口，取得脚本语言的劣势：为我的项目动静增加模块，或替换我的项目原生代码动静修复 bug。

这里就不在赘述优缺点重点看实现！

（一）首先在终端

pod search JSPatch

接下来就能够本人pod进你须要引入的工程中，或者download到本地本人加到工程中搜寻后果如下

-> JSPatch (0.1.4)  JSPatch bridge Objective-C and JavaScript. You can call any Objective-C class  and method in JavaScript by just including a small engine.  pod 'JSPatch', '~> 0.1.4'  - Homepage: https://github.com/bang590/JSPatch  - Source: https://github.com/bang590/JSPatch.git  - Versions: 0.1.4, 0.1.3, 0.1.2, 0.1.1, 0.1, 0.0.3, 0.0.2, 0.0.1 [master  repo] - 0.1.4, 0.1.3, 0.1.2, 0.1.1, 0.1, 0.0.3, 0.0.2, 0.0.1 [master-1 repo]  - Subspecs:   - JSPatch/Core (0.1.4)   - JSPatch/Extensions (0.1.4)macxy:~ xy$

个别咱们将执行的".js"文件放在服务器端每次程序启动时候能够执行比对本地js文件与服务器端js文件是否有变动这里细节就不做解释

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {   // 加载引擎  [JPEngine startEngine];//  本地JS，动静更新技术就是通过服务器获取JS更新这个JS  NSString *sourcePath = [[NSBundle mainBundle] pathForResource:@"demo" ofType:@"js"];  NSString *script = [NSString stringWithContentsOfFile:sourcePath encoding:NSUTF8StringEncoding error:nil];  [JPEngine evaluateScript:script];  从服务器获取更新JS  [NSURLConnection sendAsynchronousRequest:[NSURLRequest requestWithURL:[NSURL URLWithString:@"http://cnbang.net/test.js"]] queue:[NSOperationQueue mainQueue] completionHandler:^(NSURLResponse *response, NSData *data, NSError *connectionError) {  NSString *script = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];   //执行js  [JPEngine evaluateScript:script];  }];}

这是大略过程举个小栗子形容下js替换的具体利用；

先上一段js文件解释下oc与js交互如何拜访oc API

//按钮事件defineClass('YFJSPatchMainViewController', {//哪个类中的办法  buttonTouch: function(button) {//办法名：function(参数)//跳转到tableView    var tableViewCtrl = YFJSPatchTsetViewController.alloc().init()self.navigationController().pushViewController_animated(tableViewCtrl, YES) } })

置信大家也都看的懂那么咱们要怎么去用呢比方 我下面所写的就是要找到

YFJSPatchMainViewController这个类中的

-（void）buttonTouch：（uibutton）btn{}这个办法最开始咱们什么都没有写，当执行完js文件后这个办法就会去执行js  而后push；原理就是这样要本人去用一下才好祝您欢快

  1. require

在应用Objective-C类之前须要调用 require('className’) :

require('UIView')var view = UIView.alloc().init()

能够用逗号 , 分隔，一次性导入多个类:

require('UIView, UIColor')var view = UIView.alloc().init()var red = UIColor.redColor()

或者间接在应用时才调用 require() :

require('UIView').alloc().init()

  1. 调用OC办法

调用类办法

var redColor = UIColor.redColor();

调用实例办法

var view = UIView.alloc().init();view.setNeedsLayout();

参数传递

跟在OC一样传递参数:

var view = UIView.alloc().init();var superView = UIView.alloc().init()superView.addSubview(view)

Property

获取/批改 Property 等于调用这个 Property 的 getter / setter 办法，获取时记得加 ():

view.setBackgroundColor(redColor);var bgColor = view.backgroundColor();

办法名转换

多参数办法名应用 _ 分隔：

var indexPath = require('NSIndexPath').indexPathForRow_inSection(0, 1);

若原 OC 办法名里蕴含下划线 _，在 JS 应用双下划线 __ 代替：

// Obj-C: [JPObject _privateMethod];JPObject.__privateMethod()

  1. defineClass

API

defineClass(classDeclaration, [properties,] instanceMethods, classMethods)

@param classDeclaration: 字符串，类名/父类名和Protocol
@param properties: 新增property，字符串数组，可省略
@param instanceMethods: 要增加或笼罩的实例办法
@param classMethods: 要增加或笼罩的类办法

笼罩办法

1.在 defineClass 里定义 OC 已存在的办法即可笼罩，办法名规定与调用规定一样，应用 _ 分隔:

// OC@implementation JPTestObject- (void)tableView:(UITableView *)tableView didSelectRowAtIndexPath:(NSIndexPath *)indexPath{}@end

// JSdefineClass("JPTableViewController", {  tableView_didSelectRowAtIndexPath: function(tableView, indexPath) {    ...  },})

2.应用双下划线 __ 代表原OC办法名里的下划线 _ :

// OC@implementation JPTableViewController- (NSArray *) _dataSource {}@end

// JSdefineClass("JPTableViewController", {  __dataSource: function() {  },})

3.在办法名前加 ORIG 即可调用未笼罩前的 OC 原办法:

// OC@implementation JPTableViewController- (void)viewDidLoad {}@end

// JSdefineClass("JPTableViewController", {  viewDidLoad: function() {     self.ORIGviewDidLoad();  },})

笼罩类办法

defineClass() 第三个参数就是要增加或笼罩的类办法，规定与上述笼罩实例办法统一：

// OC@implementation JPTestObject+ (void)shareInstance{}@end

// JSdefineClass("JPTableViewController", {  //实例办法}, {  //类办法  shareInstance: function() {    ...  },})

笼罩 Category 办法

笼罩 Category 办法与笼罩一般办法一样：

@implementation UIView (custom)- (void)methodA {}+ (void)clsMethodB {}@end

defineClass('UIView', {  methodA: function() {  }}, {  clsMethodB: function() {  }});

Super

应用 self.super() 接口代表 super 关键字，调用 super 办法:

// JSdefineClass("JPTableViewController", {  viewDidLoad: function() {     self.super().viewDidLoad();  }})

Property

获取/批改 OC 定义的 Property

用调用 getter / setter 的形式获取/批改已在 OC 定义的 Property:

// OC@interface JPTableViewController@property (nonatomic) NSArray *data;@property (nonatomic) NSString *shareURL;@property (nonatomic) NSString *shareTitle;@end@implementation JPTableViewController@end

// JSdefineClass("JPTableViewController", {  viewDidLoad: function() {     var data = self.data();     //get property value     self.setData(data.toJS().push("JSPatch"));     //set property value     var sel = self;     self.bridge().registerHandler_handler('h5ToNativeShareDialog', block('NSDictionary *',function(data,responseCallback) {                  sel.setShareURL(data.objectForKey('url'));         sel.setShareTitle(data.objectForKey('title'));     }));})

动静新增 Property

能够在 defineClass() 第二个参数为类新增 property，格局为字符串数组，应用时与 OC property 接口统一：

defineClass("JPTableViewController", ['data', 'totalCount'], {  init: function() {     self = self.super().init()     self.setData(["a", "b"])     //增加新的 Property (id data)     self.setTotalCount(2)     return self  },  viewDidLoad: function() {     var data = self.data()     //获取 Property 值     var totalCount = self.totalCount()  },})

公有成员变量

应用 valueForKey() 和 setValue_forKey() 获取/批改公有成员变量:

// OC@implementation JPTableViewController {     NSArray *_data;}@end

// JSdefineClass("JPTableViewController", {  viewDidLoad: function() {     var data = self.valueForKey("_data")     //get member variables     self.setValue_forKey(["JSPatch"], "_data")     //set member variables  },})

增加新办法

能够给一个类随便增加 OC 未定义的办法，但所有的参数类型都是 id:

// OC@implementation JPTableViewController- (void)viewDidLoad{     NSString* data = [self dataAtIndex:@(1)];     NSLog(@"%@", data);      //output: Patch}@end

// JSvar data = ["JS", "Patch"]defineClass("JPTableViewController", {  dataAtIndex: function(idx) {     return idx < data.length ? data[idx]: ""  }})

若新增的办法属于 Protocol 里的接口，须要在 defineClass 的类申明参数里指明实现的 Protocol，详见下文。

Protocol

能够在定义时让一个类实现某些 Protocol 接口，写法跟 OC 一样:

defineClass("JPViewController: UIViewController<UIScrollViewDelegate, UITextViewDelegate>", {})

这样做的作用是，当增加 Protocol 里定义的办法，而类里没有实现的办法时，参数类型不再全是 id，而是主动转为 Protocol 里定义的类型:

@protocol UIAlertViewDelegate <NSObject>...- (void)alertView:(UIAlertView *)alertView clickedButtonAtIndex:(NSInteger)buttonIndex;...@end

defineClass("JPViewController: UIViewController <UIAlertViewDelegate>", {  viewDidAppear: function(animated) {    var alertView = require('UIAlertView')      .alloc()      .initWithTitle_message_delegate_cancelButtonTitle_otherButtonTitles(        "Alert",        self.dataSource().objectAtIndex(indexPath.row()),         self,         "OK",         null      )     alertView.show()  }  alertView_clickedButtonAtIndex: function(alertView, buttonIndex) {    console.log('clicked index ' + buttonIndex)  }})

  1. 非凡类型

Struct

JSPatch原生反对 CGRect / CGPoint / CGSize / NSRange 这四个 struct 类型，用 JS 对象示意:

// Obj-CUIView *view = [[UIView alloc] initWithFrame:CGRectMake(20, 20, 100, 100)];[view setCenter:CGPointMake(10,10)];[view sizeThatFits:CGSizeMake(100, 100)];CGFloat x = view.frame.origin.x;NSRange range = NSMakeRange(0, 1);

// JSvar view = UIView.alloc().initWithFrame({x:20, y:20, width:100, height:100})view.setCenter({x: 10, y: 10})view.sizeThatFits({width: 100, height:100})var x = view.frame().xvar range = {location: 0, length: 1}

其余 Struct 类型的反对请参照 增加 struct 类型反对

Selector

在JS应用字符串代表 Selector:

//Obj-C[self performSelector:@selector(viewWillAppear:) withObject:@(YES)];

//JSself.performSelector_withObject("viewWillAppear:", 1)

nil

JS 上的 null 和 undefined 都代表 OC 的 nil，如果要示意 NSNull, 用 nsnull 代替，如果要示意 NULL, 也用 null 代替:

//Obj-C@implemention JPTestObject+ (BOOL)testNull(NSNull *null) {    return [null isKindOfClass:[NSNull class]]}@end

//JSrequire('JPTestObject').testNull(nsnull) //return 1require('JPTestObject').testNull(null) //return 0

在JS外面判断是否为空要判断false:

var url = "";var rawData = NSData.dataWithContentsOfURL(NSURL.URLWithString(url));if (rawData != null) {} //这样判断是谬误的应该如下判断：if (!rawData){}在JSPatch.js源码里_formatOCToJS办法对undefined,null,isNil转换成了false。

  1. NSArray / NSString / NSDictionary

NSArray / NSString / NSDictionary 不会主动转成对应的JS类型，像一般 NSObject 一样应用它们:

//Obj-C@implementation JPObject+ (NSArray *)data{  return @[[NSMutableString stringWithString:@"JS"]]}+ (NSMutableDictionary *)dict{    return [[NSMutableDictionary alloc] init];}@end

// JSrequire('JPObject')var ocStr = JPObject.data().objectAtIndex(0)ocStr.appendString("Patch")var dict = JPObject.dict()dict.setObject_forKey(ocStr, 'name')console.log(dict.objectForKey('name')) //output: JSPatch

如果要把 NSArray / NSString / NSDictionary 转为对应的 JS 类型，应用 .toJS() 接口:

// JSvar data = require('JPObject').data().toJS()//data instanceof Array === truedata.push("Patch")var dict = JPObject.dict()dict.setObject_forKey(data.join(''), 'name')dict = dict.toJS()console.log(dict['name'])    //output: JSPatch

  1. Block

block 传递

当要把 JS 函数作为 block 参数给 OC时，须要先应用 block(paramTypes, function) 接口包装:

// Obj-C@implementation JPObject+ (void)request:(void(^)(NSString *content, BOOL success))callback{  callback(@"I'm content", YES);}@end

// JSrequire('JPObject').request(block("NSString *, BOOL", function(ctn, succ) {  if (succ) log(ctn)  //output: I'm content}))

这里 block 里的参数类型用字符串示意，写上这个 block 各个参数的类型，用逗号分隔。NSObject 对象如 NSString *, NSArray *等能够用 id 示意，但 block 对象要用 NSBlock* 示意。

从 OC 返回给 JS 的 block 会主动转为 JS function，间接调用即可:

// Obj-C@implementation JPObjecttypedef void (^JSBlock)(NSDictionary *dict);+ (JSBlock)genBlock{  NSString *ctn = @"JSPatch";  JSBlock block = ^(NSDictionary *dict) {    NSLog(@"I'm %@, version: %@", ctn, dict[@"v"])  };  return block;}+ (void)execBlock:(JSBlock)blk{}@end

// JSvar blk = require('JPObject').genBlock();blk({v: "0.0.1"});  //output: I'm JSPatch, version: 0.0.1

若要把这个从 OC 传过来的 block 再传回给 OC，同样须要再用 block() 包装，因为这里 blk 曾经是一个一般的 JS function，跟咱们下面定义的 JS function 没有区别：

// JSvar blk = require('JPObject').genBlock();blk({v: "0.0.1"});  //output: I'm JSPatch, version: 0.0.1require('JPObject').execBlock(block("id", blk));

总结：JS 没有 block 类型的变量，OC 的 block 对象传到 JS 会变成 JS function，所有要从 JS 传 block 给 OC 都须要用 block() 接口包装。

block 里应用 self 变量

在 block 里无奈应用 self 变量，须要在进入 block 之前应用长期变量保留它:

defineClass("JPViewController", {  viewDidLoad: function() {    var slf = self;    require("JPTestObject").callBlock(block(function(){      //`self` is not available here, use `slf` instead.      slf.doSomething();    });  }}

限度

从 JS 传 block 到 OC，有两个限度：

A. block 参数个数最多反对6个。（若须要反对更多，能够批改源码）
B. block 参数类型不能是 double / NSBlock / struct 类型。

另外不反对 JS 封装的 block 传到 OC 再传回 JS 去调用（起因见 issue #155）：

- (void)callBlock:(void(^)(NSString *str))block {}

defineClass('JPTestObject', {    run: function() {        self.callBlock(block('NSString*', function(str) {            console.log(str);        }));    },    callBlock: function(blk) {        //blk 这个 block 是下面的 run 函数里 JS 传到 OC 再传过来的，无奈调用。        blk("test block");       }});

  1. __weak / __strong

能够在 JS 通过 __weak() 申明一个 weak 变量，次要用于防止循环援用。

例如咱们在 OC 里为了防止 block 导致的循环援用，常常这样写：

- (void)test {    __weak id weakSelf = self;    [self setCompleteBlock:^(){        [weakSelf blabla];    }]}

在 JS 对应的能够这样写：

var weakSelf = __weak(self)self.setCompleteBlock(block(function(){    weakSelf.blabla();}))

若要在应用 weakSelf 时把它变成 strong 变量，能够用 __strong() 接口：

var weakSelf = __weak(self)self.setCompleteBlock(block(function(){    var strongSelf = __strong(weakSelf)    strongSelf.blabla();}))

  1. GCD

应用 dispatch_after() dispatch_async_main() dispatch_sync_main() dispatch_async_global_queue() 接口调用GCD办法:

// Obj-Cdispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{  // do something});dispatch_async(dispatch_get_main_queue(), ^{  // do something});

// JSdispatch_after(1.0, function(){  // do something})dispatch_async_main(function(){  // do something})dispatch_sync_main(function(){  // do something})dispatch_async_global_queue(function(){  // do something})

  1. 传递 id* 参数

如果你须要传递 id* 参数，像 NSURLConnection 里的这个接口里的 NSError **:

+ (NSData *)sendSynchronousRequest:(NSURLRequest *)request returningResponse:(NSURLResponse **)response error:(NSError **)error;

这里传入的是一个指向 NSObject 对象的指针，在办法里能够批改这个指针指向的对象，调用后内部能够拿到新指向的对象，对于这样的参数，首先须要引入 JPMemory 扩大，而后按以下步骤进行传递和获取：

  1. 应用 malloc(sizeof(id)) 创立一个指针
  2. 把指针作为参数传给办法
  3. 办法调用完，应用 pval() 拿到指针新指向的对象
  4. 应用完后调用 releaseTmpObj() 开释这个对象
  5. 应用 free() 开释指针

举个例子:

//OC- (void)testPointer:(NSError **)error {    NSError *err = [[NSError alloc]initWithDomain:@"com.jspatch" code:42 userInfo:nil];    *error = err;}

//JS//malloc() pval() free() is provided by JPMemory extensionrequire('JPEngine').addExtensions(['JPMemory'])var pError = malloc(sizeof("id"))self.testPointer(pError)var error = pval(pError)if (!error) {    console.log("success")} else {    console.log(error)}releaseTmpObj(pError)free(pError)

若反过来你想在 JS 替换上述 -testPointer: 办法，构建 NSError 对象赋给传进来的指针，能够这样写：

defineClass('JPClassName', {    testPointer: function(error){        var  tmp = require('NSError').errorWithDomain_code_userInfo("test", 1, null);        var newErrorPointer = getPointer(tmp)        memcpy(error, newErrorPointer, sizeof('id'))    });

  1. 常量、枚举、宏、全局变量

常量/枚举

Objective-C 里的常量/枚举不能间接在 JS 上应用，能够间接在 JS 上用具体值代替：

//OC[btn addTarget:self action:@selector(handleBtn) forControlEvents:UIControlEventTouchUpInside];

//UIControlEventTouchUpInside的值是1<<6btn.addTarget_action_forControlEvents(self, "handleBtn", 1<<6);

或者在 JS 上从新定义同名的全局变量：

//jsvar UIControlEventTouchUpInside  = 1 << 6;btn.addTarget_action_forControlEvents(self, "handleBtn", UIControlEventTouchUpInside);

有些常量字符串，须要在 OC 用 NSLog 打出看看它的值是什么：

//OC[[NSAttributedString alloc].initWithString:@"str" attributes:@{NSForegroundColorAttributeName: [UIColor redColor]];

下面代码中 NSForegroundColorAttributeName 是一个动态字符串常量，源码里看不出它的值，能够先用 NSLog 打出它的值再间接写在 JS 上：

//OCNSLog(@"%@", NSForegroundColorAttributeName) //output 'NSColor'

NSAttributedString.alloc().initWithString_attributes("有效啊", {'NSColor': UIColor.redColor()});

宏

获取宏值

Objective-C 里的宏同样不能间接在 JS 上应用。若定义的宏是一个值，能够在 JS 定义同样的全局变量代替，若定义的宏是程序，能够在JS开展宏：

#define TABBAR_HEIGHT 40#define SCREEN_WIDTH [[UIScreen mainScreen] bounds].size.height[view setWidth:SCREEN_WIDTH height:TABBAR_HEIGHT];

//JSview.setWidth_height(UIScreen.mainScreen().bounds().height, 40);

若宏的值是某些在底层能力获取到的值，例如 CGFLOAT_MIN，能够通过在某个类或实例办法里将它返回，或者用增加扩大的形式提供反对：

@implementation JPMacroSupport+ (void)main:(JSContext *)context{  context[@"CGFLOAT_MIN"] = ^CGFloat() {    return CGFLOAT_MIN;  }}@end

require('JPEngine').addExtensions(['JPMacroSupport'])var floatMin = CGFLOAT_MIN();

批改宏值

JSPatch 不反对批改宏的值，若要批改，须要替换所有应用到这个宏的办法。例如：

#define VIEW_HEIGHT 40@implementation JPMethodDemo+ (void)func{  UIView *view = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 100, VIEW_HEIGHT)];  ...}@end

//JSvar VIEW_HEIGHT_NEW = 20;defineClass('JPMethodDemo', {  func: function() {    var view = UIView.alloc().initWithFrame({x:0, y:0, width:100, height:VIEW_HEIGHT_NEW});    ...  }});

全局变量

在类里定义的 static 全局变量无奈在 JS 上获取到，若要在 JS 拿到这个变量，须要在 OC 有类办法或实例办法把它返回：

static NSString *name;@implementation JPTestObject+ (NSString *)name {  return name;}@end

var name = JPTestObject.name() //拿到全局变量值

  1. Swift

应用 defineClass() 笼罩 Swift 类时，类名应为 我的项目名.原类名，例如我的项目 demo 里用 Swift 定义了 ViewController 类，在 JS 笼罩这个类办法时要这样写：

defineClass('demo.ViewController', {})

对于调用已在 swift 定义好的类，也是一样：

require('demo.ViewController')

须要留神几点：

  1. 只反对调用继承自 NSObject 的 Swift 类
  2. 继承自 NSObject 的 Swift 类，其继承自父类的办法和属性能够在 JS 调用，其余自定义办法和属性同样须要加 dynamic 关键字才行。
  3. 若办法的参数/属性类型为 Swift 特有(如 Character / Tuple)，则此办法和属性无奈通过 JS 调用。
  4. Swift 我的项目在 JSPatch 新增类与 OC 无异，能够失常应用。
  5. 加载动静库

对于 iOS 内置的动静库，若原 APP 里没有加载，能够通过以下形式动静加载，以加载 SafariServices.framework 为例：

var bundle = NSBundle.bundleWithPath("/System/Library/Frameworks/SafariServices.framework");bundle.load();

加载后就能够应用 SafariServices.framework 了。

  1. 调试

能够应用 console.log() 打印一个对象，作用相当于 NSLog()，会间接在 XCode 控制台打出。

console.log() 反对任意参数，但不反对像 NSLog 这样 NSLog(@"num:%f", 1.0) 的拼接：

var view = UIView.alloc().init();var str = "test";var num = 1;console.log(view, str, num)console.log(str + num);   //间接在JS拼接字符串

也能够通过 Safari 的调试工具对 JS 进行断点调试.

举荐????：

如果你想一起进阶，理解最新面试行情无妨增加一下交换群642363427
查看原文