Erlang 21

binary




erlang

binary

मॉड्यूल

बाइनरी

मॉड्यूल सारांश

बाइनरी डेटा को संभालने के लिए लाइब्रेरी।

विवरण

इस मॉड्यूल में बाइट-ओरिएंटेड बायनेरिज़ में हेरफेर करने के लिए फ़ंक्शंस हैं। यद्यपि अधिकांश कार्यों को बिट-सिंटैक्स का उपयोग करके प्रदान किया जा सकता है, इस लाइब्रेरी में फ़ंक्शन अत्यधिक अनुकूलित हैं और उनसे अपेक्षा की जाती है कि वे या तो तेजी से निष्पादित करें या कम मेमोरी का उपभोग करें, या दोनों, शुद्ध एर्लांग में लिखे गए समकक्ष की तुलना में।

मॉड्यूल एर्लांग एन्हांसमेंट प्रपोजल (ईईपी) 31 के अनुसार प्रदान किया गया है।

ध्यान दें

पुस्तकालय बाइट-ओरिएंटेड डेटा को संभालता है। बिटस्ट्रिंग्स के लिए जो बायनेरिज़ नहीं हैं (जिसमें बिट्स के पूरे ऑक्टेट शामिल नहीं हैं) इस मॉड्यूल में किसी भी फ़ंक्शन से एक badarg अपवाद को फेंक दिया जाता है।

जानकारी का प्रकार

cp()

ओपेक डेटा प्रकार एक संकलित खोज पैटर्न का प्रतिनिधित्व करता है। गैर-पूर्वनिर्धारित खोज पैटर्न से इसे अलग करने के लिए कार्यक्रमों को अनुमति देने के लिए एक tuple() होने की गारंटी।

part() = {Start :: integer() >= 0, Length :: integer()}

बाइनरी में एक भाग (या रेंज) का एक प्रतिनिधित्व। Start एक binary() में एक शून्य-आधारित ऑफसेट है binary() और Length उस हिस्से की लंबाई है। इस मॉड्यूल में फ़ंक्शंस के इनपुट के रूप में, एक नकारात्मक हिस्से के साथ निर्मित एक रिवर्स पार्ट स्पेसिफिकेशन की अनुमति है, ताकि बाइनरी का हिस्सा Start + Length पर Start और Length - लंबा हो। यह बाइनरी के अंतिम N बाइट्स को {size(Binary), -N} रूप में संदर्भित करने के लिए उपयोगी है। इस मॉड्यूल में कार्य हमेशा सकारात्मक Length साथ part()

निर्यात

at (विषय, स्थिति) -> बाइट ()

प्रकार

बाइट में स्थिति Pos (शून्य-आधारित) बाइनरी Subject में पूर्णांक के रूप में बाइट देता है। यदि Pos > = byte_size(Subject) , तो एक badarg अपवाद उठाया जाता है।

bin_to_list (विषय) -> [बाइट ()]

प्रकार

bin_to_list(Subject, {0,byte_size(Subject)})

bin_to_list (विषय, स्थिति) -> [बाइट ()]

प्रकार

प्रत्येक को byte() सूची में प्रस्तुत करता है, प्रत्येक एक बाइट के मूल्य का प्रतिनिधित्व करता है। part() binary() किस भाग को बदलने के लिए दर्शाता है।

उदाहरण:

1> binary:bin_to_list(<<"erlang">>, {1,3}).
"rla"
%% or [114,108,97] in list notation.

यदि बाइनरी के बाहर किसी भी तरह से संदर्भ दिया जाता है, तो एक badarg अपवाद उठाया जाता है।

bin_to_list (विषय, स्थिति, लेन) -> [बाइट ()]

प्रकार

bin_to_list(Subject, {Pos, Len})

compile_pattern (पैटर्न) -> cp()

प्रकार

एक आंतरिक संरचना का निर्माण एक खोज पैटर्न के संकलन का प्रतिनिधित्व करता है, जिसे बाद में फ़ंक्शन match/3 , matches/3 , split/3 , या replace/4 cp() लौटाए जाने की गारंटी दी जाती है, ताकि प्रोग्राम को गैर-पूर्व-खोज खोज पैटर्न से अलग करने की अनुमति दी जा सके।

जब बायनेरिज़ की सूची निर्दिष्ट की जाती है, तो यह खोज करने के लिए वैकल्पिक बायनेरिज़ के सेट को दर्शाता है। उदाहरण के लिए, अगर [<<"functional">>,<<"programming">>] को Pattern रूप में निर्दिष्ट किया गया है, तो इसका मतलब या तो <<"functional">> या <<"programming">> "है। पैटर्न एक है" विकल्पों का सेट; जब केवल एक बाइनरी निर्दिष्ट किया जाता है, सेट में केवल एक तत्व होता है। एक पैटर्न में विकल्पों का क्रम महत्वपूर्ण नहीं होता है।

खोज विकल्पों के लिए उपयोग किए जाने वाले बायनेरिज़ की सूची फ्लैट और उचित होनी चाहिए।

यदि Pattern द्विआधारी नहीं है या लंबाई> 0 के साथ बायनेरिज़ की एक फ्लैट उचित सूची नहीं है, तो एक badarg अपवाद को उठाया जाता है।

कॉपी (विषय) -> बाइनरी ()

प्रकार

copy(Subject, 1) रूप में भी copy(Subject, 1)

कॉपी (विषय, एन) -> बाइनरी ()

प्रकार

बाइनरी डुप्लिकेट N के Subject साथ एक बाइनरी बनाता है।

यह फ़ंक्शन हमेशा एक नया बाइनरी बनाता है, भले ही N = 1 । बाइनरी पर copy/1 का उपयोग करके एक बड़ा बाइनरी संदर्भित करते हुए, कोई कचरा संग्रह के लिए बड़े बाइनरी को मुक्त कर सकता है।

ध्यान दें

बड़े बाइनरी को संदर्भित करने से बचने के लिए जानबूझकर एकल बाइनरी की नकल करके, कोई बाद के कचरा संग्रह के लिए बड़े बाइनरी को मुक्त करने के बजाय, जरूरत से ज्यादा द्विआधारी डेटा बना सकता है। बाइनरी डेटा साझा करना आमतौर पर अच्छा होता है। केवल विशेष मामलों में, जब छोटे हिस्से बड़े बायनेरिज़ का संदर्भ देते हैं और बड़े बायनेरिज़ अब किसी भी प्रक्रिया में उपयोग नहीं किए जाते हैं, तो जानबूझकर नकल करना एक अच्छा विचार हो सकता है।

यदि N < 0 , एक badarg अपवाद को उठाया जाता है।

decode_unsigned (विषय) -> अनसाइन्टेड

प्रकार

उसी के रूप में decode_unsigned(Subject, big)

decode_unsigned (विषय, समाप्ति) -> निरस्त

प्रकार

बाइनरी डिजिट प्रतिनिधित्व को बड़े एंडियन या छोटे एंडियन में प्रस्तुत करता है, एक एंगलैंग integer() में एक सकारात्मक पूर्णांक।

उदाहरण:

1> binary:decode_unsigned(<<169,138,199>>,big).
11111111
encode_unsigned (Unsign) -> बाइनरी ()

प्रकार

encode_unsigned(Unsigned, big)

encode_unsigned (Unsigned, Endianness) -> बाइनरी ()

प्रकार

एक सकारात्मक पूर्णांक को बाइनरी डिजिट प्रतिनिधित्व में सबसे छोटे संभव प्रतिनिधित्व में परिवर्तित करता है, या तो बड़ा एंडियन या थोड़ा एंडियन।

उदाहरण:

1> binary:encode_unsigned(11111111, big).
<<169,138,199>>
पहला (विषय) -> बाइट ()

प्रकार

बाइनरी Subject के पहले बाइट को पूर्णांक के रूप में लौटाता है। यदि Subject का आकार शून्य है, तो एक badarg अपवाद उठाया जाता है।

अंतिम (विषय) -> बाइट ()

प्रकार

बाइनरी Subject के अंतिम बाइट को पूर्णांक के रूप में लौटाता है। यदि Subject का आकार शून्य है, तो एक badarg अपवाद उठाया जाता है।

list_to_bin (बाइटलिस्ट) -> बाइनरी ()

प्रकार

पूरी तरह से erlang:list_to_binary/1 रूप में काम करता है erlang:list_to_binary/1 , पूर्णता के लिए जोड़ा गया।

longest_common_prefix (बायनेरिज़) -> पूर्णांक ()> = 0

प्रकार

सूची Binaries में बायनेरिज़ के सबसे लंबे आम उपसर्ग की लंबाई लौटाता है।

उदाहरण:

1> binary:longest_common_prefix([<<"erlang">>, <<"ergonomy">>]).
2
2> binary:longest_common_prefix([<<"erlang">>, <<"perl">>]).
0

यदि Binaries की एक फ्लैट सूची नहीं है, तो एक badarg अपवाद को उठाया जाता है।

longest_common_suffix (बायनेरिज़) -> पूर्णांक ()> = 0

प्रकार

सूची Binaries में बायनेरिज़ के सबसे लंबे सामान्य प्रत्यय की लंबाई देता है।

उदाहरण:

1> binary:longest_common_suffix([<<"erlang">>, <<"fang">>]).
3
2> binary:longest_common_suffix([<<"erlang">>, <<"perl">>]).
0

यदि Binaries की एक फ्लैट सूची नहीं है, तो एक badarg अपवाद को उठाया जाता है।

मैच (विषय, पैटर्न) -> मिला | कोई मुकाबला नहीं

प्रकार

match(Subject, Pattern, []) रूप में भी match(Subject, Pattern, [])

मैच (विषय, पैटर्न, विकल्प) -> मिला | कोई मुकाबला नहीं

प्रकार

Subject में Pattern की पहली घटना के लिए खोज करता है और स्थिति और लंबाई देता है।

फ़ंक्शन Pattern में बाइनरी के लिए {Pos, Length} देता है, जो Subject में सबसे निचले स्थान पर शुरू होता है।

उदाहरण:

1> binary:match(<<"abcde">>, [<<"bcde">>, <<"cd">>],[]).
{1,4}

भले ही <<"cd">> से पहले समाप्त होता है <<"bcde">> , <<"bcde">> पहले शुरू होता है और इसलिए यह पहला मैच है। यदि दो ओवरलैपिंग मैच एक ही स्थान पर शुरू होते हैं, तो सबसे लंबा लौटा है।

विकल्पों का सारांश:

{गुंजाइश, {प्रारंभ, लंबाई}}

केवल निर्दिष्ट भाग की खोज की जाती है। रिटर्न मान अभी भी Subject की शुरुआत से ऑफसेट है। इस मैनुअल में अनुभाग डेटा प्रकारों में वर्णित एक नकारात्मक Length की अनुमति है।

यदि Pattern में कोई भी तार नहीं मिला है, तो परमाणु nomatch वापस आ गया है।

Pattern विवरण के लिए, फ़ंक्शन compile_pattern/1

यदि {scope, {Start,Length}} ऐसे विकल्पों में निर्दिष्ट है जो Start > Subject आकार, Start + Length <0 या Start + Length > Subject आकार, एक badarg अपवाद को उठाया गया है।

मैच (विषय, पैटर्न) -> मिला

प्रकार

matches(Subject, Pattern, []) रूप में भी matches(Subject, Pattern, [])

मैच (विषय, पैटर्न, विकल्प) -> मिला

प्रकार

match/2 , लेकिन Subject समाप्त होने तक खोजा जाता है और Pattern से मेल खाने वाले सभी गैर-अतिव्यापी भागों की एक सूची (क्रम में) वापस कर दी जाती है।

पहला और सबसे लंबा मैच कम पसंद किया जाता है, जिसे निम्न उदाहरण से दर्शाया गया है:

1> binary:matches(<<"abcde">>,
                  [<<"bcde">>,<<"bc">>,<<"de">>],[]).
[{1,4}]

परिणाम से पता चलता है कि << "bcde" >> को छोटे मैच के बजाय चुना जाता है << "bc" >> (जो एक और मैच के लिए बढ़ा दिया जाएगा, << "de" >>)। यह POSIX नियमित अभिव्यक्ति (और awk जैसे कार्यक्रमों) के व्यवहार से मेल खाती है, लेकिन re (और पर्ल) में वैकल्पिक मैचों के अनुरूप नहीं है, जहां इसके बजाय खोज पैटर्न में शाब्दिक आदेश जो स्ट्रिंग मिलान का चयन करता है।

यदि किसी पैटर्न में कोई तार नहीं मिला है, तो एक खाली सूची वापस आ जाती है।

Pattern विवरण के लिए, compile_pattern/1 देखें। उपलब्ध विकल्पों के विवरण के लिए, match/3 देखें।

यदि {scope, {Start,Length}} ऐसे विकल्पों में निर्दिष्ट है जो Start > Subject आकार, Start + Length <0 या Start + Length > Subject आकार है, तो एक badarg अपवाद को उठाया जाता है।

भाग (विषय, स्थिति) -> द्विआधारी ()

प्रकार

PosLen द्वारा वर्णित बाइनरी Subject का हिस्सा PosLen

एक बाइनरी के अंत में बाइट्स निकालने के लिए एक नकारात्मक लंबाई का उपयोग किया जा सकता है:

1> Bin = <<1,2,3,4,5,6,7,8,9,10>>.
2> binary:part(Bin, {byte_size(Bin), -5}).
<<6,7,8,9,10>>
ध्यान दें

binary_part/2 और binary_part/3 तहत binary_part/2 मॉड्यूल में part/2 और part/3 भी उपलब्ध हैं। उन बीआईएफ को गार्ड परीक्षणों में अनुमति दी जाती है।

यदि बाइनरी के बाहर किसी भी तरह से संदर्भ दिया जाता है, तो एक badarg अपवाद उठाया जाता है।

भाग (विषय, स्थिति, लेन) -> द्विआधारी ()

प्रकार

part(Subject, {Pos, Len}) रूप part(Subject, {Pos, Len})

संदर्भित_बाइट_साइज़ (बाइनरी) -> पूर्णांक ()> = 0

प्रकार

यदि एक बाइनरी एक बड़े बाइनरी का संदर्भ देता है (जिसे अक्सर एक सबबिनरी के रूप में वर्णित किया जाता है), तो यह संदर्भित बाइनरी के आकार को प्राप्त करने के लिए उपयोगी हो सकता है। इस फ़ंक्शन का उपयोग copy/1 के उपयोग को ट्रिगर करने के लिए एक कार्यक्रम में किया जा सकता है। एक द्विआधारी की नकल करके, व्यक्ति मूल, संभवतः बड़े, द्विआधारी को छोटा कर सकता है जो कि एक छोटा बाइनरी एक संदर्भ है।

उदाहरण:

store(Binary, GBSet) ->
  NewBin =
      case binary:referenced_byte_size(Binary) of
          Large when Large > 2 * byte_size(Binary) ->
             binary:copy(Binary);
          _ ->
             Binary
      end,
  gb_sets:insert(NewBin,GBSet).

इस उदाहरण में, हमने बाइनरी कंटेंट को gb_sets:set() में डालने से पहले कॉपी करने के लिए चुना gb_sets:set() यदि यह बाइनरी को उस डेटा आकार से दोगुना से अधिक संदर्भित करता है जिसे हम रखना चाहते हैं। बेशक, विभिन्न कार्यक्रमों की नकल करते समय विभिन्न नियम लागू होते हैं।

जब भी बायनेरिज़ को अलग ले जाया जाता है तो बाइनरी शेयरिंग होती है। यह मौलिक कारण है कि बायनेरिज़ तेज़ हैं, अपघटन हमेशा ओ (1) जटिलता के साथ किया जा सकता है। दुर्लभ परिस्थितियों में यह डेटा साझाकरण अवांछनीय है, क्यों मेमोरी / उपयोग के लिए अनुकूलन करते समय यह फ़ंक्शन copy/1 साथ मिलकर उपयोगी हो सकता है।

बाइनरी शेयरिंग का उदाहरण:

1> A = binary:copy(<<1>>, 100).
<<1,1,1,1,1 ...
2> byte_size(A).
100
3> binary:referenced_byte_size(A)
100
4> <<_:10/binary,B:10/binary,_/binary>> = A.
<<1,1,1,1,1 ...
5> byte_size(B).
10
6> binary:referenced_byte_size(B)
100
ध्यान दें

बाइनरी डेटा को प्रक्रियाओं के बीच साझा किया जाता है। यदि कोई अन्य प्रक्रिया अभी भी बड़े बाइनरी का संदर्भ देती है, तो इस भाग की प्रतिलिपि बनाने से केवल अधिक मेमोरी का उपयोग होता है और कचरा संग्रहण के लिए बड़े बाइनरी को मुक्त नहीं करता है। चरम देखभाल के साथ इस तरह के घुसपैठ कार्यों का उपयोग करें और केवल अगर एक वास्तविक समस्या का पता चला है।

बदलें (विषय, पैटर्न, प्रतिस्थापन) -> परिणाम

प्रकार

replace(Subject, Pattern, Replacement,[])

बदलें (विषय, पैटर्न, प्रतिस्थापन, विकल्प) -> परिणाम

प्रकार

एक पूर्णांक () = <byte_size (प्रतिस्थापन)

Replacement की सामग्री के साथ Subject मिलान Pattern में भागों को बदलकर एक नया बाइनरी Replacement

यदि प्रतिस्थापन को प्रस्तुत करने वाले {insert_replaced, InsPos} का मिलान करने वाले {insert_replaced, InsPos} को परिणाम में डाला जाना है, तो विकल्प {insert_replaced, InsPos} को Subject में Replacement डालने से पहले मैचिंग भाग को निर्दिष्ट स्थान (या स्थिति) में Replacement में सम्मिलित करता है।

उदाहरण:

1> binary:replace(<<"abcde">>,<<"b">>,<<"[]">>, [{insert_replaced,1}]).
<<"a[b]cde">>
2> binary:replace(<<"abcde">>,[<<"b">>,<<"d">>],<<"[]">>,[global,{insert_replaced,1}]).
<<"a[b]c[d]e">>
3> binary:replace(<<"abcde">>,[<<"b">>,<<"d">>],<<"[]">>,[global,{insert_replaced,[1,1]}]).
<<"a[bb]c[dd]e">>
4> binary:replace(<<"abcde">>,[<<"b">>,<<"d">>],<<"[-]">>,[global,{insert_replaced,[1,2]}]).
<<"a[b-b]c[d-d]e">>

यदि प्रतिस्थापन बाइनरी के InsPos > आकार में निर्दिष्ट कोई भी स्थिति, एक badarg अपवाद उठाया जाता है।

विकल्प global और {scope, part()} split/3 रूप में काम करते हैं। रिटर्न प्रकार हमेशा एक binary()

Pattern विवरण के लिए, compile_pattern/1 देखें।

विभाजन (विषय, पैटर्न) -> भागों

प्रकार

split(Subject, Pattern, []) रूप में भी split(Subject, Pattern, [])

विभाजन (विषय, पैटर्न, विकल्प) -> भागों

प्रकार

स्प्लिट्स Subject आधार पर बायनेरिज़ की सूची में Subject । यदि विकल्प global निर्दिष्ट नहीं है, तो Subject में केवल Pattern की पहली घटना एक विभाजन को जन्म देती है।

Subject में पाए गए Pattern भाग परिणाम में शामिल नहीं हैं।

उदाहरण:

1> binary:split(<<1,255,4,0,0,0,2,3>>, [<<0,0,0>>,<<2>>],[]).
[<<1,255,4>>, <<2,3>>]
2> binary:split(<<0,1,0,0,4,255,255,9>>, [<<0,0>>, <<255,255>>],[global]).
[<<0,1>>,<<4>>,<<9>>]

विकल्पों का सारांश:

{कार्यक्षेत्र, भाग ()}

match/3 और matches/3 रूप में काम करता है। ध्यान दें कि यह केवल मिलान तारों के लिए खोज के दायरे को परिभाषित करता है, यह बंटवारे से पहले बाइनरी में कटौती नहीं करता है। परिणाम में गुंजाइश से पहले और बाद में बाइट्स रखे जाते हैं। नीचे उदाहरण देखें।

ट्रिम

परिणाम के खाली हिस्सों को निकालता है (जैसा कि re:split/3 trim होता है re:split/3

trim_all

परिणाम के सभी खाली हिस्सों को निकालता है।

वैश्विक

जब तक Subject समाप्त नहीं हो जाता तब तक विभाजन दोहराता है। वैचारिक रूप से विकल्प global matches/3 द्वारा लौटाए गए पदों पर विभाजन कार्य करता है, जबकि यह सामान्य रूप से match/3 द्वारा लौटाए गए स्थान पर काम करता है।

बंटवारे से पहले एक दायरे के बीच अंतर और द्विआधारी को अलग करने का उदाहरण:

1> binary:split(<<"banana">>, [<<"a">>],[{scope,{2,3}}]).
[<<"ban">>,<<"na">>]
2> binary:split(binary:part(<<"banana">>,{2,3}), [<<"a">>],[]).
[<<"n">>,<<"n">>]

रिटर्न प्रकार हमेशा बायनेरिज़ की एक सूची है जो सभी संदर्भ Subject । इसका अर्थ है कि Subject में डेटा को नए बायनेरिज़ में कॉपी नहीं किया जाता है, और जब तक कि विभाजन के परिणामों को संदर्भित नहीं किया जाता है तब तक Subject को कचरा एकत्र नहीं किया जा सकता है।

Pattern विवरण के लिए, compile_pattern/1 देखें।