2. 程式人生 > >[轉] Immutable 常用API簡介

[轉] Immutable 常用API簡介

阿新 • • 發佈：2018-03-02
isl rest gradle 數據讀取 cati clas 關於 com set

技術分享圖片

本文主要整理了Immutable.js常用API的使用。

Immutable 是什麽？

關於Immutable的定義，官方文檔是這樣說的：

Immutable data encourages pure functions (data-in, data-out) and lends itself to much simpler application development and enabling techniques from functional programming such as lazy evaluation.

簡而言之，Immutable數據就是一旦創建，就不能更改的數據。每當對Immutable對象進行修改的時候，就會返回一個新的Immutable對象，以此來保證數據的不可變。對於Immutable的好處及介紹，大家可以參考Immutable 詳解及 React 中實踐，這篇文章介紹的很清楚。

因為Immutable的官方文檔有點晦澀難懂，本文只是用來整理Immutable常用的API的使用，便於使用與查詢，想了解更詳細的內容，請戳這裏~

有不妥的地方歡迎大家指出~

Immutable 的幾種數據類型

  1. List: 有序索引集，類似JavaScript中的Array。
  2. Map: 無序索引集，類似JavaScript中的Object。
  3. OrderedMap: 有序的Map，根據數據的set()進行排序。
  4. Set: 沒有重復值的集合。
  5. OrderedSet: 有序的Set，根據數據的add進行排序。
  6. Stack: 有序集合，支持使用unshift（）和shift（）添加和刪除。
  7. Range(): 返回一個Seq.Indexed類型的集合，這個方法有三個參數，start表示開始值，默認值為0，end表示結束值，默認為無窮大，step代表每次增大的數值，默認為1.如果start = end,則返回空集合。
  8. Repeat(): 返回一個vSeq.Indexe類型的集合，這個方法有兩個參數，value代表需要重復的值，times代表要重復的次數，默認為無窮大。
  9. Record: 一個用於生成Record實例的類。類似於JavaScript的Object，但是只接收特定字符串為key，具有默認值。
  10. Seq: 序列，但是可能不能由具體的數據結構支持。
  11. Collection
    : 是構建所有數據結構的基類，不可以直接構建。

用的最多就是List和Map，所以在這裏主要介紹這兩種數據類型的API。

API的使用

1.fromJS()

作用：將一個js數據轉換為Immutable類型的數據。

用法：fromJS(value, converter)

簡介：value是要轉變的數據，converter是要做的操作。第二個參數可不填，默認情況會將數組準換為List類型，將對象轉換為Map類型，其余不做操作。

代碼實現：

    const obj = Immutable.fromJS({a:‘123‘,b:‘234‘},function (key, value, path) {
        console.log(key, value, path)
        return isIndexed(value) ? value.toList() : value.toOrderedMap())
    })

2.toJS()

作用：將一個Immutable數據轉換為JS類型的數據。

用法：value.toJS()

3.is()

作用：對兩個對象進行比較。

用法：is(map1,map2)

簡介：和js中對象的比較不同，在js中比較兩個對象比較的是地址，但是在Immutable中比較的是這個對象hashCode和valueOf，只要兩個對象的hashCode相等，值就是相同的，避免了深度遍歷，提高了性能。

代碼實現：

import { Map, is } from ‘immutable‘
const map1 = Map({ a: 1, b: 1, c: 1 })
const map2 = Map({ a: 1, b: 1, c: 1 })
map1 === map2   //false
Object.is(map1, map2) // false
is(map1, map2) // true

4.List 和 Map

創建

List() 和 Map()

作用：用來創建一個新的List/Map對象

用法:

//List

List(): List<any>
List<T>(): List<T>

//Map

Map(): Map<any>
Map<T>(): Map<T>

List.of() 和 Map.of()

作用：創建一個新的包含value的List/Map對象

用法：

List.of<T>(...values: Array<T>): List<T>

Map.of<T>(...values: Object<T>): Map<T>

判斷

List.isList() 和 Map.isMap()

作用：判斷一個數據結構是不是List/Map類型

用法：

List.isList(maybeList: any): boolean

Map.isMap(maybeMap: any): boolean

長度

size

作用：獲取List/Map的長度

數據讀取

get() 、 getIn()

作用：獲取數據結構中的數據

has() 、 hasIn()

作用:判斷是否存在某一個key

用法：

Immutable.fromJS([1,2,3,{a:4,b:5}]).has(‘0‘); //true
Immutable.fromJS([1,2,3,{a:4,b:5}]).has(‘0‘); //true
Immutable.fromJS([1,2,3,{a:4,b:5}]).hasIn([3,‘b‘]) //true

includes()

作用：判斷是否存在某一個value

用法：

Immutable.fromJS([1,2,3,{a:4,b:5}]).includes(2); //true
Immutable.fromJS([1,2,3,{a:4,b:5}]).includes(‘2‘); //false 不包含字符2
Immutable.fromJS([1,2,3,{a:4,b:5}]).includes(5); //false 
Immutable.fromJS([1,2,3,{a:4,b:5}]).includes({a:4,b:5}) //false
Immutable.fromJS([1,2,3,{a:4,b:5}]).includes(Immutable.fromJS({a:4,b:5})) //true

first() 、 last()

作用：用來獲取第一個元素或者最後一個元素，若沒有則返回undefined

代碼：

Immutable.fromJS([1,2,3,{a:4,b:5}]).first()//1
Immutable.fromJS([1,2,3,{a:4,b:5}]).last()//{a:4,b:5}

Immutable.fromJS({a:1,b:2,c:{d:3,e:4}}).first() //1
Immutable.fromJS({a:1,b:2,c:{d:3,e:4}}).first() //{d:3,e:4}

數據修改

註：這裏對於數據的修改，是對原數據進行操作後的值賦值給一個新的數據，並不會對原數據進行修改，因為Immutable是不可變的數據類型。

設置 set()

作用：設置第一層key、index的值

用法：

set(index: number, value: T): List<T>
set(key: K, value: V): this

List在使用的時候，將index為number值設置為value。Map在使用的時候，將key的值設置為value。

在List中使用時，若傳入的number為負數，則將index為size+index的值設置為value，例，若傳入-1，則將size-1的值設為value。若傳入的number的值超過了List的長度，則將List自動補全為傳入的number的值，將number設置為value，其余用undefined補全。註：跟js中不同，List中不存在空位，[,,,],List中若沒有值，則為undefined。

代碼實現：

//////List
const originalList = List([ 0 ]);
// List [ 0 ]
originalList.set(1, 1);
// List [ 0, 1 ]
originalList.set(0, ‘overwritten‘);
// List [ "overwritten" ]
originalList.set(2, 2);
// List [ 0, undefined, 2 ]

List().set(50000, ‘value‘).size;
// 50001

//////Map
const { Map } = require(‘immutable‘)
const originalMap = Map()
const newerMap = originalMap.set(‘key‘, ‘value‘)
const newestMap = newerMap.set(‘key‘, ‘newer value‘)

originalMap
// Map {}
newerMap
// Map { "key": "value" }
newestMap
// Map { "key": "newer value" }

setIn()

作用：設置深層結構中某屬性的值

用法：

setIn(keyPath: Iterable<any>, value: any): this

用法與set()一樣，只是第一個參數是一個數組，代表要設置的屬性所在的位置

刪除 delete

作用：用來刪除第一層結構中的屬性

用法：

delete(index: number): List<T>  //List
delete(key: K): this  //Map

deleteIn()

用來刪除深層數據，用法參考setIn

deleteAll() (Map獨有，List沒有)

作用：用來刪除Map中的多個key

用法：deleteAll(keys: Iterable<K>): this

代碼示例：

const names = Map({ a: "Aaron", b: "Barry", c: "Connor" })
names.deleteAll([ ‘a‘, ‘c‘ ])
// Map { "b": "Barry" }

更新 update()

作用：對對象中的某個屬性進行更新，可對原數據進行相關操作

用法：

update(index: number, updater: (value: T) => T): this //List
update(key: K, updater: (value: V) => V): this  //Map

代碼示例：

////List
const list = List([ ‘a‘, ‘b‘, ‘c‘ ])
const result = list.update(2, val => val.toUpperCase())

///Map
const aMap = Map({ key: ‘value‘ })
const newMap = aMap.update(‘key‘, value => value + value)

updateIn()

用法參考setIn

清除 clear()

作用：清除所有數據

用法：clear(): this

代碼示例：

Map({ key: ‘value‘ }).clear()  //Map
List([ 1, 2, 3, 4 ]).clear()   // List

List中的各種刪除與插入

List對應的數據結構是js中的數組，所以數組的一些方法在Immutable中也是通用的，比如push，pop,shift，unshift，insert。

  1. push()：在List末尾插入一個元素
  2. pop(): 在List末尾刪除一個元素
  3. unshift: 在List首部插入一個元素
  4. shift: 在List首部刪除一個元素
  5. insert：在List的index處插入元素

代碼實現：

List([ 0, 1, 2, 3, 4 ]).insert(6, 5) 
//List [ 0, 1, 2, 3, 4, 5 ]
List([ 1, 2, 3, 4 ]).push(5)
// List [ 1, 2, 3, 4, 5 ]
List([ 1, 2, 3, 4 ]).pop()
// List[ 1, 2, 3 ]
List([ 2, 3, 4]).unshift(1);
// List [ 1, 2, 3, 4 ]
List([ 0, 1, 2, 3, 4 ]).shift();
// List [ 1, 2, 3, 4 ]

List中還有一個特有的方法用法設置List的長度，setSize()

List([]).setSize(2).toJS() //[undefined,undefined]

關於merge

merge

作用：淺合並，新數據與舊數據對比，舊數據中不存在的屬性直接添加，就數據中已存在的屬性用新數據中的覆蓋

mergrWith

作用：自定義淺合並，可自行設置某些屬性的值

mergeIn

作用：對深層數據進行淺合並

mergeDeep

作用：深合並，新舊數據中同時存在的的屬性為新舊數據合並之後的數據

mergeDeepIn

作用：對深層數據進行深合並

mergrDeepWith

作用:自定義深合並，可自行設置某些屬性的值

這裏用一段示例徹底搞懂merge，此示例為Map結構，List與Map原理相同

 const Map1 = Immutable.fromJS({a:111,b:222,c:{d:333,e:444}});
 const Map2 = Immutable.fromJS({a:111,b:222,c:{e:444,f:555}});

 const Map3 = Map1.merge(Map2);
  //Map {a:111,b:222,c:{e:444,f:555}}
 const Map4 = Map1.mergeDeep(Map2);
  //Map {a:111,b:222,c:{d:333,e:444,f:555}}
 const Map5 = Map1.mergeWith((oldData,newData,key)=>{
      if(key === ‘a‘){
        return 666;
      }else{
        return newData
      }
    },Map2);
  //Map {a:666,b:222,c:{e:444,f:555}}

序列算法

concat()

作用：對象的拼接，用法與js數組中的concat()相同，返回一個新的對象。

用法：const List = list1.concat(list2)

map()

作用：遍歷整個對象，對Map/List元素進行操作，返回一個新的對象。

用法：

Map({a:1,b:2}).map(val=>10*val)
//Map{a:10,b:20}

Map特有的mapKey()

作用：遍歷整個對象，對Map元素的key進行操作，返回一個新的對象。

用法：

Map({a:1,b:2}).mapKey(val=>val+‘l‘)
//Map{al:10,bl:20}

Map特有的mapEntries()

作用：遍歷整個對象，對Map元素的key和value同時進行操作，返回一個新的對象。Map的map()也可實現此功能。

用法：

Map({a:1,b:2}).map((key,val)=>{
  return [key+‘l‘,val*10]
})
//Map{al:10,bl:20}

過濾 filter

作用：返回一個新的對象，包括所有滿足過濾條件的元素

用法：

Map({a:1,b:2}).filter((key,val)=>{
  return val == 2
})
//Map{b:2}

還有一個filterNot()方法，與此方法正好相反。

反轉 reverse

作用：將數據的結構進行反轉

代碼示例：

Immutable.fromJS([1, 2, 3, 4, 5]).reverse();
// List [5,4,3,2,1]
Immutable.fromJS({a:1,b:{c:2,d:3},e:4}).recerse();
//Map {e:4,b:{c:2,d:3},a:1}

排序 sort & sortBy

作用：對數據結構進行排序

代碼示例：

///List
Immutable.fromJS([4,3,5,2,6,1]).sort()
// List [1,2,3,4,5,6]
Immutable.fromJS([4,3,5,2,6,1]).sort((a,b)=>{
  if (a < b) { return -1; }
  if (a > b) { return 1; }
  if (a === b) { return 0; }
})
// List [1,2,3,4,5,6]
Immutable.fromJS([{a:3},{a:2},{a:4},{a:1}]).sortBy((val,index,obj)=>{
  return val.get(‘a‘)
},(a,b)=>{
  if (a < b) { return -1; }
  if (a > b) { return 1; }
  if (a === b) { return 0; }
})
//List  [ {a:3}, {a:2}, {a:4}, {a:1} ]

//Map

Immutable.fromJS( {b:1, a: 3, c: 2, d:5} ).sort()
//Map {b: 1, c: 2, a: 3, d: 5}
Immutable.fromJS( {b:1, a: 3, c: 2, d:5} ).sort((a,b)=>{
  if (a < b) { return -1; }
  if (a > b) { return 1; }
  if (a === b) { return 0; }
})
//Map {b: 1, c: 2, a: 3, d: 5}
Immutable.fromJS( {b:1, a: 3, c: 2, d:5} ).sortBy((value, key, obj)=> {
  return value
})
//Map {b: 1, c: 2, a: 3, d: 5}

分組 groupBy

作用：對數據進行分組

const listOfMaps = List([
  Map({ v: 0 }),
  Map({ v: 1 }),
  Map({ v: 1 }),
  Map({ v: 0 }),
  Map({ v: 2 })
])
const groupsOfMaps = listOfMaps.groupBy(x => x.get(‘v‘))
// Map {
//   0: List [ Map{ "v": 0 }, Map { "v": 0 } ],
//   1: List [ Map{ "v": 1 }, Map { "v": 1 } ],
//   2: List [ Map{ "v": 2 } ],
// }

查找數據

indexOf() 、 lastIndexOf Map不存在此方法

作用：和js數組中的方法相同，查找第一個或者最後一個value的index值，找不到則返回-1

用法：

Immutable.fromJS([1,2,3,4]).indexof(3) //2
Immutable.fromJS([1,2,3,4]).lastIndexof(3) //2

findIndex() 、 findLastIndex() Map不存在此方法

作用：查找滿足要求的元素的index值

用法：

Immutable.fromJS([1,2,3,4]).findIndex((value,index,array)=>{
  return value%2 === 0;
})   // 1
Immutable.fromJS([1,2,3,4]).findLastIndex((value,index,array)=>{
  return index%2 === 0;
})  // 3

find() 、 findLast()

作用：查找滿足條件的元素的value值

用法：

Immutable.fromJS([1,2,3,4]).find((value,index,array)=>{
  return value%2 === 0;
})  // 2

Immutable.fromJS([1,2,3,4]).findLast((value,index,array)=>{
  return value%2 === 0;
})  // 4

findKey() 、 findLastKey()

作用：查找滿足條件的元素的key值

用法：

Immutable.fromJS([1,2,3,4]).findKey((value,index,array)=>{
  return value%2 === 0;
})  // 1

Immutable.fromJS([1,2,3,4]).findLastKey((value,index,array)=>{
  return value%2 === 0;
})  // 3

findEntry() 、 findLastEntry()

作用：查找滿足條件的元素的鍵值對 key:value

用法：

Immutable.fromJS([1,2,3,4]).findEntry((value,index,array)=>{
  return value%2 === 0;
})  // [1,2]

Immutable.fromJS([1,2,3,4]).findLastEntry((value,index,array)=>{
  return value%2 === 0;
})  // [3,4]

keyOf() lastKeyOf()

作用：查找某一個value對應的key值

用法：

Immutable.fromJS([1,2,3,4]).keyOf(2) //1
Immutable.fromJS([1,2,3,4]).lastKeyOf(2) //1

max() 、 maxBy()

作用：查找最大值

用法:

Immutable.fromJS([1, 2, 3, 4]).max() //4

Immutable.fromJS([{a;1},{a:2},{a: 3},{a:4}]).maxBy((value,index,array)=>{
  return value.get(‘a‘)
})  //{a:4}

min() 、 minBy()

作用：查找最小值

用法:

Immutable.fromJS([1, 2, 3, 4]).min() //1

Immutable.fromJS([{a;1},{a:2},{a: 3},{a:4}]).minBy((value,index,array)=>{
  return value.get(‘a‘)
})  //{a:1}

創建子集

slice()

作用： 和原生js中數組的slice數組一樣，包含兩個參數，start和end，start代表開始截取的位置，end代表結束的位置，不包括第end的元素。若不包括end，則返回整個對象，若end為負數，則返回（start，length-end）對應的數據。若start只有一個並且為負數，則返回最後的end個元素。

用法：

Immutable.fromJS([1, 2, 3, 4]).slice(0); //[1,2,3,4]
Immutable.fromJS([1, 2, 3, 4]).slice(0,2); //[1,2]
Immutable.fromJS([1, 2, 3, 4]).slice(-2); //[3,4]
Immutable.fromJS([1, 2, 3, 4]).slice(0,-2); //[1,2]

rest()

作用：返回除第一個元素之外的所有元素

用法:Immutable.fromJS([1, 2, 3, 4]).rest()//[2,3,4]

butLast()

作用：返回除最後一個元素之外的所有元素

用法:Immutable.fromJS([1, 2, 3, 4]).rest()//[1,2,3]

skip()

作用：有一個參數n, 返回截掉前n個元素之後剩下的所有元素

用法:Immutable.fromJS([1, 2, 3, 4]).skip(1)//[2,3,4]

skipLast()

作用：有一個參數n, 返回截掉最後n個元素之後剩下的所有元素

用法:Immutable.fromJS([1, 2, 3, 4]).skip(1)//[1,2,3]

skipWhile()

作用：返回從第一次返回false之後的所有元素

Immutable.fromJS([1, 2, 3, 4]).skipWhile(list.skipWhile((value,index,list)=>{
  return value > 2;
}))// [1,2,3,4]

skipUntil()

作用：返回從第一次返回true之後的所有元素

Immutable.fromJS([1, 2, 3, 4]).skipUntil(list.skipWhile((value,index,list)=>{
  return value > 2;
}))// [3,4]

take()

作用：有一個參數n, 返回前n個元素

用法:Immutable.fromJS([1, 2, 3, 4]).take(2)//[1,2]

takeLast()

作用：有一個參數n, 返回最後n個元素

用法:Immutable.fromJS([1, 2, 3, 4]).takeLast(2)//[3,4]

takeWhile()

作用：返回從第一次返回false之前的所有元素

Immutable.fromJS([1, 2, 3, 4]).skipWhile(list.takeWhile((value,index,list)=>{
  return value > 2;
}))// []

takeUntil()

作用：返回從第一次返回true之前的所有元素

Immutable.fromJS([1, 2, 3, 4]).skipUntil(list.takeUntil((value,index,list)=>{
  return value > 2;
}))// [1,2]

處理數據

reduce()

作用：和js中數組中的reduce相同,按索引升序的順序處理元素

用法：

Immutable.fromJS([1,2,3,4]).reduce((pre,next,index,arr)=>{
  console.log(pre+next)
  return pre+next; 
})
// 3 6 10

reduceRight()

作用：和js中數組中的reduce相同,按索引降序的順序處理元素

用法：

Immutable.fromJS([1,2,3,4]).reduceRight((pre,next,index,arr)=>{
  console.log(pre+next)
  return pre+next; 
})
// 7 9 10

every()

作用：判斷整個對象總中所有的元素是不是都滿足某一個條件，都滿足返回true，反之返回false。

代碼：

Immutable.fromJS([1,2,3,4]).every((value,index,arr)=>{
  return value > 2
}) // false

some()

作用：判斷整個對象總中所有的元素是不是存在滿足某一個條件的元素，若存在返回true，反之返回false。

代碼：

Immutable.fromJS([1,2,3,4]).some((value,index,arr)=>{
  return value > 2
}) // true

join()

作用：同js中數組的join方法。把準換為字符串

用法：Immutable.fromJS([1,2,3,4]).join(‘,‘) //1,2,3,4

isEmpty()

作用：判斷是否為空

用法:

Immutable.fromJS([]).isEmpty(); // true
Immutable.fromJS({}).isEmpty(); // true

count()

作用：返回元素個數，可自定義條件，返回滿足條件的個數

用法：

const list = Immutable.fromJS([1,2,3,4]);
const map = Immutable.fromJS({a:1,b:2,c:3,d:4});

list.count((value,index,list)=>{
  return value > 2;
})    //2

map.count((value,index,list)=>{
  return value > 2;
})    //2

countBy()

作用：與count不同的是，countBy返回一個對象

用法：

const list = Immutable.fromJS([1,2,3,4]);
const map = Immutable.fromJS({a:1,b:2,c:3,d:4});

list.countBy((value,index,list)=>{
  return value > 2;
} //{false: 2, true: 2}

map.countBy((value,index,list)=>{
  return value > 2;
} //{false: 2, true: 2}

[轉] Immutable 常用API簡介

相關推薦

[轉] Immutable 常用API簡介

isl rest gradle 數據讀取 cati clas 關於 com set 本文主要整理了Immutable.js常用API的使用。 Immutable 是什麽？ 關於Immutable的定義，官方文檔是這樣說的： Immutable data

Java 8 Streams常用API簡介

常用的幾個API：filter、map、forEach、sorted、findFirst、reduce、limit/skip、min/max/distinct、allMatch/anyMatch/noneMatch map:把input Stream的每一個元素，對映成output Stre

EasyTouch5常用API簡介

ETInpt類（搖桿輸入類）： 虛擬搖桿的靜態函式： SetControlVisible : 憑藉虛擬搖桿的名字，找到的虛擬搖桿是否設定為可見 GetControlVisible : 憑藉虛擬搖桿的

( 轉）Hibernate常用API

date操作 關閉 itl lan 開始 就會 說過 上海 tar http://blog.csdn.net/yerenyuan_pku/article/details/65103203 可在度娘上摘抄如下文字： Hibernate的核心類和接口一共有6個，分別為：

Java API簡介以及以及常用的類庫介紹

什麼是Java API 呢？（Application Programming Interface）即應用程式程式設計介面。Java 語言的強大之處在於它預先定義好了多種多樣的類庫，程式設計師可以直接使用這些已經被打包好的介面和類來實現具體的功能。在編寫程式時直接匯入就行了，不

【轉】jedis常用API

轉載原文地址未知，有看到的，評論一下。立馬新增上去一、Redis Client介紹1.1、簡介Jedis Client是Redis官網推薦的一個面向java客戶端，庫檔案實現了對各類API進行封裝呼叫。Jedis原始碼工程地址：https://github.com/xetor

Junit簡介和常用API

            測試幾個的概念 白盒測試——把測試物件看作一個開啟的盒子，程式內部的邏輯結構和其他資訊對測試人員是公開的。 迴歸測試——軟體或環境的修復或更正後的“再測試”，自動測試工具對這類測試尤其有用。 單元測試——是最小粒度的測試，以測試某個功能或程式碼塊。

vue2.0的常用功能簡介

span nbsp color -i highlight href out con router 路由跳轉 當我們想要實現點擊鏈接跳轉時，可以使用$router來進行跳轉 語法如下： this.$router.push({path:"/www",query:{id:

Commons-FileUpload 常用API

內存 設置 void 緩沖 請求 rep lis body true ServerFileUpload類的常用方法 方法名稱方法描述 public void setSizeMax(long sizeMax) 設置請求信息實體內容的最大允許的字節數 public

轉 redis使用場景 簡介

-s edi select time 關註 寫入 部分 更新 header 1. 使用場景說明1.2. 排行榜1.4. 記錄用戶判定信息1.6. 緩存1.8. 會話緩存

[轉]VS2010 常用插件

5.5 compare sse 生產 blog 編碼 興趣 archive 小工具 本文來自：http://developer.51cto.com/art/201403/432954_all.htm 雖然VS2010IDE功能已經非常強大了，但是在有些地方還是可以優化，或

nodeJs常用API

自動 第一個 tps 地址 .cn 參數 nodejs url地址 完整 1、url （1）url.parse返回url對象的各種參數 url.parse(url,true/false,true/false);//默認url.parse(url,false,false);

[轉]搜索命令簡介

splay import sna browser date lang ava forecast meta An introduction to search commands Did you know you can search Google for web pages

[轉]python_常用斷言assert

shu sin con 其中 rtg work lee 一個 後置 原文地址：http://www.jianshu.com/p/eea0b0e432da python自動化測試中尋找元素並進行操作，如果在元素好找的情況下，相信大家都可以較熟練地編寫用例腳本了，但光進行操作可

JS跳轉頁面常用的幾種方法

class define bst top color defined rip dex text 第一種：(常用) <script language="javascript" type="text/javascript"> window.location.

【詳細資料】ICN6202：MIPI DSI轉LVDS芯片簡介

blog mipi png images logs log 簡介 es2017 mage ICN6202功能MIPI DSI轉LVDS，分辨率1920*1200，封裝QFN40 【詳細資料】ICN6202：MIPI DSI轉LVDS芯片簡介

Java常用API

寫入 大小 移動 是否 格式化 分行 查詢語句 boolean del 常用Java API 一、 java.io.BufferedReader類（用於從文件中讀入一段字符；所屬套件：java.io） 1、 構造函數BufferedReader(java.io.Fil

[js高手之路] es6系列教程 - Map詳解以及常用api

.com size style 系列教程 image clear rsquo images div ECMAScript 6中的Map類型是一種存儲著許多鍵值對的有序列表。鍵值對支持所有的數據類型. 鍵 0 和 ‘0’會被當做兩個不同的鍵，不會發生強

常用API（Object、String、StringBuffer、用戶登陸註冊)

類的方法 time logs 3.6 strong 設計 indexof 概述 比較運算符 常用API 今日內容介紹 u Object u String u StringBuilder 第1章 Java的API及Object類 在以前的學習過程中，我們都在學習對象基本特征、

[轉][SVN]常用操作

服務器 es2017 常用操作 blog 擴展 alt 三方 查找 最新 1. Commit 提交當前代碼到 SVN 服務器。 2. 引用第三方類庫時，不要從安裝位置引用，而是在解決方案下，添加一個 lib 的目錄，把需要的程序集復制到這裏，然後從 lib 目錄引用。 3