PHP Perl Python Ruby 语言特性的区别

statements must be semicolon terminated inside {}

newlines not separators inside (), [], {}, triple quote literals, or after backslash: \

newlines not separators inside (), [], {}, “, ”, “”, or after binary operator or backslash: \

do end

v = 1

# 3 is discarded:

list($x, $y) = array(1, 2, 3);

# $z set to NULL:

list($x, $y, $z) = array(1, 2);

# 3 is discarded:

($x, $y) = (1, 2, 3);

# $z set to undef:

($x, $y, $z) = (1, 2);

# raises ValueError:

x, y = 1, 2, 3

# raises ValueError:

x, y, z = 1, 2

# 3 is discarded:

x, y = 1, 2, 3

# z set to nil:

x, y, z = 1, 2

.= none

&= |= none

<>= &= |= ^=

.= x=

&&= ||= ^=

<>= &= |= ^=

+= -= *= /= //= %= **=

+= *=

&= |= ^=

<>= &= |= ^=

+= *=

&&= ||= ^=

<>= &= |= ^=

$y = ++$x;

$z = –$y;

my $y = ++$x;

my $z = –$y;

# x and y not mutated:

y = x.succ

z = y.pred

$v = NULL;

$a = array();

$d = array();

$x = 1;

list($y, $z) = array(2, 3);

my (@a, %d);

my $x = 1;

my ($y, $z) = (2, 3);

v = None

a, d = [], {}

x = 1

y, z = 2, 3

a, d = [], {}

x = 1

y, z = 2, 3

function or method body

nestable (with use clause):

anonymous function body

file

nestable:

function body

anonymous function body

anonymous block

function or method body

file

class block

module block

method body

nestable:

anonymous function block

anonymous block

function swap_globals() {

global $g1, $g2;

list($g1, $g2) = array($g2, $g1);

}

sub swap_globals {

($g1, $g2) = ($g2, $g1);

}

def swap_globals():

global g1, g2

g1, g2 = g2, g1

def swap_globals

$g1, $g2 = $g2, $g1

end

# constant by convention

PI = 3.14

# identifier is reassigned

PI = 3.14

# comment

another line */

comment line

another line

=cut

”’comment line

another line”’

comment line

another line

=end

! isset($v)

v is None

v.nil?

try: v

except NameError: not_defined = True

lower precedence:

and or xor

lower precedence:

and or xor not

lower precedence:

and or not

no conversion: === !==

strings: eq ne gt lt ge le

== != > = <=

“do” cmp “re”

cmp(0, 1)

cmp(‘do’, ‘re’)

“do” “re”

73.9 + “.037”

“value: ” . 8

73.9 + “.037”

“value: ” . 8

73.9 + float(‘.037’)

‘value: ‘ + str(8)

73.9 + “.037”.to_f

“value: ” + “8”.to_s

none

none

q, r = divmod(13, 5)

q, r = 13.divmod(5)

# Python 3:

13 / 5

13.fdiv(5)

tan asin acos atan);

sqrt exp log sin cos tan asin acos atan atan2

sin, cos, tan, asin, acos, atan, atan2

sqrt exp log sin cos tan asin acos atan atan2

round($x)

ceil($x)

floor($x)

abs($x)

use Number::Format ’round’;

use POSIX qw(ceil floor);

int($x)

round($x, 0)

ceil($x)

floor($x)

abs($x)

int(x)

int(round(x))

math.ceil(x)

math.floor(x)

abs(x)

x.round

x.ceil

x.floor

x.abs

max(1,2,3)

$a = array(1,2,3)

min($a)

max($a)

min(1,2,3);

max(1,2,3);

@a = (1,2,3);

min(@a);

max(@a);

max(1,2,3)

min([1,2,3])

max([1,2,3])

[1,2,3].max

float division returns Infinity

import math

math.sqrt(-2)

# returns complex float:

import cmath

cmath.sqrt(-2)

my $x = Math::BigRat->new(“22/7”);

$x->numerator();

$x->denominator();

x = Fraction(22,7)

x.numerator

x.denominator

x = Rational(22,7)

x.numerator

x.denominator

my $z = 1 + 1.414 * i;

Re($z);

Im($z);

z.real

z.imag

z = 1 + 1.414.im

z.real

z.imag

lcg_value()

none

rand()

none

random.randint(0,99)

random.random()

random.gauss(0,1)

rand

none

none

my $sd = srand;

srand($sd);

random.seed(17)

sd = random.getstate()

random.setstate(sd)

sd = srand

srand(sd)

052

0x2a

052

0x2a

052

0x2a

052

0x2a

base_convert(“60”, 7, 10);

use Math::BaseCalc;

$c = new Math::BaseCalc(digits=>

[0..6]);

$c->to_base(42);

$c->from_base(“60”);

int(“60”, 7)

“60”.to_i(7)

‘don\’t say “no”‘

‘don\’t say “no”‘

“don’t say \”no\””

“don’t ” ‘say “no”‘

”’don’t say “no””’

“””don’t say “no\””””

‘don\’t say “no”‘

“don’t ” ‘say “no”‘

\f \n \r \t \v \xhh \$ \” \ooo

single quoted:

\’ \\

\a \b \cx \e \f \n \r \t \xhh \x{hhhh} \ooo

single quoted:

\’ \\

\newline \\ \’ \” \a \b \f \n \r \t \v \ooo \xhh

Python 3:

\uhhhh \Uhhhhhhhh

\a \b \cx \e \f \n \r \s \t \v \xhh \ooo

Ruby 1.9 double quoted:

\uhhhh \u{hhhhh}

single quoted:

\’ \\

$item = “ball”;

echo “$count ${item}s\n”;

my $item = “ball”;

print “$count ${item}s\n”;

item = ‘ball’

print(‘{count} {item}s’.format(

**locals()))

item = “ball”

puts “#{count} #{item}s”

my $s2 = qq($s1 dolor sit amet);

s2 = %Q(#{s1} dolor sit amet)

sprintf($fmt, “ipsum”, 13, 3.7);

sprintf($fmt, “ipsum”, 13, 3.7)

fmt = ‘lorem {0} {1} {2}’

fmt.format(‘ipsum’, 13, 3.7)

$s = <<<EOF

lorem ipsum

dolor sit $word

EOF;

$s = <<EOF;

lorem ipsum

dolor sit $word

EOF

s = <<EOF

lorem ipsum

dolor sit #{word}

EOF

$s2 = $s . “World!”;

my $s2 = $s . “World!”;

s2 = s + ‘World!’

juxtaposition can be used to concatenate literals:

s2 = ‘Hello, ‘ “World!”

s2 = s + “World!”

juxtaposition can be used to concatenate literals:

s2 =”Hello, ” ‘World!’

preg_split(‘/\s+/’, “do re mi fa”, 2)

preg_split(‘/(\s+)/’, “do re mi fa”,

NULL, PREG_SPLIT_DELIM_CAPTURE);

str_split(“abcd”)

split(/\s+/, “do re mi fa”, 2)

split(/(\s+)/, “do re mi fa”);

split(//, “abcd”)

‘do re mi fa’.split(None, 1)

re.split(‘(\s+)’, ‘do re mi fa’)

list(‘abcd’)

“do re mi fa”.split(/\s+/, 2)

“do re mi fa”.split(/(\s+)/)

“abcd”.split(“”)

implode(” “, $a)

strtolower(“LOREM”)

ucfirst(“lorem”)

lc(“LOREM”)

ucfirst(“lorem”)

‘LOREM’.lower()

‘lorem’.capitalize()

“LOREM”.downcase

“lorem”.capitalize

ltrim(” lorem”)

rtrim(“lorem “)

use Text::Trim;

trim ” lorem “

ltrim ” lorem”

rtrim “lorem “

‘ lorem’.lstrip()

‘lorem ‘.rstrip()

” lorem”.lstrip

“lorem “.rstrip

str_pad(“lorem”, 10, ” “,

STR_PAD_LEFT)

sprintf(“%10s”, “lorem”)

‘lorem’.rjust(10)

“lorem”.rjust(10)

“lorem”.size

strrpos(“do re re”, “re”)

return FALSE if not found

rindex(“do re re”, “re”)

return -1 if not found

‘do re re’.rindex(‘re’)

raise ValueError if not found

“do re re”.rindex(“re”)

return nil if not found

$s = “lorem ipsum”;

$s[6];

substr(“lorem ipsum”, 6, 1)

ord(“A”)

ord(“A”)

ord(‘A’)

“A”[0] Ruby 1.9: “A”.ord

$outs = substr($ins, 13, 13) . substr($ins, 0, 13);

strtr(“hello”, $ins, $outs)

$s =~ tr/a-z/n-za-m/;

from string import maketrans

outs = ins[13:] + ins[:13]

‘hello’.translate(maketrans(ins,outs))

‘(/etc/hosts)’

qr(/etc/hosts)

none

%r(/etc/hosts)

. \d \D \h \H \s \S \v \V \w \W

anchors: ^ $ \A \b \B \z \Z

. \d \D \h \H \s \S \v \V \w \W

anchors: ^ $ \A \b \B \z \Z

. \d \D \s \S \w \W

anchors: ^ $ \A \b \B \Z

. \d \D \h \H \s \S \w \W

anchors: ^ $ \A \b \B \z \Z

echo “party!\n”;

}

print “party!\n”;

}

print(‘party!’)

puts “party!”

end

$s = preg_replace(‘/mi/’, “ma”, $s);

$s =~ s/mi/ma/g;

s = pile(‘mi’).sub(‘ma’, s)

s.gsub!(/mi/, “ma”)

$match = ${^MATCH};

$prematch = ${^PREMATCH};

$postmatch = ${^POSTMATCH};

}

if m:

match = m.group()

prematch = s[0:m.start(0)]

postmatch = s[m.end(0):len(s)]

if m

match = m[0]

prematch = m.pre_match

postmatch = m.post_match

end

$rx = ‘/(\d{4})-(\d{2})-(\d{2})/’;

preg_match($rx, $s, $m);

list($_, $yr, $mo, $dy) = $m;

“-06-03” =~ $rx;

($yr, $mo, $dy) = ($1, $2, $3);

m = re.search(rx, ‘-06-03’)

yr, mo, dy = m.groups()

m = rx.match(“-06-03”)

yr, mo, dy = m[1..3]

preg_match_all(‘/\w+/’, $s, $m);

$a = $m[0];

@a = $s =~ m/\w+/g;

a = re.findall(‘\w+’, s)

$s = “do re”;

$rx = ‘/(\w+) (\w+)/’;

$s = preg_replace($rx, ‘\2 \1’, $s);

my $s = “do re”;

$s =~ s/(\w+) (\w+)/$2 $1/;

rx = pile(‘(\w+) (\w+)’)

rx.sub(r’\2 \1′, ‘do re’)

“do re”.sub(/(\w+) (\w+)/, ‘\2 \1’)

/(?

\(([^()]*|\g

)*\))/

$utc_tmz = new DateTimeZone(“UTC”);

$utc = new DateTime(“now”, $utc_tmz);

my $t = localtime(time);

my $utc = gmtime(time);

t = datetime.datetime.now()

utc = datetime.datetime.utcnow()

utc = Time.now.utc

$t2 = new DateTime();

$t2->setTimestamp(1304442000);

use Time::Piece;

my $epoch = timelocal($t);

my $t2 = localtime(1304442000);

epoch = int(t.strftime(“%s”))

t2 = dt.fromtimestamp(1304442000)

t2 = Time.at(1304442000)

t = datetime.datetime.now()

epoch = int(t.strftime(“%s”))

date(“Y-m-d H:i:s”, $epoch);

$t->format(“Y-m-d H:i:s”);

$t = localtime(time);

$fmt = “%Y-%m-%d %H:%M:%S”;

print $t->strftime($fmt);

$s = “-05-03 10:00:00”;

$t = DateTime::createFromFormat($fmt,

$s);

use Time::Piece;

$s = “-05-03 10:00:00”;

$fmt = “%Y-%m-%d %H:%M:%S”;

$t = Time::Piece->strptime($s,$fmt);

s = ‘-05-03 10:00:00’

fmt = ‘%Y-%m-%d %H:%M:%S’

t = datetime.strptime(s, fmt)

s = “-05-03 10:00:00”

fmt = “%Y-%m-%d %H:%M:%S”

t = Date.strptime(s, fmt).to_time

use Date::Parse;

$epoch = str2time(“July 7, 1999”);

import dateutil.parser

s = ‘July 7, 1999’

t = dateutil.parser.parse(s)

s = “July 7, 1999”

t = Date.parse(s).to_time

$fmt = “Y-m-d H:i:s”;

$s = “-05-03 10:00:00”;

$then = DateTime::createFromFormat($fmt, $s);

$now = new DateTime(“now”);

$interval = $now->diff($then);

$now->add(new DateInterval(“PT10M3S”);

$now = localtime(time);

$now += 10 * ONE_MINUTE() + 3;

delta = datetime.timedelta(

minutes=10,

seconds=3)

t = datetime.datetime.now() + delta

s = “10 min, 3 s”

delta = Date::Delta.parse(s).in_secs

t = Time.now + delta

$s = “America/Los_Angeles”;

date_default_timezone_set($s);

timezone_name_get($tmz);

date_offset_get($t) / 3600;

$t->format(“I”);

use DateTime;

use DateTime::TimeZone;

$dt = DateTime->now();

$tz = DateTime::TimeZone->new(

name=>”local”);

$tz->name;

$tz->offset_for_datetime($dt) /

3600;

$tz->is_dst_for_datetime($dt);

tm = time.localtime()

time.tzname[tm.tm_isdst]

(time.timezone / -3600) + tm.tm_isdst

tm.tm_isdst

t.utc_offset / 3600

t.dst?

microtime());

$usec = $frac * 1000 * 1000;

($sec, $usec) = gettimeofday;

sleep(1);

sleep 1;

time.sleep(0.5)

$SIG{ALRM}= sub {die “timeout!”;};

alarm 5;

sleep 10;

};

alarm 0;

class Timeout(Exception): pass

def timeout_handler(signo, fm):

raise Timeout()

signal.signal(signal.SIGALRM,

timeout_handler)

try:

signal.alarm(5)

time.sleep(10)

except Timeout:

pass

signal.alarm(0)

begin

Timeout.timeout(5) do

sleep(10)

end

rescue Timeout::Error

end

scalar(@a)

a.length # same as size

a.empty?

evaluates as NULL:

$a[10];

increases array size to one:

$a[10] = “lorem”;

evaluates as undef:

$a[10];

increases array size to 11:

$a[10] = “lorem”;

raises IndexError:

a[10]

raises IndexError:

a[10] = ‘lorem’

evaluates as nil:

a[10]

increases array size to 11:

a[10] = “lorem”

$i = array_search(“y”, $a);

@a = qw(x y z w);

$i = first {$a[$_] eq “y”} (0..$#a);

i = a.index(‘y’)

i = a.index(“y”)

none

array_slice($a, 2, 2)

@a[2..3]

splice(@a, 2, 2)

a[2:4]

none

a[2..3]

a[2, 2]

array_push($a, 9);

$a[] = 9; # same as array_push

array_pop($a);

push @a, 9;

pop @a;

a.append(9)

a.pop()

a.push(9)

a << 9 # same as push

a.pop

array_unshift($a, 5);

array_shift($a);

unshift @a, 5;

shift @a;

a.insert(0,5)

a.pop(0)

a.unshift(5)

a.shift

$a2 = array_merge($a,array(4,5,6));

$a = array_merge($a,array(4,5,6));

@a2 = (@a,(4,5,6));

push @a, (4,5,6);

a2 = a + [4,5,6]

a.extend([4,5,6])

a2 = a + [4,5,6]

a.concat([4,5,6])

a = [None for i in range(0, 10)]

a = Array.new(10, nil)

$a2 =& $a;

none

$a4 = $a;

my @a = (1,2,[3,4]);

my $a2 = \@a;

my @a3 = @a;

my @a4 = @{dclone(\@a)};

a = [1,2,[3,4]]

a2 = a

a3 = list(a)

a4 = copy.deepcopy(a)

a2 = a

a3 = a.dup

a4 = Marshal.load(Marshal.dump(a))

echo “$i\n”;

}

print(i)

foreach ($a as $i => $s) {

echo “$s at index $i\n”;

}

for i, s in enumerate(a):

print(‘%s at index %d’ % (s, i))

a.each_with_index do |s,i|

puts “#{s} at index #{i}”

end

code

}

for i in xrange(1, 1000001):

code

code

end

Python 3:

a = list(range(1, 11))

array_reverse($a);

$a = array_reverse($a);

reverse @a;

@a = reverse @a;

a[::-1]

a.reverse()

a.reverse

a.reverse!

none

sort($a);

none, but usort sorts in place

sort @a;

@a = sort @a;

sort { lc($a) cmp lc($b) } @a;

sorted(a)

a.sort()

a.sort(key=str.lower)

a.sort

a.sort!

a.sort do |x,y|

x.downcase y.downcase

end

$a2 = array_unique($a);

$a = array_unique($a);

my @a = (1,2,2,3);

my @a2 = uniq @a;

@a = uniq @a;

a2 = list(set(a))

a = list(set(a))

a2 = a.uniq

a.uniq!

$b = array(2,3,4)

array_intersect($a, $b)

$a2 = array(2,3,4);

array_unique(array_merge($a1, $a2))

$a2 = array(2);

array_values(array_diff($a1, $a2))

none

{1,2} ^ {2,3,4}

[1,2,3] – [2]

Set[1,2] ^ Set[2,3,4]

return $x*$x;

}, array(1,2,3))

# or use list comprehension:

[x*x for x in [1,2,3]]

网友评论

文明上网理性发言 发表评论

网友评论仅供其表达个人看法，并不表明网站立场。