Title here
Summary here
program Slices;
uses
SysUtils;
type
TStringArray = array of string;
procedure PrintArray(const arr: TStringArray; const prefix: string);
var
i: Integer;
begin
Write(prefix, ' [');
for i := Low(arr) to High(arr) do
begin
if i > Low(arr) then
Write(' ');
Write(arr[i]);
end;
WriteLn(']');
end;
var
s: TStringArray;
c: TStringArray;
l: TStringArray;
t: TStringArray;
twoD: array of TStringArray;
i, j: Integer;
begin
// Dynamic arrays in Pascal are similar to slices in concept.
// An uninitialized dynamic array is empty and has length 0.
WriteLn('uninit: ', Length(s) = 0);
// To create an empty dynamic array with non-zero length, use SetLength.
SetLength(s, 3);
PrintArray(s, 'emp:');
WriteLn('len: ', Length(s), ' cap: ', Length(s));
// We can set and get elements just like with regular arrays.
s[0] := 'a';
s[1] := 'b';
s[2] := 'c';
PrintArray(s, 'set:');
WriteLn('get: ', s[2]);
// Length returns the length of the dynamic array as expected.
WriteLn('len: ', Length(s));
// To add elements to a dynamic array, we can use SetLength
// and then assign values to the new elements.
SetLength(s, Length(s) + 1);
s[High(s)] := 'd';
SetLength(s, Length(s) + 2);
s[High(s) - 1] := 'e';
s[High(s)] := 'f';
PrintArray(s, 'apd:');
// To copy a dynamic array, we can use the Copy function.
c := Copy(s);
PrintArray(c, 'cpy:');
// Pascal doesn't have a built-in slice operator, but we can
// use Copy to achieve similar functionality.
l := Copy(s, 2, 3);
PrintArray(l, 'sl1:');
l := Copy(s, 0, 5);
PrintArray(l, 'sl2:');
l := Copy(s, 2, Length(s) - 2);
PrintArray(l, 'sl3:');
// We can declare and initialize a dynamic array in a single line.
t := TStringArray.Create('g', 'h', 'i');
PrintArray(t, 'dcl:');
// Pascal doesn't have a built-in equality function for arrays,
// so we'd need to implement our own if needed.
// Dynamic arrays can be used to create multi-dimensional structures.
SetLength(twoD, 3);
for i := 0 to 2 do
begin
SetLength(twoD[i], i + 1);
for j := 0 to i do
twoD[i][j] := IntToStr(i + j);
end;
Write('2d: [');
for i := 0 to 2 do
begin
if i > 0 then
Write(' ');
PrintArray(twoD[i], '');
end;
WriteLn(']');
end.
This Pascal code demonstrates concepts similar to Go’s slices using dynamic arrays. Here are some key points:
array of Type
) which are similar to slices in Go.SetLength
is used to create or resize dynamic arrays, similar to make
in Go.append
function, so we manually resize the array and assign new values.Copy
function in Pascal can be used to achieve functionality similar to Go’s slice operations.Note that Pascal’s dynamic arrays are not exactly the same as Go’s slices in terms of underlying implementation and performance characteristics, but they serve a similar purpose in providing dynamically-sized array-like structures.