Free coupon for initial registration

Capitalize first character of all words

JavaScript Perl PHP Python Ruby Rust

Contents [hide]

Input

 can you caplitalize?

Output

 Can You Caplitalize?

Code examples

JavaScript

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class CapitalizeOnlyHeads {
    constructor(opt) {
    }
    convert(str = "") {
        return str.split(' ').map(word => word.charAt(0).toUpperCase() + word.slice(1)).join(' ');
  }
};
module.exports = CapitalizeOnlyHeads;
 
if(!module.parent) {
  let capitalizer = new CapitalizeOnlyHeads();
  const str = " can you caplitalize?";
    console.log(capitalizer.convert(str));
}

PHP

1
2
3
4
5
6
7
8
9
10
11
12
13
14
<?php
class CapitalizeOnlyHeads {
  public function __construct($opt = []){
  }
  public function convert($str="") {
    return ucwords($str);
  }
}
 
if ( !isset(debug_backtrace()[0]) ) {
  $capitalizer = new CapitalizeOnlyHeads;
  $str = " can you caplitalize?";
  print($capitalizer->convert($str)."\n");
}

Perl

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package CapitalizeOnlyHeads;
use strict;
use warnings;
 
sub new(){
  my $class = shift;
  my $self = {};
  return bless($self);
}
 
sub convert(){
  my $self = shift;
  my $str = shift;
  $str=~ s{^(\s*)([a-z])|(\s)([a-z])}{
    my $space = $1;
    my $space2 = $3;
    my $char = $2;
    my $char2 = $4;
    if($char) {
      $space.uc($char);
    }
    else{
      $space2.uc($char2);
    }
  }gesx;
  return $str;
}
 
if ($0 eq __FILE__) {
  my $capitalizer = new CapitalizeOnlyHeads();
  my $str = " can you caplitalize?";
  print($capitalizer->convert($str)."\n");
}
else{
  1;
}

Python

1
2
3
4
5
6
7
8
9
10
11
class CapitalizeOnlyHeads:
    def __init__(self, opt = {}):
        pass
 
    def convert(self, str):
        return str.title()
 
if __name__ == "__main__":
    capitalizer = CapitalizeOnlyHeads()
    str = " can you caplitalize?"
    print(capitalizer.convert(str))

Ruby

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class CapitalizeOnlyHeads
  def initialize(opt = {} )
  end
 
  def convert(str)
    last_str = ""
    str.scan(/(\s*)([^\s]*)/) {|s| last_str += s[0]+s[1].capitalize }
    print(last_str)
  end
end
 
if $0 == __FILE__
  capitalizer = CapitalizeOnlyHeads.new()
  str = " can you caplitalize?";
  puts(capitalizer.convert(str))
end

Rust

Cargo.toml

1
2
3
4
5
6
7
8
9
10
[package]
name = "caplitalize_only_heads"
version = "0.0.1"
 
[dependencies]
inflections = "*"
 
[[bin]]
name = "caplitalize_only_heads"
path = "CaplitalizeOnlyHeads.rs"

CapitalizeOnlyHeads.rs

1
2
3
4
5
6
extern crate inflections;
use inflections::Inflect;
fn main() {
  let str = " can you caplitalize?";
  println!("{}", str.to_title_case());
}
Free coupon for initial registration