Mi az a “ deklarál ” a Bash-ban?

A legtöbb esetben elegendő implicit deklarációval a bash

asdf="some text" 

De néha azt akarja, hogy a változó értéke csak egész legyen (tehát ha később, akár automatikusan is megváltozik, akkor csak egy egész szám, alapértelmezés szerint nulla bizonyos esetekben), és használhatja:

declare -i num 

vagy

declare -i num=15 

Néha tömbökre van szüksége, és akkor declare

declare -a asdf # indexed type 

vagy

Jó útmutatásokat találhat a tömbökről a bash részben, amikor az interneten a” bash tömb oktatóanyag “(idézőjelek nélkül) keresési karakterlánccal tallózik. példa

linuxconfig.org/how-to-use-arrays-in-bash-script

Azt hiszem, ezek a leggyakoribb esetek, amikor változókat deklarálsz.

Kérjük, vegye figyelembe, hogy

• egy függvényben, declare a változót lokálissá teszi (a függvényben)

• név nélkül az összes változót felsorolja (az aktív héjban)

  declare 

Végül röviden összefoglalja a declare parancsértelmezőbe beépített parancs funkcióit a a

help declare 

Megjegyzések

• paranccsal! Üdvözlet az OP-ból! Szerintem a válaszod remek, és felértékeltem, és köszönöm ezt véleményem szerint nagyon didaktikus válasznak. Épp egy kisebb szerkesztést javasoltam, amely szerény véleményem szerint még könnyebben és hozzáférhetőbben teszi lehetővé az újonnan érkezők számára az olvasást; kérjük, hajtsa végre ezt a javaslatot.
• Most láttam, hogy user:muru a szerkesztés elutasítására szavazott; kérlek, tudd, hogy én és a muru ” többször is összetűztük ” e webhely különböző szakaszaiban, és feltételezem, hogy az elutasítása nem ‘ cél és valójában káros, ellentétben a szerkesztési javaslat itt bemutatott közvetlen változtatásokkal: unix.stackexchange.com/review/suggested -edits / 325749
• @JohnDoea, láttam, hogy egy másik felhasználó is elutasította a szerkesztéseket. Szerintem néhány szerkesztésed jó, de néhányuk megváltoztatja az üzenetet, mint amit szándékoztam, ezért nem szeretném őket. Szerkeszthetem a választ úgy, hogy az szerintem jó szerkesztéseket tartalmazzon.
• köszönöm; amint azt valószínűleg tudjátok, a szerkesztések elutasítása sokkal gyakoribb az SE-ben, mint azok (akár részleges) elfogadása; köszönöm, hogy tudatta velem, hogy egy másik felhasználó elutasította a szerkesztést (én nem láttam őszintén előtte), és fontolóra vette, hogy legalább néhány szerkesztésemet beillesztem a válaszába; Nagyon tisztelem,

A help declare meglehetősen szűk. Világosabb magyarázat megtalálható a man bash vagy a info bash lapokban – ez utóbbi a forrás a következőkre.

Először néhány definíció. A változókról és attribútumokról :

A paraméter értékeket tároló entitás. … A változó egy paraméter, amelyet name jelöl. Egy változónak értéke és nulla vagy több attribútuma van. Az attribútumokat a declare beépített paranccsal rendelhetjük hozzá …

És a declare beépített :

declare

 declare [-aAfFgilnrtux] [-p] [name[=value] …]  

Változók deklarálása és attribútumok megadása. Ha nincs megadva név, akkor inkább a változók értékeit jelenítse meg.

…

-n
Adja meg mindegyiknek név nek a nameref attribútumot, ezzel egy másik változó névre hivatkozva. Ezt a másik változót a név értéke határozza meg. A név minden hivatkozását, hozzárendelését és attribútum-módosítását, kivéve azokat, amelyek a -n attribútumot használják vagy módosítják, a név értéke. …

Ne feledje, hogy a név hivatkozás változók csak a Bash 4.3 vagy újabb verzióiban érhetők el ¹ .

Ezenkívül a declare és a Bash változó attribútumainak hasznos bemutatásához válasz erre: ” Mit csinálnak declare name és declare -g? ” (amely elsősorban a változókra összpontosít “, de a hatókörre terjed ki).

Alapvetően ² , egyenértékű azzal a name=[value] hozzárendeléssel, amelyet valószínűleg ismer. Mindkét esetben a name -hez null értéket rendelnek érték, ha value hiányzik.

Ne feledje, hogy a kissé eltérő declare name helyett nem állít be a name ³ változó:

 $ declare name ## With the -p option, declare is used to display ## attributes and values of variables $ declare -p name declare -- name ## "name" exists ## Parameter expansion can be used to reveal if a variable is set: ## "isunset" is substituted to "name" only if unset $ echo "${name-isunset}" isunset  

Így a name változó lehet:

• deklarált és unset a declare name után;
• deklarált és set a null értékként name= vagy declare name= után;
• deklarált , set és nem null értékkel a name=value vagy .

Általánosabban: declare [options] name=value

1. létrehozza a name – amely egy névvel rendelkező paraméter, amely viszont csak egy része a memóriának, amelyet felhasználhat az információk tárolásához ⁴ ;
2. hozzárendel az érték value hozzá;
3. opcionálisan beállítja a name “attribútumokat, amelyek meghatározzák mind az érték fajtáját, tárolhatja (szigorúan véve nem egy típus ban, mivel a Bash nyelvét nem írja be) és a manipulálás módjait.

Az attribútumok valószínűleg könnyebb megmagyarázni egy példával: az declare -i name használatával beállíthatja az ” egész ” attribútumot a name, lehetővé téve, hogy egész számként kezeljük; a kézikönyv idézésével ” aritmetikai értékelést hajtunk végre, amikor a változóhoz “:

 ## Let"s compare an ordinary variable with an integer $ declare var $ declare -i int $ var="1+1" $ int="1+1" $ echo "$var" 1+1 ## The literal "1+1" $ echo "$int" 2 ## The result of the evaluation of 1+1  

a fentiek szerint az ilkkachu kódjában az történik, hogy:

1. Egy ref nevű változót deklarálunk, a ” nameref ” attribútumkészlet, és a $1 (az első helyzeti argumentum) tartalma it:

    declare -n ref="$1"  

   Egy név hivatkozási változó, például ref egy másik változó nevének tárolása, amely általában nem ismert előre, valószínűleg azért, mert azt akarjuk, hogy dinamikusan definiáljuk (pl. Mert egy kódrészletet újra fel akarunk használni, és rendelkezünk vele több változóra alkalmazva), és a kényelmes hivatkozást nyújtanak a hivatkozásra (és manipulálásra). (Bár nem az egyetlen: az indirekció alternatíva; lásd: Héjparaméter kibővítése ).

2. Amikor A tmp1 változó értéke a következőhöz van rendelve: ref:

    ref=$tmp1  

   egy további változó, amelynek neve a ref értéke, implicit módon deklarálva van. A tmp1 értéke szintén közvetve az implicit módon deklarált változóhoz van rendelve a ref .

kapcsolt kérdésével összefüggésben hívja a read_and_verify as

 read_and_verify domain "Prompt text here..."  

a és rendelje hozzá a tmp1 értéket (azaz a felhasználó bemenetét). Pontosan úgy van megtervezve, hogy újból felhasználja a felhasználóval interakcióban lévő kódot és kihasználja a nameref változót a domain és néhány egyéb változó deklarálásához.

Az implicit rész közelebbi megismeréséhez lépésről lépésre reprodukálhatjuk a folyamatot:

 ## Assign a value to the first positional argument $ set -- "domain" ## Declare the same "tmp1" variable as in your code $ tmp1="value for domain" ## Declare a "ref" variable with the nameref attribute set and ## assign the value "domain" to it $ declare -n ref="$1" ## Note that there is no "domain" variable yet $ declare -p domain bash: declare: domain: not found ## Assign a value to "ref" and, indirectly, to the "domain" variable ## that is implicitly declared $ ref=$tmp1 ## Verify that a variable named "domain" now exists, and that ## its value is that of "tmp1" $ declare -p domain declare -- domain="value for domain" ## Verify that "ref" is actually a reference to "domain" $ domain="new value" $ echo "$domain" new value $ declare -p ref declare -n ref="domain" $ echo "$ref" new value  

¹ _{Hivatkozás: CHANGES fájl, ” szakasz 3. A Bash új funkciói “, pont ” w “.
Ez releváns lehet: például a CentOS Linux 7.6 (jelenleg a legújabb verzió) a Bash 4.2 verzióval szállítjuk.}

² _{A szokásosnál beépített héjak, a kimerítő és tömör magyarázat megfoghatatlan, mivel különféle, esetleg heterogén műveleteket hajtanak végre. Kizárólag az attribútumok deklarálására, kijelölésére és beállítására fogok összpontosítani, és figyelembe veszem az attribútumok felsorolását, kiterjesztését és eltávolítását, mivel nem tartoznak a válasz körébe.}

³ _{A declare -p ilyen viselkedését bevezettük a Bash 4.4-be. Hivatkozás: CHANGES fájl, szakasz ” 3. Új funkciók a Bash ” pontban, ” f “.
As G-Man rámutatott a megjegyzésekben, a Bash 4.3-ban declare name; declare -p name hibát ad. De még mindig ellenőrizheti, hogy a name létezik-e a következővel: declare -p | grep "declare -- name".}

⁴ _{FullBashGuide, Paraméterek a mywiki.wooledge.org oldalon}

Megjegyzések

• (1) Nem tudom reprodukálni az első kódblokkban megjelenített eredményeket: declare name, majd declare -p name “bash: declare: name: not found” eredményt adja. (Bár declare -p | grep na declare -- name.) (2) Úgy gondolom, hogy kissé félrevezető a echo "${name-isunset}" a declare name kontextusban, amennyiben egy nem bejelentett (azaz meghatározatlan) változót ugyanúgy kezel, mint egy deklarált de unset változó. (3) Érdemes megemlítenie, hogy a névadók csak a 4.3-as és újabb verziókban állnak rendelkezésre.
• @ G-Man Köszönjük észrevételeit! ‘ mihamarabb megszólítom őket, és ‘ ll, ha szükséges, frissítem a válaszomat. Ami az (1) -t illeti, az Arch Linux rendszeren az GNU bash, version 5.0.7(1)-release (x86_64-pc-linux-gnu) fájlom továbbra is megadja az általam bemutatott eredményeket. Lehet, hogy ezt a viselkedést csak a közelmúltban vezették be, én ‘ kivizsgálom.
• Igen;

Megpróbálom elmagyarázni ezt, de bocsásson meg, ha nem követem az Ön által adott példát. Inkább megpróbálom végigvezetni a saját, más megközelítésem mentén.

Azt mondod, hogy már értesz olyan fogalmakat, mint a „változók” és „kibővítésük”, stb. háttérismeretek, amelyek egyébként mélyebb fókuszt igényelnek.

Tehát azzal kezdem, hogy basic level, a declare parancs csak egy mód arra, hogy elmondja Bash-nek, hogy változó értékre van szüksége (azaz olyan értékre, amely a szkript végrehajtása során változhat), és utaljon erre az értékre egy adott név használatával, pontosan arra a névre, amelyet maga a declare parancs mellett jelöl meg.

Vagyis:

 declare foo="bar"  

elmondja Bash-nek, hogy azt akarja, hogy a foo nevű változó értéke bar legyen.

De .. tartson egy percet … tegyük ezt anélkül, hogy egyáltalán használnánk a declare t, nem? Mint itt:

 foo="bar"  

Nagyon igaz.

Nos , előfordul, hogy a fenti egyszerű hozzárendelés valójában egy implicit módja .. valójában .. egy változó deklarálásának.

( Az is előfordul, hogy a fentiek az egyik a megváltoztatja a foo nevű változó értékét; valóban pontosan a legközvetlenebb, tömör, egyértelmű, egyenes út .. de nem ez az egyetlen .. .. erre később visszatérek .. ).

De akkor, ha így van jól lehet deklarálni egy „nevet, amely a változó értékeit megjelöli” (a továbbiakban csak „változó”, a rövidség kedvéért) anélkül, hogy egyáltalán használná a declare elemet, miért akarna valaha használja ezt a pompás „deklarál” parancsot?

A válasz abban rejlik, hogy a fenti implici A változó deklarálásának módja (foo="bar"), ez .. implicit módon .. arra készteti Bash-t, hogy vegye figyelembe azt a típusú változót, amelyet a shell szokásos használati szcenáriójában leggyakrabban használnak. .

Ez a típus a karakterlánc típusa, azaz különösebb jelentésű karaktersorozat. Ezért egy sztringet kapunk, amikor az implicit deklarációt használjuk.

De neked, mint programozónak, néha inkább egy változót kell figyelembe venned, mint például egy számot .. amellyel számtant kell végezned műveletek .. és egy olyan implicit deklaráció használatával, mint a foo=5+6 nem teszi Bash-t a 11. értékhez foo számíthat rá. Inkább hozzárendeli a foo hez a három karakter sorrendjét 5 + 6.

Szóval .. meg kell mondanod Bash-nek, hogy a foo számnak, nem pedig számnak karakterlánc .. és erre hasznos egy explicit declare.

Csak mondd:

 declare -i foo=5+6 # <<- note the "-i" option: it means "integer"  

és Bash boldogan végzi a matematikát helyetted, és a numerikus 11 értéket a .

Vagyis: a declare -i foo kimondásával megadod a foo változónak a attribute egész szám.

A számok (pontosan egész számok, mivel Bash még mindig nem érti a tizedesjegyeket, lebegőpontokat és mindezeket) deklarálása lehet az első oka a declare, de nem ez az egyetlen oka. Mint már megértette, van még néhány attribútum, amelyet megadhat a változóknak. Például megadhatja a Bash-nek, hogy a változó értékét mindig nagybetűvé tegye, bármi is legyen: ha azt mondja, hogy declare -u foo, akkor onnantól kezdve, amikor azt mondja: foo=bar Bash a BAR karakterláncot tulajdonképpen a foo változóhoz rendeli.

Ezen attribútumok bármelyikének megadása érdekében változóhoz kell használnod a declare parancsot, nincs más választás.

Most az egyik másik a declare a hírhedt „név-ref”, a -n attribútum. ( És most folytatom a korábban visszatartott koncepciót ).

A name-ref attribútum alapvetően lehetővé teszi a Bash programozók számára az érték megváltoztatásának másik módját Pontosabban közvetett módot ad erre.

Íme hogyan működik:

Ön declare egy olyan változó, amelynek -n attribútuma van, és ez nagyon ajánlott (bár nem feltétlenül szükséges, de egyszerűbbé teszi a dolgokat), hogy adjon értéket ennek nagyon változónak ugyanazon a declare parancs. Így:

 declare -n baz="foo"  

Ez azt mondja Bash-nak, hogy onnantól kezdve be, minden alkalommal, amikor a baz nevű változó értékét használja, vagy megváltoztatja, akkor a .

Ami azt jelenti, hogy onnantól kezdve yo olyat mondhatsz, hogy baz=10+3, hogy foo megkapja a 13 értéket.Feltéve természetesen, hogy a foo -et korábban egész számnak (declare -i) deklarálták, mint egy perccel ezelőtt, különben megkapja a sorrendet a négy karakterből 1 0 + 3.

Továbbá: ha közvetlenül megváltoztatja a (z) foo értéket, mint a foo=15, akkor látni fogja 15 a echo “${baz}” kimondásával is. Ez azért van, mert a baz változó, amely a foo névre hivatkozik, mindig tükrözi a foo érték.

A fenti declare -n parancsot “név-referenciának” mondják, mert ez változóvá teszi a baz hivatkozás ra egy másik változó neve re. Valójában kijelentettük, hogy a baz értéke “foo”, amelyet az -n opció miatt Bash kezel, mint a egy másik változó.

Most miért akarja a Földön valaha is ezt csinálni?

Nos .. érdemes azt mondani, hogy ez a funkció eléggé speciális igények kielégítésére szolgál.

Valójában annyira fejlett, hogy amikor egy programozó olyan problémával szembesül, amelyhez valóban névre lenne szükség, akkor az is valószínű, hogy egy ilyen problémát inkább megfelelő programozási nyelv használatával kell megoldani a Bash helyett.

Az egyik ilyen speciális igény például az, amikor a programozóként nem tudhatja a fejlesztés során hogy melyik változót kell használnia egy szkript egy adott pontjában, de ez futás közben dinamikusan teljesen ismert lesz. Tekintettel arra, hogy egyetlen programozó sem képes a futás közbeni beavatkozásra, az egyetlen lehetőség az, hogy előzetesen gondoskodjon az ilyen helyzetekről a szkriptben, és a „név-ref” lehet az egyetlen életképes út. Ennek a speciális igénynek széles körben ismert eseteként gondoljon például a beépülő modulokra. A „plugin-képes” program programozójának előzetesen általános rendelkezéseket kell hoznia a jövőbeli (és esetleg harmadik féltől származó) plug-inek számára. Ezért a programozónak olyan szolgáltatásokat kell használnia, mint a Bash név-ref.

Egy másik speciális igény az, amikor hatalmas mennyiségű adattal kell megküzdenie a RAM-ban és át kell adnia ezeket az adatokat a szkript funkciói köré, amelyeknek szintén módosítaniuk kell az adatokat. Ebben az esetben minden bizonnyal átmásolhatja ezeket az adatokat az egyik függvényből a másikba (mint például Bash, amikor dest_var="${src_var}", vagy amikor olyan funkciókat hív be, mint például a myfunc "${src_var}"), de mivel ezek az adatok óriási mennyiségűek lennének, a RAM-ot hatalmas mértékben pazarolnák és a nagyon nem hatékony működéshez. Tehát a megoldás, ha ilyen helyzetek merülnek fel, az nem az adatok másolatát, hanem az adatok hivatkozását használja. Bash-ban egy név-ref. Ez a használati eset valóban a szokás minden modern programozási nyelvben, de nagyon kivételes, ha a Bash-t illeti, mert a Bash-ot többnyire rövid egyszerű szkriptekhez tervezték, amelyek többnyire fájlokkal és külső parancsokkal foglalkoznak, és így a Bash-szkripteknek ritkán kell hatalmasat átadniuk a funkciók közötti adatmennyiség. És amikor egy szkript funkcióinak valóban meg kell osztaniuk néhány adatot (hozzáférni és módosítani), ezt általában csak egy globális változó használatával érik el, ami a Bash-szkriptekben ugyanúgy normális, mint nagyon a megfelelő programozási nyelveken elavult.

Ezután a Bash-ban lehet egy figyelemre méltó név-hivatkozási eset, és (talán ironikus módon) más típusú változók használatakor is társul:

1. „indexelt tömbként” deklarált változók (declare -a)
2. „asszociatív tömbökként” deklarált változók (declare -A).

Ezek olyan típusú változók, amelyeket könnyebben (és hatékonyabban is) átadhatunk a függvények mentén a név-hivatkozások használatával a normál másolás helyett, még akkor is, ha nem hordoznak hatalmas mennyiségű adatot.

Ha ezek a példák furcsának és érthetetlennek tűnnek, csak azért, mert a név-hivatkozások valóban haladó téma, és ritka szükség van a B tipikus használati forgatókönyvére hamu.

Tudnék mesélni olyan alkalmakról, amelyekben például a Bash-ban használtam a név-hivatkozásokat, de eddig többnyire meglehetősen „ezoterikus” és bonyolult igényekre készültek, és én attól tart, hogy ha leírnám őket, a tanulásod ezen a pontján csak bonyolítanám a dolgodat. Csak hogy megemlítsem a legkevésbé komplexet (és valószínűleg nem ezoterikusat): az értékek visszatérését a függvényekből. A Bash nem igazán támogatja ezt a funkcionalitást, ezért ugyanazt kaptam a név-hivatkozások használatával. Egyébként pontosan ezt teszi a példakódod.

Emellett egy kis személyes tanács, amely valójában jobban megfelelne egy megjegyzéshez, de nem tudtam eléggé sűríteni. illeszkedni a StackExchange megjegyzéseinek korlátaiba.

Úgy gondolom, hogy a legtöbb t úgy kell tennie, hogy jelenleg a név-hivatkozásokkal kísérletezzen az általam bemutatott egyszerű példák és talán az Ön által megadott példakód felhasználásával, figyelmen kívül hagyva Jelenleg a „miért a földön” rész, és csak a „hogyan működik” részre összpontosítva. Kicsit kísérletezve a „hogyan” rész jobban belemerül az elmédbe, így a „miért” rész megfelelő időben kiderül számodra, amikor (vagy ha) valódi gyakorlati probléma merül fel, amelyre egy név- A ref valóban jól jön.

Hozzászólások

• LL3 Nagyon tetszik a válaszod, és remekbe fogtam: végül megértem, mit tesz a nyilatkozat – – nem a változók deklarálása, hanem azok attribútumainak deklarálása; mégis sajnos elvesztettem a nyomát, amikor elkezdted elmagyarázni, mi a név-hivatkozás. Fogalmam sem volt, mit csinál, és miért kell használni.
• Vagyis – miért adná valaki ezt az attribútumot
• @JohnDoea látom. Talán csak hagyja ezt a témát egy pillanatra. Valószínűleg túl korai felfogni ezt a koncepciót a tanulás jelenlegi pillanatában. Mindenesetre bővítettem a válaszomat további példákkal és egy kis személyes kiegészítéssel arra vonatkozóan, hogy szerintem hogyan kellene tovább haladnia. Vízszintes vonalakat is elhelyeztem a declare általános magyarázatának elhatárolására a -n személyes magyarázatából a személyes kiegészítésből. Kicsit átfogalmaztam már itt-ott, de semmi lényeges, ezért úgy gondolom, hogy csak elolvassa a -n részt, valamint a kis kiegészítést.
• Köszönöm, szerintem ‘ rendben van, hogy most megtanulom ezt a dolgot, csak magyarázatra van szükségem, amit megértek, és ma újra el kell olvasnom a teljes válaszodat, én ‘ m itt körül.
• Megemlíti foo="bar" és declare foo="bar" . Érdemes megemlíteni (ha csak egy lábjegyzetben), hogy egy shell függvényben a declare foo="bar" létrehoz egy helyi változót, a foo="bar" pedig egy globális változó.

Általában declare a bash shell beállítja (vagy eltávolítja, vagy megjeleníti) a változók attribútumait . Az attribútum egyfajta kommentár, amely azt mondja, hogy “ez egy névreferencia”, vagy “ez egy asszociatív tömb”, vagy “ezt a változót mindig egész számként kell értékelni”, vagy “ez a változó csak olvasható és nem használható be re-set “, vagy” ez a változó exportálásra kerül (környezeti változó) “stb.

A beépített typeset beépített név a declare itt: bash, mivel typeset más héjakban használatos (ksh, ahol keletkezett, és például zsh) a változó attribútumok beállításához.

A névre mutató példát alaposabban megnézve itt: a kérdés:

A megjelenített shell függvény hozzáadott bit kóddal, amely használja:

#!/bin/bash function read_and_verify { read -p "Please enter value for "$1": " tmp1 read -p "Please repeat the value to verify: " tmp2 if [ "$tmp1" != "$tmp2" ]; then echo "Values unmatched. Please try again."; return 2 else declare -n ref="$1" ref=$tmp1 fi } read_and_verify foo printf "The variable "foo" has the value "%s"\n" "$foo" 

Ennek futtatása:

 $ bash script.sh Please enter value for "foo": hello Please repeat the value to verify: hello? Values unmatched. Please try again. The variable "foo" has the value "" 

Ez azt mutatja, hogy a foo változó nincs beállítva semmire, ha a felhasználó két különböző karakterláncok.

Ez azt mutatja, hogy a foo változó a karakterláncra lesz beállítva, amelyet a felhasználó adott meg, amikor kétszer beírta az ugyanazt karakterláncot .

A $foo módon a szkript fő részében a hello értéket megkapja a következő sorok: a shell függvényben:

declare -n ref="$1" ref=$tmp1 

ahol $tmp1 a karakterlánc hello adta meg a felhasználó, és $1 a foo karakterlánc, amelyet a függvény parancssorából adtak át a szkript.

Figyelje meg, hogy a ref változót declare -n névvel deklarálják név hivatkozási változóként, és hogy a foo értéket adják meg a nyilatkozatban. Ez azt jelenti, hogy ettől kezdve, amíg a változó ki nem lép a hatókörből, a ref változó bármilyen felhasználása megegyezik a foo. A ref változó egy név referencia változó , amely erre a pontra foo hivatkozik.

Ennek az a következménye, hogy ha értéket rendelünk a ref fájlhoz, amint az a deklarációt követő sorban történik, akkor az értéket a foo fájlhoz rendeli.

A hello érték ekkor elérhető a szkript fő részének $foo fájljában.