Quelle est la différence entre les contextes scalaires et liste en Perl?

Question

Quelle est la différence entre les contextes scalaires et liste en Perl et que cela a tout parallèle dans d'autres langages tels que Java ou Javascript?

Answer 1

différents opérateurs de Perl sont sensibles au contexte et produisent des résultats différents dans la liste et un contexte scalaire.

Par exemple:

my(@array) = (1, 2, 4, 8, 16);
my($first) = @array;
my(@copy1) = @array;
my @copy2  = @array;
my $count  = @array;

print "array: @array\n";
print "first: $first\n";
print "copy1: @copy1\n";
print "copy2: @copy2\n";
print "count: $count\n";

Sortie:

array: 1 2 4 8 16
first: 1
copy1: 1 2 4 8 16
copy2: 1 2 4 8 16
count: 5

• $first contient 1 (le premier élément de la matrice), parce que les parenthèses dans la my($first) fournissent un contexte de réseau, mais il y a de place que pour une valeur en $first.
• les deux @copy1 et @copy2 contiennent une copie de @array,
• et $count contient 5 parce qu'il est un contexte scalaire, et @array évalue le nombre d'éléments dans le tableau dans un contexte scalaire.

Des exemples plus élaborés pourraient être construits aussi (les résultats sont un exercice pour le lecteur):

my($item1, $item2, @rest) = @array;
my(@copy3, @copy4) = @array, @array;

Il n'y a pas parallèle direct à la liste et le contexte scalaire dans d'autres langues que je connais.

Answer 2

contexte Scalar est ce que vous obtenez lorsque vous êtes à la recherche d'une valeur unique. Liste contexte est ce que vous obtenez lorsque vous êtes à la recherche de valeurs multiples. L'un des endroits les plus communs pour voir la distinction est lorsque l'on travaille avec des tableaux:

@x = @array;  # copy an array
$x = @array;  # get the number of elements in an array

D'autres opérateurs et fonctions sont sensibles au contexte ainsi:

$x   = 'abc' =~ /(\w+)/;  # $x = 1
($x) = 'abc' =~ /(\w+)/;  # $x = 'abc'
@x   = localtime();       # (seconds, minutes, hours...)
$x   = localtime();       # 'Thu Dec 18 10:02:17 2008'

Comment un opérateur (ou fonction) se comporte dans un contexte donné est à l'opérateur. Il n'y a pas de règles générales sur la façon dont les choses sont censées se comporter.

Vous pouvez faire votre propre contexte de sous-routines sensibles en utilisant la fonction wantarray pour déterminer le contexte d'appel. Vous pouvez forcer une expression à évaluer dans un contexte scalaire en utilisant le mot-clé scalar.

En plus des contextes scalaires et liste vous verrez également « vide » (pas de valeur de rendement prévu) et « booléen » (une valeur true / false attendus) des contextes mentionnés dans la documentation.

Answer 3

Cela signifie simplement qu'un type de données sera évaluée en fonction du mode de fonctionnement. Par exemple, une affectation à un scalaire signifie que le côté droit sera évaluée comme un scalaire.

Je pense que le meilleur moyen de contexte de compréhension est d'apprendre au sujet wantarray. Alors imaginez que = est un sous-programme qui implémente wantarray:

sub = {
  return if ( ! defined wantarray ); # void: just return (doesn't make sense for =)
  return @_ if ( wantarray ); # list: return the array
  return $#_ + 1; # scalar: return the count of the @_
}

Les exemples ce travail de post comme si le sous-programme ci-dessus est appelé par passage du côté droit en tant que paramètre.

En ce qui concerne des parallèles dans d'autres langues, oui, je maintiens encore que pratiquement toutes les langues prend en charge quelque chose de similaire. Polymorphisme est similaire dans toutes les langues OO. Un autre exemple, Java convertit des objets à chaîne dans certains contextes. Et chaque langage de script typées je l'ai utilisé a des concepts similaires.