क्या स्ट्रिंग के दोनों किनारों से सफेद जगह को ट्रिम करने के लिए एक पर्ल-संगत नियमित अभिव्यक्ति है?

Question

क्या यह एक लाइन में ऐसा करने का कोई तरीका है?

$x =~ s/^\s+//; 
$x =~ s/\s+$//; 

दूसरे शब्दों में, एक स्ट्रिंग से सभी प्रमुख और पिछली सफेद जगह हटा दें।

Answer 1

$x =~ s/^\s+|\s+$//g; 

या

s/^\s+//, s/\s+$// for $x; 

Answer 2

ये रहा: $x =~ s/\A\s*(.*?)\s*\z/$1/;

Answer 3

$ x = ~/s (^ \ s +) | (\ रों + $) // छ;

Answer 4

$x =~ s/^\s*(.*?)\s*$/$1/; 

Answer 5

या इस: s/\A\s*|\s*\Z//g

Answer 6

s/^\s*(\S*\S)\s*$/$1/ 

Answer 7

मेरा पहला सवाल यह है कि ... क्यों? मुझे आपके द्वारा शुरू किए गए रेगेक्सप की तुलना में किसी भी एकल-रेगेक्स समाधान को और अधिक पठनीय नहीं दिखता है। और वे निश्चित रूप से कहीं भी तेजी से पास नहीं हैं।

#!/usr/bin/perl 

use strict; 
use warnings; 

use Benchmark qw(:all); 

my $a = 'a' x 1_000; 

my @x = (
     " $a ", 
     "$a ", 
     $a, 
     " $a" 
     ); 

cmpthese(-5, 
     { 
      single => sub { 
       for my $s (@x) 
       { 
        my $x = $s; 
        $x =~ s/^\s+|\s+$//g; 
       } 
      }, 
      double => sub { 
       for my $s (@x) 
       { 
        my $x = $s; 
        $x =~ s/^\s+//; 
        $x =~ s/\s+$//; 
       } 
      }, 
      trick => sub { 
       for my $s (@x) 
       { 
        my $x = $s; 
        s/^\s+//, s/\s+$// for $x; 
       } 
      }, 
      capture => sub { 
       for my $s (@x) 
       { 
        my $x = $s; 
        $x =~ s/\A\s*(.*?)\s*\z/$1/ 
       } 
      }, 
      kramercap => sub { 
       for my $s (@x) 
       { 
        my $x = $s; 
        ($x) = $x =~ /^\s*(.*?)\s*$/ 
       } 
      }, 
     } 
     ); 

की मेरी मशीन पर परिणाम देता है:

 
      Rate single capture kramercap  trick double 
single  2541/s  --  -12%  -13%  -96%  -96% 
capture 2902/s  14%  --  -0%  -95%  -96% 
kramercap 2911/s  15%  0%  --  -95%  -96% 
trick  60381/s  2276%  1981%  1974%  --  -7% 
double 65162/s  2464%  2145%  2138%  8%  -- 

संपादित: runrig सही है, लेकिन बहुत कम परिवर्तन करने के लिए। मैंने संशोधन से पहले स्ट्रिंग की प्रतिलिपि बनाने के लिए कोड अपडेट किया है, जो निश्चित रूप से चीजों को धीमा कर देता है। मैंने लंबे स्ट्रिंग का उपयोग करने के लिए एक और जवाब में ब्रायन डी फोय के सुझाव को भी ध्यान में रखा (हालांकि एक लाख ओवरकिल की तरह लग रहा था)। हालांकि, यह भी सुझाव देता है कि आप चाल शैली चुनने से पहले, आप समझते हैं कि आपकी स्ट्रिंग लंबाई क्या है - चाल के फायदे छोटे तारों से कम हो जाते हैं। मैंने परीक्षण की है कि सभी लंबाई में, डबल जीतता है। और यह आंखों पर अभी भी आसान है।

Answer 8

विवादास्पद से बहस, यह बिल्कुल क्यों? उपरोक्त सभी समाधान "सही" हैं, जिसमें वे एक पास में स्ट्रिंग के दोनों किनारों से व्हाइटस्पेस ट्रिम करते हैं, लेकिन कोई भी बहुत पठनीय नहीं है (शायद this one की अपेक्षा करें)। जब तक अपने कोड के लिए दर्शकों को विशेषज्ञ स्तर के पर्ल कोडर के शामिल है ऊपर उम्मीदवारों में से प्रत्येक क्या वे (वैसे भी शायद एक अच्छा विचार है) कर का वर्णन एक टिप्पणी होनी चाहिए। इसके विपरीत, इन दो पंक्तियों lookaheads, वाइल्डकार्ड, midichlorines या कुछ भी है कि मध्यम अनुभव के एक प्रोग्रामर के लिए तुरंत स्पष्ट नहीं है का उपयोग किए बिना एक ही बात को पूरा:

$string =~ s/^\s+//; 
$string =~ s/\s+$//; 

वहाँ (बेशक) एक प्रदर्शन हिट है, लेकिन के रूप में है जब तक आप कुछ microseconds निष्पादन पर चिंतित नहीं हैं, तब तक अतिरिक्त पठनीयता इसके लायक होगी। IMHO।

Answer 9

अजीब बात है तो आप इस ऊपर लाने चाहिए!

मैं हाल ही में an article analyzing the performance of twelve (!) different trim implementations पढ़ें।

हालांकि लेख विशेष रूप से जावास्क्रिप्ट regex कार्यान्वयन का उपयोग करता है, यह पर्ल सिंटैक्स का उपयोग करता है, तो मुझे लगता है कि इस चर्चा के अनुरूप है।

Answer 10

Tanktalus बहुत छोटे तार के लिए एक बेंचमार्क दिखाता है, लेकिन के रूप में तार बड़ा पाने के लिए समस्या बदतर हो।

my $a = 'a' x 1_000_000; 

my @x = (
    " $a ", 
    "$a ", 
    $a, 
    " $a" 
); 

मैं ये परिणाम प्राप्त: अपने कोड में, मैं शीर्ष भाग बदल स्ट्रिंग बड़ा हो जाता है

  Rate single capture trick double 
single 2.09/s  -- -12% -98% -98% 
capture 2.37/s  13%  -- -98% -98% 
trick 96.0/s 4491% 3948%  --  -0% 
double 96.4/s 4512% 3967%  0%  -- 

के रूप में, "चाल" और "डबल" लगभग एक ही हैं, और का उपयोग कर आम समाधान जो ज्यादातर लोग जाते हैं, "सिंगल" (मेरे साथ, क्योंकि मैं उस आदत को तोड़ नहीं सकता हूं, भले ही मुझे यह पता चले), वास्तव में चूसना शुरू कर देता है।

जब भी आप एक बेंचमार्क देखते हैं, तो यह सोचें कि यह आपको क्या बता रहा है। यह देखने के लिए कि क्या आप इसे समझते हैं, डेटा बदलें और पुनः प्रयास करें। सरणी लंबे, स्केलर्स बड़ा, और इतने पर बनाओ। लूप, ग्रीप्स, या रेगेक्स को स्टार्ट, मध्य और अंत में सामान ढूंढें। देखें कि नए परिणाम आपकी भविष्यवाणी से मेल खाते हैं या नहीं। यह पता लगाएं कि प्रवृत्ति क्या है। क्या प्रदर्शन बेहतर और बेहतर हो जाता है, एक सीमा तक पहुंचता है, फिर चोटी में गिरावट शुरू होती है, या कुछ और?

Answer 11

मैं आमतौर पर इस तरह यह कार्य करें:

प्रमुख स्थानों और पीछे वाले स्पेस के बीच

($foo) = $foo =~ /^\s*(.*?)\s*$/; 

सब कुछ वर्गीकृत किया और दिया जाता है, तो मैं वही पुरानी चर को असाइन कर सकें।

Answer 12

$var1 =~ s/(^\s*)(.*?)(\s*$)+/$2/;