ग्रोवी

Question

में संस्करण स्ट्रिंग की तुलना करें अरे मैंने एक ग्रोवी स्क्रिप्ट बनाई है जो कुछ फ़ोल्डर की संस्करण संख्या निकाल देगा। मैं फिर संस्करण संख्याओं की तुलना करना और उच्चतम का चयन करना चाहता हूं।

मैं dir फ़ोल्डर के माध्यम से चलाने के लिए मेरी स्क्रिप्ट मिला है और मैं तो इस प्रारूप में संस्करण प्राप्त: 02.2.02.01

तो मैं कुछ इस तरह हो सकता है:

• 02.2.02.01
• 02,2 .02.02
• 02.2.03.01

मैं उन्हें एक सूची के रूप में नहीं है, लेकिन जैसे इस:

baseDir.listFiles().each { file -> 
    def string = file.getName().substring(5, 15) 
    // do stuff 
} 

इसके अलावा, मैं परीक्षण किया है कि ग्रूवी उन्हें > ऑपरेटर के साथ तुलना कर सकते हैं और यह कर सकते हैं! लेकिन अब मैं उच्चतम संस्करण

Answer 1

यह प्रतीत होता है के साथ एक काम करने के लिए

String mostRecentVersion(List versions) { 
    def sorted = versions.sort(false) { a, b -> 

    List verA = a.tokenize('.') 
    List verB = b.tokenize('.') 

    def commonIndices = Math.min(verA.size(), verB.size()) 

    for (int i = 0; i < commonIndices; ++i) { 
     def numA = verA[i].toInteger() 
     def numB = verB[i].toInteger() 
     println "comparing $numA and $numB" 

     if (numA != numB) { 
     return numA <=> numB 
     } 
    } 

    // If we got this far then all the common indices are identical, so whichever version is longer must be more recent 
    verA.size() <=> verB.size() 
    } 

    println "sorted versions: $sorted" 
    sorted[-1] 
} 

यहाँ परीक्षणों के एक अपर्याप्त सेट है चुनना होगा। आपको कुछ और जोड़ना चाहिए।

assert mostRecentVersion(['02.2.02.01', '02.2.02.02', '02.2.03.01']) == '02.2.03.01' 
assert mostRecentVersion(['4', '2']) == '4' 
assert mostRecentVersion(['4.1', '4']) == '4.1' 
assert mostRecentVersion(['4.1', '5']) == '5' 

भागो इस कोड और ग्रूवी कंसोल में परीक्षण सत्यापित करने के लिए यह काम करता है कि

Answer 2

मेरा सबसे छोटा है! lol)

versions = versions.sort {a, b -> 
    def a1 = a.tokenize('.')*.toInteger(), b1 = b.tokenize('.')*.toInteger() 
    for (i in 0..<[a1.size(), b1.size()].min()) 
    if (a1[i] != b1[i]) return a1[i] <=> b1[i] 
    0 
} 

Answer 3

हम कम से कम उत्तर के लिए जा रहे हैं, यह करीब ;-)

String mostRecentVersion(List versions) { 
    versions.sort(false) { a, b -> 
    [a,b]*.tokenize('.')*.collect { it as int }.with { u, v -> 
     [u,v].transpose().findResult{ x,y-> x<=>y ?: null } ?: u.size() <=> v.size() 
    } 
    }[-1] 
} 

Answer 4

किसी Grails (जैसे Grails 2.2.3) का उपयोग कर रहा है, तो आना चाहिए, मैं पहले से ही VersionComparator लगता है बिल्कुल वही प्रदान करता है जो हमें चाहिए।

यदि आप Grails का उपयोग नहीं कर रहे हैं, तो आप हमेशा Google को इस कक्षा का स्रोत कोड बना सकते हैं।

काम कर परीक्षण का उदाहरण:

import org.codehaus.groovy.grails.plugins.VersionComparator 

assert ['1.13.4', '1.4.5'].sort(new VersionComparator()) == ['1.4.5', '1.13.4'] 
assert ['3.1.20', '3', '3.0.1', '3.1'].sort(new VersionComparator()) == ['3', '3.0.1', '3.1', '3.1.20'] 
assert ['02.2.02.02', '02.2.03.01', '02.2.02.01'].sort(new VersionComparator()) == ['02.2.02.01', '02.2.02.02', '02.2.03.01'] 
assert ['4', '2'].sort(new VersionComparator()) == ['2', '4'] 
assert ['4.1', '4'].sort(new VersionComparator()) == ['4', '4.1'] 
assert ['4.1', '5'].sort(new VersionComparator()) == ['4.1', '5'] 

assert new VersionComparator().compare('1.13.4', '1.4.5') > 0 
assert new VersionComparator().compare('1.4.5', '1.13.4') < 0 

आशा इस मदद करता है।

Answer 5

कोड जेनकींस ExtendedChoiceParameter साथ मैं उपयोग कर रहा हूँ (संस्करण स्ट्रिंग में गैर पूर्णांक के टुकड़े करने के लिए सहिष्णु)

def vers = ['none'] 
new File(this.getBinding().getVariable('dir')).eachDir() { dir -> dirs.add(dir.getName()) } 

vers.sort{x, y -> 
    def xa = x.tokenize('._-'); def ya = y.tokenize('._-') 
    def sz = Math.min(xa.size(), ya.size()) 
    for (int i = 0; i < sz; ++i) { 
    def xs = xa[i]; def ys = ya[i]; 
    if (xs.isInteger() && ys.isInteger()) { 
     def xn = xs.toInteger() 
     def yn = ys.toInteger() 
     if (xn != yn) { return xn <=> yn } 
    } else if (xs != ys) { 
     return xs <=> ys 
    } 
    } 

    return xa.size() <=> ya.size() 
}.reverse().join(',') 

Answer 6

String maxVersion(versions) { 
    versions.max { a, b -> 
     List verA = a.tokenize('.') 
     List verB = b.tokenize('.') 
     def commonIndices = Math.min(verA.size(), verB.size()) 
     for (int i = 0; i < commonIndices; ++i) { 
      def numA = verA[i].toInteger() 
      def numB = verB[i].toInteger() 
      if (numA != numB) { 
       return numA <=> numB 
      } 
     } 
     verA.size() <=> verB.size() 
    } 
} 

Answer 7

यहाँ निकिता की भागीदारी को लेकर एक थोड़ा संशोधित संस्करण है:

List versions = [ '02.2.02.01', '02.2.02.02', '02.2.03.01'] 
String mostRecentVersion = versions.sort {a, b -> 
    def a1 = a.tokenize('.')*.toInteger(), b1 = b.tokenize('.')*.toInteger() 

    for (i in 0..<[a1.size(), b1.size()].min()){  
    if (a1[i] != b1[i]) { 
     return a1[i] <=> b1[i] 
    } 
    } 
}[-1] 

assert mostRecentVersion == '02.2.03.01' 

Answer 8

यहां टिम के उत्तर का एक संशोधन है जो दो संस्करण स्ट्रिंग लेता है और एक बुलियन लौटाता है (सच है कि पहले दूसरे की तुलना में नया है)

String v1 = '02.2.01.02' 
String v2 = '02.2.06.02' 

boolean isMoreRecent(String a, String b) { 
    [a,b]*.tokenize('.')*.collect { it as int }.with { u, v -> 
     Integer result = [u,v].transpose().findResult{ x,y -> x <=> y ?: null } ?: u.size() <=> v.size() 
     return (result == 1) 
    } 
} 

assert !isMoreRecent(v1,v2) 
assert isMoreRecent(v2,v1)​ 

Answer 9

मैं एंड्रॉइड स्टूडियो 3.0 बीटा 7 में ग्रेडल 4.1 का उपयोग करता हूं। VersionNumber.java (C: \ Users \ ssfang.gradle \ wrapper \ dists \ gradle-4 के अंतर्गत है।1-सभी \ bzyivzo6n839fup2jbap0tjew \ Gradle-4.1 \ src \ कोर \ ऑर्ग \ Gradle \ util)

उदाहरण के लिए:

apply plugin: 'com.android.application' 

try{ // undocumented 
    println "${android.plugin.getSdkFolder().getAbsolutePath()}" 
    // Since 1.3.1 or 1.5.0? android studio version or android gradle plugin? 
    println "${android.getSdkDirectory().getAbsolutePath()}" 
}catch (ignored){ 
} 

// As of android gradle plugin v2.1.2 
println android.sdkDirectory.path 
println android.ndkDirectory.path 
def buildToolsVer = new File(android.sdkDirectory.path, 'build-tools').listFiles().collect{ VersionNumber.parse(it.getName()) }.sort() 
println buildToolsVer 
printf('%s, %s\n', buildToolsVer.head(), buildToolsVer.last().toString()) 

def String mostRecentVersion(List<String> versions) { 
// TreeMap<VersionNumber, String> verNum2StrMap = versions.collectEntries(new TreeMap(), { [VersionNumber.parse(it), it] }) 

// TreeMap<VersionNumber, String> verNum2StrMap = versions.inject(new TreeMap()) { memo, entry -> 
//  memo[VersionNumber.parse(entry)] = entry 
//  memo 
// } 

    TreeMap<VersionNumber, String> verNum2StrMap = versions.inject(new TreeMap()) { map, verStr -> 
     map << [(VersionNumber.parse(verStr)): verStr] 
    } 

    // println verNum2StrMap.lastEntry().value 
    verNum2StrMap.lastEntry().value 
} 

assert mostRecentVersion(['02.2.02.01', '02.2.02.02', '02.2.03.01']) == '02.2.03.01' 
assert mostRecentVersion(['4', '2']) == '4' 
assert mostRecentVersion(['4.1', '4']) == '4.1' 
assert mostRecentVersion(['4.1', '5']) == '5' 

android { 
    compileSdkVersion 25 
    buildToolsVersion "26.0.2" 
    defaultConfig { 
     applicationId "ss.xsigner" 
     minSdkVersion 14 
     targetSdkVersion 22 
     versionCode 1 
     versionName "1.0" 
     testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner" 
     setProperty("archivesBaseName", "xsigner") 
    } 
} 

-