🚀 go-pugleaf

Waldek Grudzien <waldekg@uhc.lublin.pl> wrote:

: Mam taki krótki programik :
: _______________________________________________________________________
: #!/usr/bin/perl
: use strict;
: my $c = "aaaaa";
: print $c;

: &test;

: sub test {
:   print "\n",$c,"\n";
: };
: _______________________________________________________________________

: Zgodnie z logiką użycie $c w funkcji test (łącznie z  use strict) powinno
: dać komunikat błędu 

Nie. Deklaracja my na poziomie globalnym deklaruje coś podobnego do 
zmiennej globalnej w C (dokładnie, to jest to analogiczne do zmiennej
globalnej ze static - niewidocznej poza danym plikiem). Jest ona 
tworzona w momencie napotkania deklaracji my, i dostępna z dowolnego 
miejsca w danym module.

Jest to zresztą bardzo praktyczny sposób na używanie zmiennych 
globalnych pod use strict.

: tak się jednak nie dzieje. Jeśli $c jest zadeklarowane poprzez składnię  
: local perl wypluwa komunikat błędu.

AFAIR, local nie jest dopuszczalny pod use strict. W sumie local to 
tylko zapisanie kopii zmiennej i jej automatyczne odtworzenie - nie 
zmienia to w żaden sposób faktu, że zmienna jest globalna.

-- 
Piotr Piątkowski, Uczelniane Centrum Informatyki, AGH Krakow, POLAND

On 6 Jan 1998, Piotr Piatkowski wrote:
> 
> Nie. Deklaracja my na poziomie globalnym deklaruje coś podobnego do 
> zmiennej globalnej w C (dokładnie, to jest to analogiczne do zmiennej
> globalnej ze static - niewidocznej poza danym plikiem). Jest ona 
> tworzona w momencie napotkania deklaracji my, i dostępna z dowolnego 
> miejsca w danym module.

OK. Lecz powtorze jeszcze raz pytanie - czy jest jakis sposob deklaracji 
zmiennej na "poziomie globalnym" tak, aby nie byla widoczna (odwolanie do niej
powodowalo komunikat bledu) w wywolywanych funkcjach.

                              Waldek Grudzień

    ///////////////////////////////////////////
   //  http://www.uhc.lublin.pl/~waldekg/   //
  //   Lublin/Lubartów, Poland             //
  \\   University Health Care              \\
   \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\

Waldek Grudzien <waldekg@uhc.lublin.pl> wrote:
: On 6 Jan 1998, Piotr Piatkowski wrote:
:> 
:> Nie. Deklaracja my na poziomie globalnym deklaruje coś podobnego do 
:> zmiennej globalnej w C (dokładnie, to jest to analogiczne do zmiennej
:> globalnej ze static - niewidocznej poza danym plikiem). Jest ona 
:> tworzona w momencie napotkania deklaracji my, i dostępna z dowolnego 
:> miejsca w danym module.

: OK. Lecz powtorze jeszcze raz pytanie - czy jest jakis sposob deklaracji 
: zmiennej na "poziomie globalnym" tak, aby nie byla widoczna (odwolanie do niej
: powodowalo komunikat bledu) w wywolywanych funkcjach.

Nic mi nie przychodzi do głowy. A po co? Zwykle zmienne deklaruje się
tam właśnie po to, żeby były globalne. Jeżeli nie chcesz się do nich 
odwoływać z innych funkcji, to po prostu zadeklaruj je tam gdzie ich 
potrzebujesz. Jeżeli piszesz jakoś tak:

my $x = 5;
instrukcja1();
instrukcja2();
...

sub aaa{
...
}

To może lepiej zrobić tak:

main();

sub main {
 my $x = 5;
 instrukcja1();
 instrkucja2();
 ...
}

sub aaa{
...
}

-- 
Piotr Piątkowski, Uczelniane Centrum Informatyki, AGH Krakow, POLAND

On 6 Jan 1998, Piotr Piatkowski wrote:

> : OK. Lecz powtorze jeszcze raz pytanie - czy jest jakis sposob deklaracji 
> : zmiennej na "poziomie globalnym" tak, aby nie byla widoczna (odwolanie do niej
> : powodowalo komunikat bledu) w wywolywanych funkcjach.
> 
> Nic mi nie przychodzi do głowy. A po co? Zwykle zmienne deklaruje się
> tam właśnie po to, żeby były globalne. Jeżeli nie chcesz się do nich 
> odwoływać z innych funkcji, to po prostu zadeklaruj je tam gdzie ich 
> potrzebujesz. 

Wydaje się to konieczne, jeśli w istniejącym programie chcę wykryć
odwołania do niezadeklarowanych (lokalnie w funkcji) zmiennych (co uważam
w gruncie rzeczy za bałaganiarstwo).

Pozdrawiam,
                              Waldek Grudzień

    ///////////////////////////////////////////
   //  http://www.uhc.lublin.pl/~waldekg/   //
  //   Lublin/Lubartów, Poland             //
  \\   University Health Care              \\
   \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\

Waldek Grudzien <waldekg@uhc.lublin.pl> wrote:

: Wydaje się to konieczne, jeśli w istniejącym programie chcę wykryć
: odwołania do niezadeklarowanych (lokalnie w funkcji) zmiennych (co uważam
: w gruncie rzeczy za bałaganiarstwo).

Jeżeli nie będziesz ich deklarować globalnie, to pod use strict; 
dostniesz błąd. Jeżeli zadeklarujesz je globalnie, to odwołanie do 
nich nie będzie błędem, tylko odwołaniem do zadeklarowanych zmiennych 
globalnych. Innymi słowy - dalej nie rozumiem :-)

-- 
Piotr Piątkowski, Uczelniane Centrum Informatyki, AGH Krakow, POLAND

On 7 Jan 1998, Piotr Piatkowski wrote:

> Waldek Grudzien <waldekg@uhc.lublin.pl> wrote:
> 
> : Wydaje się to konieczne, jeśli w istniejącym programie chcę wykryć
> : odwołania do niezadeklarowanych (lokalnie w funkcji) zmiennych (co uważam
> : w gruncie rzeczy za bałaganiarstwo).
> 
> Jeżeli nie będziesz ich deklarować globalnie, to pod use strict; 
> dostniesz błąd. Jeżeli zadeklarujesz je globalnie, to odwołanie do 
> nich nie będzie błędem, tylko odwołaniem do zadeklarowanych zmiennych 
> globalnych. Innymi słowy - dalej nie rozumiem :-)

No dobrze, ale może ja nie chcę, żeby zmienne (powiedzmy robocze), które
wykorzystuję (deklaruję) w "części głównej programu" były widoczne w
funkcjach (chyba, że jawnie zadeklaruję je jako globalne używając 
'use vars qw(#tu lista moich zmiennych globalnych#)' )
Uff - chyba naświetliłem już wystarczająco ;-) ?

Pozdrawiam,
                              Waldek Grudzień

    ///////////////////////////////////////////
   //  http://www.uhc.lublin.pl/~waldekg/   //
  //   Lublin/Lubartów, Poland             //
  \\   University Health Care              \\
   \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\

Waldek Grudzien <waldekg@uhc.lublin.pl> wrote:

: No dobrze, ale może ja nie chcę, żeby zmienne (powiedzmy robocze), które
: wykorzystuję (deklaruję) w "części głównej programu" były widoczne w
: funkcjach (chyba, że jawnie zadeklaruję je jako globalne używając 
: 'use vars qw(#tu lista moich zmiennych globalnych#)' )
: Uff - chyba naświetliłem już wystarczająco ;-) ?

Niby tak, ale przecież Ci tłumaczę, że nie ma czegoś takiego jak 
zmienna zadeklarowana w głównej części programu która nie jest 
globalna. Jeżeli zmienną tam deklarujesz, to jest globalna i koniec.
Jak masz dalej wątpliwości - to po prostu przyjmij że się nie da 
zrobić tego co chcesz :-)

-- 
Piotr Piątkowski, Uczelniane Centrum Informatyki, AGH Krakow, POLAND

Waldek Grudzien wrote:

> No dobrze, ale może ja nie chcę, żeby zmienne (powiedzmy robocze), które
> wykorzystuję (deklaruję) w "części głównej programu" były widoczne w
> funkcjach (chyba, że jawnie zadeklaruję je jako globalne używając
> 'use vars qw(#tu lista moich zmiennych globalnych#)' )
> Uff - chyba naświetliłem już wystarczająco ;-) ?

Hmm, ja bym powiedział, że to jest lekko nienaturalne. Zazwyczaj
większość języków programowania posługuje się pojęciem zasięgu
zmiennych. I chyba nie istnieje język który pozwala usuwać widoczność
zmiennych przy zagnieżdżaniu. (OK, nie mówmy o prywatnych elementach
obiektów)

Wydaje mi się, że nie jest to potrzebna 'feature'. Wręcz przeciwnie, ja
bym na przykład nie chciał, żeby tak było. use vars tworzy zmienne
trochę inaczej niż my, W szczególności przy używania perl'a jako
'embedded interpreter' zmienne takie są pozostawiane w pamięci pomiędzy
kolejnymi wywołaniami interpretera. 

Natomiast, jeśli obawiasz się, że jakaś funkcja używa zmiennych
globalnych i może to powodować błędy w działaniu programu, to w trakcie
testów możesz je przykryć zagnieżdżonymi definicjami.

Michał

-- 
WWW: http://www.lodz.pdi.net/~mimo  tel: Int. Acc. Code + 48 42 148340
add: Michal Mosiewicz  *  Bugaj 66 m.54 *  95-200 Pabianice  *  POLAND

On Thu, 8 Jan 1998, Michał Mosiewicz wrote:

> Waldek Grudzien wrote:
> 
> > No dobrze, ale może ja nie chcę, żeby zmienne (powiedzmy robocze), które
> > wykorzystuję (deklaruję) w "części głównej programu" były widoczne w
> > funkcjach (chyba, że jawnie zadeklaruję je jako globalne używając
> > 'use vars qw(#tu lista moich zmiennych globalnych#)' )
> > Uff - chyba naświetliłem już wystarczająco ;-) ?
> 
> Hmm, ja bym powiedział, że to jest lekko nienaturalne. Zazwyczaj
> większość języków programowania posługuje się pojęciem zasięgu
> zmiennych. I chyba nie istnieje język który pozwala usuwać widoczność
> zmiennych przy zagnieżdżaniu. (OK, nie mówmy o prywatnych elementach
> obiektów)

No nie, bez przesady - za chwilę dowiem się, że przykładowo w języku C
zmienne zadeklarowane w main {} są widoczne w innych funkcjach ...
(C nie jest też jedynym językiem, który ma taką własność)
Zauważ, że w moim pytaniu nigdzie nie upierałem się przy zagnieżdżaniem.

> Wydaje mi się, że nie jest to potrzebna 'feature'. Wręcz przeciwnie, ja
...
> Natomiast, jeśli obawiasz się, że jakaś funkcja używa zmiennych
> globalnych i może to powodować błędy w działaniu programu, to w trakcie
> testów możesz je przykryć zagnieżdżonymi definicjami.

I twoim zdaniem mam przejrzeć setki linii kodu aby poprzykrywać wszystkie 
zmienne globalne ? - dzięki ...

_____________________________________________________________________________

ROZWIĄZANIE :

Nasunęło mi się z przypominania jak to się robi w C (main {}) :
_____________________________________________________________________________
use strict;

package main; {

my $c ="ccccc";
&test;
}

sub test {
  print ":$c:";
}

_____________________________________________________________________________

Działa dokładnie tak jak chciałem : wypluwa komunikat błędu (o
niezadeklarowaniu $c).
Jeśli, chcę aby $c była globalna, po prostu deklaruję ją "powyżej main" 
i po kłopocie ...

Pozdrawiam,
                              Waldek Grudzień

    ///////////////////////////////////////////
   //  http://www.uhc.lublin.pl/~waldekg/   //
  //   Lublin/Lubartów, Poland             //
  \\   University Health Care              \\
   \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\

Waldek Grudzien wrote:
> 
> On Thu, 8 Jan 1998, Michał Mosiewicz wrote:
> 
> > Waldek Grudzien wrote:
> >
> > > No dobrze, ale może ja nie chcę, żeby zmienne (powiedzmy robocze), które
> > > wykorzystuję (deklaruję) w "części głównej programu" były widoczne w
> > > funkcjach (chyba, że jawnie zadeklaruję je jako globalne używając
> > > 'use vars qw(#tu lista moich zmiennych globalnych#)' )
> > > Uff - chyba naświetliłem już wystarczająco ;-) ?
> >
> > Hmm, ja bym powiedział, że to jest lekko nienaturalne. Zazwyczaj
> > większość języków programowania posługuje się pojęciem zasięgu
> > zmiennych. I chyba nie istnieje język który pozwala usuwać widoczność
> > zmiennych przy zagnieżdżaniu. (OK, nie mówmy o prywatnych elementach
> > obiektów)
> 
> No nie, bez przesady - za chwilę dowiem się, że przykładowo w języku C
> zmienne zadeklarowane w main {} są widoczne w innych funkcjach ...

Przecież w perlu TEŻ NIE SĄ widoczne:

#!/usr/bin/perl

&main();

sub test {
  print "\$c in test: $c\n";
}

sub main {
 my $c = "defined\n";
 &test();
 print "\$c in main: $c\n";
}  

bash$ perl test
$c in test:
$c in main: defined
                
Widać wyraźnie, że lokalna definicja funkcji $c zdeklarowanej w funkcji
main jest jak najbardziej niewidoczna w innych funkcjach.

Natomiast ja byłem przekonany, że chodzi Ci o jakiś mechanizm
przesłaniania zmiennych w zagnieżdżonych blokach. Bo w przypadku o
którym piszesz, każda funkcja była zagnieżdżona w głównym kodzie
programu. I dlatego uzyskiwała dostęp do wszystkich zmiennych które w
tym kodzie były wstawione.

Jeśli dla Ciebie "główna część programu" to po prostu funkcja main, to
nic nie stoi na przeszkodzie, żeby ją sobie napisać. Natomiast jeśli
chodzi o kod funkcji umieszczonych w ciele głównego programu, to należy
pamiętać, że w perlu cały program jest jedną dużą funkcją, w której
wszystkie inne są zagnieżdżone. I te, które są w niej zagnieżdżone
uzyskują dostęp do jej komponentów. Żeby to lepiej przedstawić to inny
przykład:

#!/usr/bin/perl

&main();

sub test {
  print "\$c in test: $c\n";
}

sub main {
 my $c = "\$c\n";
 &test();
 print "\$c in main: $c\n";
 &test1();

sub test1 {
  print "\$c in test1: $c\n";
}

}     

Jak łatwo się domyśleć wynik działania tego programu będzie następujący:

bash$ perl test
$c in test:
$c in main: defined

$c in test1: defined


Funkcja test1 jest zagnieżdżona w ciele funkcji main i dlatego uzyskuje
dostęp do zmiennych w niej zdeklarowanych. Funkcja test, która jest poza
main, tego dostępu już nie ma.

Michał
                       
-- 
WWW: http://www.lodz.pdi.net/~mimo  tel: Int. Acc. Code + 48 42 148340
add: Michal Mosiewicz  *  Bugaj 66 m.54 *  95-200 Pabianice  *  POLAND