__android_log_print就像printf 一样，在格式化字符串中设置占位符 ``fmt中
__android_log_print(ANDROID_LOG_ERROR,"SSSS","I'm %s \t ,age %d",name,age);

常见参数
	%c　　　　 一个字符(char)
	%d　　　　有符号十进制整数(int)
	%e　　　　浮点数、e-记数法
	%f　　　　 单精度浮点数(默认float)、十进制记数法（%.nf  这里n表示精确到小数位后n位.十进制计数）
	%i              有符号十进制数（与％d相同）
	%p　　　   指针
	%s　　　　 对应字符串char*（%S             对应宽字符串WCAHR*（%u　　　   无符号十进制整数(unsigned int)
	%%　　　  打印一个百分号

刚才我在n个月前待过的一个组的同学问我的某个文件的某几行代码是不是我提交的，为什么要那么写。在感慨岁月不饶人记忆力急剧衰退的同时，我也发出了这样的疑问，这玩意是我造的么，怎么看都不像啊。看着这个文件上百次的svn提交log，一阵晕，这要找到，得等到新玛雅历了。。。我决定还是来段脚本吧。
 
#!/usr/bin/python
# -*- coding:utf-8 -*-

'''
先取最新100个记录，如果还没找到，从上一次批量查询里最老版本号,继续增量往前找。
'''
import os
import sys
import readline

svnpath = "http://svn.xx.com/xxxxx/../xx.cc";
step=100
pattern = "pthread_mutex_lock"

def thankyou():
  print "thank you, bye."
  sys.exit()

def seek(_vers, _filepath, _pattern):
  for i in range(len(_vers)-1):
    content = ""
    isfound = False
    cmd = "svn diff -r%s:%s %s" % (_vers[i+1], _vers[i], _filepath)
    for line in os.popen(cmd) :
      content += line
      if line.find(_pattern)>=0 :
        isfound = True
    if isfound:
      print content
      while True :
        try:
          cmd = raw_input("Continue?(Y/N)")
        except EOFError:
          thankyou()
        except KeyboardInterrupt:
          thankyou()
        if cmd.upper() == 'Y':
          break
        else:
          thankyou()

def getvers(_ver, _step, _filepath):
  _vers = []
  if _ver:
    cmd = "svn log --quiet -r%d:1 --limit %d %s | grep -o -e 'r[0-9]\+'" % (_ver, _step, _filepath)
  else:
    cmd = "svn log --quiet --limit %d %s | grep -o -e 'r[0-9]\+'" % (_step, _filepath)
  for line in os.popen(cmd):
    _vers.append(line.strip()[1:])
  return _vers

if __name__ == "__main__":
  lastver = 1
  while lastver:
    lastver -= 1
    versions = getvers(lastver, step, svnpath)
    lens = len(versions)
    if lens :
      seek(versions, svnpath, pattern)
      if lens == step:
        lastver = int(versions[lens-1])+1
      else:
        lastver = 0

在js中字符串不是对象，它是不可被修改的，就像在使用toUpperCase方法之后不会改变原来的字符串的值，而是新创建了一个字符串。

1、length属性
length代表长度，不是length()
var broweType = 'mozilla';
console.log(broweType.length);    //输出结果为7

2、indexof()方法，判断字符串中是否有某个内容，如果有，返回一个索引，没有返回－1
console.log("检索字符串"+broweType.indexOf('zilla'));          // 返回2


if(broweType.indexOf('lla') != -1){
    //broweType中存在lla             //   判断字符串中是否存在某个内容
}//browe不存在lla

3、提取字符串
console.log(broweType.slice(0,3));                   // 输出moz
//提取字符串   提取的时候不包括最后一个数字

可以为两个参数，也可以为一个参数，为一个参数的时候从参数开始提取到最后一个
4、转换大小写
 var radData = 'My NaMe Is MuD';          //转换大小写
    console.log(radData.toLowerCase());
    console.log(radData.toUpperCase());

5、
//替换字符串
console.log(broweType.replace('moz', 'van'));

用后面的内容替换前面的内容，并返回一个新的字符串，原来的字符串并不会改变

字符串常用的方法
字符串的平常的方法，返回的是新的字符串，并不是在字符串上进行更改

String
  var str = new String()
 console.log(str)

CharAt

调用方法，返回指定下标的字符串
    var str = 'hallow world'
    console.log(str.charAt(2))
   //console.log的值为l，就像 array的下标一样，从0开始 进行计算的

indexof

参数为想要确定是否 存在的下标，存在则返回开始下标，不存在返回-1
   var str = 'hallow world'
   console.log(str.lastIndexOf('ha'))  //0

lastIndexOf

从后往前进行检索， 存在 返回下标索引值（依然是从前往后数的下标值），不存在返回-1
   var str = 'hallow world'
   console.log(str.indexof('ha'))
  //console.log的值为0，下标依然从0开始计算

slice

截取字符串，两个参数，开始下标，结束下标，下标值都是从0进行计算
  var str = 'hallow world'
  console.log(str.slice(2,5))//llo

search

查询字符换 ，存在返回 下标索引（从一开始计算，与indexof不同点 ），不存在返回-1
     var str = 'hallow world'
     console.log(str.search(‘y’))//-1

replace

顾名思义，指定字符串进行替换
   var str = 'hallow world'
   console.log(str.replace('ha','ljl'))
  //console.log的值为ljlllow world

  还可以 进行搭配别的进行使用
  let newstr = str.replace(str.slice(2,5),'ljl')
  console.log(newstr)//haljlw world

split

将字符串转换成数组，以什么为标识进行拆解
    var str = 'hallowworld'
   console.log(str.split(''))  // ["h", "a", "l", "l", "o", "w", "w", "o", "r", "l", "d"]
   //上例就是 以空格为标识进行拆解

concat

合并字符串，对两个或以上 的字符串 进行合并
  var str = 'hallowworld'
  console.log(str.concat('dasdas'))  //hallowworlddasdas

以上就是字符串常用 方法，用不足的欢迎补充
数组的常用方法
pop，shift，unshift，push
   var arr = [1,2,3,4,5,6]
     //在 数组的末尾进行添加新的数据
     arr.push(7)  //[1, 2, 3, 4, 5, 6, 7]
     //在数组的开头进行删除最后一个
     arr.shift()  // [2, 3, 4, 5, 6, 7]
     //在数组的第一个进行添加 新的数据
     arr.unshift(7) //[7, 2, 3, 4, 5, 6, 7]
     //在数组的末尾进行删除数据
     arr.pop() //[7, 2, 3, 4, 5, 6]
    console.log(arr)
    //以上都是一起执行的

concat

进行数组的合并，参数为要拼接的数组 ，返回值为新的结合数组
	var arr = [1, 2, 3, 4, 5, 6]
    let res = arr.concat([1,2,3,4])
    console.log(res) //[1, 2, 3, 4, 5, 6, 1, 2, 3, 4]

fill

意为填充，full（filler，start，end） filler为会用谁进行填充，start被填充的起始下标（包括），end结束下标（不包括）
 var arr = [1, 2, 3, 4, 5, 6]
    let res = arr.fill(1,2,4)
    console.log(res) //[1, 2, 1, 1, 5, 6]

join,reverse,sort,splice,slice,
    var arr = [1, 2, 3, 4, 5, 6]
    //将数组转化为字符串 
    let res = arr.join()
    let res = arr.sort((a, b) => a - b)
    console.log(res, typeof res) //1,2,3,4,5,6 string

    // 向/从数组中添加/删除项目，然后返回被删除的项目 ，会改变原始数组 
    let res = arr.splice(index, del, 1)
    
    // index为添加的位置，del为删除的位置，0则是不删除，1为添加项
    let res = arr.splice(2, 0, 'das')  //[1, 2, "das", 3, 4, 5, 6]
    
    // 截取数组，一个参数时，从第几位截取到最后，两位的时候，从谁起到谁结束，包括结束
    let res = arr.slice(2, 4) //3,4
    
    // 翻转数组
    let res = arr.reverse()
    console.log(res) //[6, 5, 4, 3, 2, 1]

Map

返回值为一个新数组 ，可以数组进行操作 ，配合es6的新语法会更爽 ，箭头函数
 var arr = [1,2,3,4,5,6]
 //  let newArr = arr.map(function(item){return item * 2})
 let newArr = arr.map(item => item * 2)
 console.log(newArr)
 //[2, 4, 6, 8, 10, 12]

Filter

返回符合条件的数组
  var arr = [1, 2, 3, 4, 5, 6]
    let newArr = arr.filter(item => item > 2)
    console.log(newArr)
  //[3, 4, 5, 6]

Every

每一项舒服都符合条件，如果是，就返回true，否则false
 var arr = [1, 2, 3, 4, 5, 6]
    let newArr = arr.every(item => item > 2)
    console.log(newArr) //false

some

如果其中一项符合条件就 返回 true，否则返回 false
 var arr = [1, 2, 3, 4, 5, 6]
    let newArr = arr.some(item => item > 2)
    console.log(newArr) //true

find

返回符合条件的第一个下标的索引，起始值0
  	var arr = [1, 2, 3, 4, 5, 6]
    let res = arr.find(item =>  item > 5)
    console.log(res) //6
    findIndex则返回第几个，起始值为 1

reduce

相当于一个函数累加器，接受一个回调函数的结果，然后将前一次的函数结果再和下一次的数据再次执行此回调函数.
reduce(function(上一次的值,当前值,index,array){

所进行的计算

})；
[1,2,3,4,5].reduce(function(a,b){return a+b;});
 	var arr = [1, 2, 3, 4, 5, 6]
    var res = arr.reduce((a,b) => a + b)
    console.log(res)  //21

var arr = [{
      age: 18
    },{
      age: 21
    },{
      age: 32
    }]
    var allAge = arr.map(item => item.age).reduce((a, b) => a + b)
    console.log(allAge) //71 属性值的雷类型 值得关注

数组的for循环

简单的for

简单的进行遍历，可以进行相应的操作，把这个归为数组的方法就是想做个对比
  var arr = [1,2,3,4,5,6]
  for (var i = 0; i < arr.length; i++) {
    console.log(arr[i])
    //1,2,3,4,5,6
  } 

for in

主要用于对象的遍历，我只是为了方便记忆和比较进行 合并了(*￣︶￣)
    var obj = {
      name: '二狗子',
      age: 18,
      address: 'usa'
    }
    for (const key in obj) {
      console.log('属性为>>>' + key + '-----属性值为' + obj[key])
      //属性为name-----属性值为二狗子
      //属性为age-----属性值为18
      //属性为address-----属性值为usa
    }

for of

for…of循环可以作为遍历所有数据结构的统一的方法。

　　for…of循环可以使用的范围包括数组、Set 和 Map 结构、某些类似数组的对象（比如arguments对象、DOM NodeList 对象）、后文的 Generator 对象，以及字符串。
    var arr = ['a', 'b', 'c', 'd'];
        for (let a in arr) {
          console.log(a); // 0 1 2 3
        } 
        for (let a of arr) {
          console.log(a); // a b c d
        }
        //上面代码表明，for...in循环读取键名，for...of循环读取键值。
        //如果要通过for...of循环，获取数组的索引，
        //可以借助数组实例的entries方法和keys方法