JavaScriptCore in swift

         JavaScriptCore是IOS7之后苹果悄悄推出的一个框架，用于Javascript与objective-c/swift互通。让Javascript开发者可以轻松愉快地用Javascript编写应用程序。

         根据我学习的原则，新东西学习，就一起学吧，所以边学swift边学Javascript，于是就用swift来折腾折腾JavaScriptCore。

#import "JSContext.h"
#import "JSValue.h"
#import "JSManagedValue.h"
#import "JSVirtualMachine.h"
#import "JSExport.h"

一、先看看JavaScriptCore框架的头文件：

JSContext：Javascript的运行环境，一个JSContext就是一个Javascript的一个运行环境，也叫做作用域；个人理解，这个东西就是你有swift里的一个Javascript运行环境。

JSValue：JSContext里的不同的Javascript值都可以封闭在JSVslue的对象里，包括字符串、数值、数组、函数等，甚至还有Error以及null和undefined；同时这个类型的对象可以方便快速地转化为swift里常用的数据类型，如toBool()、toUInt32()、toArray()、toDictionary()等；简单地说就是Javascript中的数据类型与swift中的数据类型相互转化的一个中间数据类型
   附：JavaScript与objective-c/swift中的数据类型对应表

  Objective-C/swift  type  |   JavaScript type
 --------------------------+---------------------
         nil               |     undefined
        NSNull             |        null
       NSString            |       string
       NSNumber            |   number, boolean
     NSDictionary          |   Object object
       NSArray             |    Array object
        NSDate             |     Date object
       NSBlock (1)         |   Function object (1)
          id (2)           |   Wrapper object (2)
        Class (3)          | Constructor object (3)

 

JSManagedValue：该类型主要是作为一个引用桥接，将JSValue转为JSManagedValue类型后，可以添加到JSVirtualMachine对象中，这样能够保证你在使用过程中JSValue对象不会被释放掉，当你不再需要该JSValue对象后，从JSVirtualMachine中移除该JSManagedValue对象，JSValue对象就会被释放并置空。

JSVirtualMachine:JSVirtualMachine就是一个用于保存弱引用对象的数组，加入该数组的弱引用对象因为会被该数组retain，所以保证了使用时不会被释放，当数组里的对象不再需要时，就从数组中移除，没有了引用的对象就会被系统释放；

JSExport:JSExport是一个协议，让JSContext运行环境中的JavaScript 可以识别该协议中定义的实例方法、类方法、属性等，让objective-c/swift与JavaScript能够自动交互；

二、框架的整体结构大概了解一二了，接下来动手写写代码

 var context:JSContext = JSContext()//JSContext就是一个JS运行环境

        context.evaluateScript("var number = 5 + 5")//往运行环境里加整形变量
        context.evaluateScript("var names = ['Grace','Joe','Mike']")//数组
        context.evaluateScript("var triple = function(value){return value * 4}")//方法


        var tripleNumber:JSValue = context.evaluateScript("triple(number)")
        println("\(tripleNumber)")//40
        let ocnames:JSValue = context.objectForKeyedSubscript("names")//取出JS运行环境里的数组（为JSValue类型）
        var len = ocnames.objectForKeyedSubscript("length")//取出来的JSValue遵循JavaScript中的数组属性，所以可以直接取到JavaScript数组中的“length”取得数组中的长度
        println("ocnames:\(ocnames) count: \(len.toInt32())")//ocnames:Grace,Joe,Mike count: 3 JSValue转化为swift中的Int:len.toInt32()
        ocnames.setObject("himily", atIndexedSubscript: 8)
        len = ocnames.objectForKeyedSubscript("length")
        println("after set 'himily' at indext 8 ocnames:\(ocnames) count: \(len.toInt32())")//after set 'himily' at indext 8 ocnames:Grace,Joe,Mike,,,,,,himily count: 9 取出来的JSValue遵循JavaScript中的数组属性,无下标越界，自动延展数组大小
        let firstName:JSValue = ocnames.objectAtIndexedSubscript(1)//取出JS运行环境里的数组中指定下标的元素
        println("first name = \(firstName)")//first name = Joe
        let tripleFun:JSValue = context.objectForKeyedSubscript("triple")//取出JS运行环境中的方法
        let tripleResult = tripleFun.callWithArguments([9])//调用JS运行环境 中的方法

代码注释已经很清楚，从上面代码我们总结几点：

1、在OC/swift里，所有JavaScript代码都需要在JavaScript运行环境（JSContext）中通过evaluateScript运行；

2、在OC/swift里，所有JavaScript中的方法、对象、属性都需要通过objectForKeyedSubscript来取得，取得所有对象均为JSValue类型

3、通过objectForKeyedSubscript取得的JavaScript中的对象，都遵循该对象在JavaScript中有的所有特性，如上述代码中数组的长度，无数组越界，自动延展的特性

4、通过objectForKeyedSubscript取得的JavaScript中的方法，均可以通过callWithArguments传入参数调用JavaScript中的方法并返回正确的结果（类型仍然为JSValue）

三、JacaScript环境中异常检测

//异常处理 用于检查和记录语法、类型和运行时的错误,该闭包可以检测当前context中所有JavaScript的出错
        context.exceptionHandler = {context,exception in
            println("JS Error:\(exception)")
        }
        context.evaluateScript("function sqare(value1,value2){return value1 * value2")//JS Error:SyntaxError: Unexpected end of script 检测到语法出错  没有右边的“}”

在OC中exceptionHandler是block 在swift中exceptionHandler是闭包，用于检测当然JSContext运行环境中所有JavaScript代码的语法错误。如上述例子抛出了语句没结束的异常；

四、JSExport

创建一个继承JSExport协议的PersonJSExports

@objc protocol PersonJSExports:JSExport{
    var firstName:String{get set}
    var lastName:String{get set}
    var birthYear:NSNumber?{get set}
}

创建一个Person,让它继承PersonJSExports协议

@objc class Person:NSObject,PersonJSExports{
    dynamic var firstName:String
    dynamic var lastName:String
    dynamic var birthYear:NSNumber?
    init(firstName:String,lastName:String){
        self.firstName = firstName
        self.lastName = lastName
        self.birthYear = NSNumber(int: 1986)
    }
}

创建一个Person的对象实例，记其成为contex环境中的“Person”

  var personal:Person = Person(firstName: "lily", lastName: "king")
        context.setObject(personal, forKeyedSubscript:"Person")//把Person类导出到JS中去
        var p:JSValue = context.objectForKeyedSubscript("Person")
        var first:JSValue = p.objectForKeyedSubscript("firstName")
        var last:JSValue = p.objectForKeyedSubscript("lastName")
        var year:JSValue = p.objectForKeyedSubscript("birthYear")

        println("p.first:\(first) p.last:\(last) p.year:\(year)")//这里面有个incorporate一词值得推敲，经过验证只有直接继承了JSExport的中自定义协议(@protocol)（定义的属性、方法）才能在JSContext中访问到 分两种情况 1.如果PersonJSExports（直接继承JSExport）里有定义firstName、lastName则打印出 p.first:lily p.last:king 2、如果PersonJSExports里没有定义firstName、lastName则打印出p.first:undefined p.last:undefined
        personal.firstName = "lucy"
        personal.lastName = "queen"
        personal.birthYear = NSNumber(int: 1999)
        var first1:JSValue = p.objectForKeyedSubscript("firstName")
        var last1:JSValue = p.objectForKeyedSubscript("lastName")
        var year1:JSValue = p.objectForKeyedSubscript("birthYear")
        println("aftter change p.first:\(first1) p.last:\(last1) p.year:\(year1)")//经过验证只有直接继承了JSExport的中自定义协议(@protocol)（定义的属性、方法）才能在JSContext中访问到 分两种情况 1.如果PersonJSExports（直接继承JSExport）里有定义firstName、lastName则打印出 p.first:lucy p.last:queen 2、如果PersonJSExports里没有定义firstName、lastName则打印出aftter change p.first:undefined p.last:undefined full name undefined

由上面代码的输出可以看到，只有直接继承了JSExport的中自定义协议(@protocol)（定义的属性、方法）才能在JSContext中访问到。

 

关于JSExport中定义的方法，用OC来写一段

定义一个UIButtonJsexport让其直接继承JSExport协议

@protocol UIButtonJsexport <JSExport>

- (void)setTitle:(NSString *)title forState:(UIControlState)state;

@end

创建 一个button，同时把UIButton添加一个UIButtonJsexport协议class_addProtocol([UIButton class], @protocol(UIButtonJsexport));

    class_addProtocol([UIButton class], @protocol(UIButtonJsexport));
    UIButton *button = [[UIButton alloc] initWithFrame:CGRectMake(100, 100, 100, 40)];
    [button setTitle:@"objective-c" forState:UIControlStateNormal];
    [button setBackgroundColor:[UIColor blueColor]];
    [self.view addSubview:button];
    context = [[JSContext alloc] init];
    [context setObject:button forKeyedSubscript:@"button"];
    context.exceptionHandler = ^(JSContext *con,JSValue *exception){
        con.exception = exception;
        NSLog(@"JS error:%@",exception);
    };
    [button addTarget:self action:@selector(click) forControlEvents:UIControlEventTouchUpInside];

点击的时候在context中改变button的title

-(void)click
{
    [context evaluateScript:@"button.setTitleForState('JavaScript',0)"];
}

当运行点击UIButton时就会看到button的title被改变了，也证明了对于已定义的类，也可以在运行时添加神奇的JSExport协议让它们可以在Objective-C和JavaScript直接实现友好互通。